xonecas.io
7814
Ta

tiny-c-agent / files

tiny-c-agent / src / api / anthropic_messages.c

15.5 KB
1// Anthropic Messages API streaming adapter.
2
3#include "api.h"
4
5#include <stdio.h>
6#include <stdlib.h>
7#include <string.h>
8
9#include <yyjson.h>
10
11#include "http.h"
12#include "util.h"
13
14#define ANTHROPIC_VERSION "2023-06-01"
15
16// ---- request --------------------------------------------------------------
17
18static void add_image_block(yyjson_mut_doc *doc, yyjson_mut_val *content,
19                            const tiny_block *b) {
20    yyjson_mut_val *img = yyjson_mut_obj(doc);
21    yyjson_mut_arr_add_val(content, img);
22    yyjson_mut_obj_add_strcpy(doc, img, "type", "image");
23    yyjson_mut_val *src = yyjson_mut_obj(doc);
24    yyjson_mut_obj_add_val(doc, img, "source", src);
25    yyjson_mut_obj_add_strcpy(doc, src, "type", "base64");
26    yyjson_mut_obj_add_strcpy(doc, src, "media_type", b->media_type ? b->media_type : "");
27    yyjson_mut_obj_add_strcpy(doc, src, "data", b->data ? b->data : "");
28}
29
30static void add_tool_result(yyjson_mut_doc *doc, yyjson_mut_val *messages, const tiny_message *m) {
31    yyjson_mut_val *um = yyjson_mut_obj(doc);
32    yyjson_mut_arr_add_val(messages, um);
33    yyjson_mut_obj_add_strcpy(doc, um, "role", "user");
34    yyjson_mut_val *content = yyjson_mut_arr(doc);
35    yyjson_mut_obj_add_val(doc, um, "content", content);
36
37    yyjson_mut_val *tr = yyjson_mut_obj(doc);
38    yyjson_mut_arr_add_val(content, tr);
39    yyjson_mut_obj_add_strcpy(doc, tr, "type", "tool_result");
40    yyjson_mut_obj_add_strcpy(doc, tr, "tool_use_id", m->tool_call_id ? m->tool_call_id : "");
41    if (m->is_error) yyjson_mut_obj_add_bool(doc, tr, "is_error", true);
42
43    bool has_images = tiny_message_has_image(m);
44    if (!has_images) {
45        tiny_buf t = {0};
46        for (size_t i = 0; i < m->blocks_len; i++)
47            if (m->blocks[i].type == TINY_BLOCK_TEXT && m->blocks[i].text)
48                buf_add(&t, m->blocks[i].text, strlen(m->blocks[i].text));
49        yyjson_mut_obj_add_strcpy(doc, tr, "content", t.data ? t.data : "");
50        free(t.data);
51        return;
52    }
53    yyjson_mut_val *blocks = yyjson_mut_arr(doc);
54    yyjson_mut_obj_add_val(doc, tr, "content", blocks);
55    for (size_t i = 0; i < m->blocks_len; i++) {
56        const tiny_block *b = &m->blocks[i];
57        if (b->type == TINY_BLOCK_TEXT) {
58            yyjson_mut_val *tx = yyjson_mut_obj(doc);
59            yyjson_mut_arr_add_val(blocks, tx);
60            yyjson_mut_obj_add_strcpy(doc, tx, "type", "text");
61            yyjson_mut_obj_add_strcpy(doc, tx, "text", b->text ? b->text : "");
62        } else if (b->type == TINY_BLOCK_IMAGE) {
63            add_image_block(doc, blocks, b);
64        }
65    }
66}
67
68static void add_message(yyjson_mut_doc *doc, yyjson_mut_val *messages, const tiny_message *m) {
69    yyjson_mut_val *o = yyjson_mut_obj(doc);
70    yyjson_mut_arr_add_val(messages, o);
71    yyjson_mut_obj_add_strcpy(doc, o, "role", m->role == TINY_ROLE_ASSISTANT ? "assistant" : "user");
72    yyjson_mut_val *content = yyjson_mut_arr(doc);
73    yyjson_mut_obj_add_val(doc, o, "content", content);
74    for (size_t i = 0; i < m->blocks_len; i++) {
75        const tiny_block *b = &m->blocks[i];
76        if (b->type == TINY_BLOCK_TEXT) {
77            yyjson_mut_val *tx = yyjson_mut_obj(doc);
78            yyjson_mut_arr_add_val(content, tx);
79            yyjson_mut_obj_add_strcpy(doc, tx, "type", "text");
80            yyjson_mut_obj_add_strcpy(doc, tx, "text", b->text ? b->text : "");
81        } else if (b->type == TINY_BLOCK_IMAGE) {
82            add_image_block(doc, content, b);
83        } else if (b->type == TINY_BLOCK_TOOL_CALL) {
84            yyjson_mut_val *tu = yyjson_mut_obj(doc);
85            yyjson_mut_arr_add_val(content, tu);
86            yyjson_mut_obj_add_strcpy(doc, tu, "type", "tool_use");
87            yyjson_mut_obj_add_strcpy(doc, tu, "id", b->tool_call_id ? b->tool_call_id : "");
88            yyjson_mut_obj_add_strcpy(doc, tu, "name", b->tool_name ? b->tool_name : "");
89            yyjson_doc *adoc = b->arguments ? yyjson_read(b->arguments, strlen(b->arguments), 0) : NULL;
90            if (adoc && yyjson_is_obj(yyjson_doc_get_root(adoc))) {
91                yyjson_mut_val *copy = yyjson_val_mut_copy(doc, yyjson_doc_get_root(adoc));
92                yyjson_mut_obj_add_val(doc, tu, "input", copy);
93            } else {
94                yyjson_mut_val *empty = yyjson_mut_obj(doc);
95                yyjson_mut_obj_add_val(doc, tu, "input", empty);
96            }
97            if (adoc) yyjson_doc_free(adoc);
98        }
99    }
100}
101
102static void add_tools(yyjson_mut_doc *doc, yyjson_mut_val *root, const tiny_context *ctx) {
103    if (ctx->tools_len == 0) return;
104    yyjson_mut_val *tools = yyjson_mut_arr(doc);
105    yyjson_mut_obj_add_val(doc, root, "tools", tools);
106    for (size_t i = 0; i < ctx->tools_len; i++) {
107        const tiny_tool *t = &ctx->tools[i];
108        yyjson_mut_val *tool = yyjson_mut_obj(doc);
109        yyjson_mut_arr_add_val(tools, tool);
110        tiny_json_tool(doc, tool, t, "input_schema");
111    }
112}
113
114// Thinking budget per effort level. Anthropic requires max_tokens > budget.
115static long budget_for(const char *effort) {
116    if (!effort) return 0;
117    if (strcmp(effort, "minimal") == 0) return 1024;
118    if (strcmp(effort, "low") == 0) return 2048;
119    if (strcmp(effort, "medium") == 0) return 4096;
120    if (strcmp(effort, "high") == 0) return 8192;
121    if (strcmp(effort, "xhigh") == 0) return 16384;
122    if (strcmp(effort, "max") == 0) return 32768;
123    return 0;
124}
125
126static char *build_request(const tiny_model *model, const tiny_context *ctx,
127                           const tiny_stream_opts *opts) {
128    yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);
129    yyjson_mut_val *root = yyjson_mut_obj(doc);
130    yyjson_mut_doc_set_root(doc, root);
131
132    long budget = opts ? budget_for(opts->effort) : 0;
133    long max_tokens = opts && opts->max_tokens > 0 ? opts->max_tokens : 8192;
134    if (budget > 0 && max_tokens <= budget) max_tokens = budget + 4096;
135
136    yyjson_mut_obj_add_strcpy(doc, root, "model", model->model ? model->model : "");
137    yyjson_mut_obj_add_int(doc, root, "max_tokens", max_tokens);
138    yyjson_mut_obj_add_bool(doc, root, "stream", true);
139    if (ctx->system_prompt && ctx->system_prompt[0])
140        yyjson_mut_obj_add_strcpy(doc, root, "system", ctx->system_prompt);
141    if (budget > 0) {
142        yyjson_mut_val *thinking = yyjson_mut_obj(doc);
143        yyjson_mut_obj_add_val(doc, root, "thinking", thinking);
144        yyjson_mut_obj_add_strcpy(doc, thinking, "type", "enabled");
145        yyjson_mut_obj_add_int(doc, thinking, "budget_tokens", budget);
146    }
147
148    yyjson_mut_val *messages = yyjson_mut_arr(doc);
149    yyjson_mut_obj_add_val(doc, root, "messages", messages);
150    for (size_t i = 0; i < ctx->messages_len;) {
151        if (ctx->messages[i].role == TINY_ROLE_TOOL) {
152            // All results of one assistant turn share a single user message.
153            size_t j = i;
154            for (; j < ctx->messages_len && ctx->messages[j].role == TINY_ROLE_TOOL; j++)
155                add_tool_result(doc, messages, &ctx->messages[j]);
156            i = j;
157        } else {
158            add_message(doc, messages, &ctx->messages[i]);
159            i++;
160        }
161    }
162
163    add_tools(doc, root, ctx);
164
165    size_t len = 0;
166    char *body = yyjson_mut_write(doc, 0, &len);
167    yyjson_mut_doc_free(doc);
168    return body;
169}
170
171// ---- streaming state ------------------------------------------------------
172
173enum { BLK_TEXT, BLK_THINKING, BLK_TOOL };
174
175typedef struct {
176    int type;
177    tiny_buf text;
178    char *id;
179    char *name;
180    tiny_buf args;
181    bool started;
182} block_acc;
183
184typedef struct {
185    block_acc *blocks;
186    size_t blocks_len;
187    long tokens_in;
188    long tokens_out;
189    char *stop_reason;
190    char *error;
191    tiny_stream_fn emit;
192    void *user;
193} anth_state;
194
195// An untrusted stream index is a hint, never a size. Anything past this is
196// treated like a missing index so a hostile chunk cannot force an allocation.
197#define MAX_STREAM_INDEX 10000
198
199static block_acc *block_at(anth_state *st, size_t index) {
200    if (index >= st->blocks_len) {
201        st->blocks = realloc(st->blocks, (index + 1) * sizeof *st->blocks);
202        if (!st->blocks) abort();
203        memset(&st->blocks[st->blocks_len], 0, (index + 1 - st->blocks_len) * sizeof *st->blocks);
204        st->blocks_len = index + 1;
205    }
206    return &st->blocks[index];
207}
208
209static void on_data(const char *json, size_t len, void *user) {
210    anth_state *st = user;
211    yyjson_doc *doc = yyjson_read(json, len, 0);
212    if (!doc) {
213        if (!st->error) st->error = xstrdup("stream: invalid JSON chunk");
214        return;
215    }
216    yyjson_val *root = yyjson_doc_get_root(doc);
217    yyjson_val *tv = yyjson_obj_get(root, "type");
218    const char *type = yyjson_is_str(tv) ? yyjson_get_str(tv) : "";
219
220    if (strcmp(type, "error") == 0) {
221        yyjson_val *err = yyjson_obj_get(root, "error");
222        yyjson_val *m = yyjson_is_obj(err) ? yyjson_obj_get(err, "message") : NULL;
223        tiny_set_str(&st->error, yyjson_is_str(m) ? yyjson_get_str(m) : "stream: provider error");
224    } else if (strcmp(type, "message_start") == 0) {
225        yyjson_val *msg = yyjson_obj_get(root, "message");
226        yyjson_val *usage = yyjson_is_obj(msg) ? yyjson_obj_get(msg, "usage") : NULL;
227        if (yyjson_is_obj(usage)) {
228            yyjson_val *v;
229            if (yyjson_is_num(v = yyjson_obj_get(usage, "input_tokens"))) st->tokens_in = (long)yyjson_get_num(v);
230            if (yyjson_is_num(v = yyjson_obj_get(usage, "output_tokens"))) st->tokens_out = (long)yyjson_get_num(v);
231        }
232    } else if (strcmp(type, "content_block_start") == 0) {
233        yyjson_val *iv = yyjson_obj_get(root, "index");
234        long raw = yyjson_is_int(iv) ? (long)yyjson_get_int(iv) : -1;
235        if (raw < 0 || raw > MAX_STREAM_INDEX) {
236            yyjson_doc_free(doc);
237            return;
238        }
239        block_acc *b = block_at(st, (size_t)raw);
240        yyjson_val *cb = yyjson_obj_get(root, "content_block");
241        yyjson_val *bt = yyjson_is_obj(cb) ? yyjson_obj_get(cb, "type") : NULL;
242        const char *bts = yyjson_is_str(bt) ? yyjson_get_str(bt) : "";
243        if (strcmp(bts, "tool_use") == 0) {
244            b->type = BLK_TOOL;
245            yyjson_val *id = yyjson_obj_get(cb, "id");
246            yyjson_val *nm = yyjson_obj_get(cb, "name");
247            if (yyjson_is_str(id)) tiny_set_str(&b->id, yyjson_get_str(id));
248            if (yyjson_is_str(nm)) tiny_set_str(&b->name, yyjson_get_str(nm));
249            if (!b->started && b->name && b->name[0]) {
250                b->started = true;
251                tiny_emit_tool_start(st->emit, st->user, b->id, b->name);
252            }
253        } else if (strcmp(bts, "thinking") == 0 || strcmp(bts, "redacted_thinking") == 0) {
254            b->type = BLK_THINKING;
255        } else {
256            b->type = BLK_TEXT;
257        }
258    } else if (strcmp(type, "content_block_delta") == 0) {
259        yyjson_val *iv = yyjson_obj_get(root, "index");
260        yyjson_val *d = yyjson_obj_get(root, "delta");
261        if (!yyjson_is_int(iv) || !yyjson_is_obj(d)) {
262            yyjson_doc_free(doc);
263            return;
264        }
265        size_t index = (size_t)yyjson_get_int(iv);
266        if (index >= st->blocks_len) {
267            yyjson_doc_free(doc);
268            return;
269        }
270        block_acc *b = &st->blocks[index];
271        yyjson_val *dt = yyjson_obj_get(d, "type");
272        const char *dts = yyjson_is_str(dt) ? yyjson_get_str(dt) : "";
273        if (strcmp(dts, "text_delta") == 0) {
274            yyjson_val *t = yyjson_obj_get(d, "text");
275            if (yyjson_is_str(t) && yyjson_get_str(t)[0]) {
276                buf_add(&b->text, yyjson_get_str(t), strlen(yyjson_get_str(t)));
277                tiny_emit_delta(st->emit, st->user, TINY_STREAM_TEXT_DELTA, yyjson_get_str(t));
278            }
279        } else if (strcmp(dts, "thinking_delta") == 0) {
280            yyjson_val *t = yyjson_obj_get(d, "thinking");
281            if (yyjson_is_str(t) && yyjson_get_str(t)[0]) {
282                buf_add(&b->text, yyjson_get_str(t), strlen(yyjson_get_str(t)));
283                tiny_emit_delta(st->emit, st->user, TINY_STREAM_REASONING_DELTA, yyjson_get_str(t));
284            }
285        } else if (strcmp(dts, "input_json_delta") == 0) {
286            yyjson_val *p = yyjson_obj_get(d, "partial_json");
287            if (yyjson_is_str(p)) buf_add(&b->args, yyjson_get_str(p), strlen(yyjson_get_str(p)));
288        }
289    } else if (strcmp(type, "message_delta") == 0) {
290        yyjson_val *d = yyjson_obj_get(root, "delta");
291        yyjson_val *sr = yyjson_is_obj(d) ? yyjson_obj_get(d, "stop_reason") : NULL;
292        if (yyjson_is_str(sr)) tiny_set_str(&st->stop_reason, yyjson_get_str(sr));
293        yyjson_val *usage = yyjson_obj_get(root, "usage");
294        if (yyjson_is_obj(usage)) {
295            yyjson_val *v;
296            if (yyjson_is_num(v = yyjson_obj_get(usage, "output_tokens"))) st->tokens_out = (long)yyjson_get_num(v);
297        }
298    }
299    yyjson_doc_free(doc);
300}
301
302static void free_state(anth_state *st) {
303    for (size_t i = 0; i < st->blocks_len; i++) {
304        free(st->blocks[i].text.data);
305        free(st->blocks[i].id);
306        free(st->blocks[i].name);
307        free(st->blocks[i].args.data);
308    }
309    free(st->blocks);
310    free(st->stop_reason);
311    free(st->error);
312}
313
314static const char *map_stop(const char *reason, bool has_calls) {
315    if (reason && strcmp(reason, "max_tokens") == 0) return "length";
316    if (has_calls) return "toolUse";
317    return "stop";
318}
319
320static void finalize(anth_state *st, tiny_message *out) {
321    bool has_calls = false;
322    for (size_t i = 0; i < st->blocks_len; i++) {
323        block_acc *b = &st->blocks[i];
324        if (b->type == BLK_TOOL) has_calls = true;
325    }
326    for (size_t i = 0; i < st->blocks_len; i++) {
327        block_acc *b = &st->blocks[i];
328        if (b->type == BLK_THINKING)
329            tiny_add_text_block(out, TINY_BLOCK_THINKING, b->text.data);
330        else if (b->type == BLK_TEXT)
331            tiny_add_text_block(out, TINY_BLOCK_TEXT, b->text.data);
332    }
333    for (size_t i = 0; i < st->blocks_len; i++) {
334        block_acc *b = &st->blocks[i];
335        if (b->type != BLK_TOOL) continue;
336        tiny_add_tool_block(out, b->id, b->name, b->args.len ? b->args.data : NULL, st->emit, st->user);
337    }
338    out->tokens_in = st->tokens_in;
339    out->tokens_out = st->tokens_out;
340    out->tokens_total = st->tokens_in + st->tokens_out;
341    out->stop_reason = xstrdup(map_stop(st->stop_reason, has_calls));
342}
343
344// ---- transport ------------------------------------------------------------
345
346
347int tiny_anthropic_messages_stream(const tiny_model *model, const tiny_context *ctx,
348                                   const tiny_stream_opts *opts,
349                                   tiny_stream_fn emit, void *user,
350                                   const volatile bool *cancel,
351                                   tiny_message *out, char **err) {
352    if (err) *err = NULL;
353    memset(out, 0, sizeof *out);
354    out->role = TINY_ROLE_ASSISTANT;
355
356    char *url = tiny_url_endpoint(model->base_url, "v1/messages");
357    if (!url) return tiny_fail(err, "provider: no base url");
358    char *body = build_request(model, ctx, opts);
359    if (!body) {
360        free(url);
361        return tiny_fail(err, "provider: cannot build request");
362    }
363
364    anth_state st = {0};
365    st.emit = emit;
366    st.user = user;
367
368    const char *extra[] = {"anthropic-version: " ANTHROPIC_VERSION, NULL};
369    tiny_api_result r = tiny_api_post(url, body, "x-api-key: ", model->api_key,
370                                      extra, cancel, on_data, &st, st.error, err);
371
372    int rc = 0;
373    if (r == TINY_API_ABORTED) {
374        out->stop_reason = xstrdup("aborted");
375    } else if (r == TINY_API_TRANSPORT_ERROR) {
376        rc = -1;
377    } else if (r == TINY_API_STREAM_ERROR) {
378        out->stop_reason = xstrdup("error");
379        out->error_message = xstrdup(st.error);
380    } else {
381        finalize(&st, out);
382    }
383    free_state(&st);
384    return rc;
385}