fix(codex): harden routed apply_patch contracts

tests/apply-patch-adapter-nudge-completeness.test.ts

@@ -0,0 +1,69 @@
+import { expect, test } from "bun:test";
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const adaptersDir = fileURLToPath(new URL("../src/adapters/", import.meta.url));
+const regressionTestPath = fileURLToPath(new URL("./apply-patch-adapter-nudge-regression.test.ts", import.meta.url));
+const adapterResolvePath = fileURLToPath(new URL("../src/server/adapter-resolve.ts", import.meta.url));
+const nudgeImport = /(?:from\s+|import\s*\()\s*["'][^"']*tool-catalog-nudge(?:\.[cm]?[jt]s)?["']/;
+
+const APPLY_PATCH_ADAPTER_STRATEGIES = {
+  "command-code": "nudge-routed",
+  "openai-chat": "nudge-routed",
+  anthropic: "nudge-routed",
+  "openai-responses": "responses-native",
+  google: "nudge-routed",
+  kiro: "nudge-routed",
+  azure: "responses-native-wrapper",
+  "azure-openai": "responses-native-wrapper",
+  cursor: "cursor-special",
+  "mimo-free": "openai-chat-wrapper",
+} as const;
+
+async function discoverNudgeCallSites(dir = adaptersDir): Promise<string[]> {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const found: string[] = [];
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      found.push(...await discoverNudgeCallSites(fullPath));
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".ts")) continue;
+
+    const source = await readFile(fullPath, "utf8");
+    if (!nudgeImport.test(source)) continue;
+
+    const relativePath = relative(adaptersDir, fullPath).split(sep).join("/");
+    found.push(`src/adapters/${relativePath}`);
+  }
+
+  return found.sort();
+}
+
+async function discoverCoveredAdapterModules(): Promise<string[]> {
+  const source = await readFile(regressionTestPath, "utf8");
+  const imports = source.matchAll(/from\s+["']\.\.\/src\/adapters\/([^"']+)["']/g);
+  return [...imports]
+    .map(match => `src/adapters/${match[1]}.ts`)
+    .sort();
+}
+
+async function discoverResolvedAdapterNames(): Promise<string[]> {
+  const source = await readFile(adapterResolvePath, "utf8");
+  return [...source.matchAll(/case\s+["']([^"']+)["']\s*:/g)]
+    .map(match => match[1]!)
+    .sort();
+}
+
+test("every tool-catalog-nudge adapter has outbound apply_patch coverage", async () => {
+  expect(await discoverNudgeCallSites()).toEqual(await discoverCoveredAdapterModules());
+});
+
+test("every resolved adapter has an explicit apply_patch strategy", async () => {
+  expect(await discoverResolvedAdapterNames()).toEqual(
+    Object.keys(APPLY_PATCH_ADAPTER_STRATEGIES).sort(),
+  );
+});

tests/apply-patch-adapter-nudge-regression.test.ts

@@ -0,0 +1,121 @@
+import { expect, test } from "bun:test";
+import { createAnthropicAdapter } from "../src/adapters/anthropic";
+import { createCommandCodeAdapter } from "../src/adapters/command-code";
+import { createGoogleAdapter } from "../src/adapters/google";
+import { createKiroAdapter } from "../src/adapters/kiro";
+import { createOpenAIChatAdapter } from "../src/adapters/openai-chat";
+import type { OcxParsedRequest, OcxProviderConfig } from "../src/types";
+
+function codeModeParsed(modelId: string): OcxParsedRequest {
+  return {
+    modelId,
+    stream: true,
+    options: {},
+    context: {
+      systemPrompt: ["Use apply_patch for local file edits."],
+      messages: [{ role: "user", content: "Patch a file.", timestamp: 1 }],
+      tools: [
+        {
+          name: "exec",
+          description: "Run JavaScript. declare const tools: { apply_patch(input: string): Promise<unknown>; };",
+          parameters: { type: "object", properties: { input: { type: "string" } } },
+        },
+        {
+          name: "wait",
+          description: "Wait for work to finish.",
+          parameters: { type: "object", properties: {} },
+        },
+        {
+          name: "request_user_input",
+          description: "Ask the user for input.",
+          parameters: { type: "object", properties: {} },
+        },
+      ],
+    },
+  } as OcxParsedRequest;
+}
+
+function assertApplyPatchIsNotForbidden(body: string): void {
+  const normalized = body.replace(/\\n/g, " ").replace(/\s+/g, " ");
+
+  // Make sure the adapter actually exercised the shared catalog-nudge call site;
+  // otherwise a missing nudge would make the prohibition assertion vacuous.
+  expect(normalized).toContain("current tool catalog as ground truth");
+
+  // The final provider request must still advertise Codex's nested patch helper.
+  // This pins the actual Code Mode declaration rather than a nonexistent literal
+  // `tools.apply_patch` token in the serialized tool description.
+  expect(normalized).toContain("declare const tools: { apply_patch(input: string): Promise<unknown>; };");
+
+  // Protect against both the original shared warning and adapter-specific wording
+  // that would steer routed models away from Codex's own patch tool.
+  expect(normalized).not.toMatch(/(?:do not|don't|never|must not|cannot|can't)[^.]{0,260}\bapply_patch\b/i);
+  expect(normalized).not.toMatch(/\bapply_patch\b[^.]{0,180}\b(?:forbidden|unavailable|off-limits)\b/i);
+}
+
+test("routed adapter call sites never forbid Codex apply_patch", async () => {
+  const cases: Array<{
+    name: string;
+    modelId: string;
+    build: (parsed: OcxParsedRequest) => Promise<{ body: string }>;
+  }> = [
+    {
+      name: "openai-chat",
+      modelId: "grok-4.6",
+      build: async parsed => createOpenAIChatAdapter({
+        adapter: "openai-chat",
+        baseUrl: "https://api.x.ai/v1",
+        apiKey: "test-key",
+      } as OcxProviderConfig).buildRequest(parsed),
+    },
+    {
+      name: "anthropic-oauth",
+      modelId: "claude-haiku-4-5",
+      build: async parsed => createAnthropicAdapter({
+        adapter: "anthropic",
+        baseUrl: "https://api.anthropic.com",
+        authMode: "oauth",
+        apiKey: "test-oauth-token",
+      } as OcxProviderConfig).buildRequest(parsed),
+    },
+    {
+      name: "google",
+      modelId: "gemini-3-pro",
+      build: async parsed => createGoogleAdapter({
+        adapter: "google",
+        baseUrl: "https://generativelanguage.googleapis.com",
+        apiKey: "test-key",
+      } as OcxProviderConfig).buildRequest(parsed),
+    },
+    {
+      name: "command-code",
+      modelId: "deepseek/deepseek-v4-flash",
+      build: async parsed => createCommandCodeAdapter({
+        adapter: "command-code",
+        baseUrl: "https://api.commandcode.ai",
+        authMode: "oauth",
+        apiKey: "test-command-key",
+        defaultMaxOutputTokens: 64_000,
+      } as OcxProviderConfig).buildRequest(parsed),
+    },
+    {
+      name: "kiro",
+      modelId: "claude-sonnet-4.5",
+      build: async parsed => {
+        parsed._kiroAuthContext = { apiRegion: "us-east-1" };
+        return createKiroAdapter({
+          adapter: "kiro",
+          baseUrl: "https://runtime.us-east-1.kiro.dev",
+          authMode: "key",
+          apiKey: "ksk_test",
+        } as OcxProviderConfig).buildRequest(parsed);
+      },
+    },
+  ];
+
+  for (const adapterCase of cases) {
+    const request = await adapterCase.build(codeModeParsed(adapterCase.modelId));
+    expect(request.body, `${adapterCase.name} should serialize a request body`).toBeTruthy();
+    assertApplyPatchIsNotForbidden(request.body);
+  }
+});

tests/apply-patch-catalog-contract.test.ts

@@ -0,0 +1,14 @@
+import { expect, test } from "bun:test";
+import { normalizeRoutedCatalogEntry } from "../src/codex/catalog/parsing";
+
+test("routed catalog rows force Codex apply_patch to the freeform tool contract", () => {
+  const row = normalizeRoutedCatalogEntry({
+    slug: "xai/grok-4.6",
+    tool_mode: "legacy",
+    apply_patch_tool_type: "function",
+    context_window: 128_000,
+  });
+
+  expect(row.tool_mode).toBe("code_mode_only");
+  expect(row.apply_patch_tool_type).toBe("freeform");
+});

tests/apply-patch-code-mode-regression.test.ts

@@ -0,0 +1,166 @@
+import { expect, test } from "bun:test";
+import { createOpenAIChatAdapter as createOpenAIChatAdapterProduction } from "../src/adapters/openai-chat";
+import { bridgeToResponsesSSE } from "../src/bridge";
+import { parseRequest } from "../src/responses/parser";
+import { buildToolBridgeMaps } from "../src/server/responses";
+import type { OcxParsedRequest, OcxProviderConfig } from "../src/types";
+import { withTestTranslatorBudget } from "./helpers/translator-budget";
+
+const provider: OcxProviderConfig = {
+  adapter: "openai-chat",
+  baseUrl: "https://api.x.ai/v1",
+  apiKey: "test-key",
+};
+
+const createOpenAIChatAdapter = (...args: Parameters<typeof createOpenAIChatAdapterProduction>) =>
+  withTestTranslatorBudget(createOpenAIChatAdapterProduction(...args));
+
+function parseSse(text: string): Array<{ event?: string; data: Record<string, unknown> }> {
+  return text.split("\n\n")
+    .map(frame => frame.trim())
+    .filter(frame => frame.length > 0 && frame !== "data: [DONE]")
+    .map(frame => {
+      const lines = frame.split("\n");
+      const event = lines.find(line => line.startsWith("event: "))?.slice(7);
+      const data = lines.find(line => line.startsWith("data: "))?.slice(6) ?? "{}";
+      return { event, data: JSON.parse(data) as Record<string, unknown> };
+    });
+}
+
+test("routed Code Mode does not forbid nested apply_patch when it is absent from the flat catalog", () => {
+  const parsed: OcxParsedRequest = {
+    modelId: "grok-4.6",
+    context: {
+      systemPrompt: ["Use apply_patch for local file edits."],
+      messages: [{ role: "user", content: "Edit the requested file.", timestamp: 0 }],
+      tools: [
+        {
+          name: "exec",
+          description: "Run JavaScript. declare const tools: { apply_patch(input: string): Promise<unknown>; };",
+          parameters: {},
+        },
+        { name: "wait", description: "Wait for an exec cell.", parameters: {} },
+        { name: "request_user_input", description: "Ask the user a question.", parameters: {} },
+      ],
+    },
+    stream: false,
+    options: {},
+  };
+
+  const request = createOpenAIChatAdapter(provider).buildRequest(parsed);
+  const body = JSON.parse(request.body) as {
+    messages: Array<{ role: string; content: unknown }>;
+    tools?: Array<{ function?: { name?: string; description?: string } }>;
+  };
+
+  const systemText = body.messages
+    .filter(message => message.role === "system" && typeof message.content === "string")
+    .map(message => message.content as string)
+    .join("\n");
+  const execTool = body.tools?.find(tool => tool.function?.name === "exec");
+
+  // Reproduce the actual Code Mode shape: patching exists only as a nested exec helper,
+  // not as a top-level wire tool. Before 0325a5a the injected nudge contradicted this
+  // contract by explicitly forbidding apply_patch, which pushed routed models to Python/sed.
+  expect(execTool?.function?.description).toContain("apply_patch");
+  expect(body.tools?.some(tool => tool.function?.name === "apply_patch")).toBe(false);
+  expect(systemText).toContain("Use apply_patch for local file edits.");
+  expect(systemText).toContain("Valid tool names for this turn are exactly `exec`, `wait`, `request_user_input`");
+  expect(systemText).toContain("Do not use neighboring-agent tool names");
+  expect(systemText).not.toMatch(/Do not use neighboring-agent tool names[^.]*apply_patch/);
+});
+
+test("routed chat round-trips a declared apply_patch custom tool with valid freeform input", async () => {
+  const patch = [
+    "*** Begin Patch",
+    "*** Add File: ocx-apply-patch-smoke.txt",
+    "+apply patch smoke",
+    "*** End Patch",
+  ].join("\n");
+  const parsed = parseRequest({
+    model: "xai/grok-4.6",
+    input: "Create the smoke-test file.",
+    stream: true,
+    tools: [{ type: "custom", name: "apply_patch", description: "Apply a patch" }],
+  });
+  const maps = buildToolBridgeMaps(parsed);
+  const adapter = createOpenAIChatAdapter(provider);
+
+  // Responses custom/freeform tools are lowered to a normal chat function with one string
+  // field. If this wrapper changes or disappears, routed chat models cannot call apply_patch.
+  const outbound = JSON.parse(adapter.buildRequest(parsed).body) as {
+    tools?: Array<{
+      type?: string;
+      function?: {
+        name?: string;
+        parameters?: { properties?: { input?: { type?: string } } };
+      };
+    }>;
+  };
+  expect(outbound.tools?.find(tool => tool.function?.name === "apply_patch")).toMatchObject({
+    type: "function",
+    function: {
+      name: "apply_patch",
+      parameters: { properties: { input: { type: "string" } } },
+    },
+  });
+
+  // Simulate the routed chat model selecting that function. The adapter must parse the call,
+  // then the Responses bridge must unwrap {input:string} back into a native custom_tool_call.
+  const upstreamPayload = JSON.stringify({
+    choices: [{
+      delta: {
+        tool_calls: [{
+          index: 0,
+          id: "call_patch",
+          type: "function",
+          function: {
+            name: "apply_patch",
+            arguments: JSON.stringify({ input: patch }),
+          },
+        }],
+      },
+      finish_reason: "tool_calls",
+    }],
+  });
+  const upstream = new Response(`data: ${upstreamPayload}\n\ndata: [DONE]\n\n`);
+  const bridged = bridgeToResponsesSSE(
+    adapter.parseStream(upstream),
+    parsed.modelId,
+    maps.toolNsMap,
+    maps.freeformToolNames,
+    maps.toolSearchToolNames,
+    undefined,
+    2_000,
+    { declaredToolNames: maps.declaredToolNames },
+  );
+  const frames = parseSse(await new Response(bridged).text());
+
+  const inputDone = frames.find(frame => frame.event === "response.custom_tool_call_input.done")?.data;
+  expect(inputDone?.input).toBe(patch);
+
+  const itemDone = frames.find(frame => {
+    if (frame.event !== "response.output_item.done") return false;
+    const item = frame.data.item as Record<string, unknown> | undefined;
+    return item?.type === "custom_tool_call" && item.name === "apply_patch";
+  })?.data.item as Record<string, unknown> | undefined;
+  expect(itemDone).toMatchObject({
+    type: "custom_tool_call",
+    call_id: "call_patch",
+    name: "apply_patch",
+    input: patch,
+    status: "completed",
+  });
+
+  const completed = frames.find(frame => frame.event === "response.completed")?.data.response as
+    | { status?: string; output?: Array<Record<string, unknown>> }
+    | undefined;
+  expect(completed?.status).toBe("completed");
+  expect(completed?.output).toContainEqual(expect.objectContaining({
+    type: "custom_tool_call",
+    name: "apply_patch",
+    input: patch,
+    status: "completed",
+  }));
+  expect(frames.some(frame => frame.event === "response.failed")).toBe(false);
+});