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}