auto-model-router 0.4.8 → 0.4.10

package/test/fixtures/harness/roo.json

@@ -0,0 +1,456 @@
+{
+ "harness": "roo",
+ "capturedAtMs": 1788827425238,
+ "headers": {
+  "content-type": "application/json",
+  "user-agent": "RooCode/3.54.0",
+  "x-omp-harness": "roo",
+  "x-title": "Roo Code",
+  "http-referer": "https://github.com/RooVetGit/Roo-Cline"
+ },
+ "body": {
+  "model": "auto",
+  "temperature": 0,
+  "messages": [
+   {
+    "role": "system",
+    "content": [
+     {
+      "type": "text",
+      "text": "You are Roo, an experienced technical leader who is inquisitive and an excellent planner. Your goal is to gather information and get context to create a detailed plan for accomplishing the user's task, which the user will review and approve before they switch into another mode to implement the solution.\n\n====\n\nMARKDOWN RULES\n\nALL responses MUST show ANY `language construct` OR filename reference a…[18131 chars]",
+      "cache_control": {
+       "type": "ephemeral"
+      }
+     }
+    ]
+   },
+   {
+    "role": "user",
+    "content": [
+     {
+      "type": "text",
+      "text": "<user_message>\nReply with the single word ok\n</user_message>"
+     },
+     {
+      "type": "text",
+      "text": "<environment_details>\n# VSCode Visible Files\n\n\n# VSCode Open Tabs\n\n\n# Current Time\nCurrent time in ISO 8601 UTC format: 2026-09-08T00:30:18.293Z\nUser time zone: America/Los_Angeles, UTC-7:00\n\n# Current Cost\n$0.00\n\n# Current Mode\n<slug>architect</slug>\n<name>🏗️ Architect</name>\n<model>auto</model>\n\n\n# Current Workspace Directory (c:/Users/drewa/AppData/Local/Temp/roo-amr) Files\nroo-settings.json\nY…[550 chars]"
+     }
+    ]
+   },
+   {
+    "role": "assistant",
+    "content": "ok"
+   },
+   {
+    "role": "user",
+    "content": [
+     {
+      "type": "text",
+      "text": "[ERROR] You did not use a tool in your previous response! Please retry with a tool use.\n\n# Reminder: Instructions for Tool Use\n\nTools are invoked using the platform's native tool calling mechanism. Each tool requires specific parameters as defined in the tool descriptions. Refer to the tool definitions provided in your system instructions for the correct parameter structure and usage examples.\n\nAl…[858 chars]"
+     },
+     {
+      "type": "text",
+      "text": "<environment_details>\n# VSCode Visible Files\n\n\n# VSCode Open Tabs\n\n\n# Current Time\nCurrent time in ISO 8601 UTC format: 2026-09-08T00:30:21.035Z\nUser time zone: America/Los_Angeles, UTC-7:00\n\n# Current Cost\n$0.00\n\n# Current Mode\n<slug>architect</slug>\n<name>🏗️ Architect</name>\n<model>auto</model>\nYou have not created a todo list yet. Create one with `update_todo_list` if your task is complicated …[450 chars]",
+      "cache_control": {
+       "type": "ephemeral"
+      }
+     }
+    ]
+   },
+   {
+    "role": "assistant",
+    "content": "",
+    "tool_calls": [
+     {
+      "id": "sqiUG7TuL",
+      "type": "function",
+      "function": {
+       "name": "update_todo_list",
+       "arguments": "{\"todos\":\"[ ] Analyze requirements\\n[x] Design architecture\\n[-] Implement core logic\\n[ ] Write tests\\n[ ] Update documentation\"}"
+      }
+     }
+    ]
+   },
+   {
+    "role": "tool",
+    "tool_call_id": "sqiUG7TuL",
+    "content": "Todo list updated successfully."
+   },
+   {
+    "role": "user",
+    "content": [
+     {
+      "type": "text",
+      "text": "<environment_details>\n# VSCode Visible Files\n\n\n# VSCode Open Tabs\n\n\n# Current Time\nCurrent time in ISO 8601 UTC format: 2026-09-08T00:30:24.425Z\nUser time zone: America/Los_Angeles, UTC-7:00\n\n# Current Cost\n$0.00\n\n# Current Mode\n<slug>architect</slug>\n<name>🏗️ Architect</name>\n<model>auto</model>\n====\n\nREMINDERS\n\nBelow is your current list of reminders for this task. Keep them updated as you prog…[780 chars]",
+      "cache_control": {
+       "type": "ephemeral"
+      }
+     }
+    ]
+   }
+  ],
+  "stream": true,
+  "stream_options": {
+   "include_usage": true
+  },
+  "tools": [
+   {
+    "type": "function",
+    "function": {
+     "name": "apply_diff",
+     "description": "Apply precise, targeted modifications to an existing file using one or more search/replace blocks. This tool is for surgical edits only; the 'SEARCH' block must exactly match the existing content, including whitespace and indentation. To make multiple targeted changes, provide multiple SEARCH/REPLACE blocks in the 'diff' parameter. Use the 'read_file' tool first if you are not confident in the exa…[425 chars]",
+     "parameters": {
+      "type": "object",
+      "properties": {
+       "path": {
+        "type": "string",
+        "description": "The path of the file to modify, relative to the current workspace directory."
+       },
+       "diff": {
+        "type": "string",
+        "description": "A string containing one or more search/replace blocks defining the changes. The ':start_line:' is required and indicates the starting line number of the original content. You must not add a start line for the replacement content. Each block must follow this format:\n<<<<<<< SEARCH\n:start_line:[line_number]\n-------\n[exact content to find]\n=======\n[new content to replace with]\n>>>>>>> REPLACE"
+       }
+      },
+      "required": [
+       "path",
+       "diff"
+      ],
+      "additionalProperties": false
+     },
+     "strict": true
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "ask_followup_question",
+     "description": "Ask the user a question to gather additional information needed to complete the task. Use when you need clarification or more details to proceed effectively.\n\nParameters:\n- question: (required) A clear, specific question addressing the information needed\n- follow_up: (required) A list of 2-4 suggested answers. Suggestions must be complete, actionable answers without placeholders. Optionally includ…[948 chars]",
+     "strict": true,
+     "parameters": {
+      "type": "object",
+      "properties": {
+       "question": {
+        "type": "string",
+        "description": "Clear, specific question that captures the missing information you need"
+       },
+       "follow_up": {
+        "type": "array",
+        "description": "Required list of 2-4 suggested responses; each suggestion must be a complete, actionable answer and may include a mode switch",
+        "items": {
+         "type": "object",
+         "properties": {
+          "text": {
+           "type": "string",
+           "description": "Suggested answer the user can pick"
+          },
+          "mode": {
+           "type": "string",
+           "description": "Optional mode slug to switch to if this suggestion is chosen (e.g., code, architect)"
+          }
+         },
+         "required": [
+          "text",
+          "mode"
+         ],
+         "additionalProperties": false
+        },
+        "minItems": 1,
+        "maxItems": 4
+       }
+      },
+      "required": [
+       "question",
+       "follow_up"
+      ],
+      "additionalProperties": false
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "attempt_completion",
+     "description": "After each tool use, the user will respond with the result of that tool use, i.e. if it succeeded or failed, along with any reasons for failure. Once you've received the results of tool uses and can confirm that the task is complete, use this tool to present the result of your work to the user. The user may respond with feedback if they are not satisfied with the result, which you can use to make …[1126 chars]",
+     "strict": true,
+     "parameters": {
+      "type": "object",
+      "properties": {
+       "result": {
+        "type": "string",
+        "description": "Final result message to deliver to the user once the task is complete"
+       }
+      },
+      "required": [
+       "result"
+      ],
+      "additionalProperties": false
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "list_files",
+     "description": "Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.\n\nParameters:\n- path: …[820 chars]",
+     "strict": true,
+     "parameters": {
+      "type": "object",
+      "properties": {
+       "path": {
+        "type": "string",
+        "description": "Directory path to inspect, relative to the workspace"
+       },
+       "recursive": {
+        "type": "boolean",
+        "description": "Set true to list contents recursively; false to show only the top level"
+       }
+      },
+      "required": [
+       "path",
+       "recursive"
+      ],
+      "additionalProperties": false
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "new_task",
+     "description": "Create a new task instance in the chosen mode using your provided message and initial todo list (if required).\n\nCRITICAL: This tool MUST be called alone. Do NOT call this tool alongside other tools in the same message turn. If you need to gather information before delegating, use other tools in a separate turn first, then call new_task by itself in the next turn.",
+     "strict": true,
+     "parameters": {
+      "type": "object",
+      "properties": {
+       "mode": {
+        "type": "string",
+        "description": "Slug of the mode to begin the new task in (e.g., code, debug, architect)"
+       },
+       "message": {
+        "type": "string",
+        "description": "Initial user instructions or context for the new task"
+       },
+       "todos": {
+        "type": "string",
+        "description": "Optional initial todo list written as a markdown checklist; required when the workspace mandates todos"
+       }
+      },
+      "required": [
+       "mode",
+       "message",
+       "todos"
+      ],
+      "additionalProperties": false
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "read_file",
+     "description": "Read a file and return its contents with line numbers for diffing or discussion. IMPORTANT: This tool reads exactly one file per call. If you need multiple files, issue multiple parallel read_file calls. Supports two modes: 'slice' (default) reads lines sequentially with offset/limit; 'indentation' extracts complete semantic code blocks around an anchor line based on indentation hierarchy. Slice m…[1373 chars]",
+     "strict": true,
+     "parameters": {
+      "type": "object",
+      "properties": {
+       "path": {
+        "type": "string",
+        "description": "Path to the file to read, relative to the workspace"
+       },
+       "mode": {
+        "type": "string",
+        "enum": [
+         "slice",
+         "indentation"
+        ],
+        "description": "Reading mode. 'slice' (default): read lines sequentially with offset/limit - use for general file exploration or when you don't have a target line number (may truncate code mid-function). 'indentation': extract complete semantic code blocks containing anchor_line - PREFERRED when you have a line number because it guarantees complete, valid code blocks. WARNING: Do not use indentation mode without …[472 chars]"
+       },
+       "offset": {
+        "type": "integer",
+        "description": "1-based line offset to start reading from (slice mode, default: 1)"
+       },
+       "limit": {
+        "type": "integer",
+        "description": "Maximum number of lines to return (slice mode, default: 2000)"
+       },
+       "indentation": {
+        "type": "object",
+        "description": "Indentation mode options. Only used when mode='indentation'. You MUST specify anchor_line for useful results - it determines which code block to extract.",
+        "properties": {
+         "anchor_line": {
+          "type": "integer",
+          "description": "1-based line number to anchor the extraction. REQUIRED for meaningful indentation mode results. The extractor finds the semantic block (function, method, class) containing this line and returns it completely. Without anchor_line, indentation mode defaults to line 1 and returns only imports/header content. Obtain anchor_line from: search results, error stack traces, definition lookups, codebase_sea…[506 chars]"
+         },
+         "max_levels": {
+          "type": "integer",
+          "description": "Maximum indentation levels to include above the anchor (indentation mode, 0 = unlimited (default)). Higher values include more parent context."
+         },
+         "include_siblings": {
+          "type": "boolean",
+          "description": "Include sibling blocks at the same indentation level as the anchor block (indentation mode, default: false). Useful for seeing related methods in a class."
+         },
+         "include_header": {
+          "type": "boolean",
+          "description": "Include file header content (imports, module-level comments) at the top of output (indentation mode, default: true)."
+         },
+         "max_lines": {
+          "type": "integer",
+          "description": "Hard cap on lines returned for indentation mode. Acts as a separate limit from the top-level 'limit' parameter."
+         }
+        },
+        "required": [
+         "anchor_line",
+         "max_levels",
+         "include_siblings",
+         "include_header",
+         "max_lines"
+        ],
+        "additionalProperties": false
+       }
+      },
+      "required": [
+       "path",
+       "mode",
+       "offset",
+       "limit",
+       "indentation"
+      ],
+      "additionalProperties": false
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "skill",
+     "description": "Load and execute a skill by name. Skills provide specialized instructions for common tasks like creating MCP servers or custom modes.\n\nUse this tool when you need to follow specific procedures documented in a skill. Available skills are listed in the AVAILABLE SKILLS section of the system prompt.",
+     "strict": true,
+     "parameters": {
+      "type": "object",
+      "properties": {
+       "skill": {
+        "type": "string",
+        "description": "Name of the skill to load (e.g., create-mcp-server, create-mode). Must match a skill name from the available skills list."
+       },
+       "args": {
+        "type": "string",
+        "description": "Optional context or arguments to pass to the skill"
+       }
+      },
+      "required": [
+       "skill",
+       "args"
+      ],
+      "additionalProperties": false
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "search_files",
+     "description": "Request to perform a regex search across files in a specified directory, providing context-rich results. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context.\n\nCraft your regex patterns carefully to balance specificity and flexibility. Use this tool to find code patterns, TODO comments, function definitions, or any text-based i…[1266 chars]",
+     "strict": true,
+     "parameters": {
+      "type": "object",
+      "properties": {
+       "path": {
+        "type": "string",
+        "description": "Directory to search recursively, relative to the workspace"
+       },
+       "regex": {
+        "type": "string",
+        "description": "Rust-compatible regular expression pattern to match"
+       },
+       "file_pattern": {
+        "type": "string",
+        "description": "Optional glob to limit which files are searched (e.g., *.ts)"
+       }
+      },
+      "required": [
+       "path",
+       "regex",
+       "file_pattern"
+      ],
+      "additionalProperties": false
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "switch_mode",
+     "description": "Request to switch to a different mode. This tool allows modes to request switching to another mode when needed, such as switching to Code mode to make code changes. The user must approve the mode switch.",
+     "strict": true,
+     "parameters": {
+      "type": "object",
+      "properties": {
+       "mode_slug": {
+        "type": "string",
+        "description": "Slug of the mode to switch to (e.g., code, ask, architect)"
+       },
+       "reason": {
+        "type": "string",
+        "description": "Explanation for why the mode switch is needed"
+       }
+      },
+      "required": [
+       "mode_slug",
+       "reason"
+      ],
+      "additionalProperties": false
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "update_todo_list",
+     "description": "Replace the entire TODO list with an updated checklist reflecting the current state. Always provide the full list; the system will overwrite the previous one. This tool is designed for step-by-step task tracking, allowing you to confirm completion of each step before updating, update multiple task statuses at once (e.g., mark one as completed and start the next), and dynamically add new todos disc…[1705 chars]",
+     "strict": true,
+     "parameters": {
+      "type": "object",
+      "properties": {
+       "todos": {
+        "type": "string",
+        "description": "Full markdown checklist in execution order, using [ ] for pending, [x] for completed, and [-] for in progress"
+       }
+      },
+      "required": [
+       "todos"
+      ],
+      "additionalProperties": false
+     }
+    }
+   },
+   {
+    "type": "function",
+    "function": {
+     "name": "write_to_file",
+     "description": "Request to write content to a file. This tool is primarily used for creating new files or for scenarios where a complete rewrite of an existing file is intentionally required. If the file exists, it will be overwritten. If it doesn't exist, it will be created. This tool will automatically create any directories needed to write the file.\n\n**Important:** You should prefer using other editing tools o…[1359 chars]",
+     "strict": true,
+     "parameters": {
+      "type": "object",
+      "properties": {
+       "path": {
+        "type": "string",
+        "description": "The path of the file to write to (relative to the current workspace directory)"
+       },
+       "content": {
+        "type": "string",
+        "description": "The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified. Do NOT include line numbers in the content."
+       }
+      },
+      "required": [
+       "path",
+       "content"
+      ],
+      "additionalProperties": false
+     }
+    }
+   }
+  ],
+  "tool_choice": "auto",
+  "parallel_tool_calls": true
+ }
+}

package/test/harness-requests.test.ts

@@ -131,6 +131,40 @@ describe("captured harness requests", () => {
 		expect(out.max_tokens).toBe(f.body.max_tokens);
 	});
 
+	test("cline cli 3.0: chat completions with native tool calls, no harness header", async () => {
+		const f = await fixture("cline-cli");
+		const req = parseChatRequest(structuredClone(f.body), new Headers(f.headers));
+		expect(f.headers["user-agent"]).toContain("ai-sdk/openai-compatible");
+		expect(req.harnessId).toBe("");
+		const names = req.tools.map((t) => t.name);
+		for (const n of ["read_files", "search_codebase", "run_commands", "fetch_web_content"]) {
+			expect(names).toContain(n);
+			expect(DEFAULT_CONFIG.digest.tools).toContain(canonicalTool(DEFAULT_CONFIG.digest, n));
+		}
+		expect("stream_options" in req.renderUpstreamBody(MUT)).toBe(false);
+	});
+
+	test("kilo cli 7.5: an OpenCode-derived request with the harness header and OpenCode tool names", async () => {
+		const f = await fixture("kilo");
+		const req = parseChatRequest(structuredClone(f.body), new Headers(f.headers));
+		expect(f.headers["user-agent"]).toContain("Kilo-Code");
+		expect(req.harnessId).toBe("kilo");
+		const names = req.tools.map((t) => t.name);
+		for (const n of ["read", "grep", "glob", "bash", "webfetch"]) expect(names).toContain(n);
+	});
+
+	test("roo code 3.54 (VS Code): native tool calls with a tool round trip and the harness header", async () => {
+		const f = await fixture("roo");
+		const req = parseChatRequest(structuredClone(f.body), new Headers(f.headers));
+		expect(f.headers["user-agent"]).toContain("RooCode");
+		expect(req.harnessId).toBe("roo");
+		const names = req.tools.map((t) => t.name);
+		for (const n of ["read_file", "search_files", "list_files", "apply_diff", "attempt_completion"]) expect(names).toContain(n);
+		expect(req.messages.some((m) => m.role === "tool")).toBe(true);
+		expect(req.messages.find((m) => m.role === "assistant" && m.toolCalls.length > 0)).toBeDefined();
+		expect("stream_options" in req.renderUpstreamBody(MUT)).toBe(false);
+	});
+
 	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));
@@ -138,6 +172,9 @@ describe("captured harness requests", () => {
 		expect(req.harnessId).toBe("codex");
 		expect(req.requestedModel).toBe("auto");
 		expect(req.stream).toBe(true);
+		// The thread id in the body becomes the session id; the root agent is not a subagent.
+		expect(req.ompSessionId).toBe((f.body.client_metadata as { thread_id: string }).thread_id);
+		expect(req.isSubagent).toBe(false);
 		// 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");

package/test/hermes-plugin.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "bun:test";
+
+/**
+ * The Hermes native plugin is Python, which this suite cannot import. Its
+ * pure functions (identity headers, digest gate and replacement, /router
+ * rendering) are exercised by hermes-plugin/native/selftest.py; this test
+ * runs it when a Python interpreter is on PATH and is skipped otherwise, so
+ * a machine without Python still passes the suite but a machine with one
+ * catches a regression.
+ */
+
+const python = Bun.which("python") ?? Bun.which("python3");
+const ROOT = `${import.meta.dir}/..`;
+
+describe("hermes native plugin", () => {
+	(python === null ? test.skip : test)("the Python self-test passes", () => {
+		const run = Bun.spawnSync([python!, "hermes-plugin/native/selftest.py"], { cwd: ROOT, stdout: "pipe", stderr: "pipe" });
+		const out = `${run.stdout.toString()}\n${run.stderr.toString()}`;
+		expect(out).toContain("ok test_identity_headers");
+		expect(out).toContain("ok test_digest");
+		expect(out).toContain("ok test_router_command");
+		expect(run.exitCode).toBe(0);
+	});
+
+	test("the plugin files parse as Python and declare the standalone kind", async () => {
+		const manifest = await Bun.file(`${ROOT}/hermes-plugin/native/plugin.yaml`).text();
+		expect(manifest).toContain("kind: standalone");
+		const src = await Bun.file(`${ROOT}/hermes-plugin/native/__init__.py`).text();
+		expect(src).toContain("def register(ctx");
+		for (const hook of ['register_hook("pre_llm_call"', 'register_middleware("llm_request"', 'register_middleware("tool_execution"', 'register_command("router"']) expect(src).toContain(hook);
+	});
+});

package/test/summary.test.ts

@@ -95,7 +95,7 @@ describe("buildDailySummary", () => {
 			// Tiny seeded turns cost more than Opus would have at list price: the honest branch renders.
 			expect(text).toContain("cost 574% MORE than anthropic/claude-opus-5 ($0.079 at list)");
 			expect(renderDailySummary({ ...s, baseline: { slug: "anthropic/claude-opus-5", usd: 2.5, savedShare: 0.7876 } })).toContain("saved 79% vs anthropic/claude-opus-5 ($2.50 at list)");
-			expect(text).toContain("1 digests for $0.001");
+			expect(text).toContain("1 digests for $0.001 (re-run rate 0%)");
 			expect(text).toContain("soft failures SPIKING (1):\n  vendor/big: 50% of 8 failed in the last 1h (7d baseline 3% of 90)");
 			expect(text).toContain("ollama: pro plan $25.20 of $60 · ~23 days of credits left");
 		} finally {

package/test/tokens.test.ts

@@ -292,7 +292,9 @@ describe("ledger.prune and markWasted", () => {
 			for (let i = 0; i < 5; i++) ledger.record(entry({ createdAtMs: now - i * 100 * DAY }));
 			expect(ledger.prune?.(0, now)).toBe(0);
 			expect(ledger.recentEntries(10)).toHaveLength(5);
+			db.run("INSERT INTO ollama_meter_samples (at_ms, meter_usd, ledger_usd) VALUES (?, 1, 1), (?, 2, 2)", [now - 400 * DAY, now - DAY]);
 			expect(ledger.prune?.(365, now)).toBe(1); // only the 400-day-old row
+			expect((db.query("SELECT COUNT(*) AS n FROM ollama_meter_samples").get() as { n: number }).n).toBe(1);
 			expect(ledger.recentEntries(10)).toHaveLength(4);
 			expect(ledger.prune?.(150, now)).toBe(2); // 200 and 300 days old
 			const left = ledger.recentEntries(10);

package/test/wire-responses.test.ts

@@ -1,7 +1,7 @@
 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 { createResponsesBufferedSink, createResponsesStreamingSink, identityHeadersFromBody, parseResponsesRequest, responsesToChatBody } from "../src/wire/openai/responses.ts";
 import type { StreamEvent, TurnSummary, UpstreamChunk } from "../src/wire/types.ts";
 
 /**
@@ -67,6 +67,20 @@ describe("responsesToChatBody", () => {
 		expect(() => responsesToChatBody({ model: "auto", input: [] })).toThrow(WireErrorException);
 	});
 
+	test("Codex identity is read from the body when the headers carry none", () => {
+		const meta = (agent: string) => JSON.stringify({ session_id: "t1", thread_id: "t1", agent_name: agent, turn_id: "u1" });
+		const body = { model: "auto", input: "x", prompt_cache_key: "t1", client_metadata: { thread_id: "t1", session_id: "t1", "x-codex-turn-metadata": meta("/root") } };
+		const main = parseResponsesRequest(body, HEADERS);
+		expect(main.ompSessionId).toBe("t1");
+		expect(main.isSubagent).toBe(false);
+		const sub = parseResponsesRequest({ ...body, client_metadata: { ...body.client_metadata, "x-codex-turn-metadata": meta("/root/explorer") } }, HEADERS);
+		expect(sub.isSubagent).toBe(true);
+		// Explicit headers win; a body without metadata adds nothing.
+		expect(identityHeadersFromBody(body, new Headers({ "X-Omp-Session": "mine" })).get("x-omp-session")).toBe("mine");
+		expect(identityHeadersFromBody({ model: "auto", input: "x" }, HEADERS).get("x-omp-session")).toBeNull();
+		expect(identityHeadersFromBody({ model: "auto", input: "x", client_metadata: { "x-codex-turn-metadata": "not json" } }, HEADERS).get("x-omp-subagent")).toBeNull();
+	});
+
 	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");