fix(openai-responses): strip hosted image_generation that conflicts with declared image_gen tool (#90)

* release: v2.7.5

* fix(openai-responses): strip hosted image_generation that conflicts with declared image_gen tool

Codex declares a client tool for the imagegen app skill (function
`image_gen.imagegen` or an `image_gen` namespace tool) AND attaches the
hosted `image_generation` tool in the same request. The ChatGPT backend
("forward" mode) tolerates the pair, but a platform `/v1/responses`
endpoint rejects it with HTTP 400: `Invalid Value: 'tools'. Function
'image_gen.imagegen' conflicts with a hosted tool in the same request.`

Routed catalog entries drop `tool_mode` (native slugs run
`code_mode_only`, embedding tools in the exec doc), so the dot-named
skill function is sent as a real tools[] entry and collides with the
hosted tool on keyed platforms.

Add `stripConflictingHostedTools`, applied only on the API-key path, to
drop the hosted entry when a conflicting declared tool is present. This
mirrors the existing `UNSUPPORTED_HOSTED_TOOLS` precedent. Forward mode
is left untouched so native imagegen keeps working.

---------

Co-authored-by: bitkyc08-arch <bitkyc08@gmail.com>

Author: kargnas

src/adapters/openai-responses.ts

@@ -175,6 +175,46 @@ function stripPreviousResponseId(body: unknown, strip: boolean): unknown {
   return rest;
 }
 
+/**
+ * Hosted tool types whose server-side function names collide with the client tools Codex
+ * declares for the matching app skill. Codex sends BOTH (e.g. hosted `image_generation` plus a
+ * declared `image_gen.imagegen` function/namespace tool for the imagegen skill). The ChatGPT
+ * backend tolerates the pair, but the platform `/v1/responses` rejects it:
+ * `Invalid Value: 'tools'. Function 'image_gen.imagegen' conflicts with a hosted tool in the
+ * same request.` Keyed hosted-type → conflicting client tool-name prefix; the hosted entry is
+ * dropped (the declared tool wins — Codex executes the skill client-side either way).
+ */
+const HOSTED_TOOL_NAME_CONFLICTS: ReadonlyArray<{ hostedType: string; namePrefix: string }> = [
+  { hostedType: "image_generation", namePrefix: "image_gen" },
+];
+
+/**
+ * Drop hosted tools whose names collide with declared function/namespace tools (see
+ * HOSTED_TOOL_NAME_CONFLICTS). Only applies on the API-key platform path: the ChatGPT backend
+ * ("forward" mode) accepts the pair, and stripping there would disable native imagegen. No-op
+ * (returns the original reference) when nothing matches.
+ */
+function stripConflictingHostedTools(body: unknown): unknown {
+  if (!isPlainObject(body) || !Array.isArray(body.tools)) return body;
+  const allTools = body.tools;
+
+  const conflicting = HOSTED_TOOL_NAME_CONFLICTS.filter(c =>
+    allTools.some(t => {
+      if (!isPlainObject(t) || typeof t.name !== "string") return false;
+      if (t.type === "namespace") return t.name === c.namePrefix;
+      return t.name === c.namePrefix || t.name.startsWith(`${c.namePrefix}.`);
+    }),
+  );
+  if (conflicting.length === 0) return body;
+
+  const tools = allTools.filter(t => {
+    const type = isPlainObject(t) && typeof t.type === "string" ? t.type : undefined;
+    if (!type) return true;
+    return !conflicting.some(c => c.hostedType === type);
+  });
+  return tools.length === allTools.length ? body : { ...body, tools };
+}
+
 /**
  * Remove hosted tool entries the target native slug rejects, so the OAuth-passthrough body never
  * carries a tool the upstream model 400s on. No-op (returns the original reference) when nothing
@@ -237,6 +277,7 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
         forward || parsed._previousResponseInputExpanded === true,
       );
       if (forward) outBody = repairOrphanedInputItems(outBody, unexpandedMiss);
+      else outBody = stripConflictingHostedTools(outBody);
       return {
         url,
         method: "POST",

tests/openai-responses-passthrough.test.ts

@@ -265,3 +265,108 @@ describe("OpenAI Responses passthrough sanitization", () => {
     expect(body.input[0]).toMatchObject({ type: "reasoning", id: "rs_1" });
   });
 });
+
+describe("OpenAI Responses hosted-tool name conflicts", () => {
+  const keyedProvider = {
+    adapter: "openai-responses",
+    baseUrl: "https://api.openai.example/v1",
+    authMode: "key" as const,
+    apiKey: "sk-test",
+  };
+  const meta = { headers: new Headers({ authorization: "Bearer token" }) };
+
+  test("keyed platform strips hosted image_generation that collides with a declared image_gen.imagegen tool", () => {
+    const adapter = createResponsesPassthroughAdapter(keyedProvider);
+    const request = adapter.buildRequest({
+      modelId: "gpt-5.6-sol",
+      context: { messages: [] },
+      stream: true,
+      options: {},
+      _rawBody: {
+        model: "gpt-5.6-sol",
+        input: [],
+        tools: [
+          { type: "function", name: "image_gen.imagegen", parameters: {} },
+          { type: "image_generation" },
+          { type: "web_search" },
+        ],
+      },
+    }, meta);
+    const body = JSON.parse(request.body) as { tools: { type: string; name?: string }[] };
+
+    // Hosted image_generation dropped; the declared client tool wins and unrelated hosted tools stay.
+    expect(body.tools).toHaveLength(2);
+    expect(body.tools.some(t => t.type === "image_generation")).toBe(false);
+    expect(body.tools.some(t => t.type === "function" && t.name === "image_gen.imagegen")).toBe(true);
+    expect(body.tools.some(t => t.type === "web_search")).toBe(true);
+  });
+
+  test("keyed platform strips hosted image_generation when the skill is declared as an image_gen namespace tool", () => {
+    const adapter = createResponsesPassthroughAdapter(keyedProvider);
+    const request = adapter.buildRequest({
+      modelId: "gpt-5.6-sol",
+      context: { messages: [] },
+      stream: true,
+      options: {},
+      _rawBody: {
+        model: "gpt-5.6-sol",
+        input: [],
+        tools: [
+          { type: "namespace", name: "image_gen" },
+          { type: "image_generation" },
+        ],
+      },
+    }, meta);
+    const body = JSON.parse(request.body) as { tools: { type: string; name?: string }[] };
+
+    expect(body.tools).toHaveLength(1);
+    expect(body.tools[0]).toMatchObject({ type: "namespace", name: "image_gen" });
+    expect(body.tools.some(t => t.type === "image_generation")).toBe(false);
+  });
+
+  test("keyed platform keeps hosted image_generation when no conflicting tool is declared", () => {
+    const adapter = createResponsesPassthroughAdapter(keyedProvider);
+    const request = adapter.buildRequest({
+      modelId: "gpt-5.6-sol",
+      context: { messages: [] },
+      stream: true,
+      options: {},
+      _rawBody: {
+        model: "gpt-5.6-sol",
+        input: [],
+        tools: [
+          { type: "function", name: "shell", parameters: {} },
+          { type: "image_generation" },
+        ],
+      },
+    }, meta);
+    const body = JSON.parse(request.body) as { tools: { type: string }[] };
+
+    expect(body.tools).toHaveLength(2);
+    expect(body.tools.some(t => t.type === "image_generation")).toBe(true);
+  });
+
+  test("forward backend preserves the image_generation + image_gen.imagegen pair", () => {
+    // The ChatGPT backend tolerates the pair; stripping there would disable native imagegen.
+    const adapter = createResponsesPassthroughAdapter(provider);
+    const request = adapter.buildRequest({
+      modelId: "gpt-5.5",
+      context: { messages: [] },
+      stream: true,
+      options: {},
+      _rawBody: {
+        model: "gpt-5.5",
+        input: [],
+        tools: [
+          { type: "function", name: "image_gen.imagegen", parameters: {} },
+          { type: "image_generation" },
+        ],
+      },
+    }, meta);
+    const body = JSON.parse(request.body) as { tools: { type: string; name?: string }[] };
+
+    expect(body.tools).toHaveLength(2);
+    expect(body.tools.some(t => t.type === "image_generation")).toBe(true);
+    expect(body.tools.some(t => t.type === "function" && t.name === "image_gen.imagegen")).toBe(true);
+  });
+});