@@ -0,0 +1,554 @@
1+//! Anthropic Messages API streaming adapter. The wire format behind every
2+//! customProvider with api "anthropic-messages".
3+
4+const std = @import("std");
5+const api = @import("../api.zig");
6+const types = @import("../types.zig");
7+const http = @import("../http.zig");
8+const json = @import("../json.zig");
9+
10+const Value = std.json.Value;
11+const anthropic_version = "2023-06-01";
12+
13+/// An untrusted stream index is a hint, never a size. Anything past this is
14+/// treated like a missing index so a hostile chunk cannot force an allocation.
15+const max_stream_index = 10_000;
16+
17+// ---- request building -----------------------------------------------------
18+
19+fn writeImage(w: *std.Io.Writer, img: types.ImageContent) !void {
20+ try w.writeAll("{\"type\":\"image\",\"source\":{\"type\":\"base64\",\"media_type\":");
21+ try json.writeString(w, img.mime_type);
22+ try w.writeAll(",\"data\":");
23+ try json.writeString(w, img.data);
24+ try w.writeAll("}}");
25+}
26+
27+/// A tool result is one block of a user message. Its content is a string when
28+/// there is only text, and an array when images must ride along.
29+fn writeToolResult(w: *std.Io.Writer, t: types.ToolResultMessage) !void {
30+ try w.writeAll("{\"type\":\"tool_result\",\"tool_use_id\":");
31+ try json.writeString(w, t.tool_call_id);
32+ if (t.is_error) try w.writeAll(",\"is_error\":true");
33+ if (t.images.len == 0) {
34+ try w.writeAll(",\"content\":");
35+ try json.writeString(w, t.text);
36+ } else {
37+ try w.writeAll(",\"content\":[{\"type\":\"text\",\"text\":");
38+ try json.writeString(w, t.text);
39+ try w.writeByte('}');
40+ for (t.images) |img| {
41+ try w.writeByte(',');
42+ try writeImage(w, img);
43+ }
44+ try w.writeByte(']');
45+ }
46+ try w.writeByte('}');
47+}
48+
49+/// An assistant turn as content blocks. Thinking blocks carry their signature
50+/// back so the provider's continuation data survives the round trip; a
51+/// thinking block without a signature becomes plain text.
52+fn writeAssistant(w: *std.Io.Writer, am: *const types.AssistantMessage) !void {
53+ try w.writeAll("{\"role\":\"assistant\",\"content\":[");
54+ var first = true;
55+ for (am.content.items) |block| switch (block) {
56+ .text => |t| {
57+ if (!first) try w.writeByte(',');
58+ first = false;
59+ try w.writeAll("{\"type\":\"text\",\"text\":");
60+ try json.writeString(w, t);
61+ try w.writeByte('}');
62+ },
63+ .thinking => |t| {
64+ if (!first) try w.writeByte(',');
65+ first = false;
66+ if (t.signature) |sig| {
67+ if (sig.len > 0) {
68+ try w.writeAll("{\"type\":\"thinking\",\"thinking\":");
69+ try json.writeString(w, t.text);
70+ try w.writeAll(",\"signature\":");
71+ try json.writeString(w, sig);
72+ try w.writeByte('}');
73+ continue;
74+ }
75+ }
76+ try w.writeAll("{\"type\":\"text\",\"text\":");
77+ try json.writeString(w, t.text);
78+ try w.writeByte('}');
79+ },
80+ .image => |img| {
81+ if (!first) try w.writeByte(',');
82+ first = false;
83+ try writeImage(w, img);
84+ },
85+ .tool_call => |c| {
86+ if (!first) try w.writeByte(',');
87+ first = false;
88+ try w.writeAll("{\"type\":\"tool_use\",\"id\":");
89+ try json.writeString(w, c.id);
90+ try w.writeAll(",\"name\":");
91+ try json.writeString(w, c.name);
92+ try w.writeAll(",\"input\":");
93+ try w.writeAll(if (c.arguments.len > 0) c.arguments else "{}");
94+ try w.writeByte('}');
95+ },
96+ };
97+ try w.writeAll("]}");
98+}
99+
100+fn writeUser(w: *std.Io.Writer, u: types.Message) !void {
101+ try w.writeAll("{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":");
102+ try json.writeString(w, u.user.content);
103+ try w.writeAll("}]}");
104+}
105+
106+fn writeTools(w: *std.Io.Writer, a: std.mem.Allocator, tools_json: []const u8, params_key: []const u8) !void {
107+ if (tools_json.len == 0) return;
108+ const root = std.json.parseFromSliceLeaky(Value, a, tools_json, .{}) catch return;
109+ if (root != .array) return;
110+ try w.writeAll(",\"tools\":[");
111+ for (root.array.items, 0..) |tool, i| {
112+ if (i > 0) try w.writeByte(',');
113+ const obj = tool.object;
114+ try w.writeAll("{\"name\":");
115+ try json.writeString(w, obj.get("name").?.string);
116+ try w.writeAll(",\"description\":");
117+ try json.writeString(w, obj.get("description").?.string);
118+ try w.writeAll(",\"");
119+ try w.writeAll(params_key);
120+ try w.writeAll("\":");
121+ try std.json.Stringify.value(obj.get("parameters").?, .{}, w);
122+ try w.writeByte('}');
123+ }
124+ try w.writeByte(']');
125+}
126+
127+/// Anthropic thinking budget per effort. Anthropic requires max_tokens to
128+/// exceed the budget, so the caller raises max_tokens when it does not.
129+fn budgetFor(effort: []const u8) u64 {
130+ const map = .{
131+ .{ "minimal", 1024 },
132+ .{ "low", 2048 },
133+ .{ "medium", 4096 },
134+ .{ "high", 8192 },
135+ .{ "xhigh", 16384 },
136+ .{ "max", 32768 },
137+ };
138+ inline for (map) |entry| {
139+ if (std.mem.eql(u8, effort, entry[0])) return entry[1];
140+ }
141+ return 0;
142+}
143+
144+fn buildBody(req: api.Request) ![]u8 {
145+ var out: std.Io.Writer.Allocating = .init(req.scratch);
146+ const w = &out.writer;
147+
148+ const budget = budgetFor(req.effort);
149+ var max_tokens: u64 = if (req.model.max_tokens > 0) req.model.max_tokens else 8192;
150+ if (budget > 0 and max_tokens <= budget) max_tokens = budget + 4096;
151+
152+ try w.writeAll("{\"model\":");
153+ try json.writeString(w, req.model.id);
154+ try w.writeAll(",\"max_tokens\":");
155+ try json.writeUint(w, max_tokens);
156+ try w.writeAll(",\"stream\":true");
157+ if (req.system_prompt.len > 0) {
158+ try w.writeAll(",\"system\":");
159+ try json.writeString(w, req.system_prompt);
160+ }
161+ if (budget > 0) {
162+ try w.writeAll(",\"thinking\":{\"type\":\"enabled\",\"budget_tokens\":");
163+ try json.writeUint(w, budget);
164+ try w.writeByte('}');
165+ }
166+
167+ try w.writeAll(",\"messages\":[");
168+ var first = true;
169+ var i: usize = 0;
170+ while (i < req.messages.len) {
171+ if (req.messages[i] == .tool_result) {
172+ // Every result of one assistant turn shares a single user message.
173+ if (!first) try w.writeByte(',');
174+ first = false;
175+ try w.writeAll("{\"role\":\"user\",\"content\":[");
176+ var first_block = true;
177+ while (i < req.messages.len and req.messages[i] == .tool_result) : (i += 1) {
178+ if (!first_block) try w.writeByte(',');
179+ first_block = false;
180+ try writeToolResult(w, req.messages[i].tool_result);
181+ }
182+ try w.writeAll("]}");
183+ continue;
184+ }
185+ if (!first) try w.writeByte(',');
186+ first = false;
187+ switch (req.messages[i]) {
188+ .user => try writeUser(w, req.messages[i]),
189+ .assistant => |am| try writeAssistant(w, am),
190+ .tool_result => unreachable,
191+ }
192+ i += 1;
193+ }
194+ try w.writeByte(']');
195+
196+ try writeTools(w, req.scratch, req.tools_json, "input_schema");
197+ try w.writeByte('}');
198+ return out.written();
199+}
200+
201+fn buildUrl(a: std.mem.Allocator, base: []const u8) ![]u8 {
202+ return std.fmt.allocPrint(a, "{s}/v1/messages", .{std.mem.trimEnd(u8, base, "/")});
203+}
204+
205+fn headers(a: std.mem.Allocator, req: api.Request, key: []const u8) ![]http.Header {
206+ var list: std.ArrayList(http.Header) = .empty;
207+ errdefer list.deinit(a);
208+ try list.append(a, .{ .name = "Content-Type", .value = "application/json" });
209+ try list.append(a, .{ .name = "Accept", .value = "text/event-stream" });
210+ try list.append(a, .{ .name = "anthropic-version", .value = anthropic_version });
211+ if (key.len > 0) try list.append(a, .{ .name = "x-api-key", .value = key });
212+ for (req.model.headers) |kv| try list.append(a, .{ .name = kv[0], .value = kv[1] });
213+ if (req.session_id) |sid| {
214+ if (req.model.session_header) |name| {
215+ if (sid.len > 0) try list.append(a, .{ .name = name, .value = sid });
216+ }
217+ }
218+ return list.toOwnedSlice(a);
219+}
220+
221+// ---- streaming state ------------------------------------------------------
222+
223+const BlockKind = enum { text, thinking, tool };
224+
225+const Block = struct {
226+ kind: BlockKind = .text,
227+ text: std.ArrayList(u8) = .empty,
228+ signature: std.ArrayList(u8) = .empty,
229+ id: []const u8 = "",
230+ name: []const u8 = "",
231+ args: std.ArrayList(u8) = .empty,
232+ started: bool = false,
233+};
234+
235+const State = struct {
236+ req: api.Request,
237+ sink: api.Sink,
238+ arena: *std.heap.ArenaAllocator,
239+ msg: *types.AssistantMessage,
240+ blocks: std.ArrayList(Block) = .empty,
241+ tokens_in: u64 = 0,
242+ tokens_out: u64 = 0,
243+ cache_read: u64 = 0,
244+ cache_write: u64 = 0,
245+ reasoning_tokens: ?u64 = null,
246+ stop_reason: ?[]const u8 = null,
247+ stream_error: ?[]const u8 = null,
248+};
249+
250+fn blockAt(st: *State, index: i64) !*Block {
251+ const idx: usize = if (index >= 0 and index <= max_stream_index)
252+ @intCast(index)
253+ else
254+ st.blocks.items.len;
255+ while (st.blocks.items.len <= idx) try st.blocks.append(st.req.pers, .{});
256+ return &st.blocks.items[idx];
257+}
258+
259+fn num(v: Value) u64 {
260+ return switch (v) {
261+ .integer => |n| @intCast(@max(n, 0)),
262+ .float => |f| @intFromFloat(@max(f, 0)),
263+ else => 0,
264+ };
265+}
266+
267+fn numField(obj: std.json.ObjectMap, key: []const u8) u64 {
268+ return num(obj.get(key) orelse return 0);
269+}
270+
271+fn applyCost(model: *const types.Model, u: *types.Usage) void {
272+ const m = 1_000_000.0;
273+ u.cost_input = @as(f64, @floatFromInt(u.input)) * model.cost_input / m;
274+ u.cost_output = @as(f64, @floatFromInt(u.output)) * model.cost_output / m;
275+ u.cost_cache_read = @as(f64, @floatFromInt(u.cache_read)) * model.cost_cache_read / m;
276+ u.cost_cache_write = 0;
277+ u.cost_total = u.cost_input + u.cost_output + u.cost_cache_read + u.cost_cache_write;
278+}
279+
280+fn handle(st: *State, obj: std.json.ObjectMap) !void {
281+ const event_type = switch (obj.get("type") orelse Value{ .null = {} }) {
282+ .string => |s| s,
283+ else => "",
284+ };
285+
286+ if (std.mem.eql(u8, event_type, "error")) {
287+ if (st.stream_error == null) st.stream_error = try st.req.pers.dupe(u8, errorMessage(obj));
288+ return;
289+ }
290+
291+ if (std.mem.eql(u8, event_type, "message_start")) {
292+ const message = obj.get("message") orelse return;
293+ if (message != .object) return;
294+ const message_obj = message.object;
295+ if (st.msg.response_id == null) {
296+ if (message_obj.get("id")) |v| {
297+ if (v == .string) st.msg.response_id = try st.req.pers.dupe(u8, v.string);
298+ }
299+ }
300+ if (message_obj.get("usage")) |usage| {
301+ if (usage == .object) {
302+ st.tokens_in = numField(usage.object, "input_tokens");
303+ st.tokens_out = numField(usage.object, "output_tokens");
304+ st.cache_read = numField(usage.object, "cache_read_input_tokens");
305+ st.cache_write = numField(usage.object, "cache_creation_input_tokens");
306+ }
307+ }
308+ return;
309+ }
310+
311+ if (std.mem.eql(u8, event_type, "content_block_start")) {
312+ const raw: i64 = switch (obj.get("index") orelse Value{ .null = {} }) {
313+ .integer => |n| n,
314+ else => -1,
315+ };
316+ if (raw < 0 or raw > max_stream_index) return;
317+ const block = try blockAt(st, raw);
318+ const cb = obj.get("content_block") orelse return;
319+ if (cb != .object) return;
320+ const bt = switch (cb.object.get("type") orelse Value{ .null = {} }) {
321+ .string => |s| s,
322+ else => "",
323+ };
324+ if (std.mem.eql(u8, bt, "tool_use")) {
325+ block.kind = .tool;
326+ if (cb.object.get("id")) |id| {
327+ if (id == .string) block.id = try st.req.pers.dupe(u8, id.string);
328+ }
329+ if (cb.object.get("name")) |name| {
330+ if (name == .string) block.name = try st.req.pers.dupe(u8, name.string);
331+ }
332+ if (!block.started and block.name.len > 0) {
333+ block.started = true;
334+ st.sink.emit(.{ .tool_start = block.name });
335+ }
336+ } else if (std.mem.eql(u8, bt, "thinking") or std.mem.eql(u8, bt, "redacted_thinking")) {
337+ block.kind = .thinking;
338+ if (std.mem.eql(u8, bt, "redacted_thinking")) {
339+ if (cb.object.get("data")) |d| {
340+ if (d == .string) try block.signature.appendSlice(st.req.pers, d.string);
341+ }
342+ }
343+ } else {
344+ block.kind = .text;
345+ }
346+ return;
347+ }
348+
349+ if (std.mem.eql(u8, event_type, "content_block_delta")) {
350+ const idx: i64 = switch (obj.get("index") orelse Value{ .null = {} }) {
351+ .integer => |n| n,
352+ else => return,
353+ };
354+ const delta = obj.get("delta") orelse return;
355+ if (delta != .object) return;
356+ if (idx < 0 or idx >= st.blocks.items.len) return;
357+ const block = &st.blocks.items[@intCast(idx)];
358+ const dt = switch (delta.object.get("type") orelse Value{ .null = {} }) {
359+ .string => |s| s,
360+ else => "",
361+ };
Cut short: this commit's diff is over 1000 lines.