auto-model-router 0.4.6 → 0.4.8

package/src/wire/openai/responses.ts

@@ -0,0 +1,365 @@
+/**
+ * OpenAI Responses API front end (`POST /v1/responses`), the wire Codex CLI
+ * speaks (it dropped chat completions in 0.150). Two halves:
+ *
+ *  - Request: a Responses body is translated into the chat-completions shape
+ *    the rest of the router already understands, then parsed by the existing
+ *    parser. `instructions` becomes the system message, `input` items become
+ *    messages (function_call → an assistant tool call, function_call_output →
+ *    a tool message), flat function tools become chat tools. Fields that only
+ *    mean something to OpenAI's stateful store are dropped.
+ *  - Response: the upstream chat stream is re-rendered as Responses SSE
+ *    events (response.created … response.completed) or, for non-streaming
+ *    callers, one Response object. The routing summary rides on the final
+ *    event as `x_auto_model_router`, as the chat wire does.
+ *
+ * Stateless only: `previous_response_id` is rejected, because the router keeps
+ * no response store. Codex sends `store: false` and the full input each turn.
+ */
+
+import { encoder, sseDataFrame } from "../../util/sse.ts";
+import type { NormRequest, ResponseSink, TurnSummary, UpstreamChunk, WireError } from "../types.ts";
+import { invalidRequest, renderErrorEnvelope } from "./errors.ts";
+import { parseChatRequest } from "./request.ts";
+
+// ---------------------------------------------------------------------------
+// Request translation
+// ---------------------------------------------------------------------------
+
+/** Responses-only fields with no chat-completions meaning; never forwarded. */
+export const RESPONSES_ONLY_PARAMS: readonly string[] = ["instructions", "input", "include", "store", "prompt_cache_key", "client_metadata", "text", "truncation", "metadata", "previous_response_id", "max_output_tokens", "max_tool_calls", "background", "conversation", "safety_identifier", "service_tier"];
+
+type Rec = Record<string, unknown>;
+const isRec = (v: unknown): v is Rec => v !== null && typeof v === "object" && !Array.isArray(v);
+
+/** One Responses content part → one chat content part (text or image). */
+function contentPart(part: unknown): Rec | null {
+	if (typeof part === "string") return { type: "text", text: part };
+	if (!isRec(part)) return null;
+	const type = typeof part.type === "string" ? part.type : "";
+	if (type === "input_text" || type === "output_text" || type === "text") return { type: "text", text: typeof part.text === "string" ? part.text : "" };
+	if (type === "input_image") {
+		const url = typeof part.image_url === "string" ? part.image_url : isRec(part.image_url) && typeof part.image_url.url === "string" ? part.image_url.url : "";
+		return url === "" ? null : { type: "image_url", image_url: { url } };
+	}
+	if (type === "refusal") return { type: "text", text: typeof part.refusal === "string" ? part.refusal : "" };
+	// input_file and unknown parts: keep a placeholder so the turn still classifies.
+	return { type: "text", text: `[${type || "unknown"} part]` };
+}
+
+function messageContent(raw: unknown): string | Rec[] {
+	if (typeof raw === "string") return raw;
+	if (!Array.isArray(raw)) return "";
+	const parts = raw.map(contentPart).filter((p): p is Rec => p !== null);
+	// A pure-text message is cheaper to carry as a string.
+	if (parts.every((p) => p.type === "text")) return parts.map((p) => p.text as string).join("");
+	return parts;
+}
+
+function outputText(raw: unknown): string {
+	if (typeof raw === "string") return raw;
+	if (Array.isArray(raw)) return raw.map((p) => (typeof p === "string" ? p : isRec(p) && typeof p.text === "string" ? p.text : "")).join("");
+	if (isRec(raw)) return JSON.stringify(raw);
+	return "";
+}
+
+/** Translates a Responses body into the chat-completions shape; throws WireErrorException on a malformed body. */
+export function responsesToChatBody(body: unknown): Rec {
+	if (!isRec(body)) throw invalidRequest("Request body must be a JSON object");
+	if (typeof body.previous_response_id === "string" && body.previous_response_id !== "") {
+		throw invalidRequest("previous_response_id is not supported: the router keeps no response store; send the full input (Codex does with store=false)");
+	}
+	const messages: Rec[] = [];
+	if (typeof body.instructions === "string" && body.instructions !== "") messages.push({ role: "system", content: body.instructions });
+
+	const input = body.input;
+	if (typeof input === "string") messages.push({ role: "user", content: input });
+	else if (Array.isArray(input)) {
+		for (const item of input) {
+			if (!isRec(item)) continue;
+			const type = typeof item.type === "string" ? item.type : typeof item.role === "string" ? "message" : "";
+			if (type === "message") {
+				const role = typeof item.role === "string" ? item.role : "user";
+				messages.push({ role, content: messageContent(item.content) });
+			} else if (type === "function_call") {
+				const call = {
+					id: typeof item.call_id === "string" ? item.call_id : typeof item.id === "string" ? item.id : `call_${messages.length}`,
+					type: "function",
+					function: { name: typeof item.name === "string" ? item.name : "", arguments: typeof item.arguments === "string" ? item.arguments : "{}" },
+				};
+				// Parallel calls arrive as consecutive items; they belong to one assistant message.
+				const last = messages[messages.length - 1];
+				if (last !== undefined && last.role === "assistant" && Array.isArray(last.tool_calls)) (last.tool_calls as Rec[]).push(call);
+				else messages.push({ role: "assistant", content: null, tool_calls: [call] });
+			} else if (type === "function_call_output") {
+				messages.push({ role: "tool", tool_call_id: typeof item.call_id === "string" ? item.call_id : "", content: outputText(item.output) });
+			}
+			// reasoning, item references, built-in tool calls: nothing the upstream can use.
+		}
+	} else if (input !== undefined) throw invalidRequest("input must be a string or an array of items");
+	if (messages.length === 0) throw invalidRequest("input must contain at least one message");
+
+	const tools: Rec[] = [];
+	if (Array.isArray(body.tools)) {
+		for (const t of body.tools) {
+			if (!isRec(t) || t.type !== "function" || typeof t.name !== "string") continue;
+			tools.push({ type: "function", function: { name: t.name, ...(typeof t.description === "string" ? { description: t.description } : {}), ...(isRec(t.parameters) ? { parameters: t.parameters } : {}) } });
+		}
+	}
+
+	const out: Rec = {};
+	for (const [k, v] of Object.entries(body)) {
+		if (RESPONSES_ONLY_PARAMS.includes(k) || k === "tools" || k === "tool_choice" || k === "reasoning") continue;
+		out[k] = v;
+	}
+	out.messages = messages;
+	if (tools.length > 0) out.tools = tools;
+	const tc = body.tool_choice;
+	if (isRec(tc) && tc.type === "function" && typeof tc.name === "string") out.tool_choice = { type: "function", function: { name: tc.name } };
+	else if (typeof tc === "string") out.tool_choice = tc;
+	if (typeof body.max_output_tokens === "number") out.max_tokens = body.max_output_tokens;
+	if (isRec(body.reasoning) && typeof body.reasoning.effort === "string") out.reasoning = { effort: body.reasoning.effort };
+	out.stream = body.stream === true;
+	return out;
+}
+
+export function parseResponsesRequest(body: unknown, headers: Headers): NormRequest {
+	const norm = parseChatRequest(responsesToChatBody(body), headers);
+	return { ...norm, protocol: "openai-responses" };
+}
+
+// ---------------------------------------------------------------------------
+// Response rendering
+// ---------------------------------------------------------------------------
+
+interface MessageItem {
+	kind: "message";
+	id: string;
+	text: string;
+	open: boolean;
+}
+interface CallItem {
+	kind: "function_call";
+	id: string;
+	callId: string;
+	name: string;
+	args: string;
+	open: boolean;
+}
+type Item = MessageItem | CallItem;
+
+function summaryFields(summary: TurnSummary): Record<string, unknown> {
+	return { model: summary.servedSlug, tier: summary.tier, cost_usd: summary.reportedUsd ?? summary.predictedUsd, attempts: summary.attempts };
+}
+
+function itemJson(it: Item, status: "in_progress" | "completed"): Rec {
+	return it.kind === "message"
+		? { id: it.id, type: "message", role: "assistant", status, content: [{ type: "output_text", text: it.text, annotations: [] }] }
+		: { id: it.id, type: "function_call", call_id: it.callId, name: it.name, arguments: it.args, status };
+}
+
+function usageJson(summary: TurnSummary): Rec {
+	const u = summary.usage;
+	return {
+		input_tokens: u.promptTokens,
+		input_tokens_details: { cached_tokens: u.cachedTokens },
+		output_tokens: u.completionTokens,
+		output_tokens_details: { reasoning_tokens: u.reasoningTokens },
+		total_tokens: u.promptTokens + u.completionTokens,
+	};
+}
+
+/**
+ * Turns the upstream chat stream into Responses output items, emitting the
+ * standard event sequence through `emit`. Shared by the streaming and the
+ * buffered sink; the buffered one simply ignores the events.
+ */
+class ResponseBuilder {
+	readonly id = `resp_${crypto.randomUUID().replaceAll("-", "")}`;
+	readonly createdAt = Math.floor(Date.now() / 1000);
+	private seq = 0;
+	private started = false;
+	readonly items: Item[] = [];
+	private readonly callsByIndex = new Map<number, CallItem>();
+	private message: MessageItem | null = null;
+
+	constructor(
+		private readonly model: string,
+		private readonly emit: (type: string, payload: Rec) => void,
+	) {}
+
+	private event(type: string, payload: Rec): void {
+		this.emit(type, { type, sequence_number: this.seq++, ...payload });
+	}
+
+	private response(status: string, extra: Rec = {}): Rec {
+		return { id: this.id, object: "response", created_at: this.createdAt, status, model: this.model, output: this.items.map((it) => itemJson(it, "completed")), ...extra };
+	}
+
+	start(): void {
+		if (this.started) return;
+		this.started = true;
+		this.event("response.created", { response: this.response("in_progress") });
+		this.event("response.in_progress", { response: this.response("in_progress") });
+	}
+
+	private openMessage(): MessageItem {
+		if (this.message !== null && this.message.open) return this.message;
+		const item: MessageItem = { kind: "message", id: `msg_${crypto.randomUUID().replaceAll("-", "")}`, text: "", open: true };
+		this.items.push(item);
+		this.message = item;
+		const output_index = this.items.length - 1;
+		this.event("response.output_item.added", { output_index, item: itemJson(item, "in_progress") });
+		this.event("response.content_part.added", { item_id: item.id, output_index, content_index: 0, part: { type: "output_text", text: "", annotations: [] } });
+		return item;
+	}
+
+	private closeMessage(): void {
+		const item = this.message;
+		if (item === null || !item.open) return;
+		item.open = false;
+		const output_index = this.items.indexOf(item);
+		this.event("response.output_text.done", { item_id: item.id, output_index, content_index: 0, text: item.text });
+		this.event("response.content_part.done", { item_id: item.id, output_index, content_index: 0, part: { type: "output_text", text: item.text, annotations: [] } });
+		this.event("response.output_item.done", { output_index, item: itemJson(item, "completed") });
+	}
+
+	private closeCall(item: CallItem): void {
+		if (!item.open) return;
+		item.open = false;
+		const output_index = this.items.indexOf(item);
+		this.event("response.function_call_arguments.done", { item_id: item.id, output_index, arguments: item.args });
+		this.event("response.output_item.done", { output_index, item: itemJson(item, "completed") });
+	}
+
+	chunk(chunk: UpstreamChunk): void {
+		for (const ev of chunk.events) {
+			if (ev.type === "start") this.start();
+			else if (ev.type === "text") {
+				if (ev.delta === "") continue;
+				this.start();
+				const item = this.openMessage();
+				item.text += ev.delta;
+				this.event("response.output_text.delta", { item_id: item.id, output_index: this.items.indexOf(item), content_index: 0, delta: ev.delta });
+			} else if (ev.type === "tool_call") {
+				this.start();
+				let item = this.callsByIndex.get(ev.index);
+				if (item === undefined) {
+					this.closeMessage();
+					item = {
+						kind: "function_call",
+						id: `fc_${crypto.randomUUID().replaceAll("-", "")}`,
+						callId: ev.id ?? `call_${crypto.randomUUID().replaceAll("-", "").slice(0, 24)}`,
+						name: ev.name ?? "",
+						args: "",
+						open: true,
+					};
+					this.callsByIndex.set(ev.index, item);
+					this.items.push(item);
+					this.event("response.output_item.added", { output_index: this.items.length - 1, item: itemJson(item, "in_progress") });
+				} else if (ev.name !== undefined && item.name === "") item.name = ev.name;
+				if (ev.argsDelta !== undefined && ev.argsDelta !== "") {
+					item.args += ev.argsDelta;
+					this.event("response.function_call_arguments.delta", { item_id: item.id, output_index: this.items.indexOf(item), delta: ev.argsDelta });
+				}
+			} else if (ev.type === "finish") {
+				this.closeMessage();
+				for (const c of this.callsByIndex.values()) this.closeCall(c);
+			}
+			// reasoning and usage: carried by the summary, not the item stream.
+		}
+	}
+
+	finish(summary: TurnSummary): Rec {
+		this.start();
+		this.closeMessage();
+		for (const c of this.callsByIndex.values()) this.closeCall(c);
+		const response = this.response("completed", { usage: usageJson(summary) });
+		this.event("response.completed", { response, x_auto_model_router: summaryFields(summary) });
+		return { ...response, x_auto_model_router: summaryFields(summary) };
+	}
+
+	fail(error: WireError): void {
+		this.event("error", { code: error.code, message: error.message });
+		this.event("response.failed", { response: this.response("failed", { error: { code: error.code, message: error.message } }) });
+	}
+}
+
+export function createResponsesStreamingSink(virtualModel: string): { sink: ResponseSink; response: Response } {
+	let controller: ReadableStreamDefaultController<Uint8Array> | null = null;
+	let closed = false;
+	const body = new ReadableStream<Uint8Array>({
+		start(c) {
+			controller = c;
+		},
+	});
+	const send = (text: string): void => {
+		if (closed) return;
+		try {
+			controller?.enqueue(encoder.encode(text));
+		} catch {
+			closed = true;
+		}
+	};
+	const close = (): void => {
+		if (closed) return;
+		closed = true;
+		try {
+			controller?.close();
+		} catch {
+			// Already closed by the runtime.
+		}
+	};
+	const builder = new ResponseBuilder(virtualModel, (type, payload) => send(`event: ${type}\n${sseDataFrame(payload)}`));
+	const sink: ResponseSink = {
+		chunk(chunk) {
+			builder.chunk(chunk);
+		},
+		error(error) {
+			builder.fail(error);
+			close();
+		},
+		finish(summary) {
+			builder.finish(summary);
+			close();
+		},
+	};
+	return { sink, response: new Response(body, { status: 200, headers: { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" } }) };
+}
+
+export function createResponsesBufferedSink(virtualModel: string): { sink: ResponseSink; response: Promise<Response> } {
+	let resolve!: (r: Response) => void;
+	const response = new Promise<Response>((r) => {
+		resolve = r;
+	});
+	let settled = false;
+	const builder = new ResponseBuilder(virtualModel, () => {});
+	const sink: ResponseSink = {
+		chunk(chunk) {
+			builder.chunk(chunk);
+		},
+		error(error) {
+			if (settled) return;
+			settled = true;
+			resolve(new Response(JSON.stringify(renderErrorEnvelope(error)), { status: error.status, headers: { "content-type": "application/json" } }));
+		},
+		finish(summary) {
+			if (settled) return;
+			settled = true;
+			const f = summaryFields(summary);
+			resolve(
+				new Response(JSON.stringify(builder.finish(summary)), {
+					status: 200,
+					headers: {
+						"content-type": "application/json",
+						"x-auto-model-router-model": String(f.model),
+						"x-auto-model-router-tier": String(f.tier),
+						"x-auto-model-router-cost-usd": String(f.cost_usd),
+						"x-auto-model-router-attempts": String(f.attempts),
+					},
+				}),
+			);
+		},
+	};
+	return { sink, response };
+}

package/src/wire/openai/sink.ts

@@ -20,6 +20,9 @@ function summaryFields(summary: TurnSummary): Record<string, unknown> {
 export function createStreamingSink(virtualModel: string): { sink: ResponseSink; response: Response } {
 	let controller: ReadableStreamDefaultController<Uint8Array> | null = null;
 	let closed = false;
+	// The upstream's chunk identity, so the trailer can be a well-formed chunk.
+	let lastId: unknown = null;
+	let lastCreated: unknown = null;
 	const body = new ReadableStream<Uint8Array>({
 		start(c) {
 			controller = c;
@@ -51,6 +54,8 @@ export function createStreamingSink(virtualModel: string): { sink: ResponseSink;
 	const sink: ResponseSink = {
 		chunk(chunk: UpstreamChunk) {
 			const raw = chunk.raw;
+			if (typeof raw.id === "string") lastId = raw.id;
+			if (typeof raw.created === "number") lastCreated = raw.created;
 			// The client asked for the virtual id and must see it, so its own
 			// bookkeeping stays consistent; the served slug stays observable
 			// under x_auto_model_router. The tier is only known at finish time, so
@@ -73,8 +78,20 @@ export function createStreamingSink(virtualModel: string): { sink: ResponseSink;
 		},
 		finish(summary: TurnSummary) {
 			// Response headers flushed with the first chunk, so x-auto-model-router-*
-			// cannot be real headers here; this final frame is their carrier.
-			send(encodeSseData({ x_auto_model_router: summaryFields(summary) }));
+			// cannot be real headers here; this final frame is their carrier. It is
+			// shaped as a real chunk with no choices (the shape OpenAI's own usage
+			// chunk has): strict clients validate every frame, and OpenCode's AI
+			// SDK rejected a bare object here ("choices: expected array").
+			send(
+				encodeSseData({
+					id: lastId ?? "auto-model-router",
+					object: "chat.completion.chunk",
+					created: lastCreated ?? Math.floor(Date.now() / 1000),
+					model: virtualModel,
+					choices: [],
+					x_auto_model_router: summaryFields(summary),
+				}),
+			);
 			send(SSE_DONE_BYTES);
 			close();
 		},

package/src/wire/types.ts

@@ -10,7 +10,7 @@
 
 import type { UsageCounts } from "../cost/types.ts";
 
-export type WireProtocol = "openai-chat" | "pi-native";
+export type WireProtocol = "openai-chat" | "openai-responses" | "pi-native";
 
 export type Role = "system" | "developer" | "user" | "assistant" | "tool";
 

package/test/digest.test.ts

@@ -198,6 +198,9 @@ describe("createDigester", () => {
 		expect(dg.noteToolCalls("omp-1", [{ name: "read", argsJson: '{"path":"src/b.ts"}' }, { name: "grep", argsJson: '{"pattern":"src/a.ts"}' }])).toBe(0);
 		expect(dg.noteToolCalls("omp-2", [{ name: "read", argsJson: '{"path":"src/a.ts"}' }])).toBe(0);
 		expect(row().wasted).toBe(false);
+		// The next request carries the call that PRODUCED the digest in its last assistant message: not a re-run.
+		expect(dg.noteToolCalls("omp-1", [{ name: "read", argsJson: '{"path":"src/a.ts","offset":1}' }])).toBe(0);
+		expect(row().wasted).toBe(false);
 		// The same read again (case-insensitive tool name, any other args): the agent wanted the full output.
 		expect(dg.noteToolCalls("omp-1", [{ name: "Read", argsJson: '{"path":"src/a.ts","limit":50}' }])).toBe(1);
 		expect(row().wasted).toBe(true);

package/test/fixtures/harness/aider.json

@@ -0,0 +1,47 @@
+{
+ "harness": "aider",
+ "capturedAtMs": 1788816104921,
+ "headers": {
+  "content-type": "application/json",
+  "user-agent": "OpenAI/Python 2.20.0"
+ },
+ "body": {
+  "messages": [
+   {
+    "role": "system",
+    "content": "Act as an expert software developer.\nTake requests for changes to the supplied code.\nIf the request is ambiguous, ask questions.\nReply in English_United States.\n\nOnce you understand the request you MUST:\n1. Determine if any code changes are needed.\n2. Explain any needed changes.\n3. If changes are needed, output a copy of each file that needs changes.\n\nTo suggest changes to a file you MUST return t\u00e2\u20ac\u00a6[1219 chars]"
+   },
+   {
+    "role": "user",
+    "content": "Change the greeting to be more casual"
+   },
+   {
+    "role": "assistant",
+    "content": "Ok, I will:\n\n1. Switch the greeting text from \"Hello\" to \"Hey\".\n\nshow_greeting.py\n```\nimport sys\n\ndef greeting(name):\n    print(f\"Hey {name}\")\n\nif __name__ == '__main__':\n    greeting(sys.argv[1])\n```\n"
+   },
+   {
+    "role": "user",
+    "content": "I switched to a new code base. Please don't consider the above files or try to edit them any longer."
+   },
+   {
+    "role": "assistant",
+    "content": "Ok."
+   },
+   {
+    "role": "user",
+    "content": "I am not sharing any files that you can edit yet."
+   },
+   {
+    "role": "assistant",
+    "content": "Ok."
+   },
+   {
+    "role": "user",
+    "content": "Reply with the single word ok\n\nTo suggest changes to a file you MUST return the entire content of the updated file.\nYou MUST use this *file listing* format:\n\npath/to/filename.js\n```\n// entire file content ...\n// ... goes in between\n```\n\nEvery *file listing* MUST use this format:\n- First line: the filename with any originally provided path; no extra markup, punctuation, comments, etc. **JUST** the \u00e2\u20ac\u00a6[896 chars]"
+   }
+  ],
+  "model": "auto",
+  "stream": true,
+  "temperature": 0
+ }
+}