v0.7.0: image input, model registry, prefix-cache savings
Images - vision gate: text-only models get a note instead of image parts and no view_image tool; unknown models retry once without images on HTTP 400 - paste: Ctrl+V and /attach paste read the clipboard (wl-paste, xclip, pngpaste/osascript, Win32 PNG or CF_DIB converted to PNG); pasting image file paths attaches them - MCP image content is stored in the session and sent with the tool result - attach: rel path validation, base64 decode, /retry keeps images Model registry - built-in src/models_builtin.json embedded at build time, merged with <config>/models.json and cached GET /models metadata (context, vision, pricing); most specific rule wins per field - /model labels, /status source, --list-models [provider] Cache and cost - stable request prefix (frozen tools, notes as messages), DeepSeek prefix completion, OpenAI/Anthropic cache hints, /cost and hit rate in the status
This commit is contained in:
WHC
+934
-221
File diff suppressed because it is too large
Load Diff
+4
-1
@@ -288,7 +288,10 @@ int cst_agent_store_info(const char *workspace, const char *id,
|
||||
cJSON *o = cJSON_Parse(line);
|
||||
const cJSON *r = cJSON_GetObjectItemCaseSensitive(o, "role");
|
||||
const cJSON *c = cJSON_GetObjectItemCaseSensitive(o, "content");
|
||||
if (cJSON_IsString(r) && strcmp(r->valuestring, "user") == 0 &&
|
||||
const cJSON *k = cJSON_GetObjectItemCaseSensitive(
|
||||
cJSON_GetObjectItemCaseSensitive(o, "meta"), "kind");
|
||||
int note = cJSON_IsString(k) && strcmp(k->valuestring, "note") == 0;
|
||||
if (cJSON_IsString(r) && strcmp(r->valuestring, "user") == 0 && !note &&
|
||||
cJSON_IsString(c) && c->valuestring[0]) {
|
||||
clip_line(info->first_user, sizeof(info->first_user), c->valuestring);
|
||||
have_first = 1;
|
||||
|
||||
+646
@@ -0,0 +1,646 @@
|
||||
#ifndef _DEFAULT_SOURCE
|
||||
#define _DEFAULT_SOURCE
|
||||
#endif
|
||||
|
||||
#include "cJSON.h"
|
||||
#include "cst_attach.h"
|
||||
#include "cst_util.h"
|
||||
#include "os_compat.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/* --- base64 -------------------------------------------------------------- */
|
||||
|
||||
static const char B64[] =
|
||||
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
|
||||
char *cst_base64_encode(const void *data, size_t n) {
|
||||
const unsigned char *p = data;
|
||||
size_t olen = ((n + 2) / 3) * 4;
|
||||
char *out = malloc(olen + 1);
|
||||
if (!out)
|
||||
return NULL;
|
||||
size_t o = 0;
|
||||
for (size_t i = 0; i < n; i += 3) {
|
||||
unsigned v = (unsigned)p[i] << 16;
|
||||
if (i + 1 < n)
|
||||
v |= (unsigned)p[i + 1] << 8;
|
||||
if (i + 2 < n)
|
||||
v |= (unsigned)p[i + 2];
|
||||
out[o++] = B64[(v >> 18) & 63];
|
||||
out[o++] = B64[(v >> 12) & 63];
|
||||
out[o++] = i + 1 < n ? B64[(v >> 6) & 63] : '=';
|
||||
out[o++] = i + 2 < n ? B64[v & 63] : '=';
|
||||
}
|
||||
out[o] = 0;
|
||||
return out;
|
||||
}
|
||||
|
||||
static int b64_val(unsigned char c) {
|
||||
if (c >= 'A' && c <= 'Z')
|
||||
return c - 'A';
|
||||
if (c >= 'a' && c <= 'z')
|
||||
return c - 'a' + 26;
|
||||
if (c >= '0' && c <= '9')
|
||||
return c - '0' + 52;
|
||||
if (c == '+' || c == '-')
|
||||
return 62;
|
||||
if (c == '/' || c == '_')
|
||||
return 63;
|
||||
return -1;
|
||||
}
|
||||
|
||||
char *cst_base64_decode(const char *s, size_t n, size_t *out_len) {
|
||||
if (out_len)
|
||||
*out_len = 0;
|
||||
if (!s)
|
||||
return NULL;
|
||||
char *out = malloc(n / 4 * 3 + 4);
|
||||
if (!out)
|
||||
return NULL;
|
||||
size_t o = 0;
|
||||
unsigned acc = 0;
|
||||
int bits = 0;
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
unsigned char c = (unsigned char)s[i];
|
||||
if (c == '=')
|
||||
break;
|
||||
if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
|
||||
continue;
|
||||
int v = b64_val(c);
|
||||
if (v < 0) {
|
||||
free(out);
|
||||
return NULL;
|
||||
}
|
||||
acc = (acc << 6) | (unsigned)v;
|
||||
bits += 6;
|
||||
if (bits >= 8) {
|
||||
bits -= 8;
|
||||
out[o++] = (char)((acc >> bits) & 0xFF);
|
||||
}
|
||||
}
|
||||
if (out_len)
|
||||
*out_len = o;
|
||||
return out;
|
||||
}
|
||||
|
||||
/* --- format sniffing ----------------------------------------------------- */
|
||||
|
||||
static int be32(const unsigned char *p) {
|
||||
return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
|
||||
}
|
||||
|
||||
static int le32(const unsigned char *p) {
|
||||
return (int)((unsigned)p[0] | ((unsigned)p[1] << 8) |
|
||||
((unsigned)p[2] << 16) | ((unsigned)p[3] << 24));
|
||||
}
|
||||
|
||||
static int le16(const unsigned char *p) {
|
||||
return (int)((unsigned)p[0] | ((unsigned)p[1] << 8));
|
||||
}
|
||||
|
||||
static const char *mime_of_ext(const char *mime) {
|
||||
if (strcmp(mime, "image/png") == 0)
|
||||
return "png";
|
||||
if (strcmp(mime, "image/jpeg") == 0)
|
||||
return "jpg";
|
||||
if (strcmp(mime, "image/gif") == 0)
|
||||
return "gif";
|
||||
if (strcmp(mime, "image/webp") == 0)
|
||||
return "webp";
|
||||
if (strcmp(mime, "image/bmp") == 0)
|
||||
return "bmp";
|
||||
return "bin";
|
||||
}
|
||||
|
||||
/* A JPEG SOF marker carries the frame size; skip it when scanning. */
|
||||
static int jpeg_sof(int marker) {
|
||||
switch (marker) {
|
||||
case 0xC0:
|
||||
case 0xC1:
|
||||
case 0xC2:
|
||||
case 0xC3:
|
||||
case 0xC5:
|
||||
case 0xC6:
|
||||
case 0xC7:
|
||||
case 0xC9:
|
||||
case 0xCA:
|
||||
case 0xCB:
|
||||
case 0xCD:
|
||||
case 0xCE:
|
||||
case 0xCF:
|
||||
return 1;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
int cst_attach_sniff(const void *data, size_t n, char *mime, size_t mime_sz) {
|
||||
const unsigned char *p = data;
|
||||
const char *m = NULL;
|
||||
if (n >= 8 && memcmp(p, "\x89PNG\r\n\x1a\n", 8) == 0)
|
||||
m = "image/png";
|
||||
else if (n >= 3 && p[0] == 0xFF && p[1] == 0xD8 && p[2] == 0xFF)
|
||||
m = "image/jpeg";
|
||||
else if (n >= 6 && memcmp(p, "GIF87a", 6) == 0)
|
||||
m = "image/gif";
|
||||
else if (n >= 6 && memcmp(p, "GIF89a", 6) == 0)
|
||||
m = "image/gif";
|
||||
else if (n >= 12 && memcmp(p, "RIFF", 4) == 0 && memcmp(p + 8, "WEBP", 4) == 0)
|
||||
m = "image/webp";
|
||||
else if (n >= 2 && p[0] == 'B' && p[1] == 'M')
|
||||
m = "image/bmp";
|
||||
if (!m)
|
||||
return -1;
|
||||
snprintf(mime, mime_sz, "%s", m);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* PNG / GIF / BMP are direct; JPEG needs a marker walk; WebP has three
|
||||
* container flavours. */
|
||||
int cst_attach_dimensions(const void *data, size_t n, int *w, int *h) {
|
||||
const unsigned char *p = data;
|
||||
*w = *h = 0;
|
||||
char mime[32];
|
||||
if (cst_attach_sniff(data, n, mime, sizeof(mime)) != 0)
|
||||
return -1;
|
||||
|
||||
if (strcmp(mime, "image/png") == 0) {
|
||||
/* 8 signature + 4 length + "IHDR" + w + h */
|
||||
if (n < 24 || memcmp(p + 12, "IHDR", 4) != 0)
|
||||
return -1;
|
||||
*w = be32(p + 16);
|
||||
*h = be32(p + 20);
|
||||
return 0;
|
||||
}
|
||||
if (strcmp(mime, "image/gif") == 0) {
|
||||
if (n < 10)
|
||||
return -1;
|
||||
*w = le16(p + 6);
|
||||
*h = le16(p + 8);
|
||||
return 0;
|
||||
}
|
||||
if (strcmp(mime, "image/bmp") == 0) {
|
||||
if (n < 26)
|
||||
return -1;
|
||||
int wi = le32(p + 18);
|
||||
int hi = le32(p + 22);
|
||||
if (wi < 0)
|
||||
wi = -wi; /* bottom-up rows are stored with a negative height */
|
||||
if (hi < 0)
|
||||
hi = -hi;
|
||||
*w = wi;
|
||||
*h = hi;
|
||||
return 0;
|
||||
}
|
||||
if (strcmp(mime, "image/webp") == 0) {
|
||||
if (n < 30)
|
||||
return -1;
|
||||
const unsigned char *c = p + 12;
|
||||
if (memcmp(c, "VP8 ", 4) == 0) {
|
||||
/* 4 tag + 3 start code, then 16-bit width / height (14 bits each) */
|
||||
if (n < 30 || !(c[7] == 0x9D && c[8] == 0x01 && c[9] == 0x2A))
|
||||
return -1;
|
||||
*w = le16(c + 10) & 0x3FFF;
|
||||
*h = le16(c + 12) & 0x3FFF;
|
||||
return 0;
|
||||
}
|
||||
if (memcmp(c, "VP8L", 4) == 0) {
|
||||
if (n < 25 || c[8] != 0x2F)
|
||||
return -1;
|
||||
unsigned b = (unsigned)c[9] | ((unsigned)c[10] << 8) |
|
||||
((unsigned)c[11] << 16) | ((unsigned)c[12] << 24);
|
||||
*w = (int)(b & 0x3FFF) + 1;
|
||||
*h = (int)((b >> 14) & 0x3FFF) + 1;
|
||||
return 0;
|
||||
}
|
||||
if (memcmp(c, "VP8X", 4) == 0) {
|
||||
if (n < 30)
|
||||
return -1;
|
||||
*w = (int)((unsigned)c[12] | ((unsigned)c[13] << 8) |
|
||||
((unsigned)c[14] << 16)) + 1;
|
||||
*h = (int)((unsigned)c[15] | ((unsigned)c[16] << 8) |
|
||||
((unsigned)c[17] << 16)) + 1;
|
||||
return 0;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
if (strcmp(mime, "image/jpeg") == 0) {
|
||||
size_t i = 2;
|
||||
while (i + 3 < n) {
|
||||
if (p[i] != 0xFF)
|
||||
return -1; /* lost sync */
|
||||
unsigned marker = p[i + 1];
|
||||
i += 2;
|
||||
if (marker == 0xD8 || (marker >= 0xD0 && marker <= 0xD7))
|
||||
continue; /* standalone markers: no payload */
|
||||
if (marker == 0xD9 || marker == 0x01)
|
||||
continue;
|
||||
if (i + 1 >= n)
|
||||
return -1;
|
||||
size_t seg = (size_t)((p[i] << 8) | p[i + 1]);
|
||||
if (seg < 2 || i + seg > n)
|
||||
return -1;
|
||||
if (jpeg_sof((int)marker) && seg >= 7) {
|
||||
*h = (p[i + 3] << 8) | p[i + 4];
|
||||
*w = (p[i + 5] << 8) | p[i + 6];
|
||||
return 0;
|
||||
}
|
||||
i += seg;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* --- storage ------------------------------------------------------------- */
|
||||
|
||||
/* <session dir>/attachments/<session stem> — beside the JSONL so moving the
|
||||
* workspace keeps the two together. */
|
||||
int cst_attach_dir(const char *session_path, char *out, size_t out_sz) {
|
||||
if (!session_path || !session_path[0])
|
||||
return -1;
|
||||
char dir[OS_PATH_MAX];
|
||||
snprintf(dir, sizeof(dir), "%s", session_path);
|
||||
char *slash = strrchr(dir, '/');
|
||||
#ifdef _WIN32
|
||||
char *bslash = strrchr(dir, '\\');
|
||||
if (bslash && (!slash || bslash > slash))
|
||||
slash = bslash;
|
||||
#endif
|
||||
char leaf[256];
|
||||
const char *base = slash ? slash + 1 : dir;
|
||||
size_t bl = strlen(base);
|
||||
if (bl >= sizeof(leaf))
|
||||
bl = sizeof(leaf) - 1;
|
||||
memcpy(leaf, base, bl);
|
||||
leaf[bl] = 0;
|
||||
if (slash)
|
||||
*(slash + 1) = 0;
|
||||
else {
|
||||
dir[0] = '.';
|
||||
dir[1] = 0;
|
||||
}
|
||||
char *dot = strstr(leaf, ".jsonl");
|
||||
if (dot)
|
||||
*dot = 0;
|
||||
char rel[320];
|
||||
snprintf(rel, sizeof(rel), "attachments/%s", leaf[0] ? leaf : "session");
|
||||
char full[OS_PATH_MAX];
|
||||
if (os_path_join(full, sizeof(full), dir, rel) != 0)
|
||||
return -1;
|
||||
if (os_mkdir_p(full, 0700) != 0)
|
||||
return -1;
|
||||
snprintf(out, out_sz, "%s", full);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Stored names are "<id>.<ext>" made by store(); anything else in a JSONL
|
||||
* (hand-edited or crafted) could point outside the attachment directory. */
|
||||
int cst_attach_rel_ok(const char *rel) {
|
||||
if (!rel || !rel[0] || rel[0] == '.')
|
||||
return 0;
|
||||
for (const char *p = rel; *p; p++) {
|
||||
char c = *p;
|
||||
if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
|
||||
(c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.'))
|
||||
return 0;
|
||||
}
|
||||
return strstr(rel, "..") == NULL;
|
||||
}
|
||||
|
||||
int cst_attach_full_path(const char *session_path, const cst_attachment_t *a,
|
||||
char *out, size_t out_sz) {
|
||||
if (!a || !cst_attach_rel_ok(a->rel))
|
||||
return -1;
|
||||
char dir[OS_PATH_MAX];
|
||||
if (cst_attach_dir(session_path, dir, sizeof(dir)) != 0)
|
||||
return -1;
|
||||
return os_path_join(out, out_sz, dir, a->rel);
|
||||
}
|
||||
|
||||
static char *read_whole(const char *path, size_t *out_len, size_t max) {
|
||||
FILE *f = fopen(path, "rb");
|
||||
if (!f)
|
||||
return NULL;
|
||||
cst_buf_t b = {0};
|
||||
char chunk[16384];
|
||||
size_t n;
|
||||
while ((n = fread(chunk, 1, sizeof(chunk), f)) > 0) {
|
||||
if (b.len + n > max || cst_buf_append(&b, chunk, n) != 0) {
|
||||
cst_buf_free(&b);
|
||||
fclose(f);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
fclose(f);
|
||||
*out_len = b.len;
|
||||
return cst_buf_steal(&b);
|
||||
}
|
||||
|
||||
/* FNV over the bytes, the name and the clock: short, stable, unique enough
|
||||
* inside one session. */
|
||||
static void make_id(const char *name, const char *data, size_t n, char *out,
|
||||
size_t out_sz) {
|
||||
uint64_t h = cst_fnv1a64(CST_FNV_INIT, data, n > 4096 ? 4096 : n);
|
||||
h = cst_fnv1a64(h, name, strlen(name));
|
||||
h = cst_fnv1a64(h, &n, sizeof(n));
|
||||
double now = os_now_ms();
|
||||
h = cst_fnv1a64(h, &now, sizeof(now));
|
||||
h = cst_fnv1a64(h, &(int){os_getpid()}, sizeof(int));
|
||||
snprintf(out, out_sz, "img-%08x", (unsigned)(h & 0xFFFFFFFFu));
|
||||
}
|
||||
|
||||
static cst_attachment_t *store(const char *session_path, const char *name,
|
||||
const char *data, size_t n, const char *origin,
|
||||
char *err, size_t err_sz) {
|
||||
if (!name || !name[0])
|
||||
name = "image";
|
||||
char mime[32];
|
||||
if (cst_attach_sniff(data, n, mime, sizeof(mime)) != 0) {
|
||||
snprintf(err, err_sz,
|
||||
"not a supported image (PNG, JPEG, GIF, WebP or BMP; "
|
||||
"checked by content, not by extension)");
|
||||
return NULL;
|
||||
}
|
||||
if (n > CST_ATTACH_MAX_BYTES) {
|
||||
snprintf(err, err_sz, "image is %.1f MB; the limit is %d MB",
|
||||
(double)n / (1024 * 1024), (int)(CST_ATTACH_MAX_BYTES >> 20));
|
||||
return NULL;
|
||||
}
|
||||
char dir[OS_PATH_MAX];
|
||||
if (cst_attach_dir(session_path, dir, sizeof(dir)) != 0) {
|
||||
snprintf(err, err_sz, "cannot create the attachment directory");
|
||||
return NULL;
|
||||
}
|
||||
cst_attachment_t *a = calloc(1, sizeof(*a));
|
||||
if (!a) {
|
||||
snprintf(err, err_sz, "out of memory");
|
||||
return NULL;
|
||||
}
|
||||
make_id(name, data, n, a->id, sizeof(a->id));
|
||||
snprintf(a->rel, sizeof(a->rel), "%s.%s", a->id, mime_of_ext(mime));
|
||||
snprintf(a->name, sizeof(a->name), "%s", name && name[0] ? name : "image");
|
||||
snprintf(a->mime, sizeof(a->mime), "%s", mime);
|
||||
snprintf(a->origin, sizeof(a->origin), "%s", origin ? origin : "user");
|
||||
snprintf(a->detail, sizeof(a->detail), "auto");
|
||||
a->bytes = (long long)n;
|
||||
cst_attach_dimensions(data, n, &a->width, &a->height);
|
||||
|
||||
char full[OS_PATH_MAX];
|
||||
if (cst_attach_full_path(session_path, a, full, sizeof(full)) != 0) {
|
||||
snprintf(err, err_sz, "attachment path is too long");
|
||||
free(a);
|
||||
return NULL;
|
||||
}
|
||||
FILE *f = fopen(full, "wb");
|
||||
if (!f) {
|
||||
snprintf(err, err_sz, "cannot write %.200s", full);
|
||||
free(a);
|
||||
return NULL;
|
||||
}
|
||||
size_t w = fwrite(data, 1, n, f);
|
||||
if (fclose(f) != 0 || w != n) {
|
||||
snprintf(err, err_sz, "cannot write %.200s", full);
|
||||
free(a);
|
||||
return NULL;
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
cst_attachment_t *cst_attach_import_bytes(const char *session_path,
|
||||
const char *name, const char *data,
|
||||
size_t n, char *err, size_t err_sz) {
|
||||
char dummy[8];
|
||||
if (!err || !err_sz) {
|
||||
err = dummy;
|
||||
err_sz = sizeof(dummy);
|
||||
}
|
||||
err[0] = 0;
|
||||
if (!session_path || !session_path[0]) {
|
||||
snprintf(err, err_sz, "no session to store the image in");
|
||||
return NULL;
|
||||
}
|
||||
if (!data || !n) {
|
||||
snprintf(err, err_sz, "image is empty");
|
||||
return NULL;
|
||||
}
|
||||
return store(session_path, name, data, n, "user", err, err_sz);
|
||||
}
|
||||
|
||||
cst_attachment_t *cst_attach_import_file(const char *session_path,
|
||||
const char *src_path, char *err,
|
||||
size_t err_sz) {
|
||||
char dummy[8];
|
||||
if (!err || !err_sz) {
|
||||
err = dummy;
|
||||
err_sz = sizeof(dummy);
|
||||
}
|
||||
err[0] = 0;
|
||||
size_t n = 0;
|
||||
char *data = read_whole(src_path, &n, CST_ATTACH_MAX_BYTES);
|
||||
if (!data) {
|
||||
snprintf(err, err_sz, "cannot read %.300s (or it is larger than %d MB)",
|
||||
src_path, (int)(CST_ATTACH_MAX_BYTES >> 20));
|
||||
return NULL;
|
||||
}
|
||||
const char *leaf = src_path;
|
||||
for (const char *p = src_path; *p; p++)
|
||||
if (*p == '/' || *p == '\\')
|
||||
leaf = p + 1;
|
||||
cst_attachment_t *a = store(session_path, leaf, data, n, "user", err, err_sz);
|
||||
free(data);
|
||||
return a;
|
||||
}
|
||||
|
||||
char *cst_attach_read(const char *session_path, const cst_attachment_t *a,
|
||||
size_t *out_len, char *err, size_t err_sz) {
|
||||
char dummy[8];
|
||||
if (!err || !err_sz) {
|
||||
err = dummy;
|
||||
err_sz = sizeof(dummy);
|
||||
}
|
||||
err[0] = 0;
|
||||
char full[OS_PATH_MAX];
|
||||
if (cst_attach_full_path(session_path, a, full, sizeof(full)) != 0) {
|
||||
snprintf(err, err_sz, "attachment has no stored file");
|
||||
return NULL;
|
||||
}
|
||||
char *data = read_whole(full, out_len, CST_ATTACH_MAX_BYTES);
|
||||
if (!data) {
|
||||
snprintf(err, err_sz,
|
||||
"%.200s is missing; the image was deleted from the session "
|
||||
"store",
|
||||
a->name);
|
||||
return NULL;
|
||||
}
|
||||
char mime[32];
|
||||
if (cst_attach_sniff(data, *out_len, mime, sizeof(mime)) != 0) {
|
||||
snprintf(err, err_sz, "%.200s in the session store is no longer an image",
|
||||
a->name);
|
||||
free(data);
|
||||
return NULL;
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
char *cst_attach_data_url(const char *session_path, const cst_attachment_t *a) {
|
||||
char err[256];
|
||||
size_t n = 0;
|
||||
char *data = cst_attach_read(session_path, a, &n, err, sizeof(err));
|
||||
if (!data)
|
||||
return NULL;
|
||||
char mime[32];
|
||||
cst_attach_sniff(data, n, mime, sizeof(mime)); /* the bytes decide */
|
||||
char *b64 = cst_base64_encode(data, n);
|
||||
free(data);
|
||||
if (!b64)
|
||||
return NULL;
|
||||
cst_buf_t b = {0};
|
||||
cst_buf_printf(&b, "data:%s;base64,", mime);
|
||||
cst_buf_puts(&b, b64);
|
||||
free(b64);
|
||||
return cst_buf_steal(&b);
|
||||
}
|
||||
|
||||
void cst_attach_describe(const cst_attachment_t *a, char *out, size_t out_sz) {
|
||||
if (!a) {
|
||||
snprintf(out, out_sz, "(none)");
|
||||
return;
|
||||
}
|
||||
const char *kind = strncmp(a->mime, "image/", 6) == 0 ? a->mime + 6 : a->mime;
|
||||
char dim[32] = "";
|
||||
if (a->width > 0 && a->height > 0)
|
||||
snprintf(dim, sizeof(dim), "%dx%d ", a->width, a->height);
|
||||
out[0] = 0;
|
||||
if (a->bytes >= 1024 * 1024)
|
||||
snprintf(out, out_sz, "%s%s %.1f MB", dim, kind,
|
||||
(double)a->bytes / (1024 * 1024));
|
||||
else
|
||||
snprintf(out, out_sz, "%s%s %.0f KB", dim, kind,
|
||||
(double)a->bytes / 1024);
|
||||
}
|
||||
|
||||
/* --- lifetime ------------------------------------------------------------ */
|
||||
|
||||
void cst_attach_free(cst_attachment_t *a) { free(a); }
|
||||
|
||||
/* Entries always live in one array (a 1-element array for a single import),
|
||||
* so freeing the block releases them all. */
|
||||
void cst_attachments_free(cst_attachment_t *list, int n) {
|
||||
(void)n;
|
||||
free(list);
|
||||
}
|
||||
|
||||
cst_attachment_t *cst_attachments_dup(const cst_attachment_t *list, int n) {
|
||||
if (!list || n <= 0)
|
||||
return NULL;
|
||||
cst_attachment_t *out = calloc((size_t)n, sizeof(*out));
|
||||
if (!out)
|
||||
return NULL;
|
||||
for (int i = 0; i < n; i++)
|
||||
out[i] = list[i];
|
||||
return out;
|
||||
}
|
||||
|
||||
int cst_attachments_push(cst_attachment_t **list, int *n, int *cap,
|
||||
const cst_attachment_t *src) {
|
||||
if (!list || !n || !cap || !src)
|
||||
return -1;
|
||||
if (*n == *cap) {
|
||||
int nc = *cap ? *cap * 2 : 4;
|
||||
cst_attachment_t *nv = realloc(*list, (size_t)nc * sizeof(**list));
|
||||
if (!nv)
|
||||
return -1;
|
||||
*list = nv;
|
||||
*cap = nc;
|
||||
}
|
||||
(*list)[(*n)++] = *src;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* --- JSONL --------------------------------------------------------------- */
|
||||
|
||||
char *cst_attachments_to_json(const cst_attachment_t *list, int n) {
|
||||
if (!list || n <= 0)
|
||||
return NULL;
|
||||
cJSON *arr = cJSON_CreateArray();
|
||||
if (!arr)
|
||||
return NULL;
|
||||
for (int i = 0; i < n; i++) {
|
||||
const cst_attachment_t *a = &list[i];
|
||||
cJSON *o = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(o, "id", a->id);
|
||||
cJSON_AddStringToObject(o, "name", a->name);
|
||||
cJSON_AddStringToObject(o, "mime", a->mime);
|
||||
cJSON_AddStringToObject(o, "rel", a->rel);
|
||||
cJSON_AddNumberToObject(o, "bytes", (double)a->bytes);
|
||||
if (a->width > 0 && a->height > 0) {
|
||||
cJSON_AddNumberToObject(o, "width", a->width);
|
||||
cJSON_AddNumberToObject(o, "height", a->height);
|
||||
}
|
||||
if (a->detail[0] && strcmp(a->detail, "auto") != 0)
|
||||
cJSON_AddStringToObject(o, "detail", a->detail);
|
||||
if (a->origin[0])
|
||||
cJSON_AddStringToObject(o, "origin", a->origin);
|
||||
cJSON_AddItemToArray(arr, o);
|
||||
}
|
||||
char *s = cJSON_PrintUnformatted(arr);
|
||||
cJSON_Delete(arr);
|
||||
return s;
|
||||
}
|
||||
|
||||
cst_attachment_t *cst_attachments_from_json(const void *array_json, int *n_out) {
|
||||
if (n_out)
|
||||
*n_out = 0;
|
||||
const cJSON *arr = array_json;
|
||||
if (!cJSON_IsArray(arr))
|
||||
return NULL;
|
||||
int n = cJSON_GetArraySize(arr);
|
||||
if (n <= 0)
|
||||
return NULL;
|
||||
cst_attachment_t *list = calloc((size_t)n, sizeof(*list));
|
||||
if (!list)
|
||||
return NULL;
|
||||
int k = 0;
|
||||
const cJSON *it = NULL;
|
||||
cJSON_ArrayForEach(it, arr) {
|
||||
if (!cJSON_IsObject(it))
|
||||
continue;
|
||||
const cJSON *jid = cJSON_GetObjectItemCaseSensitive(it, "id");
|
||||
const cJSON *jrel = cJSON_GetObjectItemCaseSensitive(it, "rel");
|
||||
if (!cJSON_IsString(jid) || !cJSON_IsString(jrel) ||
|
||||
!cst_attach_rel_ok(jrel->valuestring))
|
||||
continue;
|
||||
cst_attachment_t *a = &list[k];
|
||||
snprintf(a->id, sizeof(a->id), "%s", jid->valuestring);
|
||||
snprintf(a->rel, sizeof(a->rel), "%s", jrel->valuestring);
|
||||
const cJSON *v = cJSON_GetObjectItemCaseSensitive(it, "name");
|
||||
snprintf(a->name, sizeof(a->name), "%s",
|
||||
cJSON_IsString(v) ? v->valuestring : a->id);
|
||||
v = cJSON_GetObjectItemCaseSensitive(it, "mime");
|
||||
snprintf(a->mime, sizeof(a->mime), "%s",
|
||||
cJSON_IsString(v) ? v->valuestring : "image/*");
|
||||
v = cJSON_GetObjectItemCaseSensitive(it, "bytes");
|
||||
a->bytes = cJSON_IsNumber(v) ? (long long)v->valuedouble : 0;
|
||||
v = cJSON_GetObjectItemCaseSensitive(it, "width");
|
||||
a->width = cJSON_IsNumber(v) ? v->valueint : 0;
|
||||
v = cJSON_GetObjectItemCaseSensitive(it, "height");
|
||||
a->height = cJSON_IsNumber(v) ? v->valueint : 0;
|
||||
v = cJSON_GetObjectItemCaseSensitive(it, "detail");
|
||||
snprintf(a->detail, sizeof(a->detail), "%s",
|
||||
cJSON_IsString(v) ? v->valuestring : "auto");
|
||||
v = cJSON_GetObjectItemCaseSensitive(it, "origin");
|
||||
snprintf(a->origin, sizeof(a->origin), "%s",
|
||||
cJSON_IsString(v) ? v->valuestring : "");
|
||||
k++;
|
||||
}
|
||||
if (k == 0) {
|
||||
free(list);
|
||||
return NULL;
|
||||
}
|
||||
if (n_out)
|
||||
*n_out = k;
|
||||
return list;
|
||||
}
|
||||
+482
@@ -0,0 +1,482 @@
|
||||
#include "cst_clipboard.h"
|
||||
#include "cst_attach.h"
|
||||
#include "os_compat.h"
|
||||
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
static void set_err(char *err, size_t err_sz, const char *msg) {
|
||||
if (err && err_sz)
|
||||
snprintf(err, err_sz, "%s", msg);
|
||||
}
|
||||
|
||||
static void put_le32(unsigned char *p, unsigned long v) {
|
||||
p[0] = (unsigned char)(v & 0xff);
|
||||
p[1] = (unsigned char)((v >> 8) & 0xff);
|
||||
p[2] = (unsigned char)((v >> 16) & 0xff);
|
||||
p[3] = (unsigned char)((v >> 24) & 0xff);
|
||||
}
|
||||
|
||||
static void put_be32(unsigned char *p, unsigned long v) {
|
||||
p[0] = (unsigned char)((v >> 24) & 0xff);
|
||||
p[1] = (unsigned char)((v >> 16) & 0xff);
|
||||
p[2] = (unsigned char)((v >> 8) & 0xff);
|
||||
p[3] = (unsigned char)(v & 0xff);
|
||||
}
|
||||
|
||||
static unsigned long get_le32(const unsigned char *p) {
|
||||
return (unsigned long)p[0] | (unsigned long)p[1] << 8 |
|
||||
(unsigned long)p[2] << 16 | (unsigned long)p[3] << 24;
|
||||
}
|
||||
|
||||
static unsigned long crc32_update(unsigned long crc, const unsigned char *p,
|
||||
size_t n) {
|
||||
static unsigned long table[256];
|
||||
static int ready;
|
||||
if (!ready) {
|
||||
for (unsigned long i = 0; i < 256; i++) {
|
||||
unsigned long c = i;
|
||||
for (int k = 0; k < 8; k++)
|
||||
c = c & 1 ? 0xedb88320UL ^ (c >> 1) : c >> 1;
|
||||
table[i] = c;
|
||||
}
|
||||
ready = 1;
|
||||
}
|
||||
crc ^= 0xffffffffUL;
|
||||
for (size_t i = 0; i < n; i++)
|
||||
crc = table[(crc ^ p[i]) & 0xff] ^ (crc >> 8);
|
||||
return crc ^ 0xffffffffUL;
|
||||
}
|
||||
|
||||
static unsigned char *png_chunk(unsigned char *o, const char *type,
|
||||
const unsigned char *data, size_t n) {
|
||||
put_be32(o, (unsigned long)n);
|
||||
memcpy(o + 4, type, 4);
|
||||
if (n)
|
||||
memcpy(o + 8, data, n);
|
||||
put_be32(o + 8 + n, crc32_update(0, o + 4, n + 4));
|
||||
return o + 12 + n;
|
||||
}
|
||||
|
||||
/* RGB rows (filter byte 0 each) in stored deflate blocks: no compressor in
|
||||
* the tree, and clipboard screenshots stay well under the attach cap. */
|
||||
static char *png_from_raw(const unsigned char *raw, size_t raw_n, long w,
|
||||
long h, size_t *n) {
|
||||
size_t blocks = raw_n / 65535 + 1;
|
||||
size_t z_n = 2 + raw_n + blocks * 5 + 4;
|
||||
size_t total = 8 + (12 + 13) + (12 + z_n) + 12;
|
||||
unsigned char *out = malloc(total);
|
||||
unsigned char *z = malloc(z_n);
|
||||
if (!out || !z) {
|
||||
free(out);
|
||||
free(z);
|
||||
return NULL;
|
||||
}
|
||||
unsigned char *q = z;
|
||||
*q++ = 0x78;
|
||||
*q++ = 0x01;
|
||||
unsigned long a = 1, b = 0;
|
||||
size_t left = raw_n, pos = 0;
|
||||
do {
|
||||
size_t len = left > 65535 ? 65535 : left;
|
||||
*q++ = left == len ? 1 : 0;
|
||||
q[0] = (unsigned char)(len & 0xff);
|
||||
q[1] = (unsigned char)(len >> 8);
|
||||
q[2] = (unsigned char)(~len & 0xff);
|
||||
q[3] = (unsigned char)((~len >> 8) & 0xff);
|
||||
q += 4;
|
||||
memcpy(q, raw + pos, len);
|
||||
for (size_t i = 0; i < len; i++) {
|
||||
a = (a + raw[pos + i]) % 65521;
|
||||
b = (b + a) % 65521;
|
||||
}
|
||||
q += len;
|
||||
pos += len;
|
||||
left -= len;
|
||||
} while (left);
|
||||
put_be32(q, b << 16 | a);
|
||||
q += 4;
|
||||
|
||||
unsigned char ihdr[13];
|
||||
put_be32(ihdr, (unsigned long)w);
|
||||
put_be32(ihdr + 4, (unsigned long)h);
|
||||
ihdr[8] = 8; /* bit depth */
|
||||
ihdr[9] = 2; /* RGB */
|
||||
ihdr[10] = ihdr[11] = ihdr[12] = 0;
|
||||
unsigned char *o = out;
|
||||
memcpy(o, "\x89PNG\r\n\x1a\n", 8);
|
||||
o = png_chunk(o + 8, "IHDR", ihdr, sizeof(ihdr));
|
||||
o = png_chunk(o, "IDAT", z, (size_t)(q - z));
|
||||
o = png_chunk(o, "IEND", NULL, 0);
|
||||
free(z);
|
||||
*n = (size_t)(o - out);
|
||||
return (char *)out;
|
||||
}
|
||||
|
||||
/* CF_DIB is a BMP without its 14-byte file header; the pixel offset depends
|
||||
* on the header size, BI_BITFIELDS masks and the color table. */
|
||||
char *cst_dib_to_image(const void *dib_v, size_t sz, size_t *n) {
|
||||
const unsigned char *dib = dib_v;
|
||||
if (!dib || sz < 40)
|
||||
return NULL;
|
||||
unsigned long hsize = get_le32(dib);
|
||||
long w = (long)(int)get_le32(dib + 4);
|
||||
long hh = (long)(int)get_le32(dib + 8);
|
||||
unsigned bits = (unsigned)(dib[14] | dib[15] << 8);
|
||||
unsigned long comp = get_le32(dib + 16);
|
||||
unsigned long used = get_le32(dib + 32);
|
||||
if (hsize < 40 || hsize > sz)
|
||||
return NULL;
|
||||
size_t off = hsize;
|
||||
if (hsize == 40 && comp == 3 /* BI_BITFIELDS */)
|
||||
off += 12;
|
||||
size_t colors = used;
|
||||
if (!colors && bits <= 8)
|
||||
colors = (size_t)1 << bits;
|
||||
if (colors > 256)
|
||||
return NULL;
|
||||
off += colors * 4;
|
||||
if (off > sz)
|
||||
return NULL;
|
||||
|
||||
long h = hh < 0 ? -hh : hh;
|
||||
if ((bits == 24 || bits == 32) && (comp == 0 || comp == 3) && w > 0 &&
|
||||
h > 0 && w <= 32768 && h <= 32768) {
|
||||
size_t stride = ((size_t)w * bits / 8 + 3) & ~(size_t)3;
|
||||
size_t raw_n = (size_t)h * (1 + (size_t)w * 3);
|
||||
if (stride * (size_t)h <= sz - off && raw_n < CST_ATTACH_MAX_BYTES) {
|
||||
unsigned char *raw = malloc(raw_n);
|
||||
if (!raw)
|
||||
return NULL;
|
||||
size_t bpp = bits / 8;
|
||||
for (long y = 0; y < h; y++) {
|
||||
long src_y = hh > 0 ? h - 1 - y : y; /* positive height = bottom-up */
|
||||
const unsigned char *s = dib + off + (size_t)src_y * stride;
|
||||
unsigned char *d = raw + (size_t)y * (1 + (size_t)w * 3);
|
||||
*d++ = 0;
|
||||
for (long x = 0; x < w; x++, s += bpp) {
|
||||
*d++ = s[2];
|
||||
*d++ = s[1];
|
||||
*d++ = s[0];
|
||||
}
|
||||
}
|
||||
char *png = png_from_raw(raw, raw_n, w, h, n);
|
||||
free(raw);
|
||||
return png;
|
||||
}
|
||||
}
|
||||
|
||||
char *out = malloc(14 + sz);
|
||||
if (!out)
|
||||
return NULL;
|
||||
unsigned char *hd = (unsigned char *)out;
|
||||
hd[0] = 'B';
|
||||
hd[1] = 'M';
|
||||
put_le32(hd + 2, (unsigned long)(14 + sz));
|
||||
put_le32(hd + 6, 0);
|
||||
put_le32(hd + 10, (unsigned long)(14 + off));
|
||||
memcpy(out + 14, dib, sz);
|
||||
*n = 14 + sz;
|
||||
return out;
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
|
||||
int cst_clipboard_image(char **data, size_t *n, char *err, size_t err_sz) {
|
||||
*data = NULL;
|
||||
*n = 0;
|
||||
UINT png = RegisterClipboardFormatA("PNG");
|
||||
if (!OpenClipboard(NULL)) {
|
||||
set_err(err, err_sz, "could not open the clipboard");
|
||||
return -1;
|
||||
}
|
||||
HANDLE h = NULL;
|
||||
int is_png = 0;
|
||||
if (png && IsClipboardFormatAvailable(png)) {
|
||||
h = GetClipboardData(png);
|
||||
is_png = 1;
|
||||
} else if (IsClipboardFormatAvailable(CF_DIB)) {
|
||||
h = GetClipboardData(CF_DIB);
|
||||
}
|
||||
const unsigned char *p = h ? GlobalLock(h) : NULL;
|
||||
if (!p) {
|
||||
CloseClipboard();
|
||||
set_err(err, err_sz, "no image on the clipboard");
|
||||
return -1;
|
||||
}
|
||||
size_t sz = (size_t)GlobalSize(h);
|
||||
char *out = NULL;
|
||||
if (sz > CST_ATTACH_MAX_BYTES) {
|
||||
set_err(err, err_sz, "clipboard image is too large");
|
||||
} else if (is_png) {
|
||||
out = malloc(sz ? sz : 1);
|
||||
if (out) {
|
||||
memcpy(out, p, sz);
|
||||
*n = sz;
|
||||
}
|
||||
} else {
|
||||
out = cst_dib_to_image(p, sz, n);
|
||||
if (!out)
|
||||
set_err(err, err_sz, "clipboard bitmap is malformed");
|
||||
}
|
||||
GlobalUnlock(h);
|
||||
CloseClipboard();
|
||||
if (!out)
|
||||
return -1;
|
||||
*data = out;
|
||||
return 0;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
/* Runs cmd (stderr already redirected by the caller); 127 = not installed. */
|
||||
static int run_bytes(const char *cmd, char **data, size_t *n) {
|
||||
os_run_result_t r;
|
||||
memset(&r, 0, sizeof(r));
|
||||
if (os_run_shell_c(NULL, cmd, CST_ATTACH_MAX_BYTES + 1, &r) != 0) {
|
||||
os_run_result_free(&r);
|
||||
return -1;
|
||||
}
|
||||
if (r.exit_code != 0 || r.out_len == 0) {
|
||||
int code = r.exit_code == 127 ? 127 : -1;
|
||||
os_run_result_free(&r);
|
||||
return code;
|
||||
}
|
||||
*data = r.out;
|
||||
*n = r.out_len;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int type_ok(const char *s, size_t n) {
|
||||
if (n < 7 || n > 63 || strncmp(s, "image/", 6) != 0)
|
||||
return 0;
|
||||
for (size_t i = 0; i < n; i++)
|
||||
if (!isalnum((unsigned char)s[i]) && !strchr("/.+-", s[i]))
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Best image MIME type from a newline-separated list: PNG first. */
|
||||
static int pick_type(const char *list, size_t len, char *out, size_t out_sz) {
|
||||
out[0] = 0;
|
||||
size_t i = 0;
|
||||
while (i < len) {
|
||||
size_t j = i;
|
||||
while (j < len && list[j] != '\n' && list[j] != '\r')
|
||||
j++;
|
||||
if (type_ok(list + i, j - i)) {
|
||||
int is_png = j - i == 9 && strncmp(list + i, "image/png", 9) == 0;
|
||||
if (is_png || !out[0])
|
||||
snprintf(out, out_sz, "%.*s", (int)(j - i), list + i);
|
||||
if (is_png)
|
||||
break;
|
||||
}
|
||||
i = j + 1;
|
||||
}
|
||||
return out[0] ? 0 : -1;
|
||||
}
|
||||
|
||||
static int via_lister(const char *list_cmd, const char *get_fmt,
|
||||
const char *tool, char **data, size_t *n, char *err,
|
||||
size_t err_sz) {
|
||||
char *types = NULL;
|
||||
size_t tn = 0;
|
||||
int rc = run_bytes(list_cmd, &types, &tn);
|
||||
if (rc == 127) {
|
||||
char msg[96];
|
||||
snprintf(msg, sizeof(msg), "reading the clipboard needs %s", tool);
|
||||
set_err(err, err_sz, msg);
|
||||
return -1;
|
||||
}
|
||||
char type[64];
|
||||
int ok = rc == 0 && pick_type(types, tn, type, sizeof(type)) == 0;
|
||||
free(types);
|
||||
if (!ok) {
|
||||
set_err(err, err_sz, "no image on the clipboard");
|
||||
return -1;
|
||||
}
|
||||
char cmd[256];
|
||||
snprintf(cmd, sizeof(cmd), get_fmt, type);
|
||||
if (run_bytes(cmd, data, n) != 0) {
|
||||
set_err(err, err_sz, "could not read the clipboard image");
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef __APPLE__
|
||||
static int mac_image(char **data, size_t *n, char *err, size_t err_sz) {
|
||||
int rc = run_bytes("pngpaste - 2>/dev/null", data, n);
|
||||
if (rc == 0)
|
||||
return 0;
|
||||
char path[1024];
|
||||
int fd = os_mkstemp(path, sizeof(path), "cst-clip");
|
||||
if (fd < 0) {
|
||||
set_err(err, err_sz, "could not create a temp file");
|
||||
return -1;
|
||||
}
|
||||
close(fd);
|
||||
char cmd[1600];
|
||||
snprintf(cmd, sizeof(cmd),
|
||||
"osascript -e 'set f to open for access (POSIX file \"%s\") with "
|
||||
"write permission' -e 'set eof f to 0' -e 'write (the clipboard as "
|
||||
"\xc2\xabclass PNGf\xc2\xbb) to f' -e 'close access f' "
|
||||
">/dev/null 2>&1",
|
||||
path);
|
||||
os_run_result_t r;
|
||||
memset(&r, 0, sizeof(r));
|
||||
int ran = os_run_shell_c(NULL, cmd, 4096, &r);
|
||||
int code = r.exit_code;
|
||||
os_run_result_free(&r);
|
||||
char *buf = NULL;
|
||||
size_t len = 0;
|
||||
if (ran == 0 && code == 0) {
|
||||
FILE *f = fopen(path, "rb");
|
||||
if (f) {
|
||||
char chunk[65536];
|
||||
size_t got;
|
||||
while ((got = fread(chunk, 1, sizeof(chunk), f)) > 0 &&
|
||||
len <= CST_ATTACH_MAX_BYTES) {
|
||||
char *nb = realloc(buf, len + got);
|
||||
if (!nb)
|
||||
break;
|
||||
buf = nb;
|
||||
memcpy(buf + len, chunk, got);
|
||||
len += got;
|
||||
}
|
||||
fclose(f);
|
||||
}
|
||||
}
|
||||
remove(path);
|
||||
if (!buf || !len) {
|
||||
free(buf);
|
||||
set_err(err, err_sz, "no image on the clipboard");
|
||||
return -1;
|
||||
}
|
||||
*data = buf;
|
||||
*n = len;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
int cst_clipboard_image(char **data, size_t *n, char *err, size_t err_sz) {
|
||||
*data = NULL;
|
||||
*n = 0;
|
||||
#ifdef __APPLE__
|
||||
return mac_image(data, n, err, err_sz);
|
||||
#else
|
||||
const char *wl = getenv("WAYLAND_DISPLAY");
|
||||
if (wl && *wl)
|
||||
return via_lister("wl-paste --list-types 2>/dev/null",
|
||||
"wl-paste --no-newline --type '%s' 2>/dev/null",
|
||||
"wl-clipboard (wl-paste)", data, n, err, err_sz);
|
||||
const char *x = getenv("DISPLAY");
|
||||
if (x && *x)
|
||||
return via_lister("xclip -selection clipboard -t TARGETS -o 2>/dev/null",
|
||||
"xclip -selection clipboard -t '%s' -o 2>/dev/null",
|
||||
"xclip", data, n, err, err_sz);
|
||||
set_err(err, err_sz, "no clipboard here (no Wayland or X11 display)");
|
||||
return -1;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static int hexval(int c) {
|
||||
if (c >= '0' && c <= '9')
|
||||
return c - '0';
|
||||
if (c >= 'a' && c <= 'f')
|
||||
return c - 'a' + 10;
|
||||
if (c >= 'A' && c <= 'F')
|
||||
return c - 'A' + 10;
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* file://[host]/path -> /path, percent-decoded; 0 on success. */
|
||||
static int from_file_uri(char *s) {
|
||||
const char *p = s + 7;
|
||||
const char *slash = strchr(p, '/');
|
||||
if (!slash)
|
||||
return -1;
|
||||
if (slash != p && !(slash - p == 9 && strncmp(p, "localhost", 9) == 0))
|
||||
return -1;
|
||||
char *o = s;
|
||||
for (const char *q = slash; *q; q++) {
|
||||
if (*q == '%' && hexval(q[1]) >= 0 && hexval(q[2]) >= 0) {
|
||||
*o++ = (char)(hexval(q[1]) * 16 + hexval(q[2]));
|
||||
q += 2;
|
||||
} else {
|
||||
*o++ = *q;
|
||||
}
|
||||
}
|
||||
*o = 0;
|
||||
#ifdef _WIN32
|
||||
if (s[0] == '/' && isalpha((unsigned char)s[1]) && s[2] == ':')
|
||||
memmove(s, s + 1, strlen(s));
|
||||
#endif
|
||||
return s[0] ? 0 : -1;
|
||||
}
|
||||
|
||||
static int is_space(char c) {
|
||||
return c == ' ' || c == '\t' || c == '\r' || c == '\n';
|
||||
}
|
||||
|
||||
int cst_paste_paths(const char *text, size_t len,
|
||||
char out[][CST_PASTE_PATH_MAX], int max) {
|
||||
int n = 0;
|
||||
size_t i = 0;
|
||||
while (i < len) {
|
||||
while (i < len && is_space(text[i]))
|
||||
i++;
|
||||
if (i >= len)
|
||||
break;
|
||||
if (n >= max)
|
||||
return -1;
|
||||
char *tok = out[n];
|
||||
size_t k = 0;
|
||||
char q = 0;
|
||||
while (i < len) {
|
||||
char c = text[i];
|
||||
if (!c)
|
||||
return -1;
|
||||
if (q) {
|
||||
if (c == q) {
|
||||
q = 0;
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
} else {
|
||||
if (c == '\'' || c == '"') {
|
||||
q = c;
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
if (is_space(c))
|
||||
break;
|
||||
#ifndef _WIN32
|
||||
if (c == '\\' && i + 1 < len)
|
||||
c = text[++i];
|
||||
#endif
|
||||
}
|
||||
if (k + 1 >= CST_PASTE_PATH_MAX)
|
||||
return -1;
|
||||
tok[k++] = c;
|
||||
i++;
|
||||
}
|
||||
if (q || !k)
|
||||
return -1;
|
||||
tok[k] = 0;
|
||||
if (strncmp(tok, "file://", 7) == 0 && from_file_uri(tok) != 0)
|
||||
return -1;
|
||||
n++;
|
||||
}
|
||||
return n > 0 ? n : -1;
|
||||
}
|
||||
@@ -48,6 +48,8 @@ static const cst_key_action_info_t INFO[CST_KA_COUNT] = {
|
||||
[CST_KA_COPY] = {"copy", "Session", "copy the last reply", "/copy"},
|
||||
[CST_KA_EXPORT] = {"export", "Session", "export the transcript",
|
||||
"/export"},
|
||||
[CST_KA_PASTE_IMAGE] = {"paste_image", "Session",
|
||||
"attach the clipboard image", "/attach paste"},
|
||||
[CST_KA_MODEL] = {"model", "Model", "pick the model", "/model"},
|
||||
[CST_KA_PROVIDER] = {"provider", "Model", "switch provider", "/provider"},
|
||||
[CST_KA_EFFORT] = {"effort", "Model", "reasoning effort", "/effort"},
|
||||
@@ -89,6 +91,7 @@ static const struct {
|
||||
{CST_KA_COMPACT, "<leader> c"},
|
||||
{CST_KA_COPY, "<leader> y"},
|
||||
{CST_KA_EXPORT, "<leader> x"},
|
||||
{CST_KA_PASTE_IMAGE, "ctrl+v"},
|
||||
{CST_KA_MODEL, "<leader> m"},
|
||||
{CST_KA_PROVIDER, "<leader> p"},
|
||||
{CST_KA_EFFORT, "<leader> e"},
|
||||
|
||||
+444
-26
@@ -61,6 +61,9 @@ static void llm_apply_ca_bundle(CURL *curl) {
|
||||
#endif
|
||||
}
|
||||
|
||||
#include "cst_attach.h"
|
||||
#include "cst_models.h"
|
||||
|
||||
/* --- wire body ----------------------------------------------------------- */
|
||||
|
||||
static size_t wire_tool_cap(const cst_llm_request_t *req) {
|
||||
@@ -116,6 +119,210 @@ static cJSON *clean_string(const char *s, size_t cap) {
|
||||
return j;
|
||||
}
|
||||
|
||||
/* --- multimodal content --------------------------------------------------
|
||||
* OpenAI-compatible servers take a parts array where a plain string is also
|
||||
* accepted, so text-only messages keep the string form and only those with
|
||||
* images switch to parts. Images live in the session store and are read (and
|
||||
* base64'd) here, once per request. */
|
||||
|
||||
/* The message's "content" as a parts array, converting a string in place. */
|
||||
static cJSON *content_parts(cJSON *msg) {
|
||||
cJSON *c = cJSON_GetObjectItemCaseSensitive(msg, "content");
|
||||
if (cJSON_IsArray(c))
|
||||
return c;
|
||||
cJSON *arr = cJSON_CreateArray();
|
||||
if (cJSON_IsString(c)) {
|
||||
cJSON *t = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(t, "type", "text");
|
||||
cJSON_AddStringToObject(t, "text", c->valuestring);
|
||||
cJSON_AddItemToArray(arr, t);
|
||||
}
|
||||
cJSON_ReplaceItemInObjectCaseSensitive(msg, "content", arr);
|
||||
return arr;
|
||||
}
|
||||
|
||||
/* Append text, joining it onto a trailing text part when there is one.
|
||||
* Takes ownership of txt. */
|
||||
static void parts_add_text(cJSON *parts, cJSON *txt) {
|
||||
if (!txt)
|
||||
txt = cJSON_CreateString("");
|
||||
cJSON *last = cJSON_GetArrayItem(parts, cJSON_GetArraySize(parts) - 1);
|
||||
const cJSON *lt = last ? cJSON_GetObjectItemCaseSensitive(last, "type") : NULL;
|
||||
if (cJSON_IsString(lt) && strcmp(lt->valuestring, "text") == 0) {
|
||||
const cJSON *old = cJSON_GetObjectItemCaseSensitive(last, "text");
|
||||
cst_buf_t b = {0};
|
||||
if (cJSON_IsString(old))
|
||||
cst_buf_puts(&b, old->valuestring);
|
||||
if (b.len)
|
||||
cst_buf_puts(&b, "\n\n");
|
||||
cst_buf_puts(&b, txt->valuestring ? txt->valuestring : "");
|
||||
cJSON_ReplaceItemInObjectCaseSensitive(
|
||||
last, "text", cJSON_CreateString(b.buf ? b.buf : ""));
|
||||
cst_buf_free(&b);
|
||||
cJSON_Delete(txt);
|
||||
return;
|
||||
}
|
||||
cJSON_AddItemToArray(parts, txt);
|
||||
}
|
||||
|
||||
/* One stored image as an image_url part, or NULL with why filled in. */
|
||||
static cJSON *image_part(const cst_llm_request_t *req,
|
||||
const cst_attachment_t *a, size_t *budget, char *why,
|
||||
size_t why_sz) {
|
||||
why[0] = 0;
|
||||
if (!req->session_path || !req->session_path[0]) {
|
||||
snprintf(why, why_sz, "there is no session store to read it from");
|
||||
return NULL;
|
||||
}
|
||||
char err[256];
|
||||
size_t n = 0;
|
||||
char *data = cst_attach_read(req->session_path, a, &n, err, sizeof(err));
|
||||
if (!data) {
|
||||
snprintf(why, why_sz, "%s", err);
|
||||
return NULL;
|
||||
}
|
||||
if (n > *budget) {
|
||||
snprintf(why, why_sz, "%d KB left in the %d MB image budget",
|
||||
(int)(*budget / 1024), (int)(CST_ATTACH_MAX_TOTAL >> 20));
|
||||
free(data);
|
||||
return NULL;
|
||||
}
|
||||
*budget -= n;
|
||||
char mime[32];
|
||||
cst_attach_sniff(data, n, mime, sizeof(mime)); /* read verified it */
|
||||
char *b64 = cst_base64_encode(data, n);
|
||||
free(data);
|
||||
if (!b64) {
|
||||
snprintf(why, why_sz, "out of memory");
|
||||
return NULL;
|
||||
}
|
||||
cst_buf_t b = {0};
|
||||
cst_buf_puts(&b, "data:");
|
||||
cst_buf_puts(&b, mime);
|
||||
cst_buf_puts(&b, ";base64,");
|
||||
cst_buf_puts(&b, b64);
|
||||
free(b64);
|
||||
if (!b.buf) {
|
||||
snprintf(why, why_sz, "out of memory");
|
||||
return NULL;
|
||||
}
|
||||
cJSON *p = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(p, "type", "image_url");
|
||||
cJSON *iu = cJSON_AddObjectToObject(p, "image_url");
|
||||
cJSON_AddStringToObject(iu, "url", b.buf);
|
||||
if (a->detail[0] && strcmp(a->detail, "auto") != 0)
|
||||
cJSON_AddStringToObject(iu, "detail", a->detail);
|
||||
cst_buf_free(&b);
|
||||
return p;
|
||||
}
|
||||
|
||||
/* Append every attachment of m as image parts (or a note saying why not). */
|
||||
static void parts_add_images(const cst_llm_request_t *req, cJSON *parts,
|
||||
const cst_message_t *m, size_t *budget) {
|
||||
int n = m->nattach;
|
||||
if (n > CST_ATTACH_MAX_COUNT) {
|
||||
char note[160];
|
||||
snprintf(note, sizeof(note), "[%d of %d images sent]", CST_ATTACH_MAX_COUNT,
|
||||
n);
|
||||
parts_add_text(parts, cJSON_CreateString(note));
|
||||
n = CST_ATTACH_MAX_COUNT;
|
||||
}
|
||||
for (int i = 0; i < n; i++) {
|
||||
const cst_attachment_t *a = &m->attach[i];
|
||||
char why[256];
|
||||
cJSON *p = image_part(req, a, budget, why, sizeof(why));
|
||||
if (p) {
|
||||
cJSON_AddItemToArray(parts, p);
|
||||
continue;
|
||||
}
|
||||
char note[512];
|
||||
snprintf(note, sizeof(note), "[image \"%.120s\" not sent: %.200s]",
|
||||
a->name, why);
|
||||
parts_add_text(parts, cJSON_CreateString(note));
|
||||
}
|
||||
}
|
||||
|
||||
/* Images a tool result produced are deferred: an assistant tool_call must be
|
||||
* answered by tool messages only, so they ride in one extra user message
|
||||
* after the run of tool messages ends. *pending collects it. */
|
||||
static void defer_images(const cst_llm_request_t *req, const cst_message_t *m,
|
||||
cJSON **pending, size_t *budget) {
|
||||
cJSON *p = *pending;
|
||||
if (!p) {
|
||||
p = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(p, "role", "user");
|
||||
cJSON_AddArrayToObject(p, "content");
|
||||
*pending = p;
|
||||
}
|
||||
parts_add_images(req, cJSON_GetObjectItemCaseSensitive(p, "content"), m,
|
||||
budget);
|
||||
}
|
||||
|
||||
/* m's text plus one line per image it would have carried (malloc'd). */
|
||||
static char *image_notes(const cst_message_t *m, const char *why) {
|
||||
cst_buf_t b = {0};
|
||||
cst_buf_puts(&b, m->content ? m->content : "");
|
||||
for (int i = 0; i < m->nattach; i++) {
|
||||
char d[128];
|
||||
cst_attach_describe(&m->attach[i], d, sizeof(d));
|
||||
cst_buf_printf(&b, "%s[image \"%.120s\" (%s) not sent: %s]",
|
||||
b.len ? "\n" : "", m->attach[i].name, d, why);
|
||||
}
|
||||
return cst_buf_steal(&b);
|
||||
}
|
||||
|
||||
/* --- cache breakpoints (Anthropic-style) ----------------------------------
|
||||
* At most 4 per request. The system prompt one also covers tools[]; the
|
||||
* newest message one moves forward every step; the newest real user message
|
||||
* keeps a hit when a long tool run pushes the previous one out of the
|
||||
* provider's lookback. */
|
||||
|
||||
static void mark_message(cJSON *msg, const char *ttl) {
|
||||
const cJSON *c = cJSON_GetObjectItemCaseSensitive(msg, "content");
|
||||
if (cJSON_IsString(c) ? !c->valuestring[0] : !cJSON_IsArray(c))
|
||||
return;
|
||||
cJSON *parts = content_parts(msg);
|
||||
cJSON *last = cJSON_GetArrayItem(parts, cJSON_GetArraySize(parts) - 1);
|
||||
if (!cJSON_IsObject(last) ||
|
||||
cJSON_GetObjectItemCaseSensitive(last, "cache_control"))
|
||||
return;
|
||||
cJSON *cc = cJSON_AddObjectToObject(last, "cache_control");
|
||||
cJSON_AddStringToObject(cc, "type", "ephemeral");
|
||||
if (ttl && ttl[0])
|
||||
cJSON_AddStringToObject(cc, "ttl", ttl);
|
||||
}
|
||||
|
||||
static int msg_role_is(const cJSON *msg, const char *role) {
|
||||
const cJSON *r = cJSON_GetObjectItemCaseSensitive(msg, "role");
|
||||
return cJSON_IsString(r) && strcmp(r->valuestring, role) == 0;
|
||||
}
|
||||
|
||||
static int msg_has_content(const cJSON *msg) {
|
||||
const cJSON *c = cJSON_GetObjectItemCaseSensitive(msg, "content");
|
||||
return cJSON_IsString(c) ? c->valuestring[0] != 0 : cJSON_IsArray(c);
|
||||
}
|
||||
|
||||
static void cache_marks(cJSON *msgs, const char *ttl) {
|
||||
int n = cJSON_GetArraySize(msgs);
|
||||
cJSON *first = cJSON_GetArrayItem(msgs, 0);
|
||||
if (first && msg_role_is(first, "system"))
|
||||
mark_message(first, ttl);
|
||||
int last = -1;
|
||||
for (int i = n - 1; i > 0 && last < 0; i--)
|
||||
if (msg_has_content(cJSON_GetArrayItem(msgs, i)))
|
||||
last = i;
|
||||
if (last < 0)
|
||||
return;
|
||||
mark_message(cJSON_GetArrayItem(msgs, last), ttl);
|
||||
for (int i = last - 1; i > 0; i--) {
|
||||
cJSON *m = cJSON_GetArrayItem(msgs, i);
|
||||
if (msg_role_is(m, "user") && msg_has_content(m)) {
|
||||
mark_message(m, ttl);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static const char *role_api(cst_role_t r) {
|
||||
switch (r) {
|
||||
case CST_ROLE_SYSTEM:
|
||||
@@ -146,34 +353,80 @@ char *cst_llm_build_body(const cst_llm_request_t *req) {
|
||||
cJSON *msgs = cJSON_AddArrayToObject(root, "messages");
|
||||
size_t tcap = wire_tool_cap(req);
|
||||
cJSON *prev_user = NULL; /* merge consecutive user messages */
|
||||
cJSON *pending = NULL; /* images from tool results, waiting for a break */
|
||||
size_t img_budget = CST_ATTACH_MAX_TOTAL;
|
||||
const char *noimg = getenv("CST_NO_IMAGES");
|
||||
const char *img_off =
|
||||
noimg && noimg[0] && noimg[0] != '0'
|
||||
? "image sending is disabled (CST_NO_IMAGES)"
|
||||
: req->images_off ? "this model does not take images"
|
||||
: NULL;
|
||||
|
||||
for (int i = 0; i < req->nmsgs; i++) {
|
||||
const cst_message_t *m = &req->msgs[i];
|
||||
cst_message_t mm = req->msgs[i];
|
||||
const cst_message_t *m = &mm;
|
||||
cst_role_t role = m->role;
|
||||
if (role == CST_ROLE_TOOL && !m->tool_call_id[0])
|
||||
role = CST_ROLE_USER;
|
||||
int has_img = m->attach && m->nattach > 0;
|
||||
char *noted = NULL;
|
||||
if (has_img && img_off) {
|
||||
/* plain text: text-only APIs may refuse content arrays */
|
||||
noted = image_notes(m, img_off);
|
||||
if (noted)
|
||||
mm.content = noted;
|
||||
has_img = 0;
|
||||
}
|
||||
|
||||
/* Every tool_call must be answered by tool messages, so tool-produced
|
||||
* images only leave the queue when the run of tool results is over. */
|
||||
if (role != CST_ROLE_TOOL && pending) {
|
||||
cJSON_AddItemToArray(msgs, pending);
|
||||
prev_user = pending;
|
||||
pending = NULL;
|
||||
}
|
||||
|
||||
if (role == CST_ROLE_USER) {
|
||||
/* Text-protocol result frames are capped by the agent before framing
|
||||
* (their byte counts must stay exact), so never cap user text here. */
|
||||
cJSON *c = clean_string(m->content, 0);
|
||||
if (prev_user) {
|
||||
cJSON *pc = cJSON_GetObjectItemCaseSensitive(prev_user, "content");
|
||||
cst_buf_t b = {0};
|
||||
cst_buf_puts(&b, pc->valuestring);
|
||||
cst_buf_puts(&b, "\n\n");
|
||||
cst_buf_puts(&b, c->valuestring);
|
||||
cJSON_ReplaceItemInObjectCaseSensitive(prev_user, "content",
|
||||
cJSON_CreateString(b.buf));
|
||||
cst_buf_free(&b);
|
||||
cJSON_Delete(c);
|
||||
cJSON *pc = prev_user
|
||||
? cJSON_GetObjectItemCaseSensitive(prev_user, "content")
|
||||
: NULL;
|
||||
if (!has_img && !cJSON_IsArray(pc)) {
|
||||
cJSON *c = clean_string(m->content, 0);
|
||||
if (prev_user) {
|
||||
cst_buf_t b = {0};
|
||||
cst_buf_puts(&b, pc->valuestring);
|
||||
cst_buf_puts(&b, "\n\n");
|
||||
cst_buf_puts(&b, c->valuestring);
|
||||
cJSON_ReplaceItemInObjectCaseSensitive(prev_user, "content",
|
||||
cJSON_CreateString(b.buf));
|
||||
cst_buf_free(&b);
|
||||
cJSON_Delete(c);
|
||||
free(noted);
|
||||
continue;
|
||||
}
|
||||
cJSON *o = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(o, "role", "user");
|
||||
cJSON_AddItemToObject(o, "content", c);
|
||||
cJSON_AddItemToArray(msgs, o);
|
||||
prev_user = o;
|
||||
free(noted);
|
||||
continue;
|
||||
}
|
||||
cJSON *o = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(o, "role", "user");
|
||||
cJSON_AddItemToObject(o, "content", c);
|
||||
cJSON_AddItemToArray(msgs, o);
|
||||
prev_user = o;
|
||||
cJSON *o = prev_user;
|
||||
if (!o) {
|
||||
o = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(o, "role", "user");
|
||||
cJSON_AddArrayToObject(o, "content");
|
||||
cJSON_AddItemToArray(msgs, o);
|
||||
prev_user = o;
|
||||
}
|
||||
cJSON *parts = content_parts(o);
|
||||
parts_add_text(parts, clean_string(m->content, 0));
|
||||
if (has_img)
|
||||
parts_add_images(req, parts, m, &img_budget);
|
||||
free(noted);
|
||||
continue;
|
||||
}
|
||||
prev_user = NULL;
|
||||
@@ -198,17 +451,39 @@ char *cst_llm_build_body(const cst_llm_request_t *req) {
|
||||
} else {
|
||||
cJSON_AddItemToObject(o, "content", clean_string(m->content, 0));
|
||||
}
|
||||
if (role == CST_ROLE_ASSISTANT) {
|
||||
if (req->send_reasoning && m->reasoning && m->reasoning[0])
|
||||
cJSON_AddItemToObject(o, "reasoning_content",
|
||||
clean_string(m->reasoning, 0));
|
||||
if (m->prefix)
|
||||
cJSON_AddTrueToObject(o, "prefix");
|
||||
}
|
||||
cJSON_AddItemToArray(msgs, o);
|
||||
if (role == CST_ROLE_TOOL && has_img)
|
||||
defer_images(req, m, &pending, &img_budget);
|
||||
free(noted);
|
||||
}
|
||||
if (pending)
|
||||
cJSON_AddItemToArray(msgs, pending);
|
||||
|
||||
if (req->enable_tools) {
|
||||
cJSON *tools = cst_tools_schema_cfg(req->tool_cfg);
|
||||
cJSON *tools = req->tools_json ? cJSON_Parse(req->tools_json)
|
||||
: cst_tools_schema_cfg(req->tool_cfg);
|
||||
if (tools) {
|
||||
cJSON_AddItemToObject(root, "tools", tools);
|
||||
cJSON_AddStringToObject(root, "tool_choice",
|
||||
req->tool_choice_none ? "none" : "auto");
|
||||
}
|
||||
}
|
||||
if (req->cache_style == CST_CACHE_OPENAI && req->cache_key &&
|
||||
req->cache_key[0]) {
|
||||
cJSON_AddStringToObject(root, "prompt_cache_key", req->cache_key);
|
||||
const char *ret = getenv("CST_CACHE_RETENTION");
|
||||
if (ret && ret[0])
|
||||
cJSON_AddStringToObject(root, "prompt_cache_retention", ret);
|
||||
} else if (req->cache_style == CST_CACHE_ANTHROPIC) {
|
||||
cache_marks(msgs, req->cache_ttl);
|
||||
}
|
||||
char *out = cJSON_PrintUnformatted(root);
|
||||
cJSON_Delete(root);
|
||||
return out;
|
||||
@@ -371,11 +646,22 @@ static void handle_payload(sse_t *s, const char *payload) {
|
||||
const cJSON *pt = cJSON_GetObjectItemCaseSensitive(usage, "prompt_tokens");
|
||||
const cJSON *ct =
|
||||
cJSON_GetObjectItemCaseSensitive(usage, "completion_tokens");
|
||||
/* DeepSeek: prompt_cache_hit/miss_tokens. OpenAI and routers:
|
||||
* prompt_tokens_details.cached_tokens (+ cache_write_tokens).
|
||||
* Anthropic fields passed through: cache_read/creation_input_tokens. */
|
||||
const cJSON *hit =
|
||||
cJSON_GetObjectItemCaseSensitive(usage, "prompt_cache_hit_tokens");
|
||||
const cJSON *miss =
|
||||
cJSON_GetObjectItemCaseSensitive(usage, "prompt_cache_miss_tokens");
|
||||
const cJSON *det =
|
||||
cJSON_GetObjectItemCaseSensitive(usage, "prompt_tokens_details");
|
||||
const cJSON *cached = cJSON_GetObjectItemCaseSensitive(det, "cached_tokens");
|
||||
const cJSON *dwrite =
|
||||
cJSON_GetObjectItemCaseSensitive(det, "cache_write_tokens");
|
||||
const cJSON *aread =
|
||||
cJSON_GetObjectItemCaseSensitive(usage, "cache_read_input_tokens");
|
||||
const cJSON *awrite =
|
||||
cJSON_GetObjectItemCaseSensitive(usage, "cache_creation_input_tokens");
|
||||
if (cJSON_IsNumber(pt))
|
||||
s->st->prompt_tokens = (long)pt->valuedouble;
|
||||
if (cJSON_IsNumber(ct))
|
||||
@@ -384,6 +670,19 @@ static void handle_payload(sse_t *s, const char *payload) {
|
||||
s->st->cached_tokens = (long)hit->valuedouble;
|
||||
else if (cJSON_IsNumber(cached))
|
||||
s->st->cached_tokens = (long)cached->valuedouble;
|
||||
else if (cJSON_IsNumber(aread))
|
||||
s->st->cached_tokens = (long)aread->valuedouble;
|
||||
if (cJSON_IsNumber(dwrite))
|
||||
s->st->cache_write_tokens = (long)dwrite->valuedouble;
|
||||
else if (cJSON_IsNumber(awrite))
|
||||
s->st->cache_write_tokens = (long)awrite->valuedouble;
|
||||
if (cJSON_IsNumber(miss)) {
|
||||
s->st->cache_miss_tokens = (long)miss->valuedouble;
|
||||
} else {
|
||||
long m = s->st->prompt_tokens - s->st->cached_tokens -
|
||||
s->st->cache_write_tokens;
|
||||
s->st->cache_miss_tokens = m > 0 ? m : 0;
|
||||
}
|
||||
}
|
||||
const cJSON *choices = cJSON_GetObjectItemCaseSensitive(root, "choices");
|
||||
const cJSON *ch = cJSON_IsArray(choices) ? cJSON_GetArrayItem(choices, 0)
|
||||
@@ -526,15 +825,37 @@ static void trace_path(const char *dir, int seq, const char *ext, char *out,
|
||||
snprintf(out, n, "%s/%04d.%s", dir, seq, ext);
|
||||
}
|
||||
|
||||
static void format_http_error(sse_t *s, long http, char *err, size_t err_sz);
|
||||
|
||||
/* NNNN.sse is fed as the stream; with an NNNN.status other than 200 it is
|
||||
* the error body of that HTTP status instead. */
|
||||
static int replay_run(sse_t *s, const char *dir, int seq, char *err,
|
||||
size_t err_sz) {
|
||||
char path[OS_PATH_MAX];
|
||||
trace_path(dir, seq, "status", path, sizeof(path));
|
||||
FILE *sf = fopen(path, "rb");
|
||||
long status = 200;
|
||||
if (sf) {
|
||||
if (fscanf(sf, "%ld", &status) != 1)
|
||||
status = 200;
|
||||
fclose(sf);
|
||||
}
|
||||
trace_path(dir, seq, "sse", path, sizeof(path));
|
||||
FILE *fp = fopen(path, "rb");
|
||||
if (!fp) {
|
||||
snprintf(err, err_sz, "replay: missing %s", path);
|
||||
return -1;
|
||||
}
|
||||
if (status != 200) {
|
||||
char eb[4096];
|
||||
size_t got = fread(eb, 1, sizeof(eb), fp);
|
||||
fclose(fp);
|
||||
cst_buf_append(&s->errbody, eb, got);
|
||||
if (s->st)
|
||||
s->st->http_status = status;
|
||||
format_http_error(s, status, err, err_sz);
|
||||
return -1;
|
||||
}
|
||||
size_t chunk = 16;
|
||||
const char *e = getenv("CST_REPLAY_CHUNK");
|
||||
if (e && atoi(e) > 0)
|
||||
@@ -742,7 +1063,7 @@ finish:
|
||||
|
||||
/* --- model listing -------------------------------------------------------- */
|
||||
|
||||
#define MODELS_BODY_MAX (2 * 1024 * 1024)
|
||||
#define MODELS_BODY_MAX (8 * 1024 * 1024)
|
||||
|
||||
static size_t models_write_cb(char *ptr, size_t size, size_t nmemb, void *ud) {
|
||||
cst_buf_t *b = ud;
|
||||
@@ -752,18 +1073,97 @@ static size_t models_write_cb(char *ptr, size_t size, size_t nmemb, void *ud) {
|
||||
return n;
|
||||
}
|
||||
|
||||
static int add_model(char out[][128], int n, int max_out, const char *id) {
|
||||
if (!id || !id[0] || n >= max_out || strlen(id) >= 128)
|
||||
/* A number, or a numeric string (OpenRouter prices are strings). */
|
||||
static int json_num(const cJSON *v, double *out) {
|
||||
if (cJSON_IsNumber(v)) {
|
||||
*out = v->valuedouble;
|
||||
return 0;
|
||||
}
|
||||
if (cJSON_IsString(v) && v->valuestring[0]) {
|
||||
char *end;
|
||||
double d = strtod(v->valuestring, &end);
|
||||
if (end != v->valuestring && !*end) {
|
||||
*out = d;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int has_image(const cJSON *arr) {
|
||||
const cJSON *x;
|
||||
cJSON_ArrayForEach(x, arr) {
|
||||
if (cJSON_IsString(x) && strcmp(x->valuestring, "image") == 0)
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Optional OpenRouter-style metadata: context_length (or context_window /
|
||||
* max_model_len), architecture.input_modalities, modalities, and pricing in
|
||||
* USD per token. */
|
||||
static void model_meta(const cJSON *it, cst_model_meta_t *m) {
|
||||
static const char *const ctx_keys[] = {"context_length", "context_window",
|
||||
"max_model_len"};
|
||||
for (size_t k = 0; k < sizeof(ctx_keys) / sizeof(ctx_keys[0]); k++) {
|
||||
double d;
|
||||
if (json_num(cJSON_GetObjectItemCaseSensitive(it, ctx_keys[k]), &d) == 0 &&
|
||||
d > 0) {
|
||||
m->context = (long)d;
|
||||
break;
|
||||
}
|
||||
}
|
||||
const cJSON *arch = cJSON_GetObjectItemCaseSensitive(it, "architecture");
|
||||
const cJSON *in = cJSON_GetObjectItemCaseSensitive(arch, "input_modalities");
|
||||
const cJSON *mods = cJSON_GetObjectItemCaseSensitive(it, "modalities");
|
||||
if (cJSON_IsObject(mods))
|
||||
mods = cJSON_GetObjectItemCaseSensitive(mods, "input");
|
||||
const cJSON *modality = cJSON_GetObjectItemCaseSensitive(arch, "modality");
|
||||
if (cJSON_IsArray(in))
|
||||
m->vision = has_image(in);
|
||||
else if (cJSON_IsArray(mods))
|
||||
m->vision = has_image(mods);
|
||||
else if (cJSON_IsString(modality)) {
|
||||
const char *arrow = strstr(modality->valuestring, "->");
|
||||
size_t l = arrow ? (size_t)(arrow - modality->valuestring)
|
||||
: strlen(modality->valuestring);
|
||||
char left[64];
|
||||
snprintf(left, sizeof(left), "%.*s", (int)l, modality->valuestring);
|
||||
m->vision = strstr(left, "image") != NULL;
|
||||
}
|
||||
const cJSON *pr = cJSON_GetObjectItemCaseSensitive(it, "pricing");
|
||||
double miss, out;
|
||||
if (json_num(cJSON_GetObjectItemCaseSensitive(pr, "prompt"), &miss) == 0 &&
|
||||
json_num(cJSON_GetObjectItemCaseSensitive(pr, "completion"), &out) == 0 &&
|
||||
miss >= 0 && out >= 0) {
|
||||
double hit = miss, write = miss;
|
||||
json_num(cJSON_GetObjectItemCaseSensitive(pr, "input_cache_read"), &hit);
|
||||
json_num(cJSON_GetObjectItemCaseSensitive(pr, "input_cache_write"), &write);
|
||||
m->has_price = 1;
|
||||
m->miss = miss * 1e6;
|
||||
m->out = out * 1e6;
|
||||
m->hit = (hit >= 0 ? hit : miss) * 1e6;
|
||||
m->write = (write >= 0 ? write : miss) * 1e6;
|
||||
}
|
||||
}
|
||||
|
||||
static int add_model(cst_model_meta_t *out, int n, int max_out,
|
||||
const char *id, const cJSON *it) {
|
||||
if (!id || !id[0] || n >= max_out || strlen(id) >= sizeof(out->id))
|
||||
return n;
|
||||
for (int i = 0; i < n; i++)
|
||||
if (strcmp(out[i], id) == 0)
|
||||
if (strcmp(out[i].id, id) == 0)
|
||||
return n;
|
||||
snprintf(out[n], 128, "%s", id);
|
||||
memset(&out[n], 0, sizeof(out[n]));
|
||||
out[n].vision = -1;
|
||||
snprintf(out[n].id, sizeof(out[n].id), "%s", id);
|
||||
if (cJSON_IsObject(it))
|
||||
model_meta(it, &out[n]);
|
||||
return n + 1;
|
||||
}
|
||||
|
||||
/* {"data":[{"id":..}]}, {"models":[{"id"|"name":..}]} or a bare array. */
|
||||
static int parse_models(const char *json, char out[][128], int max_out) {
|
||||
static int parse_models(const char *json, cst_model_meta_t *out, int max_out) {
|
||||
cJSON *root = cJSON_Parse(json);
|
||||
if (!root)
|
||||
return -1;
|
||||
@@ -781,9 +1181,9 @@ static int parse_models(const char *json, char out[][128], int max_out) {
|
||||
if (!cJSON_IsString(id))
|
||||
id = cJSON_GetObjectItemCaseSensitive(it, "name");
|
||||
if (cJSON_IsString(id))
|
||||
n = add_model(out, n, max_out, id->valuestring);
|
||||
n = add_model(out, n, max_out, id->valuestring, it);
|
||||
else if (cJSON_IsString(it))
|
||||
n = add_model(out, n, max_out, it->valuestring);
|
||||
n = add_model(out, n, max_out, it->valuestring, NULL);
|
||||
}
|
||||
}
|
||||
cJSON_Delete(root);
|
||||
@@ -793,6 +1193,24 @@ static int parse_models(const char *json, char out[][128], int max_out) {
|
||||
int cst_llm_list_models(const char *api_base, const char *api_key,
|
||||
char out[][128], int max_out, char *err,
|
||||
size_t err_sz) {
|
||||
if (!out || max_out <= 0)
|
||||
return cst_llm_list_models_meta(api_base, api_key, NULL, 0, err, err_sz);
|
||||
cst_model_meta_t *m = calloc((size_t)max_out, sizeof(*m));
|
||||
if (!m) {
|
||||
if (err && err_sz)
|
||||
snprintf(err, err_sz, "out of memory");
|
||||
return -1;
|
||||
}
|
||||
int n = cst_llm_list_models_meta(api_base, api_key, m, max_out, err, err_sz);
|
||||
for (int i = 0; i < n; i++)
|
||||
snprintf(out[i], 128, "%s", m[i].id);
|
||||
free(m);
|
||||
return n;
|
||||
}
|
||||
|
||||
int cst_llm_list_models_meta(const char *api_base, const char *api_key,
|
||||
cst_model_meta_t *out, int max_out, char *err,
|
||||
size_t err_sz) {
|
||||
char dummy[8];
|
||||
if (!err || !err_sz) {
|
||||
err = dummy;
|
||||
|
||||
+82
-4
@@ -1,5 +1,6 @@
|
||||
#include "cst_agent.h"
|
||||
#include "cst_ext.h"
|
||||
#include "cst_models.h"
|
||||
#include "cst_tools.h"
|
||||
#include "cst_version.h"
|
||||
#include "os_compat.h"
|
||||
@@ -29,6 +30,8 @@ static void usage(const char *argv0) {
|
||||
" -N, --new start a new session\n"
|
||||
" -R, --resume ID open a session by id or unique prefix\n"
|
||||
" -L, --list-sessions list sessions and exit\n"
|
||||
" --list-models [P] what is known about each provider's models\n"
|
||||
" (built-in, <config>/models.json, GET /models)\n"
|
||||
" -A, --approval MODE ask | auto (default: edits run, shell in\n"
|
||||
" the sandbox or by safe rules) | yolo\n"
|
||||
" -y, --yolo same as --approval yolo (this run only)\n"
|
||||
@@ -81,6 +84,62 @@ static int parse_confirm(const char *s, cst_agent_config_t *cfg) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void list_one_model(const char *provider, const char *id,
|
||||
const char *where) {
|
||||
cst_model_info_t mi;
|
||||
cst_model_info(provider, id, &mi);
|
||||
char tag[48], price[128] = "";
|
||||
cst_model_info_label(&mi, tag, sizeof(tag));
|
||||
if (mi.has_price)
|
||||
snprintf(price, sizeof(price), " %s%g/%g/%g per 1M (miss/hit/out)",
|
||||
mi.price.currency, mi.price.miss, mi.price.hit, mi.price.out);
|
||||
printf(" %-40s %-18s %-8s%s [%s]\n", id, tag, where, price, mi.source);
|
||||
}
|
||||
|
||||
/* --list-models [provider]: the merged registry, to check models.json. */
|
||||
static int list_models(const char *only) {
|
||||
char user[1100] = "";
|
||||
cst_models_user_path(user, sizeof(user));
|
||||
FILE *uf = user[0] ? fopen(user, "rb") : NULL;
|
||||
printf("user file: %s%s\n", user[0] ? user : "(no config dir)",
|
||||
uf ? "" : " (none)");
|
||||
if (uf)
|
||||
fclose(uf);
|
||||
if (cst_models_load_error()[0])
|
||||
printf("warning: %s\n", cst_models_load_error());
|
||||
int shown = 0;
|
||||
static cst_model_meta_t cached[1024];
|
||||
for (int i = 0; i < cst_provider_count(); i++) {
|
||||
const cst_provider_t *p = cst_provider_at(i);
|
||||
if (only && only[0] && strcmp(p->name, only) != 0)
|
||||
continue;
|
||||
shown++;
|
||||
printf("\n%s %s (%s; key %s)\n", p->name, p->api_base,
|
||||
cst_provider_source(p), p->key_env[0] ? p->key_env : "-");
|
||||
char listed[16][128];
|
||||
int nl = cst_provider_models(p, listed, 16);
|
||||
for (int k = 0; k < nl; k++)
|
||||
list_one_model(p->name, listed[k],
|
||||
strcmp(listed[k], p->model) == 0 ? "default" : "listed");
|
||||
long age = 0;
|
||||
int nc = cst_models_cache_load(p->name, cached, 1024, &age);
|
||||
if (nc > 0) {
|
||||
printf(" -- %d from GET /models, fetched %ldh ago%s\n", nc,
|
||||
age / 3600, age >= CST_MODELS_CACHE_TTL ? " (stale)" : "");
|
||||
for (int k = 0; k < nc; k++)
|
||||
list_one_model(p->name, cached[k].id, "api");
|
||||
} else if (!nl) {
|
||||
printf(" (no models listed; the first one GET /models returns is "
|
||||
"used)\n");
|
||||
}
|
||||
}
|
||||
if (only && only[0] && !shown) {
|
||||
fprintf(stderr, "unknown provider: %s\n", only);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int list_sessions(const char *ws) {
|
||||
static char ids[200][128];
|
||||
int n = cst_agent_store_list(ws, ids, 200);
|
||||
@@ -286,6 +345,7 @@ int main(int argc, char **argv) {
|
||||
{"effort", required_argument, 0, 'e'},
|
||||
{"help", no_argument, 0, 'h'},
|
||||
{"version", no_argument, 0, 'V'},
|
||||
{"list-models", optional_argument, 0, 0x100},
|
||||
{0, 0, 0, 0}};
|
||||
int c;
|
||||
while ((c = getopt_long(argc, argv, "w:s:b:k:m:P:r:n:T:Hp:dahVNcR:LyA:C:e:", opts, NULL)) !=
|
||||
@@ -385,6 +445,14 @@ int main(int argc, char **argv) {
|
||||
usage(argv[0]);
|
||||
curl_global_cleanup();
|
||||
return 0;
|
||||
case 0x100: {
|
||||
const char *only = optarg;
|
||||
if (!only && optind < argc && argv[optind][0] != '-')
|
||||
only = argv[optind++];
|
||||
int rc = list_models(only);
|
||||
curl_global_cleanup();
|
||||
return rc;
|
||||
}
|
||||
case 'V':
|
||||
printf("cst-agent %s\n", CST_VERSION);
|
||||
curl_global_cleanup();
|
||||
@@ -543,10 +611,20 @@ int main(int argc, char **argv) {
|
||||
/* Router presets have no fixed model: take the first one the API lists
|
||||
* (the TUI does the same after its /models probe). */
|
||||
if (!cfg.model[0] && cfg.headless) {
|
||||
char ids[1][128], err[256] = "";
|
||||
if (cst_llm_list_models(cfg.api_base, cfg.api_key, ids, 1, err,
|
||||
sizeof(err)) > 0) {
|
||||
snprintf(cfg.model, sizeof(cfg.model), "%s", ids[0]);
|
||||
static cst_model_meta_t list[512];
|
||||
char err[256] = "";
|
||||
long age = 0;
|
||||
int n = cst_models_cache_load(cfg.provider, list, 1, &age);
|
||||
if (n <= 0 || age >= CST_MODELS_CACHE_TTL) {
|
||||
int r = cst_llm_list_models_meta(cfg.api_base, cfg.api_key, list, 512,
|
||||
err, sizeof(err));
|
||||
if (r >= 0)
|
||||
cst_models_cache_save(cfg.provider, cfg.api_base, list, r);
|
||||
if (r >= 0 || n <= 0)
|
||||
n = r;
|
||||
}
|
||||
if (n > 0) {
|
||||
snprintf(cfg.model, sizeof(cfg.model), "%s", list[0].id);
|
||||
} else {
|
||||
fprintf(stderr, "no model for %s: pass --model (%s)\n", cfg.provider,
|
||||
err[0] ? err : "the API listed none");
|
||||
|
||||
@@ -6,6 +6,8 @@
|
||||
#endif
|
||||
|
||||
#include "cst_mcp.h"
|
||||
#include "cst_agent.h"
|
||||
#include "cst_attach.h"
|
||||
|
||||
#include <pthread.h>
|
||||
#include <stdatomic.h>
|
||||
@@ -602,7 +604,56 @@ static int auto_approved(const mcp_srv_t *s, const char *tool) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void put_content(cst_buf_t *b, const cJSON *item) {
|
||||
/* Images a tool call returned, stored beside the session. */
|
||||
typedef struct {
|
||||
const char *session;
|
||||
const char *server;
|
||||
cst_attachment_t *list;
|
||||
int n, cap;
|
||||
} mcp_imgs_t;
|
||||
|
||||
/* An image content item goes into the session store and rides along with the
|
||||
* tool result; the text keeps a one-line description. 0 when stored. */
|
||||
static int put_image(cst_buf_t *b, const cJSON *item, mcp_imgs_t *im) {
|
||||
const cJSON *d = cJSON_GetObjectItemCaseSensitive(item, "data");
|
||||
if (!im || !cJSON_IsString(d))
|
||||
return -1;
|
||||
char err[256] = "no session to store the image in";
|
||||
if (im->n >= CST_ATTACH_MAX_COUNT) {
|
||||
snprintf(err, sizeof(err), "more than %d images", CST_ATTACH_MAX_COUNT);
|
||||
} else if (im->session && im->session[0]) {
|
||||
size_t n = 0;
|
||||
char *raw = cst_base64_decode(d->valuestring, strlen(d->valuestring), &n);
|
||||
char name[96];
|
||||
snprintf(name, sizeof(name), "%s-%d", im->server, im->n + 1);
|
||||
cst_attachment_t *a =
|
||||
raw ? cst_attach_import_bytes(im->session, name, raw, n, err,
|
||||
sizeof(err))
|
||||
: NULL;
|
||||
if (!raw)
|
||||
snprintf(err, sizeof(err), "bad base64");
|
||||
free(raw);
|
||||
if (a) {
|
||||
snprintf(a->origin, sizeof(a->origin), "mcp");
|
||||
int pushed = cst_attachments_push(&im->list, &im->n, &im->cap, a) == 0;
|
||||
char desc[128];
|
||||
cst_attach_describe(a, desc, sizeof(desc));
|
||||
cst_attach_free(a);
|
||||
if (pushed) {
|
||||
cst_buf_printf(b, "[image %s (shown to you as an image)]", desc);
|
||||
return 0;
|
||||
}
|
||||
snprintf(err, sizeof(err), "out of memory");
|
||||
}
|
||||
}
|
||||
const cJSON *mt = cJSON_GetObjectItemCaseSensitive(item, "mimeType");
|
||||
cst_buf_printf(b, "[image %s, %zu bytes base64, not shown: %s]",
|
||||
cJSON_IsString(mt) ? mt->valuestring : "",
|
||||
strlen(d->valuestring), err);
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void put_content(cst_buf_t *b, const cJSON *item, mcp_imgs_t *im) {
|
||||
const cJSON *type = cJSON_GetObjectItemCaseSensitive(item, "type");
|
||||
const char *t = cJSON_IsString(type) ? type->valuestring : "";
|
||||
if (b->len && b->buf[b->len - 1] != '\n')
|
||||
@@ -611,6 +662,9 @@ static void put_content(cst_buf_t *b, const cJSON *item) {
|
||||
const cJSON *x = cJSON_GetObjectItemCaseSensitive(item, "text");
|
||||
if (cJSON_IsString(x))
|
||||
cst_buf_puts(b, x->valuestring);
|
||||
} else if (strcmp(t, "image") == 0 &&
|
||||
cJSON_IsString(cJSON_GetObjectItemCaseSensitive(item, "data"))) {
|
||||
put_image(b, item, im);
|
||||
} else if (strcmp(t, "image") == 0 || strcmp(t, "audio") == 0) {
|
||||
const cJSON *mt = cJSON_GetObjectItemCaseSensitive(item, "mimeType");
|
||||
const cJSON *d = cJSON_GetObjectItemCaseSensitive(item, "data");
|
||||
@@ -660,7 +714,6 @@ static int set_out(cst_tool_result_t *r, int code, const char *fmt, ...) {
|
||||
|
||||
static int mcp_tool_run(const cst_tool_ctx_t *ctx, const ctl_tool_call_t *c,
|
||||
cst_tool_result_t *r, void *ud) {
|
||||
(void)ctx;
|
||||
mtool_t *mt = ud;
|
||||
mcp_srv_t *s = mt->srv;
|
||||
pthread_mutex_lock(&s->mu);
|
||||
@@ -690,9 +743,12 @@ static int mcp_tool_run(const cst_tool_ctx_t *ctx, const ctl_tool_call_t *c,
|
||||
const cJSON *res = cJSON_GetObjectItemCaseSensitive(resp, "result");
|
||||
const cJSON *content = cJSON_GetObjectItemCaseSensitive(res, "content");
|
||||
cst_buf_t b = {0};
|
||||
mcp_imgs_t im = {0};
|
||||
im.session = ctx && ctx->agent ? cst_agent_session_path(ctx->agent) : NULL;
|
||||
im.server = s->name;
|
||||
const cJSON *it = NULL;
|
||||
cJSON_ArrayForEach(it, content) {
|
||||
put_content(&b, it);
|
||||
put_content(&b, it, &im);
|
||||
if (b.len > MCP_OUT_MAX)
|
||||
break;
|
||||
}
|
||||
@@ -716,6 +772,8 @@ static int mcp_tool_run(const cst_tool_ctx_t *ctx, const ctl_tool_call_t *c,
|
||||
cJSON_Delete(resp);
|
||||
r->out_len = b.len;
|
||||
r->out = cst_buf_steal(&b);
|
||||
r->attach = im.list; /* one block, freed by cst_tool_result_free */
|
||||
r->nattach = im.n;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,818 @@
|
||||
#include "cst_models.h"
|
||||
|
||||
#include "cJSON.h"
|
||||
#include "os_compat.h"
|
||||
|
||||
#include <ctype.h>
|
||||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
|
||||
static const char BUILTIN[] = {
|
||||
#include "models_builtin.inc"
|
||||
0};
|
||||
|
||||
const char *cst_models_builtin_json(void) { return BUILTIN; }
|
||||
|
||||
#define MAX_PROV 32
|
||||
#define MAX_PMODELS 16
|
||||
#define MAX_RULES 256
|
||||
|
||||
typedef struct {
|
||||
cst_provider_t pub; /* points into the buffers below */
|
||||
char name[64];
|
||||
char api_base[256];
|
||||
char model[128];
|
||||
char key_env[64];
|
||||
int passback, prefix;
|
||||
char effort[16]; /* "", "passthrough", "openai" */
|
||||
char models[MAX_PMODELS][128];
|
||||
int nmodels;
|
||||
const char *source;
|
||||
} prov_t;
|
||||
|
||||
enum { F_CONTEXT = 1, F_VISION = 2, F_CACHE = 4, F_REASONING = 8, F_PRICE = 16 };
|
||||
|
||||
typedef struct {
|
||||
char match[128]; /* lowercase */
|
||||
int spec; /* literal characters: higher is more specific */
|
||||
unsigned has; /* F_* set by this rule */
|
||||
long context;
|
||||
int vision, cache, reasoning;
|
||||
cst_price_t price;
|
||||
} rule_t;
|
||||
|
||||
typedef struct {
|
||||
char provider[64];
|
||||
long fetched_at;
|
||||
cst_model_meta_t m;
|
||||
} cached_t;
|
||||
|
||||
static pthread_mutex_t g_mu = PTHREAD_MUTEX_INITIALIZER;
|
||||
|
||||
static struct {
|
||||
int loaded;
|
||||
prov_t prov[MAX_PROV];
|
||||
int nprov;
|
||||
rule_t builtin[MAX_RULES];
|
||||
int nbuiltin;
|
||||
rule_t user[MAX_RULES];
|
||||
int nuser;
|
||||
cached_t *cache;
|
||||
int ncache;
|
||||
char err[1400];
|
||||
} R;
|
||||
|
||||
/* --- parsing ------------------------------------------------------------- */
|
||||
|
||||
static void lower_copy(char *out, size_t n, const char *s) {
|
||||
size_t i = 0;
|
||||
for (; s && s[i] && i + 1 < n; i++)
|
||||
out[i] = (char)tolower((unsigned char)s[i]);
|
||||
out[i] = 0;
|
||||
}
|
||||
|
||||
static const char *jstr(const cJSON *o, const char *k) {
|
||||
const cJSON *v = cJSON_GetObjectItemCaseSensitive(o, k);
|
||||
return cJSON_IsString(v) ? v->valuestring : NULL;
|
||||
}
|
||||
|
||||
static void fix_pub(prov_t *p) {
|
||||
p->pub.name = p->name;
|
||||
p->pub.api_base = p->api_base;
|
||||
p->pub.model = p->model;
|
||||
p->pub.key_env = p->key_env;
|
||||
}
|
||||
|
||||
static prov_t *prov_by_name(const char *name) {
|
||||
for (int i = 0; i < R.nprov; i++)
|
||||
if (strcmp(R.prov[i].name, name) == 0)
|
||||
return &R.prov[i];
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void parse_providers(const cJSON *obj, const char *source) {
|
||||
const cJSON *it = NULL;
|
||||
cJSON_ArrayForEach(it, obj) {
|
||||
if (!cJSON_IsObject(it) || !it->string || !it->string[0])
|
||||
continue;
|
||||
prov_t *p = prov_by_name(it->string);
|
||||
if (!p) {
|
||||
if (R.nprov >= MAX_PROV)
|
||||
continue;
|
||||
p = &R.prov[R.nprov++];
|
||||
memset(p, 0, sizeof(*p));
|
||||
snprintf(p->name, sizeof(p->name), "%s", it->string);
|
||||
fix_pub(p);
|
||||
}
|
||||
p->source = source;
|
||||
const char *s;
|
||||
if ((s = jstr(it, "api_base")))
|
||||
snprintf(p->api_base, sizeof(p->api_base), "%s", s);
|
||||
if ((s = jstr(it, "key_env")))
|
||||
snprintf(p->key_env, sizeof(p->key_env), "%s", s);
|
||||
if ((s = jstr(it, "default_model")))
|
||||
snprintf(p->model, sizeof(p->model), "%s", s);
|
||||
if ((s = jstr(it, "effort")))
|
||||
snprintf(p->effort, sizeof(p->effort), "%s", s);
|
||||
const cJSON *b = cJSON_GetObjectItemCaseSensitive(it, "reasoning_passback");
|
||||
if (cJSON_IsBool(b))
|
||||
p->passback = cJSON_IsTrue(b);
|
||||
b = cJSON_GetObjectItemCaseSensitive(it, "prefix_completion");
|
||||
if (cJSON_IsBool(b))
|
||||
p->prefix = cJSON_IsTrue(b);
|
||||
const cJSON *ms = cJSON_GetObjectItemCaseSensitive(it, "models");
|
||||
if (cJSON_IsArray(ms)) {
|
||||
p->nmodels = 0;
|
||||
const cJSON *m = NULL;
|
||||
cJSON_ArrayForEach(m, ms) {
|
||||
if (cJSON_IsString(m) && m->valuestring[0] && p->nmodels < MAX_PMODELS)
|
||||
snprintf(p->models[p->nmodels++], 128, "%s", m->valuestring);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static int parse_price(const cJSON *o, cst_price_t *pr) {
|
||||
const cJSON *miss = cJSON_GetObjectItemCaseSensitive(o, "miss");
|
||||
const cJSON *out = cJSON_GetObjectItemCaseSensitive(o, "out");
|
||||
if (!cJSON_IsNumber(miss) || !cJSON_IsNumber(out))
|
||||
return -1;
|
||||
memset(pr, 0, sizeof(*pr));
|
||||
pr->miss = miss->valuedouble;
|
||||
pr->out = out->valuedouble;
|
||||
const cJSON *v = cJSON_GetObjectItemCaseSensitive(o, "hit");
|
||||
pr->hit = cJSON_IsNumber(v) ? v->valuedouble : pr->miss;
|
||||
v = cJSON_GetObjectItemCaseSensitive(o, "write");
|
||||
pr->write = cJSON_IsNumber(v) ? v->valuedouble : pr->miss;
|
||||
const char *c = jstr(o, "currency");
|
||||
snprintf(pr->currency, sizeof(pr->currency), "%s", c ? c : "$");
|
||||
pr->offpeak_half =
|
||||
cJSON_IsTrue(cJSON_GetObjectItemCaseSensitive(o, "offpeak_half"));
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int parse_rule(const cJSON *o, rule_t *r) {
|
||||
const char *m = jstr(o, "match");
|
||||
if (!m || !m[0])
|
||||
return -1;
|
||||
memset(r, 0, sizeof(*r));
|
||||
lower_copy(r->match, sizeof(r->match), m);
|
||||
for (const char *q = r->match; *q; q++)
|
||||
if (*q != '*')
|
||||
r->spec++;
|
||||
const cJSON *v = cJSON_GetObjectItemCaseSensitive(o, "context");
|
||||
if (cJSON_IsNumber(v) && v->valuedouble > 0) {
|
||||
r->context = (long)v->valuedouble;
|
||||
r->has |= F_CONTEXT;
|
||||
}
|
||||
v = cJSON_GetObjectItemCaseSensitive(o, "vision");
|
||||
if (cJSON_IsBool(v)) {
|
||||
r->vision = cJSON_IsTrue(v);
|
||||
r->has |= F_VISION;
|
||||
}
|
||||
v = cJSON_GetObjectItemCaseSensitive(o, "reasoning");
|
||||
if (cJSON_IsBool(v)) {
|
||||
r->reasoning = cJSON_IsTrue(v);
|
||||
r->has |= F_REASONING;
|
||||
}
|
||||
const char *c = jstr(o, "cache");
|
||||
if (c) {
|
||||
if (strcmp(c, "openai") == 0)
|
||||
r->cache = CST_CACHE_OPENAI;
|
||||
else if (strcmp(c, "anthropic") == 0)
|
||||
r->cache = CST_CACHE_ANTHROPIC;
|
||||
else
|
||||
r->cache = CST_CACHE_AUTO;
|
||||
r->has |= F_CACHE;
|
||||
}
|
||||
v = cJSON_GetObjectItemCaseSensitive(o, "price");
|
||||
if (cJSON_IsObject(v) && parse_price(v, &r->price) == 0)
|
||||
r->has |= F_PRICE;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int parse_doc(const char *json, int user, char *err, size_t err_sz) {
|
||||
cJSON *doc = cJSON_Parse(json);
|
||||
if (!cJSON_IsObject(doc)) {
|
||||
cJSON_Delete(doc);
|
||||
snprintf(err, err_sz, "not a JSON object");
|
||||
return -1;
|
||||
}
|
||||
parse_providers(cJSON_GetObjectItemCaseSensitive(doc, "providers"),
|
||||
user ? "user" : "built-in");
|
||||
rule_t *rules = user ? R.user : R.builtin;
|
||||
int *n = user ? &R.nuser : &R.nbuiltin;
|
||||
const cJSON *it = NULL;
|
||||
cJSON_ArrayForEach(it, cJSON_GetObjectItemCaseSensitive(doc, "models")) {
|
||||
if (*n < MAX_RULES && parse_rule(it, &rules[*n]) == 0)
|
||||
(*n)++;
|
||||
}
|
||||
cJSON_Delete(doc);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static char *read_file(const char *path) {
|
||||
FILE *f = fopen(path, "rb");
|
||||
if (!f)
|
||||
return NULL;
|
||||
char *buf = NULL;
|
||||
size_t len = 0;
|
||||
char chunk[8192];
|
||||
size_t got;
|
||||
while ((got = fread(chunk, 1, sizeof(chunk), f)) > 0 && len < (8u << 20)) {
|
||||
char *nb = realloc(buf, len + got + 1);
|
||||
if (!nb)
|
||||
break;
|
||||
buf = nb;
|
||||
memcpy(buf + len, chunk, got);
|
||||
len += got;
|
||||
}
|
||||
fclose(f);
|
||||
if (buf)
|
||||
buf[len] = 0;
|
||||
return buf;
|
||||
}
|
||||
|
||||
static int cache_path(const char *provider, char *out, size_t n) {
|
||||
char dir[1024];
|
||||
if (!provider || !provider[0] || os_config_dir(dir, sizeof(dir)) != 0)
|
||||
return -1;
|
||||
for (const char *q = provider; *q; q++)
|
||||
if (!isalnum((unsigned char)*q) && !strchr("._-", *q))
|
||||
return -1;
|
||||
int w = snprintf(out, n, "%s/models-cache/%s.json", dir, provider);
|
||||
return w > 0 && (size_t)w < n ? 0 : -1;
|
||||
}
|
||||
|
||||
static void meta_from_json(const cJSON *o, cst_model_meta_t *m) {
|
||||
memset(m, 0, sizeof(*m));
|
||||
m->vision = -1;
|
||||
const char *id = jstr(o, "id");
|
||||
snprintf(m->id, sizeof(m->id), "%s", id ? id : "");
|
||||
const cJSON *v = cJSON_GetObjectItemCaseSensitive(o, "context");
|
||||
if (cJSON_IsNumber(v) && v->valuedouble > 0)
|
||||
m->context = (long)v->valuedouble;
|
||||
v = cJSON_GetObjectItemCaseSensitive(o, "vision");
|
||||
if (cJSON_IsBool(v))
|
||||
m->vision = cJSON_IsTrue(v);
|
||||
v = cJSON_GetObjectItemCaseSensitive(o, "price");
|
||||
cst_price_t pr;
|
||||
if (cJSON_IsObject(v) && parse_price(v, &pr) == 0) {
|
||||
m->has_price = 1;
|
||||
m->miss = pr.miss;
|
||||
m->hit = pr.hit;
|
||||
m->write = pr.write;
|
||||
m->out = pr.out;
|
||||
}
|
||||
}
|
||||
|
||||
/* Appends provider's cache file to R.cache (caller holds the lock). */
|
||||
static void load_cache(const char *provider) {
|
||||
char path[1100];
|
||||
if (cache_path(provider, path, sizeof(path)) != 0)
|
||||
return;
|
||||
char *txt = read_file(path);
|
||||
cJSON *doc = txt ? cJSON_Parse(txt) : NULL;
|
||||
free(txt);
|
||||
const cJSON *fa = cJSON_GetObjectItemCaseSensitive(doc, "fetched_at");
|
||||
long at = cJSON_IsNumber(fa) ? (long)fa->valuedouble : 0;
|
||||
const cJSON *it = NULL;
|
||||
cJSON_ArrayForEach(it, cJSON_GetObjectItemCaseSensitive(doc, "models")) {
|
||||
cst_model_meta_t m;
|
||||
meta_from_json(it, &m);
|
||||
if (!m.id[0])
|
||||
continue;
|
||||
cached_t *nc = realloc(R.cache, (size_t)(R.ncache + 1) * sizeof(*nc));
|
||||
if (!nc)
|
||||
break;
|
||||
R.cache = nc;
|
||||
cached_t *c = &R.cache[R.ncache++];
|
||||
snprintf(c->provider, sizeof(c->provider), "%s", provider);
|
||||
c->fetched_at = at;
|
||||
c->m = m;
|
||||
}
|
||||
cJSON_Delete(doc);
|
||||
}
|
||||
|
||||
static void drop_cache(const char *provider) {
|
||||
int w = 0;
|
||||
for (int i = 0; i < R.ncache; i++)
|
||||
if (provider && strcmp(R.cache[i].provider, provider) != 0)
|
||||
R.cache[w++] = R.cache[i];
|
||||
R.ncache = w;
|
||||
}
|
||||
|
||||
static void reset_locked(void) {
|
||||
R.nprov = 0;
|
||||
R.nbuiltin = 0;
|
||||
R.nuser = 0;
|
||||
drop_cache(NULL);
|
||||
R.err[0] = 0;
|
||||
}
|
||||
|
||||
static void load_caches_locked(void) {
|
||||
for (int i = 0; i < R.nprov; i++)
|
||||
load_cache(R.prov[i].name);
|
||||
}
|
||||
|
||||
int cst_models_user_path(char *out, size_t out_sz) {
|
||||
char dir[1024];
|
||||
if (os_config_dir(dir, sizeof(dir)) != 0)
|
||||
return -1;
|
||||
int w = snprintf(out, out_sz, "%s/models.json", dir);
|
||||
return w > 0 && (size_t)w < out_sz ? 0 : -1;
|
||||
}
|
||||
|
||||
static void load_default_locked(void) {
|
||||
reset_locked();
|
||||
char e[128];
|
||||
if (parse_doc(BUILTIN, 0, e, sizeof(e)) != 0)
|
||||
snprintf(R.err, sizeof(R.err), "built-in model data: %s", e);
|
||||
char path[1100];
|
||||
char *user = cst_models_user_path(path, sizeof(path)) == 0
|
||||
? read_file(path)
|
||||
: NULL;
|
||||
if (user && parse_doc(user, 1, e, sizeof(e)) != 0)
|
||||
snprintf(R.err, sizeof(R.err), "%s: %s", path, e);
|
||||
free(user);
|
||||
load_caches_locked();
|
||||
R.loaded = 1;
|
||||
}
|
||||
|
||||
static void ensure_locked(void) {
|
||||
if (!R.loaded)
|
||||
load_default_locked();
|
||||
}
|
||||
|
||||
void cst_models_reload(void) {
|
||||
pthread_mutex_lock(&g_mu);
|
||||
load_default_locked();
|
||||
pthread_mutex_unlock(&g_mu);
|
||||
}
|
||||
|
||||
int cst_models_load_json(const char *builtin_json, const char *user_json,
|
||||
char *err, size_t err_sz) {
|
||||
char dummy[8];
|
||||
if (!err || !err_sz) {
|
||||
err = dummy;
|
||||
err_sz = sizeof(dummy);
|
||||
}
|
||||
err[0] = 0;
|
||||
pthread_mutex_lock(&g_mu);
|
||||
reset_locked();
|
||||
int rc = 0;
|
||||
if (builtin_json && parse_doc(builtin_json, 0, err, err_sz) != 0)
|
||||
rc = -1;
|
||||
if (rc == 0 && user_json && parse_doc(user_json, 1, err, err_sz) != 0)
|
||||
rc = -1;
|
||||
load_caches_locked();
|
||||
R.loaded = 1;
|
||||
pthread_mutex_unlock(&g_mu);
|
||||
return rc;
|
||||
}
|
||||
|
||||
const char *cst_models_load_error(void) {
|
||||
pthread_mutex_lock(&g_mu);
|
||||
ensure_locked();
|
||||
pthread_mutex_unlock(&g_mu);
|
||||
return R.err;
|
||||
}
|
||||
|
||||
/* --- providers ----------------------------------------------------------- */
|
||||
|
||||
const cst_provider_t *cst_provider_find(const char *name) {
|
||||
if (!name || !name[0])
|
||||
return NULL;
|
||||
pthread_mutex_lock(&g_mu);
|
||||
ensure_locked();
|
||||
prov_t *p = prov_by_name(name);
|
||||
pthread_mutex_unlock(&g_mu);
|
||||
return p ? &p->pub : NULL;
|
||||
}
|
||||
|
||||
const cst_provider_t *cst_provider_default(void) {
|
||||
const cst_provider_t *p = cst_provider_find(getenv("CST_PROVIDER"));
|
||||
return p ? p : cst_provider_at(0);
|
||||
}
|
||||
|
||||
int cst_provider_count(void) {
|
||||
pthread_mutex_lock(&g_mu);
|
||||
ensure_locked();
|
||||
int n = R.nprov;
|
||||
pthread_mutex_unlock(&g_mu);
|
||||
return n;
|
||||
}
|
||||
|
||||
const cst_provider_t *cst_provider_at(int i) {
|
||||
pthread_mutex_lock(&g_mu);
|
||||
ensure_locked();
|
||||
const cst_provider_t *p = i >= 0 && i < R.nprov ? &R.prov[i].pub : NULL;
|
||||
pthread_mutex_unlock(&g_mu);
|
||||
return p;
|
||||
}
|
||||
|
||||
const char *cst_provider_source(const cst_provider_t *p) {
|
||||
for (int i = 0; p && i < MAX_PROV; i++)
|
||||
if (p == &R.prov[i].pub)
|
||||
return R.prov[i].source ? R.prov[i].source : "built-in";
|
||||
return "";
|
||||
}
|
||||
|
||||
int cst_provider_models(const cst_provider_t *p, char out[][128], int max) {
|
||||
int n = 0;
|
||||
pthread_mutex_lock(&g_mu);
|
||||
for (int i = 0; p && i < R.nprov; i++) {
|
||||
if (p != &R.prov[i].pub)
|
||||
continue;
|
||||
for (int k = 0; k < R.prov[i].nmodels && n < max; k++)
|
||||
snprintf(out[n++], 128, "%s", R.prov[i].models[k]);
|
||||
}
|
||||
pthread_mutex_unlock(&g_mu);
|
||||
return n;
|
||||
}
|
||||
|
||||
static int push_name(char out[][128], int *n, int max, const char *name) {
|
||||
if (!name || !name[0] || *n >= max)
|
||||
return 0;
|
||||
for (int i = 0; i < *n; i++)
|
||||
if (strcmp(out[i], name) == 0)
|
||||
return 0;
|
||||
snprintf(out[(*n)++], 128, "%s", name);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int cst_models_list(const char *current, char out[][128], int max_out) {
|
||||
if (!out || max_out <= 0)
|
||||
return 0;
|
||||
int n = 0;
|
||||
const char *env = getenv("CST_MODELS");
|
||||
if (env && env[0]) {
|
||||
char buf[1024];
|
||||
snprintf(buf, sizeof(buf), "%s", env);
|
||||
for (char *tok = buf; *tok;) {
|
||||
while (*tok == ':' || *tok == ',' || *tok == ' ')
|
||||
tok++;
|
||||
char *end = tok;
|
||||
while (*end && *end != ':' && *end != ',')
|
||||
end++;
|
||||
char save = *end;
|
||||
*end = 0;
|
||||
char *t = end;
|
||||
while (t > tok && (t[-1] == ' ' || t[-1] == '\t'))
|
||||
*--t = 0;
|
||||
push_name(out, &n, max_out, tok);
|
||||
*end = save;
|
||||
tok = *end ? end + 1 : end;
|
||||
}
|
||||
} else {
|
||||
pthread_mutex_lock(&g_mu);
|
||||
ensure_locked();
|
||||
for (int i = 0; i < R.nprov; i++)
|
||||
for (int k = 0; k < R.prov[i].nmodels; k++)
|
||||
push_name(out, &n, max_out, R.prov[i].models[k]);
|
||||
pthread_mutex_unlock(&g_mu);
|
||||
}
|
||||
push_name(out, &n, max_out, current);
|
||||
return n;
|
||||
}
|
||||
|
||||
/* --- model lookup -------------------------------------------------------- */
|
||||
|
||||
/* '*' matches any run; without one the pattern is a prefix. */
|
||||
static int glob(const char *p, const char *s) {
|
||||
if (!strchr(p, '*'))
|
||||
return strncmp(s, p, strlen(p)) == 0;
|
||||
while (*p) {
|
||||
if (*p == '*') {
|
||||
while (*p == '*')
|
||||
p++;
|
||||
if (!*p)
|
||||
return 1;
|
||||
for (; *s; s++)
|
||||
if (glob(p, s))
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
if (*p != *s)
|
||||
return 0;
|
||||
p++;
|
||||
s++;
|
||||
}
|
||||
return !*s;
|
||||
}
|
||||
|
||||
static void set_field(cst_model_info_t *o, unsigned f, const rule_t *r) {
|
||||
switch (f) {
|
||||
case F_CONTEXT:
|
||||
o->context = r->context;
|
||||
break;
|
||||
case F_VISION:
|
||||
o->vision = r->vision;
|
||||
break;
|
||||
case F_CACHE:
|
||||
o->cache_style = r->cache;
|
||||
break;
|
||||
case F_REASONING:
|
||||
o->reasoning = r->reasoning;
|
||||
break;
|
||||
case F_PRICE:
|
||||
o->price = r->price;
|
||||
o->has_price = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void add_source(cst_model_info_t *o, const char *src) {
|
||||
if (strstr(o->source, src))
|
||||
return;
|
||||
size_t l = strlen(o->source);
|
||||
snprintf(o->source + l, sizeof(o->source) - l, "%s%s", l ? "+" : "", src);
|
||||
}
|
||||
|
||||
static void apply_rules(const rule_t *rules, int n, const char *full,
|
||||
const char *bare, unsigned *have, cst_model_info_t *o,
|
||||
const char *src) {
|
||||
for (unsigned f = 1; f <= F_PRICE; f <<= 1) {
|
||||
if (*have & f)
|
||||
continue;
|
||||
const rule_t *best = NULL;
|
||||
for (int i = 0; i < n; i++) {
|
||||
const rule_t *r = &rules[i];
|
||||
if (!(r->has & f) || (best && r->spec <= best->spec))
|
||||
continue;
|
||||
if (glob(r->match, strchr(r->match, '/') ? full : bare))
|
||||
best = r;
|
||||
}
|
||||
if (best) {
|
||||
set_field(o, f, best);
|
||||
*have |= f;
|
||||
add_source(o, src);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void apply_cache(const char *provider, const char *model,
|
||||
unsigned *have, cst_model_info_t *o) {
|
||||
for (int i = 0; i < R.ncache; i++) {
|
||||
const cached_t *c = &R.cache[i];
|
||||
if ((provider && strcmp(c->provider, provider) != 0) ||
|
||||
strcmp(c->m.id, model) != 0)
|
||||
continue;
|
||||
unsigned before = *have;
|
||||
if (!(*have & F_CONTEXT) && c->m.context > 0) {
|
||||
o->context = c->m.context;
|
||||
*have |= F_CONTEXT;
|
||||
}
|
||||
if (!(*have & F_VISION) && c->m.vision >= 0) {
|
||||
o->vision = c->m.vision;
|
||||
*have |= F_VISION;
|
||||
}
|
||||
if (!(*have & F_PRICE) && c->m.has_price) {
|
||||
memset(&o->price, 0, sizeof(o->price));
|
||||
snprintf(o->price.currency, sizeof(o->price.currency), "$");
|
||||
o->price.miss = c->m.miss;
|
||||
o->price.hit = c->m.hit;
|
||||
o->price.write = c->m.write;
|
||||
o->price.out = c->m.out;
|
||||
o->has_price = 1;
|
||||
*have |= F_PRICE;
|
||||
}
|
||||
if (*have != before)
|
||||
add_source(o, "api");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
static int env_price(cst_price_t *out) {
|
||||
const char *e = getenv("CST_PRICE");
|
||||
if (!e || !e[0])
|
||||
return -1;
|
||||
memset(out, 0, sizeof(*out));
|
||||
char cur[8] = "";
|
||||
int n = sscanf(e, "%lf,%lf,%lf,%lf,%7s", &out->miss, &out->hit, &out->out,
|
||||
&out->write, cur);
|
||||
if (n < 3)
|
||||
return -1;
|
||||
if (n < 4)
|
||||
out->write = out->miss;
|
||||
snprintf(out->currency, sizeof(out->currency), "%s", cur);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void cst_model_info(const char *provider, const char *model,
|
||||
cst_model_info_t *out) {
|
||||
memset(out, 0, sizeof(*out));
|
||||
out->vision = -1;
|
||||
unsigned have = 0;
|
||||
const char *e = getenv("CST_CTX_TOKENS");
|
||||
if (e && atol(e) > 0) {
|
||||
out->context = atol(e);
|
||||
have |= F_CONTEXT;
|
||||
add_source(out, "env");
|
||||
}
|
||||
if (env_price(&out->price) == 0) {
|
||||
out->has_price = 1;
|
||||
have |= F_PRICE;
|
||||
add_source(out, "env");
|
||||
}
|
||||
if (model && model[0]) {
|
||||
char full[256], bare[256];
|
||||
lower_copy(full, sizeof(full), model);
|
||||
const char *slash = strrchr(full, '/');
|
||||
snprintf(bare, sizeof(bare), "%s", slash && slash[1] ? slash + 1 : full);
|
||||
pthread_mutex_lock(&g_mu);
|
||||
ensure_locked();
|
||||
apply_rules(R.user, R.nuser, full, bare, &have, out, "user");
|
||||
if (provider && !prov_by_name(provider))
|
||||
provider = NULL;
|
||||
apply_cache(provider, model, &have, out);
|
||||
apply_rules(R.builtin, R.nbuiltin, full, bare, &have, out, "built-in");
|
||||
pthread_mutex_unlock(&g_mu);
|
||||
}
|
||||
if (!(have & F_CONTEXT)) {
|
||||
out->context = 128000;
|
||||
add_source(out, "default");
|
||||
}
|
||||
}
|
||||
|
||||
void cst_model_info_label(const cst_model_info_t *mi, char *out, size_t n) {
|
||||
char ctx[32];
|
||||
if (mi->context >= 1000000)
|
||||
snprintf(ctx, sizeof(ctx), "%.0fM", (double)mi->context / 1e6);
|
||||
else
|
||||
snprintf(ctx, sizeof(ctx), "%ldK", (mi->context + 500) / 1000);
|
||||
snprintf(out, n, "%s%s", ctx,
|
||||
mi->vision == 1 ? " · vision"
|
||||
: mi->vision == 0 ? " · text only"
|
||||
: "");
|
||||
}
|
||||
|
||||
/* --- wrappers kept for the rest of the code ------------------------------ */
|
||||
|
||||
long cst_model_context_tokens(const char *model) {
|
||||
cst_model_info_t i;
|
||||
cst_model_info(NULL, model, &i);
|
||||
return i.context;
|
||||
}
|
||||
|
||||
int cst_model_price(const char *model, cst_price_t *out) {
|
||||
cst_model_info_t i;
|
||||
cst_model_info(NULL, model, &i);
|
||||
*out = i.price;
|
||||
if (!i.has_price)
|
||||
memset(out, 0, sizeof(*out));
|
||||
return i.has_price ? 0 : -1;
|
||||
}
|
||||
|
||||
/* "https://api.deepseek.com/v1" -> "api.deepseek.com" */
|
||||
static void host_of(const char *url, char *out, size_t n) {
|
||||
const char *s = strstr(url, "://");
|
||||
s = s ? s + 3 : url;
|
||||
size_t i = 0;
|
||||
for (; s[i] && s[i] != '/' && i + 1 < n; i++)
|
||||
out[i] = s[i];
|
||||
out[i] = 0;
|
||||
}
|
||||
|
||||
void cst_model_caps(const char *provider, const char *api_base,
|
||||
const char *model, cst_model_caps_t *out) {
|
||||
memset(out, 0, sizeof(*out));
|
||||
pthread_mutex_lock(&g_mu);
|
||||
ensure_locked();
|
||||
/* provider extensions follow the provider, or its host behind any name */
|
||||
for (int i = 0; i < R.nprov; i++) {
|
||||
const prov_t *p = &R.prov[i];
|
||||
if (!p->passback && !p->prefix)
|
||||
continue;
|
||||
char host[256];
|
||||
host_of(p->api_base, host, sizeof(host));
|
||||
if ((provider && strcmp(provider, p->name) == 0) ||
|
||||
(api_base && host[0] && strstr(api_base, host))) {
|
||||
out->reasoning_passback |= p->passback;
|
||||
out->prefix_completion |= p->prefix;
|
||||
}
|
||||
}
|
||||
pthread_mutex_unlock(&g_mu);
|
||||
cst_model_info_t mi;
|
||||
cst_model_info(provider, model, &mi);
|
||||
out->vision = mi.vision;
|
||||
const char *e = getenv("CST_NO_CACHE_HINTS");
|
||||
if ((e && e[0] == '1') || !model)
|
||||
return;
|
||||
out->cache_style = mi.cache_style;
|
||||
}
|
||||
|
||||
const char *cst_effort_wire(const char *provider, const char *model,
|
||||
const char *effort) {
|
||||
if (!cst_effort_valid(effort) || !provider || !model)
|
||||
return NULL;
|
||||
char mode[16] = "";
|
||||
pthread_mutex_lock(&g_mu);
|
||||
ensure_locked();
|
||||
const prov_t *p = prov_by_name(provider);
|
||||
if (p)
|
||||
snprintf(mode, sizeof(mode), "%s", p->effort);
|
||||
pthread_mutex_unlock(&g_mu);
|
||||
if (strcmp(mode, "passthrough") == 0)
|
||||
return effort;
|
||||
if (strcmp(mode, "openai") == 0) {
|
||||
cst_model_info_t mi;
|
||||
cst_model_info(provider, model, &mi);
|
||||
if (mi.reasoning)
|
||||
return strcmp(effort, "max") == 0 ? "high" : effort;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* --- fetched cache ------------------------------------------------------- */
|
||||
|
||||
int cst_models_cache_save(const char *provider, const char *api_base,
|
||||
const cst_model_meta_t *list, int n) {
|
||||
char path[1100];
|
||||
if (!list || n < 0 || cache_path(provider, path, sizeof(path)) != 0)
|
||||
return -1;
|
||||
char dir[1100];
|
||||
snprintf(dir, sizeof(dir), "%s", path);
|
||||
char *sl = strrchr(dir, '/');
|
||||
if (sl)
|
||||
*sl = 0;
|
||||
os_mkdir_p(dir, 0700);
|
||||
|
||||
long now = (long)time(NULL);
|
||||
cJSON *doc = cJSON_CreateObject();
|
||||
cJSON_AddNumberToObject(doc, "fetched_at", (double)now);
|
||||
if (api_base)
|
||||
cJSON_AddStringToObject(doc, "api_base", api_base);
|
||||
cJSON *arr = cJSON_AddArrayToObject(doc, "models");
|
||||
for (int i = 0; i < n; i++) {
|
||||
const cst_model_meta_t *m = &list[i];
|
||||
cJSON *o = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(o, "id", m->id);
|
||||
if (m->context > 0)
|
||||
cJSON_AddNumberToObject(o, "context", (double)m->context);
|
||||
if (m->vision >= 0)
|
||||
cJSON_AddBoolToObject(o, "vision", m->vision);
|
||||
if (m->has_price) {
|
||||
cJSON *p = cJSON_AddObjectToObject(o, "price");
|
||||
cJSON_AddStringToObject(p, "currency", "$");
|
||||
cJSON_AddNumberToObject(p, "miss", m->miss);
|
||||
cJSON_AddNumberToObject(p, "hit", m->hit);
|
||||
cJSON_AddNumberToObject(p, "write", m->write);
|
||||
cJSON_AddNumberToObject(p, "out", m->out);
|
||||
}
|
||||
cJSON_AddItemToArray(arr, o);
|
||||
}
|
||||
char *txt = cJSON_Print(doc);
|
||||
cJSON_Delete(doc);
|
||||
if (!txt)
|
||||
return -1;
|
||||
char tmp[1200];
|
||||
snprintf(tmp, sizeof(tmp), "%s.tmp", path);
|
||||
FILE *f = fopen(tmp, "wb");
|
||||
int rc = -1;
|
||||
if (f) {
|
||||
size_t len = strlen(txt);
|
||||
rc = fwrite(txt, 1, len, f) == len ? 0 : -1;
|
||||
if (fclose(f) != 0)
|
||||
rc = -1;
|
||||
if (rc == 0)
|
||||
rc = os_rename_replace(tmp, path);
|
||||
if (rc != 0)
|
||||
remove(tmp);
|
||||
}
|
||||
free(txt);
|
||||
if (rc == 0) {
|
||||
pthread_mutex_lock(&g_mu);
|
||||
ensure_locked();
|
||||
drop_cache(provider);
|
||||
load_cache(provider);
|
||||
pthread_mutex_unlock(&g_mu);
|
||||
}
|
||||
return rc;
|
||||
}
|
||||
|
||||
int cst_models_cache_load(const char *provider, cst_model_meta_t *out, int max,
|
||||
long *age_s) {
|
||||
if (age_s)
|
||||
*age_s = 0;
|
||||
if (!provider)
|
||||
return -1;
|
||||
pthread_mutex_lock(&g_mu);
|
||||
ensure_locked();
|
||||
int n = 0, found = 0;
|
||||
for (int i = 0; i < R.ncache; i++) {
|
||||
const cached_t *c = &R.cache[i];
|
||||
if (strcmp(c->provider, provider) != 0)
|
||||
continue;
|
||||
if (!found && age_s)
|
||||
*age_s = (long)time(NULL) - c->fetched_at;
|
||||
found = 1;
|
||||
if (out && n < max)
|
||||
out[n++] = c->m;
|
||||
}
|
||||
pthread_mutex_unlock(&g_mu);
|
||||
return found ? n : -1;
|
||||
}
|
||||
+20
-130
@@ -1,120 +1,32 @@
|
||||
#include "cst_agent.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#define MODEL_MAX_LEN 128
|
||||
/* Provider and model data live in model_registry.c (cst_models.h). */
|
||||
|
||||
static const cst_provider_t PROVIDERS[] = {
|
||||
{"minimax", "https://api.minimax.cn/v1", "MiniMax-M2.7", "MINIMAX_API_KEY"},
|
||||
{"deepseek", "https://api.deepseek.com/v1", "deepseek-flash",
|
||||
"DEEPSEEK_API_KEY"},
|
||||
{"openai", "https://api.openai.com/v1", "gpt-4.1-mini", "OPENAI_API_KEY"},
|
||||
/* Router: no fixed model; the first id from GET /models is picked. */
|
||||
{"teamorouter", "https://api.teamorouter.com/v1", "",
|
||||
"TEAMOROUTER_API_KEY"},
|
||||
};
|
||||
|
||||
const cst_provider_t *cst_provider_find(const char *name) {
|
||||
if (!name || !name[0])
|
||||
return NULL;
|
||||
for (size_t i = 0; i < sizeof(PROVIDERS) / sizeof(PROVIDERS[0]); i++) {
|
||||
if (strcmp(PROVIDERS[i].name, name) == 0)
|
||||
return &PROVIDERS[i];
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const cst_provider_t *cst_provider_default(void) {
|
||||
const cst_provider_t *p = cst_provider_find(getenv("CST_PROVIDER"));
|
||||
return p ? p : &PROVIDERS[0];
|
||||
}
|
||||
|
||||
static int already(char out[][MODEL_MAX_LEN], int n, const char *name) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
if (strcmp(out[i], name) == 0)
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int push(char out[][MODEL_MAX_LEN], int *n, int max, const char *name) {
|
||||
if (!name || !name[0] || *n >= max)
|
||||
int cst_price_is_peak(time_t when) {
|
||||
time_t bj = when + 8 * 3600;
|
||||
struct tm tmv;
|
||||
#ifdef _WIN32
|
||||
gmtime_s(&tmv, &bj);
|
||||
#else
|
||||
gmtime_r(&bj, &tmv);
|
||||
#endif
|
||||
if (tmv.tm_wday == 0 || tmv.tm_wday == 6)
|
||||
return 0;
|
||||
if (already(out, *n, name))
|
||||
return 0;
|
||||
snprintf(out[*n], MODEL_MAX_LEN, "%s", name);
|
||||
(*n)++;
|
||||
return 1;
|
||||
return (tmv.tm_hour >= 9 && tmv.tm_hour < 12) ||
|
||||
(tmv.tm_hour >= 14 && tmv.tm_hour < 18);
|
||||
}
|
||||
|
||||
int cst_models_list(const char *current, char out[][128], int max_out) {
|
||||
if (!out || max_out <= 0)
|
||||
double cst_price_cost(const cst_price_t *p, long miss, long hit, long write,
|
||||
long out, time_t when) {
|
||||
if (!p)
|
||||
return 0;
|
||||
int n = 0;
|
||||
|
||||
const char *env = getenv("CST_MODELS");
|
||||
if (env && env[0]) {
|
||||
char buf[1024];
|
||||
snprintf(buf, sizeof(buf), "%s", env);
|
||||
char *p = buf;
|
||||
while (*p && n < max_out) {
|
||||
while (*p == ':' || *p == ' ' || *p == ',')
|
||||
p++;
|
||||
if (!*p)
|
||||
break;
|
||||
char *start = p;
|
||||
while (*p && *p != ':' && *p != ',')
|
||||
p++;
|
||||
char save = *p;
|
||||
*p = 0;
|
||||
char *end = start + strlen(start);
|
||||
while (end > start && (end[-1] == ' ' || end[-1] == '\t'))
|
||||
*--end = 0;
|
||||
push(out, &n, max_out, start);
|
||||
*p = save;
|
||||
if (*p)
|
||||
p++;
|
||||
}
|
||||
} else {
|
||||
push(out, &n, max_out, "deepseek-flash");
|
||||
push(out, &n, max_out, "deepseek-v4-pro");
|
||||
push(out, &n, max_out, "MiniMax-M2.7");
|
||||
push(out, &n, max_out, "MiniMax-M2.5");
|
||||
push(out, &n, max_out, "gpt-4.1-mini");
|
||||
push(out, &n, max_out, "gpt-4o");
|
||||
}
|
||||
|
||||
if (current && current[0])
|
||||
push(out, &n, max_out, current);
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
/* Context window in tokens (CST_CTX_TOKENS overrides). Prefix match. */
|
||||
long cst_model_context_tokens(const char *model) {
|
||||
const char *e = getenv("CST_CTX_TOKENS");
|
||||
if (e && atol(e) > 0)
|
||||
return atol(e);
|
||||
static const struct {
|
||||
const char *prefix;
|
||||
long tokens;
|
||||
} T[] = {{"deepseek", 128000}, {"MiniMax", 196608}, {"minimax", 196608},
|
||||
{"gpt-4.1", 1047576}, {"gpt-4o", 128000}, {"gpt-5", 400000},
|
||||
{"o3", 200000}, {"o4", 200000}, {"claude", 200000},
|
||||
{"qwen", 131072}, {"glm", 128000}, {"kimi", 131072}};
|
||||
if (model) {
|
||||
/* routers name models "vendor/model" */
|
||||
const char *slash = strrchr(model, '/');
|
||||
if (slash && slash[1])
|
||||
model = slash + 1;
|
||||
for (size_t i = 0; i < sizeof(T) / sizeof(T[0]); i++) {
|
||||
if (strncmp(model, T[i].prefix, strlen(T[i].prefix)) == 0)
|
||||
return T[i].tokens;
|
||||
}
|
||||
}
|
||||
return 128000;
|
||||
double c = (miss * p->miss + hit * p->hit + write * p->write +
|
||||
out * p->out) / 1e6;
|
||||
if (p->offpeak_half && !cst_price_is_peak(when))
|
||||
c /= 2;
|
||||
return c;
|
||||
}
|
||||
|
||||
int cst_effort_valid(const char *effort) {
|
||||
@@ -125,25 +37,3 @@ int cst_effort_valid(const char *effort) {
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
const char *cst_effort_wire(const char *provider, const char *model,
|
||||
const char *effort) {
|
||||
if (!cst_effort_valid(effort) || !provider || !model)
|
||||
return NULL;
|
||||
if (strcmp(provider, "deepseek") == 0)
|
||||
return effort;
|
||||
/* OpenAI reasoning models take low | medium | high. */
|
||||
if (strcmp(provider, "openai") == 0 &&
|
||||
(strncmp(model, "o1", 2) == 0 || strncmp(model, "o3", 2) == 0 ||
|
||||
strncmp(model, "o4", 2) == 0 || strncmp(model, "gpt-5", 5) == 0))
|
||||
return strcmp(effort, "max") == 0 ? "high" : effort;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int cst_provider_count(void) {
|
||||
return (int)(sizeof(PROVIDERS) / sizeof(PROVIDERS[0]));
|
||||
}
|
||||
|
||||
const cst_provider_t *cst_provider_at(int i) {
|
||||
return i >= 0 && i < cst_provider_count() ? &PROVIDERS[i] : NULL;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,70 @@
|
||||
{
|
||||
"providers": {
|
||||
"minimax": {
|
||||
"api_base": "https://api.minimax.cn/v1",
|
||||
"key_env": "MINIMAX_API_KEY",
|
||||
"default_model": "MiniMax-M2.7",
|
||||
"models": ["MiniMax-M2.7", "MiniMax-M2.5"]
|
||||
},
|
||||
"deepseek": {
|
||||
"api_base": "https://api.deepseek.com/v1",
|
||||
"key_env": "DEEPSEEK_API_KEY",
|
||||
"default_model": "deepseek-flash",
|
||||
"models": ["deepseek-flash", "deepseek-v4-pro"],
|
||||
"reasoning_passback": true,
|
||||
"prefix_completion": true,
|
||||
"effort": "passthrough"
|
||||
},
|
||||
"openai": {
|
||||
"api_base": "https://api.openai.com/v1",
|
||||
"key_env": "OPENAI_API_KEY",
|
||||
"default_model": "gpt-4.1-mini",
|
||||
"models": ["gpt-4.1-mini", "gpt-4o"],
|
||||
"effort": "openai"
|
||||
},
|
||||
"teamorouter": {
|
||||
"api_base": "https://api.teamorouter.com/v1",
|
||||
"key_env": "TEAMOROUTER_API_KEY",
|
||||
"default_model": ""
|
||||
}
|
||||
},
|
||||
"models": [
|
||||
{"match": "deepseek", "context": 1000000, "vision": false,
|
||||
"price": {"currency": "¥", "miss": 2, "hit": 0.04, "out": 8, "offpeak_half": true}},
|
||||
{"match": "deepseek-v4-pro",
|
||||
"price": {"currency": "¥", "miss": 9, "hit": 0.3, "out": 27, "offpeak_half": true}},
|
||||
{"match": "deepseek-vl", "vision": true},
|
||||
{"match": "minimax", "context": 196608, "vision": false},
|
||||
|
||||
{"match": "gpt-", "cache": "openai"},
|
||||
{"match": "gpt-4.1", "context": 1047576, "vision": true,
|
||||
"price": {"currency": "$", "miss": 2, "hit": 0.5, "out": 8}},
|
||||
{"match": "gpt-4.1-mini",
|
||||
"price": {"currency": "$", "miss": 0.4, "hit": 0.1, "out": 1.6}},
|
||||
{"match": "gpt-4o", "context": 128000, "vision": true,
|
||||
"price": {"currency": "$", "miss": 2.5, "hit": 1.25, "out": 10}},
|
||||
{"match": "gpt-4o-mini",
|
||||
"price": {"currency": "$", "miss": 0.15, "hit": 0.075, "out": 0.6}},
|
||||
{"match": "gpt-5", "context": 400000, "vision": true, "reasoning": true},
|
||||
{"match": "o1", "vision": true, "cache": "openai", "reasoning": true},
|
||||
{"match": "o3", "context": 200000, "vision": true, "cache": "openai", "reasoning": true},
|
||||
{"match": "o4", "context": 200000, "vision": true, "cache": "openai", "reasoning": true},
|
||||
|
||||
{"match": "anthropic/", "cache": "anthropic"},
|
||||
{"match": "claude", "context": 200000, "vision": true, "cache": "anthropic"},
|
||||
{"match": "claude-sonnet",
|
||||
"price": {"currency": "$", "miss": 3, "hit": 0.3, "write": 3.75, "out": 15}},
|
||||
|
||||
{"match": "gemini", "context": 1048576, "vision": true},
|
||||
{"match": "grok", "context": 256000},
|
||||
{"match": "grok-4", "vision": true},
|
||||
{"match": "qwen", "context": 131072},
|
||||
{"match": "glm", "context": 128000},
|
||||
{"match": "glm-*v*", "vision": true},
|
||||
{"match": "kimi", "context": 131072},
|
||||
{"match": "pixtral", "vision": true},
|
||||
{"match": "llava", "vision": true},
|
||||
{"match": "*-vl*", "vision": true},
|
||||
{"match": "*vision*", "vision": true}
|
||||
]
|
||||
}
|
||||
+54
-1
@@ -7,6 +7,7 @@
|
||||
|
||||
#include "cJSON.h"
|
||||
#include "cst_agent.h"
|
||||
#include "cst_attach.h"
|
||||
|
||||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
@@ -97,7 +98,11 @@ static void msg_free(cst_message_t *m) {
|
||||
free(m->content);
|
||||
free(m->tool_calls_json);
|
||||
free(m->meta_json);
|
||||
m->content = m->tool_calls_json = m->meta_json = NULL;
|
||||
free(m->reasoning);
|
||||
cst_attachments_free(m->attach, m->nattach);
|
||||
m->content = m->tool_calls_json = m->meta_json = m->reasoning = NULL;
|
||||
m->attach = NULL;
|
||||
m->nattach = 0;
|
||||
}
|
||||
|
||||
static int session_grow(cst_session_t *s) {
|
||||
@@ -127,6 +132,16 @@ static int session_push_mem(cst_session_t *s, const cst_message_t *src) {
|
||||
d->tool_calls_json = xstrdup(src->tool_calls_json);
|
||||
if (src->meta_json && src->meta_json[0])
|
||||
d->meta_json = xstrdup(src->meta_json);
|
||||
if (src->reasoning && src->reasoning[0])
|
||||
d->reasoning = xstrdup(src->reasoning);
|
||||
if (src->attach && src->nattach > 0) {
|
||||
d->attach = cst_attachments_dup(src->attach, src->nattach);
|
||||
if (!d->attach) {
|
||||
msg_free(d);
|
||||
return -1;
|
||||
}
|
||||
d->nattach = src->nattach;
|
||||
}
|
||||
s->nmsgs++;
|
||||
return 0;
|
||||
}
|
||||
@@ -174,9 +189,14 @@ static void load_existing(cst_session_t *s) {
|
||||
if (cJSON_IsObject(mo))
|
||||
meta = cJSON_PrintUnformatted(mo);
|
||||
m.meta_json = meta;
|
||||
m.reasoning = (char *)jstr(o, "reasoning");
|
||||
const cJSON *at = cJSON_GetObjectItemCaseSensitive(o, "attachments");
|
||||
if (cJSON_IsArray(at))
|
||||
m.attach = cst_attachments_from_json(at, &m.nattach);
|
||||
session_push_mem(s, &m);
|
||||
free(tcj);
|
||||
free(meta);
|
||||
cst_attachments_free(m.attach, m.nattach);
|
||||
cJSON_Delete(o);
|
||||
}
|
||||
free(line);
|
||||
@@ -249,6 +269,8 @@ static int write_line(FILE *fp, const cst_message_t *msg) {
|
||||
cJSON_AddStringToObject(o, "tool_calls_json", msg->tool_calls_json);
|
||||
}
|
||||
}
|
||||
if (msg->reasoning && msg->reasoning[0])
|
||||
cJSON_AddStringToObject(o, "reasoning", msg->reasoning);
|
||||
if (msg->meta_json && msg->meta_json[0]) {
|
||||
cJSON *mo = cJSON_Parse(msg->meta_json);
|
||||
if (cJSON_IsObject(mo))
|
||||
@@ -256,6 +278,28 @@ static int write_line(FILE *fp, const cst_message_t *msg) {
|
||||
else
|
||||
cJSON_Delete(mo);
|
||||
}
|
||||
if (msg->attach && msg->nattach > 0) {
|
||||
cJSON *arr = cJSON_CreateArray();
|
||||
for (int i = 0; i < msg->nattach; i++) {
|
||||
const cst_attachment_t *a = &msg->attach[i];
|
||||
cJSON *it = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(it, "id", a->id);
|
||||
cJSON_AddStringToObject(it, "name", a->name);
|
||||
cJSON_AddStringToObject(it, "mime", a->mime);
|
||||
cJSON_AddStringToObject(it, "rel", a->rel);
|
||||
cJSON_AddNumberToObject(it, "bytes", (double)a->bytes);
|
||||
if (a->width > 0 && a->height > 0) {
|
||||
cJSON_AddNumberToObject(it, "width", a->width);
|
||||
cJSON_AddNumberToObject(it, "height", a->height);
|
||||
}
|
||||
if (a->detail[0])
|
||||
cJSON_AddStringToObject(it, "detail", a->detail);
|
||||
if (a->origin[0])
|
||||
cJSON_AddStringToObject(it, "origin", a->origin);
|
||||
cJSON_AddItemToArray(arr, it);
|
||||
}
|
||||
cJSON_AddItemToObject(o, "attachments", arr);
|
||||
}
|
||||
char *txt = cJSON_PrintUnformatted(o);
|
||||
cJSON_Delete(o);
|
||||
if (!txt)
|
||||
@@ -310,6 +354,7 @@ int cst_session_clear(cst_session_t *s, int keep_system) {
|
||||
if (s->msgs[i].role == CST_ROLE_SYSTEM) {
|
||||
sys.role = CST_ROLE_SYSTEM;
|
||||
sys.content = xstrdup(s->msgs[i].content ? s->msgs[i].content : "");
|
||||
sys.meta_json = xstrdup(s->msgs[i].meta_json);
|
||||
have_sys = sys.content != NULL;
|
||||
break;
|
||||
}
|
||||
@@ -322,6 +367,7 @@ int cst_session_clear(cst_session_t *s, int keep_system) {
|
||||
write_line(s->fp, &sys);
|
||||
}
|
||||
free(sys.content);
|
||||
free(sys.meta_json);
|
||||
pthread_mutex_unlock(&s->mu);
|
||||
return rc;
|
||||
}
|
||||
@@ -339,6 +385,11 @@ int cst_session_rewrite(cst_session_t *s, const cst_message_t *msgs, int n) {
|
||||
copy[i].tool_calls_json =
|
||||
msgs[i].tool_calls_json ? strdup(msgs[i].tool_calls_json) : NULL;
|
||||
copy[i].meta_json = msgs[i].meta_json ? strdup(msgs[i].meta_json) : NULL;
|
||||
copy[i].reasoning = msgs[i].reasoning ? strdup(msgs[i].reasoning) : NULL;
|
||||
copy[i].attach = msgs[i].attach && msgs[i].nattach > 0
|
||||
? cst_attachments_dup(msgs[i].attach, msgs[i].nattach)
|
||||
: NULL;
|
||||
copy[i].nattach = copy[i].attach ? msgs[i].nattach : 0;
|
||||
}
|
||||
pthread_mutex_lock(&s->mu);
|
||||
free_all(s);
|
||||
@@ -352,6 +403,8 @@ int cst_session_rewrite(cst_session_t *s, const cst_message_t *msgs, int n) {
|
||||
free(copy[i].content);
|
||||
free(copy[i].tool_calls_json);
|
||||
free(copy[i].meta_json);
|
||||
free(copy[i].reasoning);
|
||||
cst_attachments_free(copy[i].attach, copy[i].nattach);
|
||||
}
|
||||
free(copy);
|
||||
return rc;
|
||||
|
||||
@@ -14,6 +14,7 @@
|
||||
|
||||
#include <regex.h>
|
||||
|
||||
#include "cst_attach.h"
|
||||
#include "cst_tools.h"
|
||||
#include "cst_util.h"
|
||||
#include "os_compat.h"
|
||||
@@ -241,6 +242,47 @@ int cst_tool_read_file2(const cst_tool_ctx_t *ctx, const ctl_tool_call_t *c,
|
||||
return tool_take_buf(r, &b, 0);
|
||||
}
|
||||
|
||||
/* --- view_image ---------------------------------------------------------- */
|
||||
|
||||
/* Show an image to the model: the bytes are copied into the session's
|
||||
* attachment store and travel as a multimodal content part of the result. */
|
||||
int cst_tool_view_image(const cst_tool_ctx_t *ctx, const ctl_tool_call_t *c,
|
||||
cst_tool_result_t *r) {
|
||||
const char *path = tool_arg(c, "path");
|
||||
if (!path || !path[0])
|
||||
return tool_set_result(r, "error: missing path", 1);
|
||||
const char *session = ctx->agent ? cst_agent_session_path(ctx->agent) : NULL;
|
||||
if (!session || !session[0])
|
||||
return tool_set_result(r, "error: no session to store the image in", 1);
|
||||
char full[OS_PATH_MAX];
|
||||
if (resolve(ctx, path, full, sizeof(full)) != 0)
|
||||
return tool_set_resultf(r, 1,
|
||||
"error: path outside workspace or missing parent: "
|
||||
"%.200s",
|
||||
path);
|
||||
if (is_dir(full))
|
||||
return tool_set_resultf(r, 1, "error: %.200s is a directory", path);
|
||||
|
||||
char err[256];
|
||||
cst_attachment_t *a = cst_attach_import_file(session, full, err, sizeof(err));
|
||||
if (!a)
|
||||
return tool_set_resultf(r, 1, "error: cannot show %.200s: %s", path, err);
|
||||
snprintf(a->origin, sizeof(a->origin), "view_image");
|
||||
const char *d = tool_arg(c, "detail");
|
||||
if (d && (strcmp(d, "low") == 0 || strcmp(d, "high") == 0))
|
||||
snprintf(a->detail, sizeof(a->detail), "%s", d);
|
||||
|
||||
char desc[128];
|
||||
cst_attach_describe(a, desc, sizeof(desc));
|
||||
cst_buf_t out = {0};
|
||||
cst_buf_printf(&out, "view_image %.200s: %s\n(shown to you as an image)\n",
|
||||
path, desc);
|
||||
int rc = tool_take_buf(r, &out, 0);
|
||||
r->attach = a; /* one entry; freed as a block by cst_tool_result_free */
|
||||
r->nattach = 1;
|
||||
return rc;
|
||||
}
|
||||
|
||||
/* --- edit_file ----------------------------------------------------------- */
|
||||
|
||||
static size_t count_occ(const char *hay, size_t hn, const char *needle,
|
||||
|
||||
+42
-4
@@ -56,6 +56,15 @@ static const cst_tool_def_t TOOLS[] = {
|
||||
{"limit", I, 0, "maximum number of lines"},
|
||||
{"line_numbers", B, 0, "`N|` line prefixes (default true)"}},
|
||||
CST_TP_READ, 1, run_read_file, NULL, NO_DYN},
|
||||
{"view_image",
|
||||
"Show a local image to yourself: PNG, JPEG, GIF, WebP or BMP, checked by "
|
||||
"content. The file is copied into the session store and comes back as an "
|
||||
"image you can actually see (not as text). Use it for screenshots, "
|
||||
"diagrams and UI checks; path resolves like read_file's.",
|
||||
NULL,
|
||||
{{"path", S, 1, "image file path relative to the workspace"},
|
||||
{"detail", S, 0, "low or high (provider hint; default auto)"}},
|
||||
CST_TP_READ, 0, cst_tool_view_image, NULL, NO_DYN},
|
||||
{"run_shell",
|
||||
"Run a non-interactive shell command in the workspace root for builds, "
|
||||
"tests, git and other CLIs (stdin is empty; long runs are killed). "
|
||||
@@ -333,8 +342,8 @@ int cst_tool_active(const cst_agent_config_t *cfg, const cst_tool_def_t *t) {
|
||||
return 1;
|
||||
if (cfg->tool_profile == CST_TOOLS_MINIMAL && !t->minimal)
|
||||
return 0;
|
||||
if ((cfg->plan_mode || cfg->read_only) &&
|
||||
(t->perm == CST_TP_WRITE || t->perm == CST_TP_SHELL))
|
||||
/* plan_mode is enforced when a call runs, so tools[] stays the same */
|
||||
if (cfg->read_only && (t->perm == CST_TP_WRITE || t->perm == CST_TP_SHELL))
|
||||
return 0;
|
||||
if (cfg->depth > 0 && strcmp(t->name, "task") == 0)
|
||||
return 0;
|
||||
@@ -413,16 +422,44 @@ static int is_minimal(const cst_agent_config_t *cfg) {
|
||||
return cfg && cfg->tool_profile == CST_TOOLS_MINIMAL;
|
||||
}
|
||||
|
||||
static int is_external(const cst_tool_def_t *t) {
|
||||
return t->owner && strncmp(t->owner, "builtin:", 8) != 0;
|
||||
}
|
||||
|
||||
static int by_name(const void *x, const void *y) {
|
||||
const cst_tool_def_t *a = *(const cst_tool_def_t *const *)x;
|
||||
const cst_tool_def_t *b = *(const cst_tool_def_t *const *)y;
|
||||
return strcmp(a->name, b->name);
|
||||
}
|
||||
|
||||
void *cst_tools_schema_cfg(const cst_agent_config_t *cfg) {
|
||||
cJSON *arr = cJSON_CreateArray();
|
||||
if (!arr)
|
||||
return NULL;
|
||||
int legacy = is_minimal(cfg);
|
||||
int n = cst_tool_count();
|
||||
/* Built-ins in registry order, then plugin/MCP tools by name: servers
|
||||
* finish starting in any order, and tools[] is part of the cached prefix. */
|
||||
const cst_tool_def_t **order = calloc((size_t)(n ? n : 1), sizeof(*order));
|
||||
if (!order) {
|
||||
cJSON_Delete(arr);
|
||||
return NULL;
|
||||
}
|
||||
int nb = 0, no = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
const cst_tool_def_t *t = cst_tool_at(i);
|
||||
if (!t || !cst_tool_active(cfg, t))
|
||||
continue;
|
||||
if (t && cst_tool_active(cfg, t) && !is_external(t))
|
||||
order[no++] = t;
|
||||
}
|
||||
nb = no;
|
||||
for (int i = 0; i < n; i++) {
|
||||
const cst_tool_def_t *t = cst_tool_at(i);
|
||||
if (t && cst_tool_active(cfg, t) && is_external(t))
|
||||
order[no++] = t;
|
||||
}
|
||||
qsort(order + nb, (size_t)(no - nb), sizeof(*order), by_name);
|
||||
for (int i = 0; i < no; i++) {
|
||||
const cst_tool_def_t *t = order[i];
|
||||
cJSON *tool = cJSON_CreateObject();
|
||||
cJSON_AddStringToObject(tool, "type", "function");
|
||||
cJSON *fn = cJSON_AddObjectToObject(tool, "function");
|
||||
@@ -457,6 +494,7 @@ void *cst_tools_schema_cfg(const cst_agent_config_t *cfg) {
|
||||
}
|
||||
cJSON_AddItemToArray(arr, tool);
|
||||
}
|
||||
free(order);
|
||||
return arr;
|
||||
}
|
||||
|
||||
|
||||
@@ -10,6 +10,7 @@
|
||||
|
||||
#include "cJSON.h"
|
||||
#include "cst_agent.h"
|
||||
#include "cst_attach.h"
|
||||
#include "cst_sandbox.h"
|
||||
#include "cst_util.h"
|
||||
#include "os_compat.h"
|
||||
@@ -26,6 +27,9 @@ void cst_tool_result_free(cst_tool_result_t *r) {
|
||||
free(r->out);
|
||||
r->out = NULL;
|
||||
r->out_len = 0;
|
||||
cst_attachments_free(r->attach, r->nattach);
|
||||
r->attach = NULL;
|
||||
r->nattach = 0;
|
||||
}
|
||||
|
||||
void cst_tool_call_clear(ctl_tool_call_t *c) {
|
||||
|
||||
@@ -48,6 +48,8 @@ int cst_tool_ask_user(const cst_tool_ctx_t *ctx, const ctl_tool_call_t *c,
|
||||
cst_tool_result_t *r);
|
||||
int cst_tool_web_fetch(const cst_tool_ctx_t *ctx, const ctl_tool_call_t *c,
|
||||
cst_tool_result_t *r);
|
||||
int cst_tool_view_image(const cst_tool_ctx_t *ctx, const ctl_tool_call_t *c,
|
||||
cst_tool_result_t *r);
|
||||
|
||||
int cst_preview_write_file(const cst_tool_ctx_t *ctx,
|
||||
const ctl_tool_call_t *c, char **out);
|
||||
|
||||
@@ -4,9 +4,12 @@
|
||||
|
||||
#include "cJSON.h"
|
||||
#include "cst_agent.h"
|
||||
#include "cst_attach.h"
|
||||
#include "cst_clipboard.h"
|
||||
#include "cst_keymap.h"
|
||||
#include "cst_ext.h"
|
||||
#include "cst_mcp.h"
|
||||
#include "cst_models.h"
|
||||
#include "cst_plugins.h"
|
||||
#include "cst_skills.h"
|
||||
#include "cst_subagent.h"
|
||||
@@ -340,6 +343,7 @@ typedef struct {
|
||||
size_t cur; /* cursor byte offset into inbuf */
|
||||
int in_paste;
|
||||
int paste_cr; /* last pasted byte was CR (fold CRLF) */
|
||||
size_t paste_at, paste_len0; /* cursor and length when the paste began */
|
||||
char status_msg[512];
|
||||
char title[128]; /* session title or first prompt, for the header */
|
||||
struct timespec ctrlc_at;
|
||||
@@ -1981,6 +1985,12 @@ static int ctx_percent(const tui_t *t, long *used) {
|
||||
return win > 0 ? (int)(*used * 100 / win) : 0;
|
||||
}
|
||||
|
||||
static const char *money_sym(const char *cur) {
|
||||
if (g_ascii && strcmp(cur, "¥") == 0)
|
||||
return "CNY ";
|
||||
return cur;
|
||||
}
|
||||
|
||||
static int approval_mode(const tui_t *t) {
|
||||
const cst_agent_config_t *cfg = cst_agent_config(t->agent);
|
||||
if (!cfg)
|
||||
@@ -2019,8 +2029,20 @@ static void draw_status(tui_t *t) {
|
||||
int pct = ctx_percent(t, &used);
|
||||
char tok[32];
|
||||
fmt_tokens(used, tok, sizeof(tok));
|
||||
snprintf(right, sizeof(right), "%s (%d%%)%s\033[97mctrl+p\033[39m commands",
|
||||
tok, pct, dot_sep());
|
||||
char usage[64] = "";
|
||||
cst_usage_t u;
|
||||
cst_agent_usage(t->agent, &u, NULL);
|
||||
if (u.requests > 0 && u.prompt > 0) {
|
||||
int n = snprintf(usage, sizeof(usage), "%shit %ld%%", dot_sep(),
|
||||
u.cached * 100 / u.prompt);
|
||||
if (u.priced && n > 0 && (size_t)n < sizeof(usage))
|
||||
snprintf(usage + n, sizeof(usage) - (size_t)n, "%s%s%s%.2f",
|
||||
dot_sep(), g_ascii ? "~" : "≈", money_sym(u.currency),
|
||||
u.cost);
|
||||
}
|
||||
snprintf(right, sizeof(right),
|
||||
"%s (%d%%)%s%s\033[97mctrl+p\033[39m commands", tok, pct, usage,
|
||||
dot_sep());
|
||||
rw = vis_cols(right);
|
||||
if (rw > w)
|
||||
rw = w;
|
||||
@@ -2078,7 +2100,14 @@ static void draw_mode_line(tui_t *t, WINDOW *w, int y, int maxw) {
|
||||
x += draw_ansi_at(w, y, x, room - x + 2, cfg->provider, CP_BOX_MUTED, 0, 0);
|
||||
if (eff) {
|
||||
x += draw_ansi_at(w, y, x, room - x + 2, dot_sep(), CP_BOX_MUTED, 0, 0);
|
||||
draw_ansi_at(w, y, x, room - x + 2, eff, CP_BOX_PRIMARY, 0, 0);
|
||||
x += draw_ansi_at(w, y, x, room - x + 2, eff, CP_BOX_PRIMARY, 0, 0);
|
||||
}
|
||||
int npick = cst_agent_pending_count(t->agent);
|
||||
if (npick > 0) {
|
||||
char mark[32];
|
||||
snprintf(mark, sizeof(mark), "%d image%s", npick, npick > 1 ? "s" : "");
|
||||
x += draw_ansi_at(w, y, x, room - x + 2, dot_sep(), CP_BOX_MUTED, 0, 0);
|
||||
draw_ansi_at(w, y, x, room - x + 2, mark, CP_BOX_PRIMARY, 0, 0);
|
||||
}
|
||||
if (rw)
|
||||
draw_ansi_at(w, y, maxw - rw - 2, rw, right, rpair, 0, 0);
|
||||
@@ -2789,11 +2818,23 @@ static void reload_hist_from_session(tui_t *t) {
|
||||
else
|
||||
b->expanded = 0;
|
||||
t->last_tool_idx = t->hist.n - 1;
|
||||
} else if (cst_message_is_note(m)) {
|
||||
b->kind = BLK_SYSTEM;
|
||||
const char *c = m->content ? m->content : "";
|
||||
const char *nl = strchr(c, '\n');
|
||||
block_set_body(b, c, nl ? (size_t)(nl - c) : strlen(c));
|
||||
} else if (m->role == CST_ROLE_USER) {
|
||||
b->kind = BLK_USER;
|
||||
block_set_title(b, "You");
|
||||
block_set_body(b, m->content ? m->content : "",
|
||||
m->content ? strlen(m->content) : 0);
|
||||
cst_buf_t ub = {0};
|
||||
cst_buf_puts(&ub, m->content ? m->content : "");
|
||||
for (int k = 0; k < m->nattach; k++) {
|
||||
char d[128];
|
||||
cst_attach_describe(&m->attach[k], d, sizeof(d));
|
||||
cst_buf_printf(&ub, "\n[image %s · %s]", m->attach[k].name, d);
|
||||
}
|
||||
block_set_body(b, ub.buf ? ub.buf : "", ub.len);
|
||||
cst_buf_free(&ub);
|
||||
b->expanded = 1;
|
||||
} else if (m->role == CST_ROLE_ASSISTANT) {
|
||||
b->kind = BLK_ASSISTANT;
|
||||
@@ -3839,6 +3880,7 @@ typedef struct {
|
||||
char provider[32];
|
||||
char base[512];
|
||||
char key[512];
|
||||
int have_cache; /* a cached list is showing: keep it if the fetch fails */
|
||||
} probe_arg_t;
|
||||
|
||||
static void am_store(const char *provider, int r, char ids[][128],
|
||||
@@ -3855,12 +3897,49 @@ static void am_store(const char *provider, int r, char ids[][128],
|
||||
pthread_mutex_unlock(&g_am_mu);
|
||||
}
|
||||
|
||||
/* GET /models; a good answer also refreshes models-cache/<provider>.json. */
|
||||
static int fetch_models(const char *provider, const char *base,
|
||||
const char *key, char ids[][128], int max, char *err,
|
||||
size_t err_sz) {
|
||||
cst_model_meta_t *m = calloc((size_t)max, sizeof(*m));
|
||||
if (!m) {
|
||||
snprintf(err, err_sz, "out of memory");
|
||||
return -1;
|
||||
}
|
||||
int r = cst_llm_list_models_meta(base, key, m, max, err, err_sz);
|
||||
if (r >= 0)
|
||||
cst_models_cache_save(provider, base, m, r);
|
||||
for (int i = 0; i < r; i++)
|
||||
snprintf(ids[i], 128, "%s", m[i].id);
|
||||
free(m);
|
||||
return r;
|
||||
}
|
||||
|
||||
/* The cached list for provider into ids: count, or -1; *fresh when it is
|
||||
* younger than CST_MODELS_CACHE_TTL. */
|
||||
static int cached_models(const char *provider, char ids[][128], int max,
|
||||
int *fresh) {
|
||||
*fresh = 0;
|
||||
cst_model_meta_t *m = calloc((size_t)max, sizeof(*m));
|
||||
if (!m)
|
||||
return -1;
|
||||
long age = 0;
|
||||
int n = cst_models_cache_load(provider, m, max, &age);
|
||||
for (int i = 0; i < n; i++)
|
||||
snprintf(ids[i], 128, "%s", m[i].id);
|
||||
free(m);
|
||||
*fresh = n > 0 && age >= 0 && age < CST_MODELS_CACHE_TTL;
|
||||
return n > 0 ? n : -1;
|
||||
}
|
||||
|
||||
static void *probe_thread(void *arg) {
|
||||
probe_arg_t *a = arg;
|
||||
static char ids[AM_MAX][128]; /* one probe runs per provider switch */
|
||||
char err[256];
|
||||
int r = cst_llm_list_models(a->base, a->key, ids, AM_MAX, err, sizeof(err));
|
||||
am_store(a->provider, r, ids, err);
|
||||
int r = fetch_models(a->provider, a->base, a->key, ids, AM_MAX, err,
|
||||
sizeof(err));
|
||||
if (r >= 0 || r == CST_MODELS_AUTH || !a->have_cache)
|
||||
am_store(a->provider, r, ids, err);
|
||||
memset(a->key, 0, sizeof(a->key));
|
||||
free(a);
|
||||
pthread_mutex_lock(&g_am_mu);
|
||||
@@ -3883,16 +3962,28 @@ static void start_probe(tui_t *t) {
|
||||
const cst_agent_config_t *cfg = cst_agent_config(t->agent);
|
||||
if (!cfg || !cfg->api_key[0] || g_am_threads > 0)
|
||||
return;
|
||||
static char ids[AM_MAX][128];
|
||||
int fresh = 0;
|
||||
int nc = cached_models(cfg->provider, ids, AM_MAX, &fresh);
|
||||
pthread_mutex_lock(&g_am_mu);
|
||||
snprintf(g_am.provider, sizeof(g_am.provider), "%s", cfg->provider);
|
||||
pthread_mutex_unlock(&g_am_mu);
|
||||
if (nc > 0)
|
||||
am_store(cfg->provider, nc, ids, "");
|
||||
if (fresh)
|
||||
return;
|
||||
probe_arg_t *a = calloc(1, sizeof(*a));
|
||||
if (!a)
|
||||
return;
|
||||
snprintf(a->provider, sizeof(a->provider), "%s", cfg->provider);
|
||||
snprintf(a->base, sizeof(a->base), "%s", cfg->api_base);
|
||||
snprintf(a->key, sizeof(a->key), "%s", cfg->api_key);
|
||||
a->have_cache = nc > 0;
|
||||
pthread_mutex_lock(&g_am_mu);
|
||||
snprintf(g_am.provider, sizeof(g_am.provider), "%s", cfg->provider);
|
||||
g_am.state = AM_RUNNING;
|
||||
g_am.n = 0;
|
||||
if (nc <= 0) {
|
||||
g_am.state = AM_RUNNING;
|
||||
g_am.n = 0;
|
||||
}
|
||||
g_am_threads++;
|
||||
pthread_mutex_unlock(&g_am_mu);
|
||||
pthread_t th;
|
||||
@@ -3973,7 +4064,7 @@ static int obtain_key(tui_t *t, const char *provider, char *out, size_t n,
|
||||
draw_status(t);
|
||||
static char ids[AM_MAX][128];
|
||||
char err[256];
|
||||
int r = cst_llm_list_models(base, out, ids, AM_MAX, err, sizeof(err));
|
||||
int r = fetch_models(provider, base, out, ids, AM_MAX, err, sizeof(err));
|
||||
if (r == CST_MODELS_AUTH) {
|
||||
snprintf(hint, sizeof(hint), "%s rejected that key (%.200s) — paste "
|
||||
"another one",
|
||||
@@ -4202,6 +4293,16 @@ static void cmd_delete(tui_t *t, char *arg, int *quit) {
|
||||
push_system_line(t, "(deleted session %s)", victim);
|
||||
}
|
||||
|
||||
/* "name 1M · vision (api)" for the /model picker. */
|
||||
static void model_label(const char *provider, const char *name, int api,
|
||||
char *out, size_t n) {
|
||||
cst_model_info_t mi;
|
||||
cst_model_info(provider, name, &mi);
|
||||
char tag[40];
|
||||
cst_model_info_label(&mi, tag, sizeof(tag));
|
||||
snprintf(out, n, "%-40.72s %.32s%s", name, tag, api ? " (api)" : "");
|
||||
}
|
||||
|
||||
static void cmd_model(tui_t *t, char *arg, int *quit) {
|
||||
(void)quit;
|
||||
cst_agent_config_t *cfg = cst_agent_config_mut(t->agent);
|
||||
@@ -4212,8 +4313,8 @@ static void cmd_model(tui_t *t, char *arg, int *quit) {
|
||||
set_status(t, "fetching the model list…");
|
||||
draw_status(t);
|
||||
char err[256];
|
||||
na = cst_llm_list_models(cfg->api_base, cfg->api_key, names, AM_MAX, err,
|
||||
sizeof(err));
|
||||
na = fetch_models(cfg->provider, cfg->api_base, cfg->api_key, names,
|
||||
AM_MAX, err, sizeof(err));
|
||||
pthread_mutex_lock(&g_am_mu);
|
||||
snprintf(g_am.provider, sizeof(g_am.provider), "%s", cfg->provider);
|
||||
pthread_mutex_unlock(&g_am_mu);
|
||||
@@ -4226,7 +4327,7 @@ static void cmd_model(tui_t *t, char *arg, int *quit) {
|
||||
if (na < 0)
|
||||
na = 0;
|
||||
for (int i = 0; i < na; i++)
|
||||
snprintf(labels[i], 128, "%.100s (api)", names[i]);
|
||||
model_label(cfg->provider, names[i], 1, labels[i], 128);
|
||||
char builtin[32][128];
|
||||
int nb = cst_models_list(cfg->model, builtin, 32);
|
||||
int n = na;
|
||||
@@ -4237,7 +4338,7 @@ static void cmd_model(tui_t *t, char *arg, int *quit) {
|
||||
if (dup)
|
||||
continue;
|
||||
memcpy(names[n], builtin[i], 128);
|
||||
memcpy(labels[n], builtin[i], 128);
|
||||
model_label(cfg->provider, builtin[i], 0, labels[n], 128);
|
||||
n++;
|
||||
}
|
||||
int cur_idx = -1;
|
||||
@@ -4252,8 +4353,13 @@ static void cmd_model(tui_t *t, char *arg, int *quit) {
|
||||
snprintf(cfg->model, sizeof(cfg->model), "%.127s", arg);
|
||||
}
|
||||
cst_settings_remember(cfg);
|
||||
push_system_line(t, "(model → %s, context %ld tokens)", cfg->model,
|
||||
cst_model_context_tokens(cfg->model));
|
||||
cst_model_info_t mi;
|
||||
cst_model_info(cfg->provider, cfg->model, &mi);
|
||||
push_system_line(t, "(model → %s, context %ld tokens%s)", cfg->model,
|
||||
mi.context,
|
||||
mi.vision == 1 ? ", takes images"
|
||||
: mi.vision == 0 ? ", text only"
|
||||
: "");
|
||||
}
|
||||
|
||||
static void cmd_key(tui_t *t, char *arg, int *quit) {
|
||||
@@ -4320,16 +4426,18 @@ static void cmd_provider(tui_t *t, char *arg, int *quit) {
|
||||
}
|
||||
} else {
|
||||
int n = cst_provider_count();
|
||||
char items[16][128];
|
||||
char items[32][128];
|
||||
int cur_idx = 0;
|
||||
for (int i = 0; i < n && i < 16; i++) {
|
||||
for (int i = 0; i < n && i < 32; i++) {
|
||||
const cst_provider_t *q = cst_provider_at(i);
|
||||
snprintf(items[i], 128, "%-11s %s (%s)", q->name, q->api_base,
|
||||
q->model[0] ? q->model : "models from API");
|
||||
snprintf(items[i], 128, "%-11.24s %.48s (%.24s%s)", q->name,
|
||||
q->api_base, q->model[0] ? q->model : "models from API",
|
||||
strcmp(cst_provider_source(q), "user") == 0 ? " · models.json"
|
||||
: "");
|
||||
if (strcmp(q->name, cfg->provider) == 0)
|
||||
cur_idx = i;
|
||||
}
|
||||
int pick = picker_run(t, "Provider", items, n < 16 ? n : 16, cur_idx);
|
||||
int pick = picker_run(t, "Provider", items, n < 32 ? n : 32, cur_idx);
|
||||
if (pick < 0)
|
||||
return;
|
||||
p = cst_provider_at(pick);
|
||||
@@ -4568,6 +4676,15 @@ static void cmd_status(tui_t *t, char *arg, int *quit) {
|
||||
push_system_line(t, " provider %s %s", cfg->provider, cfg->api_base);
|
||||
push_system_line(t, " model %s context %ld/%ld tokens (%ld%%)",
|
||||
cfg->model, used, win, win ? used * 100 / win : 0);
|
||||
{
|
||||
cst_model_info_t mi;
|
||||
cst_model_info(cfg->provider, cfg->model, &mi);
|
||||
char tag[48];
|
||||
cst_model_info_label(&mi, tag, sizeof(tag));
|
||||
push_system_line(t, " model info %s · from %s%s%s", tag, mi.source,
|
||||
cst_models_load_error()[0] ? " · " : "",
|
||||
cst_models_load_error());
|
||||
}
|
||||
push_system_line(t, " effort %s%s", cfg->effort,
|
||||
cst_effort_wire(cfg->provider, cfg->model, cfg->effort)
|
||||
? ""
|
||||
@@ -4596,6 +4713,57 @@ static void cmd_status(tui_t *t, char *arg, int *quit) {
|
||||
notes && notes[0] ? "AGENTS.md loaded" : "(no AGENTS.md)");
|
||||
push_system_line(t, " undo %d turn(s) can be undone",
|
||||
cst_agent_undo_available(t->agent));
|
||||
cst_usage_t u;
|
||||
cst_agent_usage(t->agent, &u, NULL);
|
||||
if (u.requests > 0 && u.prompt > 0)
|
||||
push_system_line(t, " cache %ld%% of %ld prompt tokens hit (/cost)",
|
||||
u.cached * 100 / u.prompt, u.prompt);
|
||||
}
|
||||
|
||||
static void push_usage(tui_t *t, const char *label, const cst_usage_t *u) {
|
||||
if (u->requests == 0) {
|
||||
push_system_line(t, " %-9s no requests yet", label);
|
||||
return;
|
||||
}
|
||||
long hitp = u->prompt > 0 ? u->cached * 100 / u->prompt : 0;
|
||||
push_system_line(t,
|
||||
" %-9s %d request(s) · prompt %ld (hit %ld = %ld%%, miss "
|
||||
"%ld) · output %ld",
|
||||
label, u->requests, u->prompt, u->cached, hitp, u->miss,
|
||||
u->out);
|
||||
if (u->write)
|
||||
push_system_line(t, " %-9s cache write %ld tokens", "", u->write);
|
||||
if (u->priced)
|
||||
push_system_line(t, " %-9s %s %s%.4f", "", g_ascii ? "~" : "≈",
|
||||
money_sym(u->currency), u->cost);
|
||||
}
|
||||
|
||||
static void cmd_cost(tui_t *t, char *arg, int *quit) {
|
||||
(void)arg;
|
||||
(void)quit;
|
||||
const cst_agent_config_t *cfg = cst_agent_config(t->agent);
|
||||
cst_usage_t s, last;
|
||||
cst_agent_usage(t->agent, &s, &last);
|
||||
push_system_line(t, "Token use and cost (%s):", cfg->model);
|
||||
push_usage(t, "session", &s);
|
||||
push_usage(t, "last turn", &last);
|
||||
cst_price_t p;
|
||||
if (cst_model_price(cfg->model, &p) != 0) {
|
||||
push_system_line(t, " price unknown for this model; set "
|
||||
"CST_PRICE=miss,hit,out[,write[,currency]] (per 1M "
|
||||
"tokens)");
|
||||
return;
|
||||
}
|
||||
const char *c = money_sym(p.currency);
|
||||
push_system_line(t,
|
||||
" price per 1M tokens: miss %s%.2f · hit %s%.2f · "
|
||||
"output %s%.2f",
|
||||
c, p.miss, c, p.hit, c, p.out);
|
||||
if (p.offpeak_half)
|
||||
push_system_line(t,
|
||||
" now %s (off-peak is half price: outside "
|
||||
"Mon–Fri 9–12 / 14–18 Beijing time)",
|
||||
cst_price_is_peak(time(NULL)) ? "peak" : "off-peak");
|
||||
}
|
||||
|
||||
static void cmd_todo(tui_t *t, char *arg, int *quit) {
|
||||
@@ -4707,8 +4875,17 @@ static void cmd_export(tui_t *t, char *arg, int *quit) {
|
||||
if (msg_is_tool_result(m)) {
|
||||
fprintf(fp, "**Tool result** `%s`\n\n", m->tool_name);
|
||||
md_fence(fp, c, 4000);
|
||||
} else if (cst_message_is_note(m)) {
|
||||
fprintf(fp, "> %.*s\n\n", (int)strcspn(c, "\n"), c);
|
||||
} else if (m->role == CST_ROLE_USER) {
|
||||
fprintf(fp, "## User\n\n%s\n\n", c);
|
||||
for (int k = 0; k < m->nattach; k++) {
|
||||
char d[128];
|
||||
cst_attach_describe(&m->attach[k], d, sizeof(d));
|
||||
fprintf(fp, "- image `%s` (%s)\n", m->attach[k].name, d);
|
||||
}
|
||||
if (m->nattach)
|
||||
fputc('\n', fp);
|
||||
} else {
|
||||
fprintf(fp, "## Assistant\n\n%s\n\n", c);
|
||||
if (m->tool_calls_json && m->tool_calls_json[0]) {
|
||||
@@ -4722,6 +4899,116 @@ static void cmd_export(tui_t *t, char *arg, int *quit) {
|
||||
push_system_line(t, "(exported to %s)", path);
|
||||
}
|
||||
|
||||
/* The newest `added` picks, and a warning when the model would not see them. */
|
||||
static void report_attached(tui_t *t, int added) {
|
||||
int n = cst_agent_pending_count(t->agent);
|
||||
for (int i = n - added; i < n; i++) {
|
||||
char line[256];
|
||||
if (i >= 0 &&
|
||||
cst_agent_pending_describe(t->agent, i, line, sizeof(line)) == 0)
|
||||
push_system_line(t, "Attached %s — it goes with your next message.",
|
||||
line);
|
||||
}
|
||||
if (added > 0 && cst_agent_sees_images(t->agent) == 0)
|
||||
push_system_line(t, "Note: %s does not take images; they are sent as a "
|
||||
"text note until you /model to one that does.",
|
||||
cst_agent_config(t->agent)->model);
|
||||
}
|
||||
|
||||
/* /attach: stage images for the next user message. The bytes are copied into
|
||||
* the session's attachment directory now, so a picture picked from /tmp keeps
|
||||
* working after the file is gone. */
|
||||
static void cmd_attach(tui_t *t, char *arg, int *quit) {
|
||||
(void)quit;
|
||||
int n = cst_agent_pending_count(t->agent);
|
||||
if (!arg || !arg[0] || strcmp(arg, "list") == 0) {
|
||||
if (n == 0) {
|
||||
push_system_line(t, "No images picked. Usage: /attach <path>");
|
||||
return;
|
||||
}
|
||||
push_system_line(t, "%d image%s with the next message (sent once):", n,
|
||||
n > 1 ? "s" : "");
|
||||
for (int i = 0; i < n; i++) {
|
||||
char line[256];
|
||||
if (cst_agent_pending_describe(t->agent, i, line, sizeof(line)) == 0)
|
||||
push_system_line(t, " %d. %s", i + 1, line);
|
||||
}
|
||||
push_system_line(t, "(/attach clear drops them)");
|
||||
return;
|
||||
}
|
||||
if (strcmp(arg, "clear") == 0 || strcmp(arg, "none") == 0) {
|
||||
cst_agent_pending_clear(t->agent);
|
||||
push_system_line(t, "Dropped the picked images.");
|
||||
return;
|
||||
}
|
||||
char err[256];
|
||||
if (strcmp(arg, "paste") == 0) {
|
||||
char *img = NULL;
|
||||
size_t len = 0;
|
||||
if (cst_clipboard_image(&img, &len, err, sizeof(err)) != 0) {
|
||||
push_system_line(t, "Error: %s", err);
|
||||
return;
|
||||
}
|
||||
char mime[32], name[32];
|
||||
const char *ext = cst_attach_sniff(img, len, mime, sizeof(mime)) == 0 &&
|
||||
strchr(mime, '/')
|
||||
? strchr(mime, '/') + 1
|
||||
: "png";
|
||||
snprintf(name, sizeof(name), "clipboard.%s", ext);
|
||||
int rc = cst_agent_attach_bytes(t->agent, name, img, len, err, sizeof(err));
|
||||
free(img);
|
||||
if (rc != 0) {
|
||||
push_system_line(t, "Error: %s", err);
|
||||
return;
|
||||
}
|
||||
report_attached(t, 1);
|
||||
return;
|
||||
}
|
||||
if (cst_agent_attach_file(t->agent, arg, err, sizeof(err)) != 0) {
|
||||
push_system_line(t, "Error: %s", err);
|
||||
return;
|
||||
}
|
||||
report_attached(t, 1);
|
||||
}
|
||||
|
||||
static int file_is_image(const char *path) {
|
||||
FILE *f = fopen(path, "rb");
|
||||
if (!f)
|
||||
return 0;
|
||||
unsigned char head[16];
|
||||
size_t got = fread(head, 1, sizeof(head), f);
|
||||
fclose(f);
|
||||
char mime[32];
|
||||
return cst_attach_sniff(head, got, mime, sizeof(mime)) == 0;
|
||||
}
|
||||
|
||||
/* A paste that is nothing but image file paths (a file dropped on the
|
||||
* terminal) attaches those files instead of typing the paths. */
|
||||
static void paste_image_paths(tui_t *t) {
|
||||
size_t from = t->paste_at, to = t->cur;
|
||||
if (to <= from || to - from != t->in_len - t->paste_len0 ||
|
||||
to - from > CST_PASTE_MAX_PATHS * CST_PASTE_PATH_MAX)
|
||||
return;
|
||||
static char paths[CST_PASTE_MAX_PATHS][CST_PASTE_PATH_MAX];
|
||||
int n = cst_paste_paths(t->inbuf + from, to - from, paths,
|
||||
CST_PASTE_MAX_PATHS);
|
||||
if (n <= 0)
|
||||
return;
|
||||
for (int i = 0; i < n; i++)
|
||||
if (!file_is_image(paths[i]))
|
||||
return;
|
||||
input_erase(t, from, to);
|
||||
int added = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
char err[256];
|
||||
if (cst_agent_attach_file(t->agent, paths[i], err, sizeof(err)) == 0)
|
||||
added++;
|
||||
else
|
||||
push_system_line(t, "Error: %s", err);
|
||||
}
|
||||
report_attached(t, added);
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
#define COPY_VIA "clipboard"
|
||||
#else
|
||||
@@ -5015,7 +5302,7 @@ static void show_subagent(tui_t *t, const char *pid,
|
||||
const char *final = NULL;
|
||||
for (int i = 0; i < n; i++) {
|
||||
const cst_message_t *m = cst_session_get(s, i);
|
||||
if (!m->content)
|
||||
if (!m->content || cst_message_is_note(m))
|
||||
continue;
|
||||
if (m->role == CST_ROLE_USER && !m->tool_call_id[0]) {
|
||||
push_system_line(t, " prompt: %.300s", m->content);
|
||||
@@ -5118,6 +5405,8 @@ static const slash_cmd_t SLASH[] = {
|
||||
cmd_mouse},
|
||||
{"max-steps", "", "[N]", "tool steps allowed per turn", 1, cmd_max_steps},
|
||||
{"status", "", "", "session, model, context and settings", 1, cmd_status},
|
||||
{"cost", "usage", "", "tokens, cache hit rate and estimated cost", 1,
|
||||
cmd_cost},
|
||||
{"todo", "tasks", "", "show the agent's task list", 1, cmd_todo},
|
||||
{"undo", "", "", "revert file changes of the last turn", 0, cmd_undo},
|
||||
{"retry", "", "", "drop the last reply and ask again", 0, cmd_retry},
|
||||
@@ -5127,6 +5416,9 @@ static const slash_cmd_t SLASH[] = {
|
||||
{"export", "", "[file]", "write the transcript as Markdown", 1,
|
||||
cmd_export},
|
||||
{"copy", "", "", "copy the last reply (OSC 52)", 1, cmd_copy},
|
||||
{"attach", "image", "[path|paste|clear]",
|
||||
"send image(s) with the next message",
|
||||
1, cmd_attach},
|
||||
{"init", "", "", "have the agent write AGENTS.md", 0, cmd_init},
|
||||
{"details", "", "", "expand/collapse all tool output", 1, cmd_details},
|
||||
{"thinking", "", "[on|off]", "show Thought blocks expanded or collapsed",
|
||||
@@ -5430,7 +5722,15 @@ static int begin_turn(tui_t *t, char *prompt) {
|
||||
if (ub) {
|
||||
ub->kind = BLK_USER;
|
||||
block_set_title(ub, "You");
|
||||
block_set_body(ub, prompt, strlen(prompt));
|
||||
cst_buf_t body = {0};
|
||||
cst_buf_puts(&body, prompt);
|
||||
for (int k = 0; k < cst_agent_pending_count(t->agent); k++) {
|
||||
char d[128];
|
||||
if (cst_agent_pending_describe(t->agent, k, d, sizeof(d)) == 0)
|
||||
cst_buf_printf(&body, "\n[image %s]", d);
|
||||
}
|
||||
block_set_body(ub, body.buf ? body.buf : "", body.len);
|
||||
cst_buf_free(&body);
|
||||
ub->expanded = 1;
|
||||
}
|
||||
t->think_idx = -1;
|
||||
@@ -6646,10 +6946,13 @@ int cst_tui_run(cst_agent_t *agent) {
|
||||
if (wch == KEY_PASTE_BEGIN) {
|
||||
t.in_paste = 1;
|
||||
t.paste_cr = 0;
|
||||
t.paste_at = t.cur;
|
||||
t.paste_len0 = t.in_len;
|
||||
continue;
|
||||
}
|
||||
if (wch == KEY_PASTE_END) {
|
||||
t.in_paste = 0;
|
||||
paste_image_paths(&t);
|
||||
input_changed(&t);
|
||||
after_edit(&t);
|
||||
continue;
|
||||
|
||||
Reference in New Issue
Block a user