@@ -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+}