xonecas.io
7814
Ta

tiny-c-agent / commit b8c7cd6

feat: skills, prompts and other wires.

xonecas2026-10-03 b8c7cd609c662a21d15df8a87a5cc9a78eb1283a parent bc37a5d

28 files changed

This diff is too big to show in full. The first 1000 lines are below, and every file is listed with its counts.

src/agent.c+1−1
@@ -244,7 +244,7 @@ void cage_agent_turn(cage_agent *a, const char *input) {
244244 .messages_len = a->messages_len,
245245 };
246246 cage_stream_opts opts = {
247- .effort = a->effort,
247+ .effort = a->model.effort,
248248 .session_id = a->session ? cage_session_id(a->session) : NULL,
249249 };
250250
src/agent.h+0−1
@@ -17,7 +17,6 @@ typedef struct {
1717 const char *system_prompt;
1818 const cage_tool *tools;
1919 size_t tools_len;
20- const char *effort;
2120
2221 // Tool execution. Required once the model asks for a tool.
2322 cage_runtime *runtime;
src/api.h+18−0
@@ -11,4 +11,22 @@ int cage_openai_completions_stream(const cage_model *model, const cage_context *
1111 const volatile bool *cancel,
1212 cage_message *out, char **err);
1313
14+int cage_openai_responses_stream(const cage_model *model, const cage_context *ctx,
15+ const cage_stream_opts *opts,
16+ cage_stream_fn emit, void *user,
17+ const volatile bool *cancel,
18+ cage_message *out, char **err);
19+
20+int cage_anthropic_messages_stream(const cage_model *model, const cage_context *ctx,
21+ const cage_stream_opts *opts,
22+ cage_stream_fn emit, void *user,
23+ const volatile bool *cancel,
24+ cage_message *out, char **err);
25+
26+int cage_google_generative_ai_stream(const cage_model *model, const cage_context *ctx,
27+ const cage_stream_opts *opts,
28+ cage_stream_fn emit, void *user,
29+ const volatile bool *cancel,
30+ cage_message *out, char **err);
31+
1432 #endif
src/api/anthropic_messages.c+490−0
@@ -0,0 +1,490 @@
1+// Anthropic Messages API streaming adapter.
2+
3+#include "api.h"
4+
5+#include <stdarg.h>
6+#include <stdio.h>
7+#include <stdlib.h>
8+#include <string.h>
9+
10+#include <yyjson.h>
11+
12+#include "http.h"
13+
14+#define ANTHROPIC_VERSION "2023-06-01"
15+
16+static void *xmalloc(size_t n) {
17+ void *p = malloc(n);
18+ if (!p) abort();
19+ return p;
20+}
21+
22+static char *xstrdup(const char *s) {
23+ size_t n = strlen(s) + 1;
24+ char *p = xmalloc(n);
25+ memcpy(p, s, n);
26+ return p;
27+}
28+
29+static int fail(char **err, const char *fmt, ...) {
30+ char detail[512];
31+ va_list ap;
32+ va_start(ap, fmt);
33+ vsnprintf(detail, sizeof detail, fmt, ap);
34+ va_end(ap);
35+ *err = xstrdup(detail);
36+ return -1;
37+}
38+
39+typedef struct {
40+ char *data;
41+ size_t len;
42+ size_t cap;
43+} buf;
44+
45+static void buf_add(buf *b, const char *p, size_t n) {
46+ if (b->len + n + 1 > b->cap) {
47+ size_t cap = b->cap ? b->cap : 64;
48+ while (cap < b->len + n + 1) cap *= 2;
49+ b->data = realloc(b->data, cap);
50+ if (!b->data) abort();
51+ b->cap = cap;
52+ }
53+ memcpy(b->data + b->len, p, n);
54+ b->len += n;
55+ b->data[b->len] = '\0';
56+}
57+
58+// ---- request --------------------------------------------------------------
59+
60+static void add_image_block(yyjson_mut_doc *doc, yyjson_mut_val *content,
61+ const cage_block *b) {
62+ yyjson_mut_val *img = yyjson_mut_obj(doc);
63+ yyjson_mut_arr_add_val(content, img);
64+ yyjson_mut_obj_add_strcpy(doc, img, "type", "image");
65+ yyjson_mut_val *src = yyjson_mut_obj(doc);
66+ yyjson_mut_obj_add_val(doc, img, "source", src);
67+ yyjson_mut_obj_add_strcpy(doc, src, "type", "base64");
68+ yyjson_mut_obj_add_strcpy(doc, src, "media_type", b->media_type ? b->media_type : "");
69+ yyjson_mut_obj_add_strcpy(doc, src, "data", b->data ? b->data : "");
70+}
71+
72+static void add_tool_result(yyjson_mut_doc *doc, yyjson_mut_val *messages, const cage_message *m) {
73+ yyjson_mut_val *um = yyjson_mut_obj(doc);
74+ yyjson_mut_arr_add_val(messages, um);
75+ yyjson_mut_obj_add_strcpy(doc, um, "role", "user");
76+ yyjson_mut_val *content = yyjson_mut_arr(doc);
77+ yyjson_mut_obj_add_val(doc, um, "content", content);
78+
79+ yyjson_mut_val *tr = yyjson_mut_obj(doc);
80+ yyjson_mut_arr_add_val(content, tr);
81+ yyjson_mut_obj_add_strcpy(doc, tr, "type", "tool_result");
82+ yyjson_mut_obj_add_strcpy(doc, tr, "tool_use_id", m->tool_call_id ? m->tool_call_id : "");
83+ if (m->is_error) yyjson_mut_obj_add_bool(doc, tr, "is_error", true);
84+
85+ bool has_images = cage_message_has_image(m);
86+ if (!has_images) {
87+ buf t = {0};
88+ for (size_t i = 0; i < m->blocks_len; i++)
89+ if (m->blocks[i].type == CAGE_BLOCK_TEXT && m->blocks[i].text)
90+ buf_add(&t, m->blocks[i].text, strlen(m->blocks[i].text));
91+ yyjson_mut_obj_add_strcpy(doc, tr, "content", t.data ? t.data : "");
92+ free(t.data);
93+ return;
94+ }
95+ yyjson_mut_val *blocks = yyjson_mut_arr(doc);
96+ yyjson_mut_obj_add_val(doc, tr, "content", blocks);
97+ for (size_t i = 0; i < m->blocks_len; i++) {
98+ const cage_block *b = &m->blocks[i];
99+ if (b->type == CAGE_BLOCK_TEXT) {
100+ yyjson_mut_val *tx = yyjson_mut_obj(doc);
101+ yyjson_mut_arr_add_val(blocks, tx);
102+ yyjson_mut_obj_add_strcpy(doc, tx, "type", "text");
103+ yyjson_mut_obj_add_strcpy(doc, tx, "text", b->text ? b->text : "");
104+ } else if (b->type == CAGE_BLOCK_IMAGE) {
105+ add_image_block(doc, blocks, b);
106+ }
107+ }
108+}
109+
110+static void add_message(yyjson_mut_doc *doc, yyjson_mut_val *messages, const cage_message *m) {
111+ yyjson_mut_val *o = yyjson_mut_obj(doc);
112+ yyjson_mut_arr_add_val(messages, o);
113+ yyjson_mut_obj_add_strcpy(doc, o, "role", m->role == CAGE_ROLE_ASSISTANT ? "assistant" : "user");
114+ yyjson_mut_val *content = yyjson_mut_arr(doc);
115+ yyjson_mut_obj_add_val(doc, o, "content", content);
116+ for (size_t i = 0; i < m->blocks_len; i++) {
117+ const cage_block *b = &m->blocks[i];
118+ if (b->type == CAGE_BLOCK_TEXT) {
119+ yyjson_mut_val *tx = yyjson_mut_obj(doc);
120+ yyjson_mut_arr_add_val(content, tx);
121+ yyjson_mut_obj_add_strcpy(doc, tx, "type", "text");
122+ yyjson_mut_obj_add_strcpy(doc, tx, "text", b->text ? b->text : "");
123+ } else if (b->type == CAGE_BLOCK_IMAGE) {
124+ add_image_block(doc, content, b);
125+ } else if (b->type == CAGE_BLOCK_TOOL_CALL) {
126+ yyjson_mut_val *tu = yyjson_mut_obj(doc);
127+ yyjson_mut_arr_add_val(content, tu);
128+ yyjson_mut_obj_add_strcpy(doc, tu, "type", "tool_use");
129+ yyjson_mut_obj_add_strcpy(doc, tu, "id", b->tool_call_id ? b->tool_call_id : "");
130+ yyjson_mut_obj_add_strcpy(doc, tu, "name", b->tool_name ? b->tool_name : "");
131+ yyjson_doc *adoc = b->arguments ? yyjson_read(b->arguments, strlen(b->arguments), 0) : NULL;
132+ if (adoc && yyjson_is_obj(yyjson_doc_get_root(adoc))) {
133+ yyjson_mut_val *copy = yyjson_val_mut_copy(doc, yyjson_doc_get_root(adoc));
134+ yyjson_mut_obj_add_val(doc, tu, "input", copy);
135+ } else {
136+ yyjson_mut_val *empty = yyjson_mut_obj(doc);
137+ yyjson_mut_obj_add_val(doc, tu, "input", empty);
138+ }
139+ if (adoc) yyjson_doc_free(adoc);
140+ }
141+ }
142+}
143+
144+static void add_tools(yyjson_mut_doc *doc, yyjson_mut_val *root, const cage_context *ctx) {
145+ if (ctx->tools_len == 0) return;
146+ yyjson_mut_val *tools = yyjson_mut_arr(doc);
147+ yyjson_mut_obj_add_val(doc, root, "tools", tools);
148+ for (size_t i = 0; i < ctx->tools_len; i++) {
149+ const cage_tool *t = &ctx->tools[i];
150+ yyjson_mut_val *tool = yyjson_mut_obj(doc);
151+ yyjson_mut_arr_add_val(tools, tool);
152+ yyjson_mut_obj_add_strcpy(doc, tool, "name", t->name);
153+ yyjson_mut_obj_add_strcpy(doc, tool, "description", t->description ? t->description : "");
154+ const char *params = t->parameters ? t->parameters : "{}";
155+ yyjson_doc *pdoc = yyjson_read(params, strlen(params), 0);
156+ if (pdoc) {
157+ yyjson_mut_val *copy = yyjson_val_mut_copy(doc, yyjson_doc_get_root(pdoc));
158+ yyjson_mut_obj_add_val(doc, tool, "input_schema", copy);
159+ yyjson_doc_free(pdoc);
160+ }
161+ }
162+}
163+
164+// Thinking budget per effort level. Anthropic requires max_tokens > budget.
165+static long budget_for(const char *effort) {
166+ if (!effort) return 0;
167+ if (strcmp(effort, "minimal") == 0) return 1024;
168+ if (strcmp(effort, "low") == 0) return 2048;
169+ if (strcmp(effort, "medium") == 0) return 4096;
170+ if (strcmp(effort, "high") == 0) return 8192;
171+ if (strcmp(effort, "xhigh") == 0) return 16384;
172+ if (strcmp(effort, "max") == 0) return 32768;
173+ return 0;
174+}
175+
176+static char *build_request(const cage_model *model, const cage_context *ctx,
177+ const cage_stream_opts *opts) {
178+ yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);
179+ yyjson_mut_val *root = yyjson_mut_obj(doc);
180+ yyjson_mut_doc_set_root(doc, root);
181+
182+ long budget = opts ? budget_for(opts->effort) : 0;
183+ long max_tokens = opts && opts->max_tokens > 0 ? opts->max_tokens : 8192;
184+ if (budget > 0 && max_tokens <= budget) max_tokens = budget + 4096;
185+
186+ yyjson_mut_obj_add_strcpy(doc, root, "model", model->model ? model->model : "");
187+ yyjson_mut_obj_add_int(doc, root, "max_tokens", max_tokens);
188+ yyjson_mut_obj_add_bool(doc, root, "stream", true);
189+ if (ctx->system_prompt && ctx->system_prompt[0])
190+ yyjson_mut_obj_add_strcpy(doc, root, "system", ctx->system_prompt);
191+ if (budget > 0) {
192+ yyjson_mut_val *thinking = yyjson_mut_obj(doc);
193+ yyjson_mut_obj_add_val(doc, root, "thinking", thinking);
194+ yyjson_mut_obj_add_strcpy(doc, thinking, "type", "enabled");
195+ yyjson_mut_obj_add_int(doc, thinking, "budget_tokens", budget);
196+ }
197+
198+ yyjson_mut_val *messages = yyjson_mut_arr(doc);
199+ yyjson_mut_obj_add_val(doc, root, "messages", messages);
200+ for (size_t i = 0; i < ctx->messages_len;) {
201+ if (ctx->messages[i].role == CAGE_ROLE_TOOL) {
202+ // All results of one assistant turn share a single user message.
203+ size_t j = i;
204+ for (; j < ctx->messages_len && ctx->messages[j].role == CAGE_ROLE_TOOL; j++)
205+ add_tool_result(doc, messages, &ctx->messages[j]);
206+ i = j;
207+ } else {
208+ add_message(doc, messages, &ctx->messages[i]);
209+ i++;
210+ }
211+ }
212+
213+ add_tools(doc, root, ctx);
214+
215+ size_t len = 0;
216+ char *body = yyjson_mut_write(doc, 0, &len);
217+ yyjson_mut_doc_free(doc);
218+ return body;
219+}
220+
221+// ---- streaming state ------------------------------------------------------
222+
223+enum { BLK_TEXT, BLK_THINKING, BLK_TOOL };
224+
225+typedef struct {
226+ int type;
227+ buf text;
228+ char *id;
229+ char *name;
230+ buf args;
231+} block_acc;
232+
233+typedef struct {
234+ block_acc *blocks;
235+ size_t blocks_len;
236+ long tokens_in;
237+ long tokens_out;
238+ char *stop_reason;
239+ char *error;
240+ cage_stream_fn emit;
241+ void *user;
242+} anth_state;
243+
244+static void emit_delta(anth_state *st, cage_stream_type type, const char *delta) {
245+ if (!st->emit) return;
246+ cage_stream_event ev = {.type = type, .delta = delta};
247+ st->emit(&ev, st->user);
248+}
249+
250+static block_acc *block_at(anth_state *st, size_t index) {
251+ if (index >= st->blocks_len) {
252+ st->blocks = realloc(st->blocks, (index + 1) * sizeof *st->blocks);
253+ if (!st->blocks) abort();
254+ memset(&st->blocks[st->blocks_len], 0, (index + 1 - st->blocks_len) * sizeof *st->blocks);
255+ st->blocks_len = index + 1;
256+ }
257+ return &st->blocks[index];
258+}
259+
260+static void set_str(char **dst, const char *src) {
261+ free(*dst);
262+ *dst = xstrdup(src ? src : "");
263+}
264+
265+static void handle_data(anth_state *st, const char *json, size_t len) {
266+ yyjson_doc *doc = yyjson_read(json, len, 0);
267+ if (!doc) {
268+ if (!st->error) st->error = xstrdup("stream: invalid JSON chunk");
269+ return;
270+ }
271+ yyjson_val *root = yyjson_doc_get_root(doc);
272+ yyjson_val *tv = yyjson_obj_get(root, "type");
273+ const char *type = yyjson_is_str(tv) ? yyjson_get_str(tv) : "";
274+
275+ if (strcmp(type, "error") == 0) {
276+ yyjson_val *err = yyjson_obj_get(root, "error");
277+ yyjson_val *m = yyjson_is_obj(err) ? yyjson_obj_get(err, "message") : NULL;
278+ set_str(&st->error, yyjson_is_str(m) ? yyjson_get_str(m) : "stream: provider error");
279+ } else if (strcmp(type, "message_start") == 0) {
280+ yyjson_val *msg = yyjson_obj_get(root, "message");
281+ yyjson_val *usage = yyjson_is_obj(msg) ? yyjson_obj_get(msg, "usage") : NULL;
282+ if (yyjson_is_obj(usage)) {
283+ yyjson_val *v;
284+ if (yyjson_is_num(v = yyjson_obj_get(usage, "input_tokens"))) st->tokens_in = (long)yyjson_get_num(v);
285+ if (yyjson_is_num(v = yyjson_obj_get(usage, "output_tokens"))) st->tokens_out = (long)yyjson_get_num(v);
286+ }
287+ } else if (strcmp(type, "content_block_start") == 0) {
288+ yyjson_val *iv = yyjson_obj_get(root, "index");
289+ if (!yyjson_is_int(iv)) {
290+ yyjson_doc_free(doc);
291+ return;
292+ }
293+ block_acc *b = block_at(st, (size_t)yyjson_get_int(iv));
294+ yyjson_val *cb = yyjson_obj_get(root, "content_block");
295+ yyjson_val *bt = yyjson_is_obj(cb) ? yyjson_obj_get(cb, "type") : NULL;
296+ const char *bts = yyjson_is_str(bt) ? yyjson_get_str(bt) : "";
297+ if (strcmp(bts, "tool_use") == 0) {
298+ b->type = BLK_TOOL;
299+ yyjson_val *id = yyjson_obj_get(cb, "id");
300+ yyjson_val *nm = yyjson_obj_get(cb, "name");
301+ if (yyjson_is_str(id)) set_str(&b->id, yyjson_get_str(id));
302+ if (yyjson_is_str(nm)) set_str(&b->name, yyjson_get_str(nm));
303+ } else if (strcmp(bts, "thinking") == 0 || strcmp(bts, "redacted_thinking") == 0) {
304+ b->type = BLK_THINKING;
305+ } else {
306+ b->type = BLK_TEXT;
307+ }
308+ } else if (strcmp(type, "content_block_delta") == 0) {
309+ yyjson_val *iv = yyjson_obj_get(root, "index");
310+ yyjson_val *d = yyjson_obj_get(root, "delta");
311+ if (!yyjson_is_int(iv) || !yyjson_is_obj(d)) {
312+ yyjson_doc_free(doc);
313+ return;
314+ }
315+ size_t index = (size_t)yyjson_get_int(iv);
316+ if (index >= st->blocks_len) {
317+ yyjson_doc_free(doc);
318+ return;
319+ }
320+ block_acc *b = &st->blocks[index];
321+ yyjson_val *dt = yyjson_obj_get(d, "type");
322+ const char *dts = yyjson_is_str(dt) ? yyjson_get_str(dt) : "";
323+ if (strcmp(dts, "text_delta") == 0) {
324+ yyjson_val *t = yyjson_obj_get(d, "text");
325+ if (yyjson_is_str(t) && yyjson_get_str(t)[0]) {
326+ buf_add(&b->text, yyjson_get_str(t), strlen(yyjson_get_str(t)));
327+ emit_delta(st, CAGE_STREAM_TEXT_DELTA, yyjson_get_str(t));
328+ }
329+ } else if (strcmp(dts, "thinking_delta") == 0) {
330+ yyjson_val *t = yyjson_obj_get(d, "thinking");
331+ if (yyjson_is_str(t) && yyjson_get_str(t)[0]) {
332+ buf_add(&b->text, yyjson_get_str(t), strlen(yyjson_get_str(t)));
333+ emit_delta(st, CAGE_STREAM_REASONING_DELTA, yyjson_get_str(t));
334+ }
335+ } else if (strcmp(dts, "input_json_delta") == 0) {
336+ yyjson_val *p = yyjson_obj_get(d, "partial_json");
337+ if (yyjson_is_str(p)) buf_add(&b->args, yyjson_get_str(p), strlen(yyjson_get_str(p)));
338+ }
339+ } else if (strcmp(type, "message_delta") == 0) {
340+ yyjson_val *d = yyjson_obj_get(root, "delta");
341+ yyjson_val *sr = yyjson_is_obj(d) ? yyjson_obj_get(d, "stop_reason") : NULL;
342+ if (yyjson_is_str(sr)) set_str(&st->stop_reason, yyjson_get_str(sr));
343+ yyjson_val *usage = yyjson_obj_get(root, "usage");
344+ if (yyjson_is_obj(usage)) {
345+ yyjson_val *v;
346+ if (yyjson_is_num(v = yyjson_obj_get(usage, "output_tokens"))) st->tokens_out = (long)yyjson_get_num(v);
347+ }
348+ }
349+ yyjson_doc_free(doc);
350+}
351+
352+static void on_data(const char *json, size_t len, void *user) {
353+ handle_data(user, json, len);
354+}
355+
356+static void free_state(anth_state *st) {
357+ for (size_t i = 0; i < st->blocks_len; i++) {
358+ free(st->blocks[i].text.data);
359+ free(st->blocks[i].id);
360+ free(st->blocks[i].name);
361+ free(st->blocks[i].args.data);
362+ }
363+ free(st->blocks);
364+ free(st->stop_reason);
365+ free(st->error);
366+}
367+
368+static const char *map_stop(const char *reason, bool has_calls) {
369+ if (reason && strcmp(reason, "max_tokens") == 0) return "length";
370+ if (has_calls) return "toolUse";
371+ return "stop";
372+}
373+
374+static void finalize(anth_state *st, cage_message *out) {
375+ bool has_calls = false;
376+ for (size_t i = 0; i < st->blocks_len; i++) {
377+ block_acc *b = &st->blocks[i];
378+ if (b->type == BLK_TOOL) has_calls = true;
379+ }
380+ for (size_t i = 0; i < st->blocks_len; i++) {
381+ block_acc *b = &st->blocks[i];
382+ if (b->type == BLK_THINKING && b->text.len > 0) {
383+ cage_block *blk = cage_message_add_block(out, CAGE_BLOCK_THINKING);
384+ blk->text = xstrdup(b->text.data);
385+ } else if (b->type == BLK_TEXT && b->text.len > 0) {
386+ cage_block *blk = cage_message_add_block(out, CAGE_BLOCK_TEXT);
387+ blk->text = xstrdup(b->text.data);
388+ }
389+ }
390+ for (size_t i = 0; i < st->blocks_len; i++) {
391+ block_acc *b = &st->blocks[i];
392+ if (b->type != BLK_TOOL) continue;
393+ cage_block *blk = cage_message_add_block(out, CAGE_BLOCK_TOOL_CALL);
394+ blk->tool_call_id = xstrdup(b->id ? b->id : "");
395+ blk->tool_name = xstrdup(b->name ? b->name : "");
396+ blk->arguments = xstrdup(b->args.len ? b->args.data : "{}");
397+ if (st->emit) {
398+ cage_stream_event ev = {
399+ .type = CAGE_STREAM_TOOL_CALL,
400+ .tool_call_id = blk->tool_call_id,
401+ .tool_name = blk->tool_name,
402+ .tool_arguments = blk->arguments,
403+ };
404+ st->emit(&ev, st->user);
405+ }
406+ }
407+ out->tokens_in = st->tokens_in;
408+ out->tokens_out = st->tokens_out;
409+ out->tokens_total = st->tokens_in + st->tokens_out;
410+ out->stop_reason = xstrdup(map_stop(st->stop_reason, has_calls));
411+}
412+
413+// ---- transport ------------------------------------------------------------
414+
415+static char *endpoint_url(const char *base) {
416+ if (!base || !base[0]) return NULL;
417+ size_t n = strlen(base);
418+ const char *path = "v1/messages";
419+ bool slash = base[n - 1] == '/';
420+ size_t size = n + strlen(path) + 2;
421+ char *url = xmalloc(size);
422+ snprintf(url, size, slash ? "%s%s" : "%s/%s", base, path);
423+ return url;
424+}
425+
426+int cage_anthropic_messages_stream(const cage_model *model, const cage_context *ctx,
427+ const cage_stream_opts *opts,
428+ cage_stream_fn emit, void *user,
429+ const volatile bool *cancel,
430+ cage_message *out, char **err) {
431+ if (err) *err = NULL;
432+ memset(out, 0, sizeof *out);
433+ out->role = CAGE_ROLE_ASSISTANT;
434+
435+ char *url = endpoint_url(model->base_url);
436+ if (!url) return fail(err, "provider: no base url");
437+ char *body = build_request(model, ctx, opts);
438+ if (!body) {
439+ free(url);
440+ return fail(err, "provider: cannot build request");
441+ }
442+
443+ anth_state st = {0};
444+ st.emit = emit;
445+ st.user = user;
446+
447+ char *auth = NULL;
448+ struct curl_slist *headers = NULL;
449+ headers = curl_slist_append(headers, "Content-Type: application/json");
450+ headers = curl_slist_append(headers, "Accept: text/event-stream");
451+ headers = curl_slist_append(headers, "anthropic-version: " ANTHROPIC_VERSION);
452+ if (model->api_key && model->api_key[0]) {
453+ size_t n = strlen(model->api_key) + 12;
454+ auth = xmalloc(n);
455+ snprintf(auth, n, "x-api-key: %s", model->api_key);
456+ headers = curl_slist_append(headers, auth);
457+ }
458+
459+ cage_http_request req = {
460+ .url = url,
461+ .body = body,
462+ .headers = headers,
463+ .cancel = cancel,
464+ .on_data = on_data,
465+ .user = &st,
466+ };
467+ cage_http_stream(&req);
468+
469+ int rc = 0;
470+ if (req.aborted) {
471+ out->stop_reason = xstrdup("aborted");
472+ } else if (req.error) {
473+ *err = req.error;
474+ req.error = NULL;
475+ rc = -1;
476+ } else if (st.error) {
477+ out->stop_reason = xstrdup("error");
478+ out->error_message = xstrdup(st.error);
479+ } else {
480+ finalize(&st, out);
481+ }
482+
483+ curl_slist_free_all(headers);
484+ free(auth);
485+ free(req.error);
486+ free(url);
487+ free(body);
488+ free_state(&st);
489+ return rc;
490+}
src/api/google_generative_ai.c+471−0
@@ -0,0 +1,471 @@
1+// Google Generative AI (Gemini) streaming adapter.
2+
3+#include "api.h"
4+
5+#include <stdarg.h>
6+#include <stdio.h>
7+#include <stdlib.h>
8+#include <string.h>
9+
10+#include <yyjson.h>
11+
12+#include "http.h"
13+
14+static void *xmalloc(size_t n) {
15+ void *p = malloc(n);
16+ if (!p) abort();
17+ return p;
18+}
19+
20+static char *xstrdup(const char *s) {
21+ size_t n = strlen(s) + 1;
22+ char *p = xmalloc(n);
23+ memcpy(p, s, n);
24+ return p;
25+}
26+
27+static int fail(char **err, const char *fmt, ...) {
28+ char detail[512];
29+ va_list ap;
30+ va_start(ap, fmt);
31+ vsnprintf(detail, sizeof detail, fmt, ap);
32+ va_end(ap);
33+ *err = xstrdup(detail);
34+ return -1;
35+}
36+
37+typedef struct {
38+ char *data;
39+ size_t len;
40+ size_t cap;
41+} buf;
42+
43+static void buf_add(buf *b, const char *p, size_t n) {
44+ if (b->len + n + 1 > b->cap) {
45+ size_t cap = b->cap ? b->cap : 64;
46+ while (cap < b->len + n + 1) cap *= 2;
47+ b->data = realloc(b->data, cap);
48+ if (!b->data) abort();
49+ b->cap = cap;
50+ }
51+ memcpy(b->data + b->len, p, n);
52+ b->len += n;
53+ b->data[b->len] = '\0';
54+}
55+
56+// ---- request --------------------------------------------------------------
57+
58+static void add_text_part(yyjson_mut_doc *doc, yyjson_mut_val *parts, const char *text) {
59+ yyjson_mut_val *p = yyjson_mut_obj(doc);
60+ yyjson_mut_arr_add_val(parts, p);
61+ yyjson_mut_obj_add_strcpy(doc, p, "text", text ? text : "");
62+}
63+
64+static void add_function_call(yyjson_mut_doc *doc, yyjson_mut_val *parts, const cage_block *b) {
65+ yyjson_mut_val *p = yyjson_mut_obj(doc);
66+ yyjson_mut_arr_add_val(parts, p);
67+ yyjson_mut_val *fc = yyjson_mut_obj(doc);
68+ yyjson_mut_obj_add_val(doc, p, "functionCall", fc);
69+ yyjson_mut_obj_add_strcpy(doc, fc, "name", b->tool_name ? b->tool_name : "");
70+ yyjson_doc *adoc = b->arguments ? yyjson_read(b->arguments, strlen(b->arguments), 0) : NULL;
71+ if (adoc && yyjson_is_obj(yyjson_doc_get_root(adoc))) {
72+ yyjson_mut_obj_add_val(doc, fc, "args", yyjson_val_mut_copy(doc, yyjson_doc_get_root(adoc)));
73+ } else {
74+ yyjson_mut_obj_add_val(doc, fc, "args", yyjson_mut_obj(doc));
75+ }
76+ if (adoc) yyjson_doc_free(adoc);
77+}
78+
79+static void add_message(yyjson_mut_doc *doc, yyjson_mut_val *contents, const cage_message *m) {
80+ yyjson_mut_val *o = yyjson_mut_obj(doc);
81+ yyjson_mut_arr_add_val(contents, o);
82+ yyjson_mut_obj_add_strcpy(doc, o, "role", m->role == CAGE_ROLE_ASSISTANT ? "model" : "user");
83+ yyjson_mut_val *parts = yyjson_mut_arr(doc);
84+ yyjson_mut_obj_add_val(doc, o, "parts", parts);
85+ for (size_t i = 0; i < m->blocks_len; i++) {
86+ const cage_block *b = &m->blocks[i];
87+ if (b->type == CAGE_BLOCK_TEXT) {
88+ add_text_part(doc, parts, b->text);
89+ } else if (b->type == CAGE_BLOCK_IMAGE) {
90+ yyjson_mut_val *p = yyjson_mut_obj(doc);
91+ yyjson_mut_arr_add_val(parts, p);
92+ yyjson_mut_val *inl = yyjson_mut_obj(doc);
93+ yyjson_mut_obj_add_val(doc, p, "inlineData", inl);
94+ yyjson_mut_obj_add_strcpy(doc, inl, "mimeType", b->media_type ? b->media_type : "");
95+ yyjson_mut_obj_add_strcpy(doc, inl, "data", b->data ? b->data : "");
96+ } else if (b->type == CAGE_BLOCK_TOOL_CALL) {
97+ add_function_call(doc, parts, b);
98+ }
99+ }
100+}
101+
102+// A run of tool results becomes one user turn of functionResponse parts.
103+static const char *tool_name_for(const cage_context *ctx, const char *id) {
104+ for (size_t i = 0; i < ctx->messages_len; i++) {
105+ const cage_message *m = &ctx->messages[i];
106+ for (size_t k = 0; k < m->blocks_len; k++) {
107+ const cage_block *b = &m->blocks[k];
108+ if (b->type == CAGE_BLOCK_TOOL_CALL && b->tool_call_id && id &&
109+ strcmp(b->tool_call_id, id) == 0)
110+ return b->tool_name ? b->tool_name : "";
111+ }
112+ }
113+ return "";
114+}
115+
116+static void add_tool_results(yyjson_mut_doc *doc, yyjson_mut_val *contents,
117+ const cage_context *ctx, size_t from, size_t to) {
118+ yyjson_mut_val *o = yyjson_mut_obj(doc);
119+ yyjson_mut_arr_add_val(contents, o);
120+ yyjson_mut_obj_add_strcpy(doc, o, "role", "user");
121+ yyjson_mut_val *parts = yyjson_mut_arr(doc);
122+ yyjson_mut_obj_add_val(doc, o, "parts", parts);
123+ for (size_t i = from; i < to; i++) {
124+ const cage_message *m = &ctx->messages[i];
125+ buf t = {0};
126+ for (size_t k = 0; k < m->blocks_len; k++)
127+ if (m->blocks[k].type == CAGE_BLOCK_TEXT && m->blocks[k].text)
128+ buf_add(&t, m->blocks[k].text, strlen(m->blocks[k].text));
129+ yyjson_mut_val *p = yyjson_mut_obj(doc);
130+ yyjson_mut_arr_add_val(parts, p);
131+ yyjson_mut_val *fr = yyjson_mut_obj(doc);
132+ yyjson_mut_obj_add_val(doc, p, "functionResponse", fr);
133+ yyjson_mut_obj_add_strcpy(doc, fr, "name", tool_name_for(ctx, m->tool_call_id));
134+ yyjson_mut_val *resp = yyjson_mut_obj(doc);
135+ yyjson_mut_obj_add_val(doc, fr, "response", resp);
136+ yyjson_mut_obj_add_strcpy(doc, resp, m->is_error ? "error" : "output", t.data ? t.data : "");
137+ free(t.data);
138+ }
139+}
140+
141+static void add_tools(yyjson_mut_doc *doc, yyjson_mut_val *root, const cage_context *ctx) {
142+ if (ctx->tools_len == 0) return;
143+ yyjson_mut_val *tools = yyjson_mut_arr(doc);
144+ yyjson_mut_obj_add_val(doc, root, "tools", tools);
145+ yyjson_mut_val *group = yyjson_mut_obj(doc);
146+ yyjson_mut_arr_add_val(tools, group);
147+ yyjson_mut_val *decls = yyjson_mut_arr(doc);
148+ yyjson_mut_obj_add_val(doc, group, "functionDeclarations", decls);
149+ for (size_t i = 0; i < ctx->tools_len; i++) {
150+ const cage_tool *t = &ctx->tools[i];
151+ yyjson_mut_val *d = yyjson_mut_obj(doc);
152+ yyjson_mut_arr_add_val(decls, d);
153+ yyjson_mut_obj_add_strcpy(doc, d, "name", t->name);
154+ yyjson_mut_obj_add_strcpy(doc, d, "description", t->description ? t->description : "");
155+ const char *params = t->parameters ? t->parameters : "{}";
156+ yyjson_doc *pdoc = yyjson_read(params, strlen(params), 0);
157+ if (pdoc) {
158+ yyjson_mut_val *copy = yyjson_val_mut_copy(doc, yyjson_doc_get_root(pdoc));
159+ yyjson_mut_obj_add_val(doc, d, "parametersJsonSchema", copy);
160+ yyjson_doc_free(pdoc);
161+ }
162+ }
163+}
164+
165+static long budget_for(const char *effort) {
166+ if (!effort) return -1;
167+ if (strcmp(effort, "off") == 0) return 0;
168+ if (strcmp(effort, "minimal") == 0) return 512;
169+ if (strcmp(effort, "low") == 0) return 1024;
170+ if (strcmp(effort, "medium") == 0) return 4096;
171+ if (strcmp(effort, "high") == 0) return 8192;
172+ if (strcmp(effort, "xhigh") == 0) return 16384;
173+ if (strcmp(effort, "max") == 0) return 24576;
174+ return -1;
175+}
176+
177+static char *build_request(const cage_context *ctx, const cage_stream_opts *opts) {
178+ yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);
179+ yyjson_mut_val *root = yyjson_mut_obj(doc);
180+ yyjson_mut_doc_set_root(doc, root);
181+
182+ yyjson_mut_val *contents = yyjson_mut_arr(doc);
183+ yyjson_mut_obj_add_val(doc, root, "contents", contents);
184+ for (size_t i = 0; i < ctx->messages_len;) {
185+ if (ctx->messages[i].role == CAGE_ROLE_TOOL) {
186+ size_t j = i;
187+ for (; j < ctx->messages_len && ctx->messages[j].role == CAGE_ROLE_TOOL; j++) {}
188+ add_tool_results(doc, contents, ctx, i, j);
189+ i = j;
190+ } else {
191+ add_message(doc, contents, &ctx->messages[i]);
192+ i++;
193+ }
194+ }
195+
196+ if (ctx->system_prompt && ctx->system_prompt[0]) {
197+ yyjson_mut_val *si = yyjson_mut_obj(doc);
198+ yyjson_mut_obj_add_val(doc, root, "systemInstruction", si);
199+ yyjson_mut_val *parts = yyjson_mut_arr(doc);
200+ yyjson_mut_obj_add_val(doc, si, "parts", parts);
201+ add_text_part(doc, parts, ctx->system_prompt);
202+ }
203+
204+ add_tools(doc, root, ctx);
205+
206+ yyjson_mut_val *gen = NULL;
207+ if (opts && opts->max_tokens > 0) {
208+ gen = yyjson_mut_obj(doc);
209+ yyjson_mut_obj_add_int(doc, gen, "maxOutputTokens", opts->max_tokens);
210+ }
211+ long budget = opts ? budget_for(opts->effort) : -1;
212+ if (budget >= 0) {
213+ if (!gen) gen = yyjson_mut_obj(doc);
214+ yyjson_mut_val *tc = yyjson_mut_obj(doc);
215+ yyjson_mut_obj_add_val(doc, gen, "thinkingConfig", tc);
216+ if (budget > 0) yyjson_mut_obj_add_bool(doc, tc, "includeThoughts", true);
217+ yyjson_mut_obj_add_int(doc, tc, "thinkingBudget", budget);
218+ }
219+ if (gen) yyjson_mut_obj_add_val(doc, root, "generationConfig", gen);
220+
221+ size_t len = 0;
222+ char *body = yyjson_mut_write(doc, 0, &len);
223+ yyjson_mut_doc_free(doc);
224+ return body;
225+}
226+
227+// ---- streaming state ------------------------------------------------------
228+
229+typedef struct {
230+ char *id;
231+ char *name;
232+ buf args;
233+} gcall;
234+
235+typedef struct {
236+ buf text;
237+ buf reasoning;
238+ gcall *calls;
239+ size_t calls_len;
240+ long tokens_in;
241+ long tokens_out;
242+ long tokens_total;
243+ char *finish;
244+ char *error;
245+ cage_stream_fn emit;
246+ void *user;
247+} google_state;
248+
249+static void emit_delta(google_state *st, cage_stream_type type, const char *delta) {
250+ if (!st->emit) return;
251+ cage_stream_event ev = {.type = type, .delta = delta};
252+ st->emit(&ev, st->user);
253+}
254+
255+static void add_call(google_state *st, const char *name, yyjson_val *args) {
256+ st->calls = realloc(st->calls, (st->calls_len + 1) * sizeof *st->calls);
257+ if (!st->calls) abort();
258+ gcall *c = &st->calls[st->calls_len++];
259+ memset(c, 0, sizeof *c);
260+ c->name = xstrdup(name ? name : "");
261+ char id[64];
262+ snprintf(id, sizeof id, "%s_%zu", c->name, st->calls_len);
263+ c->id = xstrdup(id);
264+ if (args) {
265+ size_t len = 0;
266+ char *txt = yyjson_val_write(args, 0, &len);
267+ if (txt) {
268+ buf_add(&c->args, txt, len);
269+ free(txt);
270+ }
271+ }
272+}
273+
274+static void handle_chunk(google_state *st, const char *json, size_t len) {
275+ yyjson_doc *doc = yyjson_read(json, len, 0);
276+ if (!doc) {
277+ if (!st->error) st->error = xstrdup("stream: invalid JSON chunk");
278+ return;
279+ }
280+ yyjson_val *root = yyjson_doc_get_root(doc);
281+
282+ yyjson_val *err = yyjson_obj_get(root, "error");
283+ if (yyjson_is_obj(err)) {
284+ yyjson_val *m = yyjson_obj_get(err, "message");
285+ if (!st->error) st->error = xstrdup(yyjson_is_str(m) ? yyjson_get_str(m) : "stream: provider error");
286+ yyjson_doc_free(doc);
287+ return;
288+ }
289+
290+ yyjson_val *cands = yyjson_obj_get(root, "candidates");
291+ if (yyjson_is_arr(cands) && yyjson_arr_size(cands) > 0) {
292+ yyjson_val *cand = yyjson_arr_get_first(cands);
293+ yyjson_val *content = yyjson_obj_get(cand, "content");
294+ yyjson_val *parts = yyjson_is_obj(content) ? yyjson_obj_get(content, "parts") : NULL;
295+ if (yyjson_is_arr(parts)) {
296+ size_t idx, max;
297+ yyjson_val *part;
298+ yyjson_arr_foreach(parts, idx, max, part) {
299+ yyjson_val *fc = yyjson_obj_get(part, "functionCall");
300+ if (yyjson_is_obj(fc)) {
301+ yyjson_val *name = yyjson_obj_get(fc, "name");
302+ yyjson_val *args = yyjson_obj_get(fc, "args");
303+ add_call(st, yyjson_is_str(name) ? yyjson_get_str(name) : "", args);
304+ continue;
305+ }
306+ yyjson_val *txt = yyjson_obj_get(part, "text");
307+ if (!yyjson_is_str(txt) || !yyjson_get_str(txt)[0]) continue;
308+ yyjson_val *thought = yyjson_obj_get(part, "thought");
309+ const char *s = yyjson_get_str(txt);
310+ if (yyjson_is_bool(thought) && yyjson_get_bool(thought)) {
311+ buf_add(&st->reasoning, s, strlen(s));
312+ emit_delta(st, CAGE_STREAM_REASONING_DELTA, s);
313+ } else {
314+ buf_add(&st->text, s, strlen(s));
315+ emit_delta(st, CAGE_STREAM_TEXT_DELTA, s);
316+ }
317+ }
318+ }
319+ yyjson_val *fr = yyjson_obj_get(cand, "finishReason");
320+ if (yyjson_is_str(fr)) {
321+ free(st->finish);
322+ st->finish = xstrdup(yyjson_get_str(fr));
323+ }
324+ }
325+
326+ yyjson_val *usage = yyjson_obj_get(root, "usageMetadata");
327+ if (yyjson_is_obj(usage)) {
328+ yyjson_val *v;
329+ if (yyjson_is_num(v = yyjson_obj_get(usage, "promptTokenCount"))) st->tokens_in = (long)yyjson_get_num(v);
330+ if (yyjson_is_num(v = yyjson_obj_get(usage, "candidatesTokenCount"))) st->tokens_out = (long)yyjson_get_num(v);
331+ if (yyjson_is_num(v = yyjson_obj_get(usage, "thoughtsTokenCount"))) st->tokens_out += (long)yyjson_get_num(v);
332+ if (yyjson_is_num(v = yyjson_obj_get(usage, "totalTokenCount"))) st->tokens_total = (long)yyjson_get_num(v);
333+ }
334+ yyjson_doc_free(doc);
335+}
336+
337+static void on_data(const char *json, size_t len, void *user) {
338+ handle_chunk(user, json, len);
339+}
340+
341+static void free_state(google_state *st) {
342+ free(st->text.data);
343+ free(st->reasoning.data);
344+ for (size_t i = 0; i < st->calls_len; i++) {
345+ free(st->calls[i].id);
346+ free(st->calls[i].name);
347+ free(st->calls[i].args.data);
348+ }
349+ free(st->calls);
350+ free(st->finish);
351+ free(st->error);
352+}
353+
354+static void finalize(google_state *st, cage_message *out) {
355+ if (st->reasoning.len > 0) {
356+ cage_block *b = cage_message_add_block(out, CAGE_BLOCK_THINKING);
357+ b->text = xstrdup(st->reasoning.data);
358+ }
359+ if (st->text.len > 0) {
360+ cage_block *b = cage_message_add_block(out, CAGE_BLOCK_TEXT);
361+ b->text = xstrdup(st->text.data);
362+ }
363+ for (size_t i = 0; i < st->calls_len; i++) {
364+ gcall *c = &st->calls[i];
365+ cage_block *b = cage_message_add_block(out, CAGE_BLOCK_TOOL_CALL);
366+ b->tool_call_id = xstrdup(c->id);
367+ b->tool_name = xstrdup(c->name);
368+ b->arguments = xstrdup(c->args.len ? c->args.data : "{}");
369+ if (st->emit) {
370+ cage_stream_event ev = {
371+ .type = CAGE_STREAM_TOOL_CALL,
372+ .tool_call_id = b->tool_call_id,
373+ .tool_name = b->tool_name,
374+ .tool_arguments = b->arguments,
375+ };
376+ st->emit(&ev, st->user);
377+ }
378+ }
379+ out->tokens_in = st->tokens_in;
380+ out->tokens_out = st->tokens_out;
381+ out->tokens_total = st->tokens_total ? st->tokens_total : st->tokens_in + st->tokens_out;
382+ if (st->finish && strcmp(st->finish, "MAX_TOKENS") == 0) out->stop_reason = xstrdup("length");
383+ else if (st->calls_len > 0) out->stop_reason = xstrdup("toolUse");
384+ else out->stop_reason = xstrdup("stop");
385+}
386+
387+// ---- transport ------------------------------------------------------------
388+
389+static char *endpoint_url(const char *base, const char *model) {
390+ if (!base || !base[0] || !model || !model[0]) return NULL;
391+ const char *id = model;
392+ const char *prefix = "models/";
393+ size_t n = strlen(base);
394+ bool slash = base[n - 1] == '/';
395+ const char *sep = slash ? "" : "/";
396+ if (strncmp(id, prefix, 6) == 0) {
397+ size_t size = n + strlen(sep) + strlen(id) + 32;
398+ char *url = xmalloc(size);
399+ snprintf(url, size, "%s%s%s:streamGenerateContent?alt=sse", base, sep, id);
400+ return url;
401+ }
402+ size_t size = n + strlen(sep) + strlen(prefix) + strlen(id) + 40;
403+ char *url = xmalloc(size);
404+ snprintf(url, size, "%s%s%s%s:streamGenerateContent?alt=sse", base, sep, prefix, id);
405+ return url;
406+}
407+
408+int cage_google_generative_ai_stream(const cage_model *model, const cage_context *ctx,
409+ const cage_stream_opts *opts,
410+ cage_stream_fn emit, void *user,
411+ const volatile bool *cancel,
412+ cage_message *out, char **err) {
413+ if (err) *err = NULL;
414+ memset(out, 0, sizeof *out);
415+ out->role = CAGE_ROLE_ASSISTANT;
416+
417+ char *url = endpoint_url(model->base_url, model->model);
418+ if (!url) return fail(err, "provider: no base url");
419+ char *body = build_request(ctx, opts);
420+ if (!body) {
421+ free(url);
422+ return fail(err, "provider: cannot build request");
423+ }
424+
425+ google_state st = {0};
426+ st.emit = emit;
427+ st.user = user;
428+
429+ char *auth = NULL;
430+ struct curl_slist *headers = NULL;
431+ headers = curl_slist_append(headers, "Content-Type: application/json");
432+ headers = curl_slist_append(headers, "Accept: text/event-stream");
433+ if (model->api_key && model->api_key[0]) {
434+ size_t n = strlen(model->api_key) + 20;
435+ auth = xmalloc(n);
436+ snprintf(auth, n, "x-goog-api-key: %s", model->api_key);
437+ headers = curl_slist_append(headers, auth);
438+ }
439+
440+ cage_http_request req = {
441+ .url = url,
442+ .body = body,
443+ .headers = headers,
444+ .cancel = cancel,
445+ .on_data = on_data,
446+ .user = &st,
447+ };
448+ cage_http_stream(&req);
449+
450+ int rc = 0;
451+ if (req.aborted) {
452+ out->stop_reason = xstrdup("aborted");
453+ } else if (req.error) {
454+ *err = req.error;
455+ req.error = NULL;
456+ rc = -1;
457+ } else if (st.error) {
458+ out->stop_reason = xstrdup("error");
459+ out->error_message = xstrdup(st.error);
460+ } else {
461+ finalize(&st, out);
462+ }
463+
464+ curl_slist_free_all(headers);
465+ free(auth);
466+ free(req.error);
467+ free(url);
468+ free(body);
Cut short: this commit's diff is over 1000 lines.
src/api/http.c+157−0
Cut short: this commit's diff is over 1000 lines.
src/api/http.h+36−0
Cut short: this commit's diff is over 1000 lines.
src/api/openai_completions.c+24−111
Cut short: this commit's diff is over 1000 lines.
src/api/openai_responses.c+483−0
Cut short: this commit's diff is over 1000 lines.
src/api/sse.c+54−0
Cut short: this commit's diff is over 1000 lines.
src/api/sse.h+26−0
Cut short: this commit's diff is over 1000 lines.
src/catalog.c+41−0
Cut short: this commit's diff is over 1000 lines.
src/catalog.h+10−0
Cut short: this commit's diff is over 1000 lines.
src/codemode.c+4−0
Cut short: this commit's diff is over 1000 lines.
src/config.c+154−0
Cut short: this commit's diff is over 1000 lines.
src/config.h+5−0
Cut short: this commit's diff is over 1000 lines.
src/main.c+12−29
Cut short: this commit's diff is over 1000 lines.
src/provider.c+8−3
Cut short: this commit's diff is over 1000 lines.
src/provider.h+3−0
Cut short: this commit's diff is over 1000 lines.
src/resolve.c+7−1
Cut short: this commit's diff is over 1000 lines.
src/resolve.h+4−0
Cut short: this commit's diff is over 1000 lines.
src/resources.c+259−0
Cut short: this commit's diff is over 1000 lines.
src/resources.h+38−0
Cut short: this commit's diff is over 1000 lines.
src/tool.h+1−0
Cut short: this commit's diff is over 1000 lines.
src/tui/commands.c+240−17
Cut short: this commit's diff is over 1000 lines.
src/tui/commands.h+8−0
Cut short: this commit's diff is over 1000 lines.
src/tui/tui.c+103−19
Cut short: this commit's diff is over 1000 lines.
src/tui/tui.h+2−1
Cut short: this commit's diff is over 1000 lines.