auto-model-router 0.4.7 → 0.4.8

package/test/fixtures/harness/opencode.json

@@ -0,0 +1,338 @@
+{
+ "harness": "opencode",
+ "capturedAtMs": 1788816092608,
+ "headers": {
+  "content-type": "application/json",
+  "user-agent": "opencode/1.18.16 ai-sdk/provider-utils/4.0.23 runtime/bun/1.3.14",
+  "x-omp-harness": "opencode"
+ },
+ "body": {
+  "model": "auto",
+  "max_tokens": 32000,
+  "messages": [
+   {
+    "role": "system",
+    "content": "You are opencode, an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.\n\nIMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files.\n\nIf the user \u00e2\u20ac\u00a6[10797 chars]"
+   },
+   {
+    "role": "user",
+    "content": "\"Reply with the single word ok\""
+   }
+  ],
+  "tools": [
+   {
+    "type": "function",
+    "function": {
+     "name": "bash",
+     "description": "Executes a given bash command in a persistent shell session with optional timeout, ensuring proper handling and security measures.\n\nBe aware: OS: win32, Shell: bash\n\nAll commands run in the current working directory by default. Use the `workdir` parameter if you need to run a command in a different directory. AVOID using `cd <directory> && <command>` patterns - use `workdir` instead.\n\nUse `C:\\User\u00e2\u20ac\u00a6[4657 chars]",
+     "parameters": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "properties": {
+       "command": {
+        "type": "string",
+        "description": "The command to execute"
+       },
+       "timeout": {
+        "minimum": -9007199254740991,
+        "exclusiveMinimum": 0,
+        "type": "integer",
+        "maximum": 9007199254740991,
+        "description": "Optional timeout in milliseconds"
+       },
+       "workdir": {
+        "type": "string",
+        "description": "The working directory to run the command in. Defaults to the current directory. Use this instead of 'cd' commands."
+       }
+      },
+      "required": [
+       "command"
+      ]
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "edit",
+     "description": "Performs exact string replacements in files. \n\nUsage:\n- You must use your `Read` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. \n- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: line number + co\u00e2\u20ac\u00a6[1369 chars]",
+     "parameters": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "properties": {
+       "filePath": {
+        "type": "string",
+        "description": "The absolute path to the file to modify"
+       },
+       "oldString": {
+        "type": "string",
+        "description": "The text to replace"
+       },
+       "newString": {
+        "type": "string",
+        "description": "The text to replace it with (must be different from oldString)"
+       },
+       "replaceAll": {
+        "type": "boolean",
+        "description": "Replace all occurrences of oldString (default false)"
+       }
+      },
+      "required": [
+       "filePath",
+       "oldString",
+       "newString"
+      ]
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "glob",
+     "description": "- Fast file pattern matching tool that works with any codebase size\n- Supports glob patterns like \"**/*.js\" or \"src/**/*.ts\"\n- Returns matching file paths\n- Use this tool when you need to find files by name patterns\n- When you are doing an open-ended search that may require multiple rounds of globbing and grepping, use the Task tool instead\n- You have the capability to call multiple tools in a sin\u00e2\u20ac\u00a6[517 chars]",
+     "parameters": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "properties": {
+       "pattern": {
+        "type": "string",
+        "description": "The glob pattern to match files against"
+       },
+       "path": {
+        "type": "string",
+        "description": "The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter \"undefined\" or \"null\" - simply omit it for the default behavior. Must be a valid directory path if provided."
+       }
+      },
+      "required": [
+       "pattern"
+      ]
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "grep",
+     "description": "- Fast content search tool that works with any codebase size\n- Searches file contents using regular expressions\n- Supports full regex syntax (eg. \"log.*Error\", \"function\\s+\\w+\", etc.)\n- Filter files by pattern with the include parameter (eg. \"*.js\", \"*.{ts,tsx}\")\n- Returns file paths and line numbers with matching lines\n- Use this tool when you need to find files containing specific patterns\n- If \u00e2\u20ac\u00a6[657 chars]",
+     "parameters": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "properties": {
+       "pattern": {
+        "type": "string",
+        "description": "The regex pattern to search for in file contents"
+       },
+       "path": {
+        "type": "string",
+        "description": "The directory to search in. Defaults to the current working directory."
+       },
+       "include": {
+        "type": "string",
+        "description": "File pattern to include in the search (e.g. \"*.js\", \"*.{ts,tsx}\")"
+       }
+      },
+      "required": [
+       "pattern"
+      ]
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "read",
+     "description": "Read a file or directory from the local filesystem. If the path does not exist, an error is returned.\n\nUsage:\n- The filePath parameter should be an absolute path.\n- By default, this tool returns up to 2000 lines from the start of the file.\n- The offset parameter is the line number to start from (1-indexed).\n- To read later sections, call this tool again with a larger offset.\n- Use the grep tool to\u00e2\u20ac\u00a6[1158 chars]",
+     "parameters": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "properties": {
+       "filePath": {
+        "type": "string",
+        "description": "The absolute path to the file or directory to read"
+       },
+       "offset": {
+        "minimum": 0,
+        "type": "integer",
+        "maximum": 9007199254740991,
+        "description": "The line number to start reading from (1-indexed)"
+       },
+       "limit": {
+        "minimum": 0,
+        "type": "integer",
+        "maximum": 9007199254740991,
+        "description": "The maximum number of lines to read (defaults to 2000)"
+       }
+      },
+      "required": [
+       "filePath"
+      ]
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "skill",
+     "description": "Load a specialized skill when the task at hand matches one of the skills listed in the system prompt.\n\nUse this tool to inject the skill's instructions and resources into current conversation. The output may contain detailed workflow guidance as well as references to scripts, files, etc in the same directory as the skill.\n\nThe skill name must match one of the skills listed in your system prompt.\n",
+     "parameters": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "properties": {
+       "name": {
+        "type": "string",
+        "description": "The name of the skill from available_skills"
+       }
+      },
+      "required": [
+       "name"
+      ]
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "task",
+     "description": "Launch a new agent to handle complex, multistep tasks autonomously.\n\nWhen using the Task tool, you must specify a subagent_type parameter to select which agent type to use.\n\nWhen NOT to use the Task tool:\n- If you want to read a specific file path, use the Read or Glob tool instead of the Task tool, to find the match more quickly\n- If you are searching for a specific class definition like \"class F\u00e2\u20ac\u00a6[3019 chars]",
+     "parameters": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "properties": {
+       "description": {
+        "type": "string",
+        "description": "A short (3-5 words) description of the task"
+       },
+       "prompt": {
+        "type": "string",
+        "description": "The task for the agent to perform"
+       },
+       "subagent_type": {
+        "type": "string",
+        "description": "The type of specialized agent to use for this task"
+       },
+       "task_id": {
+        "type": "string",
+        "description": "This should only be set if you mean to resume a previous task (you can pass a prior task_id and the task will continue the same subagent session as before instead of creating a fresh one)"
+       },
+       "command": {
+        "type": "string",
+        "description": "The command that triggered this task"
+       }
+      },
+      "required": [
+       "description",
+       "prompt",
+       "subagent_type"
+      ]
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "todowrite",
+     "description": "Create and maintain a structured task list for the current coding session. Tracks progress, organizes multi-step work, and surfaces status to the user.\n\n## When to use\nUse proactively when:\n- The task requires 3+ distinct steps or actions (not just 3 tool calls for a single conceptual step)\n- The work is non-trivial and benefits from planning\n- The user provides multiple tasks (numbered or comma-s\u00e2\u20ac\u00a6[2012 chars]",
+     "parameters": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "properties": {
+       "todos": {
+        "type": "array",
+        "items": {
+         "type": "object",
+         "properties": {
+          "content": {
+           "type": "string",
+           "description": "Brief description of the task"
+          },
+          "status": {
+           "type": "string",
+           "description": "Current status of the task: pending, in_progress, completed, cancelled"
+          },
+          "priority": {
+           "type": "string",
+           "description": "Priority level of the task: high, medium, low"
+          }
+         },
+         "required": [
+          "content",
+          "status",
+          "priority"
+         ]
+        },
+        "description": "The updated todo list"
+       }
+      },
+      "required": [
+       "todos"
+      ]
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "webfetch",
+     "description": "- Fetches content from a specified URL\n- Takes a URL and optional format as input\n- Fetches the URL content, converts to requested format (markdown by default)\n- Returns the content in the specified format\n- Use this tool when you need to retrieve and analyze web content\n\nUsage notes:\n  - IMPORTANT: if another tool is present that offers better web fetching capabilities, is more targeted to the ta\u00e2\u20ac\u00a6[750 chars]",
+     "parameters": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "properties": {
+       "url": {
+        "type": "string",
+        "description": "The URL to fetch content from"
+       },
+       "format": {
+        "type": "string",
+        "enum": [
+         "text",
+         "markdown",
+         "html"
+        ],
+        "description": "The format to return the content in (text, markdown, or html). Defaults to markdown.",
+        "default": "markdown"
+       },
+       "timeout": {
+        "type": "number",
+        "description": "Optional timeout in seconds (max 120)"
+       }
+      },
+      "required": [
+       "url"
+      ]
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "write",
+     "description": "Writes a file to the local filesystem.\n\nUsage:\n- This tool will overwrite the existing file if there is one at the provided path.\n- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.\n- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.\n- NEVER proacti\u00e2\u20ac\u00a6[623 chars]",
+     "parameters": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "properties": {
+       "content": {
+        "type": "string",
+        "description": "The content to write to the file"
+       },
+       "filePath": {
+        "type": "string",
+        "description": "The absolute path to the file to write (must be absolute, not relative)"
+       }
+      },
+      "required": [
+       "content",
+       "filePath"
+      ]
+     }
+    }
+   }
+  ],
+  "tool_choice": "auto",
+  "stream": true,
+  "stream_options": {
+   "include_usage": true
+  }
+ }
+}

package/test/harness-requests.test.ts

@@ -5,13 +5,16 @@ import { canonicalTool, digestApplies } from "../src/server/digest.ts";
 import { OPENAI_ONLY_PARAMS, parseChatRequest } from "../src/wire/openai/request.ts";
 import type { UpstreamMutations } from "../src/wire/types.ts";
 import { parsePolicy, shouldSend } from "../omp-extension/digest-logic.ts";
+import { RESPONSES_ONLY_PARAMS, parseResponsesRequest } from "../src/wire/openai/responses.ts";
 
 /**
- * Request shapes the config-only harnesses send to an OpenAI-compatible
- * endpoint, as each harness documents them: the router must parse them,
- * keep their tool calls and headers, and drop the OpenAI-platform-only
- * parameters before dispatch. These are representative bodies, not captured
- * traffic; a harness release that changes its shape belongs here as a new case.
+ * Request shapes other harnesses send: the router must parse them, keep their
+ * tool calls and headers, and drop the OpenAI-platform-only parameters before
+ * dispatch. The first block holds representative bodies for harnesses that
+ * could not be run here (Cline/Roo/Kilo) or that illustrate a header set; the
+ * second block parses requests actually captured with tools/capture-proxy.ts
+ * (Aider, OpenCode, Codex). A harness release that changes its shape belongs
+ * here as a refreshed capture.
  */
 
 const MUT: UpstreamMutations = { slug: "x/y", fallbacks: [], sessionId: "s", cacheBreakpointMessageIndices: [], reasoning: undefined, maxTokens: undefined, stripAssistantReasoning: false };
@@ -19,25 +22,6 @@ const MUT: UpstreamMutations = { slug: "x/y", fallbacks: [], sessionId: "s", cac
 const TOOL = (name: string) => ({ type: "function", function: { name, description: name, parameters: { type: "object", properties: { path: { type: "string" } } } } });
 
 const HARNESSES: Record<string, { headers: Record<string, string>; body: Record<string, unknown>; toolCall?: string }> = {
-	codex: {
-		headers: { "X-Omp-Harness": "codex" },
-		body: {
-			model: "auto",
-			messages: [
-				{ role: "developer", content: "You are Codex." },
-				{ role: "user", content: "fix the failing test" },
-				{ role: "assistant", content: null, tool_calls: [{ id: "call_1", type: "function", function: { name: "shell", arguments: '{"command":["cat","x.ts"]}' } }] },
-				{ role: "tool", tool_call_id: "call_1", content: "export const x = 1;" },
-			],
-			tools: [TOOL("shell"), TOOL("apply_patch")],
-			stream: true,
-			store: false,
-			prompt_cache_key: "session-abc",
-			reasoning_effort: "medium",
-			parallel_tool_calls: false,
-		},
-		toolCall: "shell",
-	},
 	aider: {
 		headers: { "X-Omp-Harness": "aider" },
 		body: { model: "auto", messages: [{ role: "system", content: "Act as an expert software developer." }, { role: "user", content: "add a retry helper" }], stream: true, temperature: 0, extra_body: {} },
@@ -119,6 +103,53 @@ describe("config-only harness request shapes", () => {
 	});
 });
 
+/** A request a harness actually sent, captured with tools/capture-proxy.ts (bodies trimmed, ids scrubbed). */
+async function fixture(name: string): Promise<{ headers: Record<string, string>; body: Record<string, unknown> }> {
+	return (await Bun.file(`${import.meta.dir}/fixtures/harness/${name}.json`).json()) as { headers: Record<string, string>; body: Record<string, unknown> };
+}
+
+describe("captured harness requests", () => {
+	test("aider 0.86: plain chat completions, no tools, no harness header", async () => {
+		const f = await fixture("aider");
+		const req = parseChatRequest(structuredClone(f.body), new Headers(f.headers));
+		expect(f.headers["user-agent"]).toContain("OpenAI/Python");
+		expect(req.harnessId).toBe("");
+		expect(req.stream).toBe(true);
+		expect(req.tools).toHaveLength(0);
+		expect(req.messages[0]?.role).toBe("system");
+		expect(req.renderUpstreamBody(MUT).model).toBe("x/y");
+	});
+
+	test("opencode 1.18: chat completions with tools, stream options and the harness header", async () => {
+		const f = await fixture("opencode");
+		const req = parseChatRequest(structuredClone(f.body), new Headers(f.headers));
+		expect(req.harnessId).toBe("opencode");
+		expect(req.tools.length).toBeGreaterThan(5);
+		expect(req.tools.map((t) => t.name)).toContain("read");
+		const out = req.renderUpstreamBody(MUT);
+		expect("stream_options" in out).toBe(false);
+		expect(out.max_tokens).toBe(f.body.max_tokens);
+	});
+
+	test("codex 0.153: Responses API body translates to a routed chat request", async () => {
+		const f = await fixture("codex-responses");
+		const req = parseResponsesRequest(structuredClone(f.body), new Headers(f.headers));
+		expect(req.protocol).toBe("openai-responses");
+		expect(req.harnessId).toBe("codex");
+		expect(req.requestedModel).toBe("auto");
+		expect(req.stream).toBe(true);
+		// instructions became the system message; the input items follow in order.
+		expect(req.messages.map((m) => m.role)).toEqual(["system", "developer", "user", "user"]);
+		expect(req.messages[0]?.text).toContain("coding agent running in the Codex CLI");
+		expect(req.tools.map((t) => t.name)).toContain("exec_command");
+		const out = req.renderUpstreamBody(MUT);
+		for (const key of RESPONSES_ONLY_PARAMS) expect(key in out).toBe(false);
+		expect(Array.isArray(out.messages)).toBe(true);
+		expect((out.tools as { function: { name: string } }[])[0]?.function.name).toBe("exec_command");
+		expect(out.parallel_tool_calls).toBe(true);
+	});
+});
+
 describe("digest tool aliases across harnesses", () => {
 	const d = { ...DEFAULT_CONFIG.digest, enabled: true, minBytes: 10, maxBytes: 10_000 };
 	test("harness spellings map onto the canonical tools list on both sides", () => {

package/test/wire-responses.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, test } from "bun:test";
+
+import { WireErrorException } from "../src/wire/openai/errors.ts";
+import { createResponsesBufferedSink, createResponsesStreamingSink, parseResponsesRequest, responsesToChatBody } from "../src/wire/openai/responses.ts";
+import type { StreamEvent, TurnSummary, UpstreamChunk } from "../src/wire/types.ts";
+
+/**
+ * The Responses API wire: request translation into the chat shape the router
+ * routes on, and rendering of the upstream chat stream as Responses events.
+ */
+
+const HEADERS = new Headers({ "X-Omp-Harness": "codex" });
+
+describe("responsesToChatBody", () => {
+	test("instructions, messages, function calls and their outputs become chat messages", () => {
+		const chat = responsesToChatBody({
+			model: "auto",
+			instructions: "Be terse.",
+			input: [
+				{ type: "message", role: "user", content: [{ type: "input_text", text: "list files" }] },
+				{ type: "function_call", call_id: "call_1", name: "shell", arguments: '{"cmd":"ls"}' },
+				{ type: "function_call", call_id: "call_2", name: "shell", arguments: '{"cmd":"pwd"}' },
+				{ type: "function_call_output", call_id: "call_1", output: "a.ts b.ts" },
+				{ type: "function_call_output", call_id: "call_2", output: [{ type: "input_text", text: "/repo" }] },
+				{ type: "reasoning", summary: [] },
+				{ role: "user", content: "and now?" },
+			],
+			tools: [{ type: "function", name: "shell", description: "run", parameters: { type: "object" }, strict: false }, { type: "web_search" }],
+			tool_choice: { type: "function", name: "shell" },
+			max_output_tokens: 512,
+			reasoning: { effort: "low", summary: "auto" },
+			store: false,
+			include: ["reasoning.encrypted_content"],
+			prompt_cache_key: "k",
+			stream: true,
+			parallel_tool_calls: true,
+		});
+		expect(chat.messages).toEqual([
+			{ role: "system", content: "Be terse." },
+			{ role: "user", content: "list files" },
+			{
+				role: "assistant",
+				content: null,
+				tool_calls: [
+					{ id: "call_1", type: "function", function: { name: "shell", arguments: '{"cmd":"ls"}' } },
+					{ id: "call_2", type: "function", function: { name: "shell", arguments: '{"cmd":"pwd"}' } },
+				],
+			},
+			{ role: "tool", tool_call_id: "call_1", content: "a.ts b.ts" },
+			{ role: "tool", tool_call_id: "call_2", content: "/repo" },
+			{ role: "user", content: "and now?" },
+		]);
+		expect(chat.tools).toEqual([{ type: "function", function: { name: "shell", description: "run", parameters: { type: "object" } } }]);
+		expect(chat.tool_choice).toEqual({ type: "function", function: { name: "shell" } });
+		expect(chat.max_tokens).toBe(512);
+		expect(chat.reasoning).toEqual({ effort: "low" });
+		expect(chat.stream).toBe(true);
+		expect(chat.parallel_tool_calls).toBe(true);
+		for (const k of ["instructions", "input", "store", "include", "prompt_cache_key", "max_output_tokens"]) expect(k in chat).toBe(false);
+	});
+
+	test("a string input is one user message; images survive; previous_response_id is refused", () => {
+		expect(responsesToChatBody({ model: "auto", input: "hi" }).messages).toEqual([{ role: "user", content: "hi" }]);
+		const withImage = responsesToChatBody({ model: "auto", input: [{ type: "message", role: "user", content: [{ type: "input_text", text: "what is this" }, { type: "input_image", image_url: "data:image/png;base64,AAAA" }] }] });
+		expect(withImage.messages).toEqual([{ role: "user", content: [{ type: "text", text: "what is this" }, { type: "image_url", image_url: { url: "data:image/png;base64,AAAA" } }] }]);
+		expect(() => responsesToChatBody({ model: "auto", input: "x", previous_response_id: "resp_1" })).toThrow(WireErrorException);
+		expect(() => responsesToChatBody({ model: "auto", input: [] })).toThrow(WireErrorException);
+	});
+
+	test("parseResponsesRequest yields a routed request tagged with the wire", () => {
+		const req = parseResponsesRequest({ model: "auto-model-router/auto-cheap", input: "hello", stream: false }, HEADERS);
+		expect(req.protocol).toBe("openai-responses");
+		expect(req.requestedModel).toBe("auto-cheap");
+		expect(req.harnessId).toBe("codex");
+		expect(req.messages).toHaveLength(1);
+		expect(req.stream).toBe(false);
+	});
+});
+
+const SUMMARY: TurnSummary = {
+	servedSlug: "openai/gpt-5.5",
+	tier: "simple",
+	attempts: 1,
+	predictedUsd: 0.001,
+	reportedUsd: 0.0012,
+	usage: { promptTokens: 120, cachedTokens: 100, cacheWriteTokens: 0, completionTokens: 9, reasoningTokens: 2, images: 0 },
+	reasons: [],
+	escalated: false,
+};
+const chunk = (...events: StreamEvent[]): UpstreamChunk => ({ raw: { id: "gen-1", object: "chat.completion.chunk", model: "openai/gpt-5.5" }, events });
+
+function parseEvents(text: string): { event: string; data: Record<string, unknown> }[] {
+	return text
+		.split("\n\n")
+		.filter((f) => f.startsWith("event: "))
+		.map((f) => {
+			const [eventLine = "", ...rest] = f.split("\n");
+			const dataLine = rest.find((l) => l.startsWith("data: ")) ?? "data: {}";
+			return { event: eventLine.slice("event: ".length), data: JSON.parse(dataLine.slice("data: ".length)) as Record<string, unknown> };
+		});
+}
+
+describe("createResponsesStreamingSink", () => {
+	test("renders text then a function call as the standard event sequence, ending in response.completed with usage", async () => {
+		const { sink, response } = createResponsesStreamingSink("auto");
+		expect(response.headers.get("content-type")).toBe("text/event-stream");
+		sink.chunk(chunk({ type: "start", servedSlug: "openai/gpt-5.5", generationId: "gen-1" }));
+		sink.chunk(chunk({ type: "text", delta: "Run" }));
+		sink.chunk(chunk({ type: "text", delta: "ning" }));
+		sink.chunk(chunk({ type: "tool_call", index: 0, id: "call_9", name: "shell", argsDelta: '{"cmd":' }));
+		sink.chunk(chunk({ type: "tool_call", index: 0, argsDelta: '"ls"}' }));
+		sink.chunk(chunk({ type: "finish", reason: "tool_calls" }, { type: "usage", usage: SUMMARY.usage, reportedCostUsd: 0.0012 }));
+		sink.finish(SUMMARY);
+		const text = await response.text();
+		const events = parseEvents(text);
+		expect(events.map((e) => e.event)).toEqual([
+			"response.created",
+			"response.in_progress",
+			"response.output_item.added",
+			"response.content_part.added",
+			"response.output_text.delta",
+			"response.output_text.delta",
+			"response.output_text.done",
+			"response.content_part.done",
+			"response.output_item.done",
+			"response.output_item.added",
+			"response.function_call_arguments.delta",
+			"response.function_call_arguments.delta",
+			"response.function_call_arguments.done",
+			"response.output_item.done",
+			"response.completed",
+		]);
+		// Every frame names its type and carries a rising sequence number.
+		events.forEach((e, i) => {
+			expect(e.data.type).toBe(e.event);
+			expect(e.data.sequence_number).toBe(i);
+		});
+		const completed = events.at(-1)!.data;
+		const resp = completed.response as { status: string; model: string; output: Record<string, unknown>[]; usage: Record<string, unknown> };
+		expect(resp.status).toBe("completed");
+		expect(resp.model).toBe("auto");
+		expect(resp.output).toHaveLength(2);
+		expect(resp.output[0]).toMatchObject({ type: "message", role: "assistant", status: "completed", content: [{ type: "output_text", text: "Running" }] });
+		expect(resp.output[1]).toMatchObject({ type: "function_call", call_id: "call_9", name: "shell", arguments: '{"cmd":"ls"}', status: "completed" });
+		expect(resp.usage).toEqual({ input_tokens: 120, input_tokens_details: { cached_tokens: 100 }, output_tokens: 9, output_tokens_details: { reasoning_tokens: 2 }, total_tokens: 129 });
+		expect(completed.x_auto_model_router).toEqual({ model: "openai/gpt-5.5", tier: "simple", cost_usd: 0.0012, attempts: 1 });
+		// The Responses stream has no [DONE] sentinel.
+		expect(text).not.toContain("[DONE]");
+	});
+
+	test("an error becomes an error event and response.failed", async () => {
+		const { sink, response } = createResponsesStreamingSink("auto");
+		sink.error({ status: 502, code: "upstream_error", message: "boom" });
+		const events = parseEvents(await response.text());
+		expect(events.map((e) => e.event)).toEqual(["error", "response.failed"]);
+		expect(events[0]!.data).toMatchObject({ code: "upstream_error", message: "boom" });
+	});
+});
+
+describe("createResponsesBufferedSink", () => {
+	test("aggregates the stream into one Response object with the routing headers", async () => {
+		const { sink, response } = createResponsesBufferedSink("auto");
+		sink.chunk(chunk({ type: "start", servedSlug: "openai/gpt-5.5", generationId: "gen-1" }, { type: "text", delta: "4" }, { type: "finish", reason: "stop" }));
+		sink.finish(SUMMARY);
+		const res = await response;
+		expect(res.status).toBe(200);
+		expect(res.headers.get("x-auto-model-router-model")).toBe("openai/gpt-5.5");
+		const body = (await res.json()) as { object: string; status: string; output: { type: string; content: { text: string }[] }[]; usage: { total_tokens: number } };
+		expect(body.object).toBe("response");
+		expect(body.status).toBe("completed");
+		expect(body.output[0]?.content[0]?.text).toBe("4");
+		expect(body.usage.total_tokens).toBe(129);
+	});
+});

package/test/wire-sink.test.ts

@@ -53,6 +53,11 @@ describe("createStreamingSink", () => {
 		// Headers flushed with the first chunk, so the summary arrives as the
 		// final x_auto_model_router frame before [DONE].
 		const last = frames[frames.length - 1] as Record<string, unknown>;
+		// A well-formed chunk with no choices, so strict SSE clients (OpenCode's AI SDK) accept it.
+		expect(last.object).toBe("chat.completion.chunk");
+		expect(last.choices).toEqual([]);
+		expect(last.id).toBe("gen-1");
+		expect(last.model).toBe("auto");
 		expect(last.x_auto_model_router).toEqual({
 			model: "openai/gpt-5.5",
 			tier: "simple",