codex-copilot-dx 0.6.13 → 0.6.15

package/README.md

@@ -7,7 +7,7 @@ Use [Codex Desktop](https://openai.com/codex), [Claude Code](https://claude.com/
 A single in-process adapter (port `2026`) exposes both APIs over one Copilot
 account by default, or over isolated Codex and Claude accounts when configured:
 
-- **Codex** -> OpenAI Responses API (`/v1/responses`, `/v1/responses/compact`); Responses-only models and compaction proxy directly, chat models convert to Chat Completions.
+- **Codex** -> OpenAI Responses API (`/v1/responses`, `/v1/responses/compact`); Responses-only models and compaction proxy directly, while chat models convert the text, image, and function-tool subset and explicitly reject incompatible top-level items, tools, and tool choices.
 - **Claude Code** -> Anthropic Messages API (`/v1/messages`, `/v1/messages/count_tokens`), translated to/from Chat Completions.
 - **Claude App** -> optional Claude Desktop App gateway profile using the same local Messages API plus local model discovery for the configured gateway key.
 - **PM Studio** -> optional macOS app patch that keeps the active PM profile for GPT models while routing enabled Claude models through an isolated CCDX Claude account.
@@ -91,7 +91,10 @@ Once enabled, routing is fixed by API surface rather than by model name:
 
 The two profiles keep separate service tokens, API bases, refresh/backoff state,
 model endpoint metadata, and credential-bound model caches. Switching either
-GitHub account invalidates that profile's old cache instead of borrowing it. If the isolated Claude profile later
+GitHub account invalidates that profile's old cache instead of borrowing it.
+Cached catalogs are fresh for two hours; older catalogs remain immediately
+available for up to seven days while CCDX refreshes them in the background.
+If the isolated Claude profile later
 becomes invalid, Claude requests fail with a reauthentication instruction while
 Codex remains available; CCDX never silently falls back to the enterprise
 account. Reauthorize it explicitly with:
@@ -301,7 +304,7 @@ To actively verify the protocol path through an already-running adapter, run:
 ccdx doctor --compat
 ```
 
-The compatibility doctor sends a few minimal Copilot requests to check Codex Auto-review, native Responses, streaming history, compaction, image tool namespace handling, and Anthropic streaming. It consumes a small amount of Copilot usage, never starts the adapter or device flow, and does not change client configuration. Combine it with `--online` when both the saved-token entitlement check and the adapter protocol checks are needed.
+The compatibility doctor sends a few minimal Copilot requests to check Codex Auto-review, native Responses, streaming history, compaction, and Anthropic streaming. It consumes a small amount of Copilot usage, never starts the adapter or device flow, and does not change client configuration. Combine it with `--online` when both the saved-token entitlement check and the adapter protocol checks are needed.
 
 For a read-only summary of the running adapter, use:
 
@@ -438,9 +441,9 @@ Before image encoding, CCDX leaves ordinary visual history byte-for-byte unchang
 
 When expanded Responses history exceeds Copilot's 50-image request limit, the adapter removes older duplicate image occurrences first, then keeps the 50 most recent images. This applies only to the forwarded request: local history remains complete, current images are preferred over older history, and requests at or below the limit are unchanged.
 
-For `/v1/responses/compact`, the adapter sends one terminal `compaction_trigger` in unary mode, validates that Copilot returned completed compaction state, and rebuilds a replayable snapshot from recent system, developer, user, and assistant messages plus every compaction item. Only a validated snapshot becomes a new local history root. Later turns continue from it without re-expanding pre-compaction history; existing older response branches remain available until normal history eviction.
+For `/v1/responses/compact`, the adapter sends one terminal `compaction_trigger` in unary mode, validates that Copilot returned completed compaction state, and preserves the complete upstream compacted window as the canonical next context. Only a validated window becomes a new local history root. Later turns continue from it without re-expanding pre-compaction history; existing older response branches remain available until normal history eviction.
 
-Successful streaming responses are accepted only when the upstream body is SSE and reaches its protocol terminal event. Unexpected EOF becomes a protocol-native stream error, and repeated blank tool-argument deltas are stopped per tool call. Inference responses forward safe quota, retry, model, trace, and upstream request-ID metadata; cookies, authorization, body-length, and encoding headers are not forwarded.
+Successful streaming responses are accepted only when the upstream body is SSE and reaches its protocol terminal event; bytes after that terminal are not forwarded. Unexpected EOF becomes a protocol-native stream error, and repeated blank tool-argument deltas are stopped per tool call. Inference responses forward safe quota, retry, model, trace, and upstream request-ID metadata; cookies, authorization, body-length, and encoding headers are not forwarded.
 
 Newer ChatGPT/Codex clients can advertise an `image_gen` namespace that already exists upstream. The adapter removes that exact conflicting client tool before forwarding and retries once only when Copilot explicitly reports an image namespace collision. Image inputs and screenshot optimization remain enabled.
 
@@ -456,4 +459,4 @@ npm run verify
 npm run bench:payload
 ```
 
-`npm test` runs the unit and handler-level suite. `npm run test:smoke` starts a real local HTTP adapter with fully injected offline upstreams. `npm run bench:check` enforces relative token-counting performance and request-admission resource limits. `npm run pack:check` verifies the npm tarball contents without publishing. `npm run bench:payload` remains a report-only, isolated-process benchmark for 5-60 MiB image payloads and does not contact Copilot. The CI workflow runs the verification checks on supported Node.js release lines.
+`npm test` runs the unit and handler-level suite. `npm run test:smoke` starts a real local HTTP adapter with fully injected offline upstreams. `npm run bench:check` enforces relative token-counting performance, linear SSE scanning, and request-admission resource limits. `npm run pack:check` verifies the npm tarball contents without publishing. `npm run bench:payload` remains a report-only, isolated-process benchmark for 5-60 MiB image payloads and does not contact Copilot. The CI workflow runs the verification checks on supported Node.js release lines.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.6.13",
+  "version": "0.6.15",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",

package/scripts/benchmark.mjs

@@ -31,6 +31,65 @@ function median(values) {
     : ordered[middle];
 }
 
+function sseLinearityProbe() {
+  return runProbe(`
+    import { webStreamLines } from "./src/stream.mjs";
+
+    const chunkBytes = 16 * 1024;
+    const maxBufferBytes = 8 * 1024 * 1024;
+    const chunk = new TextEncoder().encode("x".repeat(chunkBytes));
+    const results = [];
+    for (const inputMiB of [1, 2, 4, 8]) {
+      const inputBytes = inputMiB * 1024 * 1024;
+      let remaining = inputBytes;
+      const response = {
+        body: new ReadableStream({
+          pull(controller) {
+            if (remaining === 0) {
+              controller.close();
+              return;
+            }
+            const nextBytes = Math.min(chunk.byteLength, remaining);
+            controller.enqueue(nextBytes === chunk.byteLength ? chunk : chunk.subarray(0, nextBytes));
+            remaining -= nextBytes;
+          },
+        }, { highWaterMark: 0 }),
+      };
+      const originalByteLength = Buffer.byteLength;
+      let byteLengthCalls = 0;
+      let scannedBytes = 0;
+      Buffer.byteLength = function trackedByteLength(value, ...args) {
+        const bytes = originalByteLength(value, ...args);
+        byteLengthCalls += 1;
+        scannedBytes += bytes;
+        return bytes;
+      };
+      let lines = 0;
+      let outputBytes = 0;
+      const started = performance.now();
+      try {
+        for await (const line of webStreamLines(response, { maxBufferBytes })) {
+          lines += 1;
+          outputBytes += originalByteLength(line);
+        }
+      } finally {
+        Buffer.byteLength = originalByteLength;
+      }
+      results.push({
+        input_mib: inputMiB,
+        chunks: Math.ceil(inputBytes / chunkBytes),
+        lines,
+        output_bytes: outputBytes,
+        byte_length_calls: byteLengthCalls,
+        scanned_bytes: scannedBytes,
+        scan_ratio: +(scannedBytes / inputBytes).toFixed(3),
+        elapsed_ms: +(performance.now() - started).toFixed(1),
+      });
+    }
+    process.stdout.write(JSON.stringify({ chunk_kib: chunkBytes / 1024, max_buffer_mib: 8, results }));
+  `);
+}
+
 function deterministicPixels(byteLength, initialSeed) {
   const pixels = Buffer.alloc(byteLength);
   let seed = initialSeed;
@@ -422,6 +481,7 @@ const report = {
 };
 
 if (checkMode) {
+  report.sse_linearity = sseLinearityProbe();
   report.large_token_count = {
     proxy: largeTokenCountProbe("proxy"),
     materialized_array: largeTokenCountProbe("array"),
@@ -466,6 +526,20 @@ if (checkMode) {
   if (report.tool_output_parse_cache.parse_calls !== 1) {
     failures.push(`stringified tool output parsed ${report.tool_output_parse_cache.parse_calls} times instead of once`);
   }
+  const expectedSseSizes = [1, 2, 4, 8];
+  if (report.sse_linearity.results.length !== expectedSseSizes.length
+    || report.sse_linearity.results.some((sample, index) => sample.input_mib !== expectedSseSizes[index])) {
+    failures.push("SSE linearity probe did not cover 1/2/4/8 MiB inputs");
+  }
+  for (const sample of report.sse_linearity.results) {
+    const inputBytes = sample.input_mib * 1024 * 1024;
+    if (sample.lines !== 1 || sample.output_bytes !== inputBytes) {
+      failures.push(`SSE parser changed the ${sample.input_mib}MiB fragmented line`);
+    }
+    if (sample.scanned_bytes > inputBytes * 1.01 || sample.byte_length_calls > sample.chunks + 1) {
+      failures.push(`SSE parser scan complexity is not linear at ${sample.input_mib}MiB`);
+    }
+  }
   for (const payload of report.large_payload_peak) {
     if (payload.admission_max_active_mib > payload.admission_budget_mib) {
       failures.push(`request admission exceeded its budget at ${payload.target_request_mib}MiB x${payload.concurrency}`);

package/src/adapter.mjs

@@ -41,14 +41,18 @@ export {
   responseHistoryStats,
 } from "./response-history.mjs";
 export { forwardToChat, responsesToChat } from "./responses-bridge.mjs";
+export {
+  openCopilotResponse,
+} from "./copilot-responses-compat.mjs";
 export {
   isEncryptedContentVerificationError,
   isImageNamespaceCollisionError,
-  openCopilotResponse,
+  sanitizeImageNamespaceCollisionRequest,
+} from "./copilot-responses-policy.mjs";
+export {
   prepareResponsesRequest,
   rememberResponseHistory,
   sanitizeEncryptedReasoningRequest,
-  sanitizeImageNamespaceCollisionRequest,
   stripInternalResponsesInputFields,
 } from "./responses-request.mjs";
 

package/src/anthropic-handler.mjs

@@ -20,6 +20,42 @@ import { requireUpstreamEventStream, withChatStreamUsage } from "./stream-contra
 import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
 import { recordAnthropicUsage } from "./usage.mjs";
 
+const PROMPT_TOO_LONG_MESSAGE = "prompt is too long: your prompt is too long. Please reduce the number of messages or use a model with a larger context window.";
+
+function contextWindowErrorBody(text) {
+  let error;
+  try {
+    const parsed = JSON.parse(text);
+    error = parsed && typeof parsed === "object" ? parsed.error : null;
+  } catch {
+    error = { message: text };
+  }
+  if (!error || typeof error !== "object") return null;
+  const code = error.code;
+  const message = typeof error.message === "string" ? error.message.toLowerCase() : "";
+  const matches = code === "context_length_exceeded"
+    || code === "model_max_prompt_tokens_exceeded"
+    || message.includes("exceeds the context window of this model")
+    || message.includes("maximum context length is")
+    || message.includes("request body is too large for model context window");
+  if (!matches) return null;
+  return JSON.stringify({
+    type: "error",
+    error: { type: "invalid_request_error", message: PROMPT_TOO_LONG_MESSAGE },
+  });
+}
+
+function sendAnthropicUpstreamError(res, response, text) {
+  const rewritten = contextWindowErrorBody(text);
+  if (!rewritten) {
+    sendUpstreamError(res, response, text);
+    return;
+  }
+  const headers = new Headers(response.headers);
+  headers.set("content-type", "application/json");
+  sendUpstreamError(res, { status: response.status, headers }, rewritten);
+}
+
 export function createAnthropicCountTokensHandler(options) {
   const { acquireRequest, requestBodyTimeoutMs } = options;
 
@@ -76,7 +112,7 @@ export function createAnthropicMessagesHandler(options) {
         const upstream = await chatCompletionsFn(withChatStreamUsage(chatReq), { signal: abort.signal });
         releaseRequest();
         if (!upstream.ok) {
-          sendUpstreamError(res, upstream, await upstream.text());
+          sendAnthropicUpstreamError(res, upstream, await upstream.text());
           return;
         }
         await requireUpstreamEventStream(upstream);
@@ -113,7 +149,7 @@ export function createAnthropicMessagesHandler(options) {
         releaseRequest();
         const data = await upstream.text();
         if (!upstream.ok) {
-          sendUpstreamError(res, upstream, data);
+          sendAnthropicUpstreamError(res, upstream, data);
           return;
         }
         const anthropicMessage = chatToAnthropic(JSON.parse(data), requestedModel, { forceModel: forceRequestedModel });

package/src/anthropic.mjs

@@ -44,26 +44,10 @@ function toolResultContent(content) {
 }
 
 // Convert one Anthropic message into zero or more OpenAI messages.
-function convertMessage(msg) {
-  const out = [];
-  const role = msg.role; // "user" | "assistant"
-
-  if (typeof msg.content === "string") {
-    out.push({ role, content: msg.content });
-    return out;
-  }
-  if (!Array.isArray(msg.content)) return out;
-
-  // tool_result blocks must become independent role:"tool" messages.
-  const toolResults = msg.content.filter((b) => b.type === "tool_result");
-  for (const tr of toolResults) {
-    out.push({ role: "tool", tool_call_id: tr.tool_use_id, content: toolResultContent(tr.content) });
-  }
-
-  // Convert remaining text, image, and tool_use blocks.
+function convertContentBlocks(role, blocks) {
   const textImageParts = [];
   const toolCalls = [];
-  for (const b of msg.content) {
+  for (const b of blocks) {
     if (b.type === "text") {
       textImageParts.push({ type: "text", text: b.text });
     } else if (b.type === "image") {
@@ -80,17 +64,66 @@ function convertMessage(msg) {
     const m = { role, content: null, tool_calls: toolCalls };
     if (textImageParts.length === 1 && textImageParts[0].type === "text") m.content = textImageParts[0].text;
     else if (textImageParts.length > 0) m.content = textImageParts;
-    out.push(m);
+    return m;
   } else if (textImageParts.length > 0) {
     if (textImageParts.length === 1 && textImageParts[0].type === "text") {
-      out.push({ role, content: textImageParts[0].text });
+      return { role, content: textImageParts[0].text };
     } else {
-      out.push({ role, content: textImageParts });
+      return { role, content: textImageParts };
+    }
+  }
+  return null;
+}
+
+function convertMessage(msg) {
+  const out = [];
+  const role = msg.role; // "user" | "assistant"
+
+  if (typeof msg.content === "string") {
+    out.push({ role, content: msg.content });
+    return out;
+  }
+  if (!Array.isArray(msg.content)) return out;
+
+  if (!msg.content.some((block) => block.type === "tool_result")) {
+    const converted = convertContentBlocks(role, msg.content);
+    if (converted) out.push(converted);
+    return out;
+  }
+
+  let contentBlocks = [];
+  const flushContent = () => {
+    const converted = convertContentBlocks(role, contentBlocks);
+    if (converted) out.push(converted);
+    contentBlocks = [];
+  };
+  for (const block of msg.content) {
+    if (block.type !== "tool_result") {
+      contentBlocks.push(block);
+      continue;
     }
+    flushContent();
+    out.push({
+      role: "tool",
+      tool_call_id: block.tool_use_id,
+      content: toolResultContent(block.content),
+    });
   }
+  flushContent();
   return out;
 }
 
+function toolInputSchema(inputSchema) {
+  if (inputSchema
+    && typeof inputSchema === "object"
+    && !Array.isArray(inputSchema)
+    && inputSchema.type === "object"
+    && Object.keys(inputSchema).length === 1) {
+    return { type: "object", properties: {} };
+  }
+  return inputSchema;
+}
+
 function mapToolChoice(tc) {
   if (!tc) return undefined;
   switch (tc.type) {
@@ -119,7 +152,7 @@ export function anthropicToChat(body, options = {}) {
   if (Array.isArray(body.tools) && body.tools.length) {
     chatReq.tools = body.tools.map((t) => ({
       type: "function",
-      function: { name: t.name, description: t.description, parameters: t.input_schema },
+      function: { name: t.name, description: t.description, parameters: toolInputSchema(t.input_schema) },
     }));
   }
   const tc = mapToolChoice(body.tool_choice);
@@ -130,6 +163,14 @@ export function anthropicToChat(body, options = {}) {
 
 function uid() { return randomUUID().replace(/-/g, ""); }
 
+function invalidToolArguments(toolName) {
+  const name = String(toolName || "unknown").slice(0, 100);
+  return invalidUpstreamStream(
+    `Upstream Chat Completions tool "${name}" did not return valid JSON object arguments`,
+    "upstream_tool_arguments_json_invalid",
+  );
+}
+
 export function chatToAnthropic(openaiResp, model, options = {}) {
   const choice = openaiResp.choices?.[0];
   const msg = choice?.message || {};
@@ -138,8 +179,20 @@ export function chatToAnthropic(openaiResp, model, options = {}) {
   if (msg.content) content.push({ type: "text", text: msg.content });
   if (Array.isArray(msg.tool_calls)) {
     for (const tc of msg.tool_calls) {
-      let input = {};
-      try { input = JSON.parse(tc.function.arguments || "{}"); } catch { input = {}; }
+      const rawArguments = tc.function?.arguments;
+      let input;
+      if (rawArguments === undefined || rawArguments === null || rawArguments === "") {
+        input = {};
+      } else {
+        try {
+          input = JSON.parse(rawArguments);
+        } catch {
+          throw invalidToolArguments(tc.function?.name);
+        }
+        if (!input || typeof input !== "object" || Array.isArray(input)) {
+          throw invalidToolArguments(tc.function?.name);
+        }
+      }
       content.push({ type: "tool_use", id: tc.id, name: tc.function.name, input });
     }
   }

package/src/config.mjs

@@ -9,8 +9,39 @@ const CONFIG_PATH = path.join(os.homedir(), ".codex", "config.toml");
 const MODEL_CONTEXT_WINDOW = 1_000_000;
 const MODEL_AUTO_COMPACT_TOKEN_LIMIT = 900_000;
 
+function isTomlTableHeader(line) {
+  const source = line.trimStart();
+  const openingBrackets = source.startsWith("[[") ? 2 : source.startsWith("[") ? 1 : 0;
+  if (!openingBrackets) return false;
+
+  let quote = "";
+  let escaped = false;
+  for (let index = openingBrackets; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (quote === '"' && char === "\\" && !escaped) {
+        escaped = true;
+        continue;
+      }
+      if (char === quote && !escaped) quote = "";
+      escaped = false;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char !== "]" || (openingBrackets === 2 && source[index + 1] !== "]")) continue;
+
+    if (!source.slice(openingBrackets, index).trim()) return false;
+    const tail = source.slice(index + openingBrackets).trim();
+    return tail === "" || tail.startsWith("#");
+  }
+  return false;
+}
+
 function setTopLevelTomlDefault(lines, key, value) {
-  let end = lines.findIndex((line) => /^\s*\[[^\]]+\]\s*$/.test(line));
+  let end = lines.findIndex(isTomlTableHeader);
   if (end === -1) end = lines.length;
 
   const keyRe = new RegExp(`^\\s*${key}\\s*=`);
@@ -28,7 +59,7 @@ function setTomlKey(lines, sectionName, key, value) {
 
   let end = lines.length;
   for (let i = start + 1; i < lines.length; i++) {
-    if (/^\s*\[[^\]]+\]\s*$/.test(lines[i])) {
+    if (isTomlTableHeader(lines[i])) {
       end = i;
       break;
     }
@@ -57,7 +88,11 @@ export function computeUpdatedCodexConfig(content, adapterPort = 2026, adapterHo
 
   let changed = false;
   const openaiLine = `openai_base_url = "${baseUrl}"`;
-  const openaiIndex = lines.findIndex((line) => /^openai_base_url\s*=/.test(line));
+  const firstSection = lines.findIndex(isTomlTableHeader);
+  const topLevelEnd = firstSection === -1 ? lines.length : firstSection;
+  const openaiIndex = lines.findIndex((line, index) => (
+    index < topLevelEnd && /^\s*openai_base_url\s*=/.test(line)
+  ));
   if (openaiIndex === -1) {
     lines.unshift(openaiLine);
     changed = true;

package/src/copilot-responses-compat.mjs

@@ -0,0 +1,73 @@
+import { responses as copilotResponses } from "./copilot.mjs";
+import {
+  isEncryptedContentVerificationError,
+  isImageNamespaceCollisionError,
+  sanitizeImageNamespaceCollisionRequest,
+} from "./copilot-responses-policy.mjs";
+import { httpError } from "./http-transport.mjs";
+import {
+  finalizeEncryptedHistoryRebase,
+  sanitizeEncryptedReasoningRequest,
+} from "./responses-request.mjs";
+import { status } from "./status.mjs";
+
+// Ordered Copilot-only fallbacks. Each policy is single-use and must be gated
+// by an exact upstream failure plus a request transformation that changes the
+// payload. Generic Responses preparation does not decide whether to retry.
+const RETRY_POLICIES = Object.freeze([
+  Object.freeze({
+    id: "image-namespace-collision",
+    matches: isImageNamespaceCollisionError,
+    apply: sanitizeImageNamespaceCollisionRequest,
+    warning: "image_gen namespace rejected by upstream; retrying without the conflicting image tool",
+  }),
+  Object.freeze({
+    id: "encrypted-replay-rejected",
+    matches: isEncryptedContentVerificationError,
+    apply: sanitizeEncryptedReasoningRequest,
+    warning: "encrypted replay content rejected by upstream; retrying without unavailable encrypted content",
+  }),
+]);
+
+export async function openCopilotResponse(reqContext, upstream = copilotResponses, options = {}) {
+  const usedPolicies = new Set();
+  let payloadPrepared = false;
+  for (let attempt = 0; attempt <= RETRY_POLICIES.length; attempt += 1) {
+    options.assertPrepareActive?.();
+    const resp = await upstream(reqContext.body, {
+      assertActive: options.assertPrepareActive,
+      signal: options.signal,
+      currentInputStart: reqContext.currentInputStart,
+      onUpstreamStart: options.onUpstreamStart,
+      payloadPrepared,
+    });
+    options.assertPrepareActive?.();
+    payloadPrepared = true;
+    if (resp.ok) {
+      reqContext = finalizeEncryptedHistoryRebase(reqContext);
+      return { resp, reqContext };
+    }
+
+    const errorText = await resp.text();
+    options.assertPrepareActive?.();
+    let retryPolicy = null;
+    let retryContext = null;
+    for (const policy of RETRY_POLICIES) {
+      if (usedPolicies.has(policy.id) || !policy.matches(resp.status, errorText)) continue;
+      const candidate = policy.apply(reqContext);
+      if (candidate) {
+        retryPolicy = policy;
+        retryContext = candidate;
+        break;
+      }
+    }
+    if (retryPolicy && retryContext) {
+      usedPolicies.add(retryPolicy.id);
+      reqContext = retryContext;
+      console.warn(status("warn", retryPolicy.warning));
+      continue;
+    }
+    return { resp, reqContext, errorText };
+  }
+  throw httpError("Responses compatibility retry limit exceeded", 502);
+}

package/src/copilot-responses-policy.mjs

@@ -0,0 +1,78 @@
+function cloneJson(value) {
+  return value === undefined ? undefined : structuredClone(value);
+}
+
+export function isEncryptedContentVerificationError(statusCode, text) {
+  if (statusCode < 400 || !text) return false;
+  const lower = String(text).toLowerCase();
+  const reasoningFailure = lower.includes("encrypted content")
+    && lower.includes("could not be verified")
+    && (lower.includes("could not be decrypted") || lower.includes("could not be parsed"));
+  const functionOutputFailure = lower.includes("encrypted function output content")
+    && lower.includes("could not be decrypted or decoded");
+  const missingEncryptedContent = statusCode < 500
+    && /missing required parameter:\s*(['"]?)input\[\d+\](?:\.[a-z0-9_]+|\[\d+\])*\.encrypted_content\1(?=\.?(?:\s|$|["},\]]))/.test(lower);
+  return reasoningFailure || functionOutputFailure || missingEncryptedContent;
+}
+
+export function isImageNamespaceCollisionError(statusCode, text) {
+  if (statusCode < 400 || !text) return false;
+  const lower = String(text).toLowerCase();
+  return lower.includes("namespace")
+    && lower.includes("image_gen")
+    && lower.includes("collid");
+}
+
+export function isCopilotImageNamespaceTool(tool, { collisionFallback = false } = {}) {
+  if (!tool || typeof tool !== "object") return false;
+  const type = String(tool.type || "").toLowerCase();
+  if (["image_gen", "image_generation"].includes(type)) return true;
+  if (!collisionFallback) return false;
+  const name = String(tool.name || tool.function?.name || "").toLowerCase();
+  const namespace = String(tool.namespace || "").toLowerCase();
+  if (["image_gen", "image_generation"].includes(name)) return true;
+  if (namespace === "image_gen" || namespace === "image_generation") return true;
+  return [type, name, namespace].some((value) => value.startsWith("image_gen"));
+}
+
+function toolName(tool) {
+  return String(tool?.name || tool?.function?.name || "").trim();
+}
+
+// Copilot currently rejects the public image-generation tool. Keep this
+// provider-owned policy paired with tool_choice so request invariants survive
+// the removal. Revalidate against Copilot before deleting or broadening it.
+// Reference: https://github.com/Menci/Floway/blob/ac2bbb04352033a7d9d74574a9d465d40395ef06/packages/provider-copilot/src/interceptors/openai-responses/strip-image-generation.ts
+export function applyCopilotResponsesRequestPolicies(body, options = {}) {
+  if (!Array.isArray(body?.tools)) return false;
+  const removedNames = new Set();
+  const filtered = body.tools.filter((tool) => {
+    const removed = isCopilotImageNamespaceTool(tool, options);
+    if (removed) {
+      const name = toolName(tool);
+      if (name) removedNames.add(name);
+    }
+    return !removed;
+  });
+  if (filtered.length === body.tools.length) return false;
+  if (filtered.length) body.tools = filtered;
+  else delete body.tools;
+
+  const choiceName = toolName(body.tool_choice);
+  const choiceTargetsRemovedTool = choiceName
+    && removedNames.has(choiceName)
+    && !filtered.some((tool) => toolName(tool) === choiceName);
+  if (isCopilotImageNamespaceTool(body.tool_choice, options)
+    || choiceTargetsRemovedTool
+    || (body.tool_choice === "required" && !body.tools)) {
+    delete body.tool_choice;
+  }
+  return true;
+}
+
+export function sanitizeImageNamespaceCollisionRequest(reqContext) {
+  if (!Array.isArray(reqContext?.body?.tools)) return null;
+  const body = cloneJson(reqContext.body);
+  if (!applyCopilotResponsesRequestPolicies(body, { collisionFallback: true })) return null;
+  return { ...reqContext, body };
+}

package/src/doctor.mjs

@@ -181,13 +181,12 @@ export async function inspectAdapterCompatibility({
   });
 
   if (firstResponse) {
-    await runCompatibilityCheck(checks, "Responses stream, history, and image tool compatibility", async () => {
+    await runCompatibilityCheck(checks, "Responses stream and history compatibility", async () => {
       const text = await compatibilityRequest(fetchImpl, `${baseUrl}/v1/responses`, {
         model: responsesModel,
         stream: true,
         previous_response_id: firstResponse.id,
         input: "Reply with OK again.",
-        tools: [{ type: "image_generation" }],
       }, timeoutMs);
       if (!/^event:\s*response\.completed\s*$/m.test(text)) throw new Error("stream did not contain response.completed");
     });