[agent] fix: send Google structured output on the generateContent wire and map Anthropic parallel=false

scripts/test-layout/layout.json

@@ -208,6 +208,7 @@
     "anthropic-image-normalize.test.ts": "adapters/anthropic",
     "anthropic-image-retry-e2e.test.ts": "adapters/anthropic",
     "anthropic-image-retry.test.ts": "adapters/anthropic",
+    "anthropic-parallel-tool-disable.test.ts": "adapters/anthropic",
     "anthropic-pool-toggle-copy.test.ts": "adapters/anthropic",
     "anthropic-quorum-cache.test.ts": "routing",
     "anthropic-quota-dispatch.test.ts": "adapters/anthropic",
@@ -723,6 +724,7 @@
     "google-output-clamp.test.ts": "adapters/google",
     "google-provider-metadata-roundtrip.test.ts": "adapters/google",
     "google-signature-history-roundtrip.test.ts": "adapters/google",
+    "google-structured-output.test.ts": "adapters/google",
     "google-tool-result-adjacency.test.ts": "adapters/google",
     "google-tool-schema.test.ts": "adapters/google",
     "google-vertex-http.test.ts": "adapters/google",

src/adapters/anthropic.ts

@@ -1019,6 +1019,22 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
         else if (tc === "required") body.tool_choice = { type: "any" };
         else if (isAllowedToolChoice(tc)) body.tool_choice = { type: tc.mode === "required" ? "any" : "auto" };
         else if (typeof tc === "object" && "name" in tc) body.tool_choice = { type: "tool", name: toolNames.toWire(resolveToolChoiceWireName(parsed.context.tools, tc.name)) };
+      } else if (tools && parsed.options.parallelToolCalls === false) {
+        // The caller asked for one tool call at a time but sent no explicit choice.
+        // Anthropic carries that intent INSIDE tool_choice, so the implicit default
+        // has to be stated before the flag has somewhere to live.
+        body.tool_choice = { type: "auto" };
+      }
+      // disable_parallel_tool_use is nested in tool_choice and caps the model at one
+      // tool call for auto/any/tool. Under type "none" tool use is already off, so the
+      // flag is irrelevant there, and with no tools on the wire no tool_choice exists.
+      // This constrains the model's OUTPUT, not execution order: sequential tool use is
+      // enforced by the caller returning each tool_result before the next request.
+      const settledToolChoice = body.tool_choice as { type?: string } | undefined;
+      if (parsed.options.parallelToolCalls === false
+          && settledToolChoice !== undefined
+          && settledToolChoice.type !== "none") {
+        body.tool_choice = { ...settledToolChoice, disable_parallel_tool_use: true };
       }
 
       const url = anthropicMessagesUrl(provider.baseUrl);

src/adapters/google-wire-compiler.ts

@@ -149,6 +149,14 @@ function compileGenerationConfig(value: unknown): JsonObject | undefined {
     const valid = value.responseModalities.filter((m): m is string => typeof m === "string" && ["TEXT", "IMAGE", "AUDIO"].includes(m));
     if (valid.length > 0) out.responseModalities = valid;
   }
+  // Structured output. This compiler is a whitelist, so without these two the adapter
+  // could set a schema and it would still be dropped before the wire.
+  if (typeof value.responseMimeType === "string" && value.responseMimeType.length > 0) {
+    out.responseMimeType = value.responseMimeType;
+  }
+  // Carried through unmodified: a caller-authored output schema is not a tool
+  // declaration, so sanitizeGeminiToolParameters must not touch it.
+  if (isObject(value.responseJsonSchema)) out.responseJsonSchema = value.responseJsonSchema;
   return Object.keys(out).length > 0 ? out : undefined;
 }
 

src/adapters/google.ts

@@ -789,6 +789,37 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       : {}),
 
     async buildRequest(parsed: OcxParsedRequest) {
+      // Structured-output admission runs FIRST, before messagesToGeminiFormat writes
+      // lastInjectedCallIds/lastReasoningReplayScope: a refused request must not leave
+      // adapter-scoped replay state pointing at call ids that never went out. These
+      // refusals are local and precede any fetch, and carry no request content, schema
+      // body, URL or credential.
+      const requestedTextFormat = parsed.options.textFormat;
+      if (requestedTextFormat) {
+        if (provider.googleMode === "cloud-code-assist") {
+          // Not implemented or verified by opencodex for the Cloud Code Assist envelope,
+          // including Claude models served through it. This is not a claim that the
+          // upstream cannot do it — silence would return unconstrained prose as success,
+          // which is the failure this fix exists to remove.
+          throw new Error(
+            "google cloud-code-assist structured output is not implemented by opencodex — "
+            + "remove response_format or route this model through AI Studio or Vertex",
+          );
+        }
+        if (isImageCapableModel(parsed.modelId)) {
+          // An image-output model is configured with responseModalities; constraining the
+          // same turn to JSON text is contradictory. Say so rather than dropping the schema.
+          throw new Error(
+            "google image-capable models cannot combine image output with structured output — "
+            + "remove response_format or select a text model",
+          );
+        }
+        if (requestedTextFormat.type === "json_schema" && !requestedTextFormat.schema) {
+          // Downgrading a malformed json_schema to bare JSON mode would silently drop the
+          // constraint the caller asked for.
+          throw new Error("google structured output requires text.format.schema for type json_schema");
+        }
+      }
       const routedModelId = provider.googleMode === "cloud-code-assist"
         ? resolveAntigravityEffortWireModel(
             parsed.modelId,
@@ -846,6 +877,21 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       if (!generationConfig.thinkingConfig && isImageCapableModel(parsed.modelId)) {
         generationConfig.responseModalities = ["TEXT", "IMAGE"];
       }
+      // Structured output travels in generationConfig on generateContent itself.
+      // responseJsonSchema takes ordinary JSON Schema (lowercase types), which is what
+      // options.textFormat.schema already holds; responseSchema would require Gemini's
+      // uppercase typed Schema form, and the docs require omitting it when
+      // responseJsonSchema is used. The response type does not change — the model
+      // returns text containing the conforming JSON — so response parsing is untouched.
+      // The tool-parameter sanitizer is deliberately NOT applied: it narrows a schema
+      // to the function-declaration subset and would corrupt a valid output schema.
+      const textFormat = parsed.options.textFormat;
+      if (textFormat) {
+        generationConfig.responseMimeType = "application/json";
+        if (textFormat.type === "json_schema" && textFormat.schema) {
+          generationConfig.responseJsonSchema = textFormat.schema;
+        }
+      }
       if (Object.keys(generationConfig).length > 0) body.generationConfig = generationConfig;
 
       const method = parsed.stream ? "streamGenerateContent" : "generateContent";

structure/providers/chat-compat.md

@@ -292,3 +292,17 @@ byte-limit boundaries.
 Canonical Spark Lite metadata follows the final serialized model and surviving nonempty Lite tool catalog; see [Responses transport](../transports/responses.md).
 
 Translated Chat request construction uses the [inline-image budget](../transports/streaming-health.md#translated-chat-inline-image-budget); the shared normalizer counts retained bytes even when a wire-specific drop callback keeps the image attached.
+## Anthropic parallel tool use
+
+`options.parallelToolCalls === false` maps onto Anthropic's nested
+`tool_choice.disable_parallel_tool_use`. Because the flag lives inside
+`tool_choice`, a request that carries only the parallel intent and no explicit
+choice gets a synthesized `{type:"auto"}` so the flag has somewhere to live;
+`required` maps to `{type:"any"}` and a named choice to `{type:"tool"}`, and both
+accept it. `{type:"none"}` does not receive the flag because tool use is already off,
+and a request with no tools on the wire emits no `tool_choice` at all. An unset or
+true `parallelToolCalls` is byte-identical to previous behavior.
+
+The flag constrains the model's output, not execution ordering. Sequential tool use
+is enforced by the caller's own loop returning each `tool_result` before issuing the
+next request; this mapping does not provide that.

structure/providers/google.md

@@ -47,3 +47,27 @@ mismatched, and standalone results become marked text instead of unpaired functi
 Representable data-URL images remain sibling `inline_data` parts in either case.
 
 > Decision record: [ADR-0058](../decisions/ADR-0058-google-tool-result-adjacency-repair.md)
+## Structured output on generateContent
+
+A caller's Responses `text.format` reaches the Gemini wire as
+`generationConfig.responseMimeType: "application/json"` plus, for `json_schema`,
+`generationConfig.responseJsonSchema` carrying the schema unchanged.
+`responseJsonSchema` takes ordinary JSON Schema with lowercase type names, which is
+the shape `options.textFormat.schema` already holds; `responseSchema` takes Gemini's
+uppercase typed `Schema` form and is omitted when `responseJsonSchema` is used. The
+response type is unchanged — the model returns text containing conforming JSON — so
+response parsing is untouched.
+
+The schema is carried verbatim. `sanitizeGeminiToolParameters` narrows a schema to
+the function-declaration subset and must never be applied to a caller-authored output
+schema. `compileGenerationConfig` in `google-wire-compiler.ts` is a whitelist, so
+both keys are listed there as well; setting them in the adapter alone would drop them
+before the wire.
+
+Three cases refuse explicitly rather than dropping the constraint silently:
+cloud-code-assist, which opencodex does not implement or verify for this field
+(including Claude models served through that envelope — this is not a claim about
+what the upstream can do); an image-capable model, whose `responseModalities`
+configuration contradicts JSON-constrained text; and a `json_schema` format carrying
+no schema, which would otherwise downgrade to bare JSON mode. An image-capable model
+with no structured-output request keeps its existing `responseModalities` behavior.

tests/adapters/anthropic/anthropic-parallel-tool-disable.test.ts

@@ -0,0 +1,87 @@
+/**
+ * Audit F4 (2026-09-14): `options.parallelToolCalls === false` had no Anthropic
+ * consumer. The caller asked for one tool call at a time and the request went out
+ * unconstrained.
+ *
+ * Anthropic carries that intent as `disable_parallel_tool_use` nested INSIDE
+ * `tool_choice`. Per the tool-use docs its per-mode meaning is:
+ *   auto -> at most one call; any -> exactly one; tool -> exactly one;
+ *   none -> tool use already off, so the flag is irrelevant.
+ * The old code also emitted tool_choice only when an explicit choice was set, so a
+ * request carrying only parallel_tool_calls:false emitted nothing at all — the
+ * implicit default has to be stated for the flag to have somewhere to live.
+ *
+ * The flag constrains the model's OUTPUT, not execution order.
+ */
+import { describe, expect, test } from "bun:test";
+import { createAnthropicAdapter } from "../../../src/adapters/anthropic";
+import type { OcxParsedRequest, OcxProviderConfig, OcxTool } from "../../../src/types";
+
+const provider = { adapter: "anthropic", baseUrl: "https://api.anthropic.com", apiKey: "sk-x", authMode: "apiKey" } as unknown as OcxProviderConfig;
+
+const TOOL = { name: "lookup", description: "Look something up", parameters: { type: "object", properties: {} } } as OcxTool;
+
+async function toolChoiceOf(options: Record<string, unknown>, withTools = true): Promise<Record<string, unknown> | undefined> {
+  const parsed = {
+    modelId: "anthropic/claude-sonnet-4.5",
+    stream: false,
+    options,
+    context: { messages: [{ role: "user", content: "hi", timestamp: 0 }], ...(withTools ? { tools: [TOOL] } : {}) },
+  } as unknown as OcxParsedRequest;
+  const { body } = await createAnthropicAdapter(provider).buildRequest(parsed);
+  const parsedBody = JSON.parse(typeof body === "string" ? body : JSON.stringify(body)) as { tool_choice?: Record<string, unknown> };
+  return parsedBody.tool_choice;
+}
+
+describe("F4 parallel=false maps onto nested disable_parallel_tool_use", () => {
+  test("implicit auto is synthesized so the intent has somewhere to live", async () => {
+    expect(await toolChoiceOf({ parallelToolCalls: false }))
+      .toEqual({ type: "auto", disable_parallel_tool_use: true });
+  });
+
+  test("an explicit auto carries the flag", async () => {
+    expect(await toolChoiceOf({ toolChoice: "auto", parallelToolCalls: false }))
+      .toEqual({ type: "auto", disable_parallel_tool_use: true });
+  });
+
+  test("required maps to any and carries the flag", async () => {
+    expect(await toolChoiceOf({ toolChoice: "required", parallelToolCalls: false }))
+      .toEqual({ type: "any", disable_parallel_tool_use: true });
+  });
+
+  test("a named tool choice carries the flag", async () => {
+    const choice = await toolChoiceOf({ toolChoice: { name: "lookup" }, parallelToolCalls: false });
+
+    expect(choice).toMatchObject({ type: "tool", disable_parallel_tool_use: true });
+    expect(choice!.name).toBe("lookup");
+  });
+
+  test("allowed-tools auto and required both carry the flag", async () => {
+    // The IR shape is { allowedTools, mode } (src/types/tools.ts:294-299), which
+    // isAllowedToolChoice detects by the allowedTools key.
+    expect(await toolChoiceOf({ toolChoice: { allowedTools: ["lookup"], mode: "auto" }, parallelToolCalls: false }))
+      .toEqual({ type: "auto", disable_parallel_tool_use: true });
+    expect(await toolChoiceOf({ toolChoice: { allowedTools: ["lookup"], mode: "required" }, parallelToolCalls: false }))
+      .toEqual({ type: "any", disable_parallel_tool_use: true });
+  });
+});
+
+describe("F4 cases that must not change", () => {
+  test("none stays bare — tool use is already off, so the flag is irrelevant", async () => {
+    expect(await toolChoiceOf({ toolChoice: "none", parallelToolCalls: false })).toEqual({ type: "none" });
+  });
+
+  test("no tools on the wire means no tool_choice at all", async () => {
+    expect(await toolChoiceOf({ parallelToolCalls: false }, false)).toBeUndefined();
+  });
+
+  test("parallel unset is byte-identical to today", async () => {
+    expect(await toolChoiceOf({ toolChoice: "auto" })).toEqual({ type: "auto" });
+    expect(await toolChoiceOf({})).toBeUndefined();
+  });
+
+  test("parallel true never attaches the flag", async () => {
+    expect(await toolChoiceOf({ toolChoice: "auto", parallelToolCalls: true })).toEqual({ type: "auto" });
+    expect(await toolChoiceOf({ parallelToolCalls: true })).toBeUndefined();
+  });
+});