codex-copilot-dx 0.4.41 → 0.4.43

package/src/responses-bridge.mjs

@@ -7,6 +7,28 @@ function cloneJson(value) {
   return value === undefined ? undefined : structuredClone(value);
 }
 
+function chatImagePart(part) {
+  if (!part || typeof part !== "object") return null;
+  let imageUrl = null;
+  if (part.type === "input_image" || part.type === "image_url") {
+    const raw = part.image_url ?? part.url;
+    imageUrl = typeof raw === "string"
+      ? { url: raw }
+      : raw && typeof raw === "object" ? cloneJson(raw) : null;
+  } else if (part.type === "image" && part.source?.type === "base64" && typeof part.source.data === "string") {
+    imageUrl = { url: `data:${part.source.media_type || "image/png"};base64,${part.source.data}` };
+  }
+  if (imageUrl && part.detail !== undefined && imageUrl.detail === undefined) imageUrl.detail = part.detail;
+  return imageUrl?.url ? { type: "image_url", image_url: imageUrl } : null;
+}
+
+export function responsesBodyUsesCustomTools(body) {
+  if (body?.tool_choice?.type === "custom") return true;
+  if (Array.isArray(body?.tools) && body.tools.some((tool) => tool?.type === "custom")) return true;
+  return Array.isArray(body?.input)
+    && body.input.some((item) => item?.type === "custom_tool_call" || item?.type === "custom_tool_call_output");
+}
+
 export function responsesToChat(body) {
   const messages = [];
   if (body.instructions) messages.push({ role: "system", content: body.instructions });
@@ -19,13 +41,10 @@ export function responsesToChat(body) {
       if (!part || typeof part !== "object") continue;
       if (["input_text", "output_text", "text"].includes(part.type)) {
         parts.push({ type: "text", text: String(part.text || "") });
-      } else if (part.type === "input_image" || part.type === "image_url") {
-        const raw = part.image_url ?? part.url;
-        const imageUrl = typeof raw === "string"
-          ? { url: raw }
-          : raw && typeof raw === "object" ? cloneJson(raw) : null;
-        if (imageUrl && part.detail !== undefined && imageUrl.detail === undefined) imageUrl.detail = part.detail;
-        if (imageUrl?.url) parts.push({ type: "image_url", image_url: imageUrl });
+      } else if (["input_image", "image_url", "image"].includes(part.type)) {
+        const imagePart = chatImagePart(part);
+        if (imagePart) parts.push(imagePart);
+        else parts.push({ type: "text", text: JSON.stringify(part) });
       } else {
         parts.push({ type: "text", text: JSON.stringify(part) });
       }
@@ -40,6 +59,8 @@ export function responsesToChat(body) {
     for (const item of body.input) {
       if (item.type === "message") {
         messages.push({ role: item.role, content: messageContent(item.content) });
+      } else if (["input_image", "image_url", "image"].includes(item.type)) {
+        messages.push({ role: "user", content: messageContent([item]) });
       } else if (item.type === "function_call") {
         messages.push({
           role: "assistant",
@@ -113,14 +134,13 @@ export function chatToResponses(chatResp, model) {
 
 export async function forwardToChat(chatReq, emitEvent, onDone, onError, options = {}) {
   delete chatReq.max_tokens;
+  const upstreamReq = chatReq.stream === true ? chatReq : { ...chatReq, stream: true };
+  const bodyText = upstreamReq === chatReq ? options.bodyText : undefined;
   let resp;
   try {
     const chatCompletionsFn = options.chatCompletionsFn || chatCompletions;
     try {
-      resp = await chatCompletionsFn({
-        ...chatReq,
-        stream: true,
-      }, { signal: options.signal });
+      resp = await chatCompletionsFn(upstreamReq, { signal: options.signal, bodyText });
     } finally {
       options.releaseRequest?.();
     }

package/src/responses-byte-budget.mjs

@@ -0,0 +1,314 @@
+import {
+  isResponsesToolOutputItem,
+  readResponsesImagePart,
+  readResponsesToolOutputParts,
+} from "./responses-content.mjs";
+
+const IMAGE_OMISSION_TEXT = "[CCDX: earlier image omitted to fit the upstream request byte budget.]";
+
+function bodyPayload(reqBody) {
+  const bodyText = JSON.stringify(reqBody);
+  return { bodyText, bodyBytes: Buffer.byteLength(bodyText) };
+}
+
+function inlineImageIdentity(part) {
+  const identity = readResponsesImagePart(part)?.identity;
+  return identity ? { kind: "inline:data", value: identity } : null;
+}
+
+function imageMarkerPart(record) {
+  if (record.kind === "message") {
+    return {
+      type: record.role === "assistant" ? "output_text" : "input_text",
+      text: IMAGE_OMISSION_TEXT,
+    };
+  }
+  return { type: record.usesAnthropicParts ? "text" : "input_text", text: IMAGE_OMISSION_TEXT };
+}
+
+function collectResponseImages(inputItems, currentInputStart) {
+  const records = [];
+  const refs = [];
+  const addContainer = (parts, options) => {
+    if (!Array.isArray(parts)) return;
+    const record = {
+      parts,
+      kind: options.kind,
+      role: options.role,
+      commit: options.commit,
+      stringified: options.stringified,
+      originalOutput: options.originalOutput,
+      usesAnthropicParts: false,
+    };
+    for (let partIndex = 0; partIndex < parts.length; partIndex += 1) {
+      const identity = inlineImageIdentity(parts[partIndex]);
+      if (!identity) continue;
+      if (parts[partIndex].type === "image") record.usesAnthropicParts = true;
+      refs.push({
+        record,
+        partIndex,
+        historical: options.historical,
+        identity,
+      });
+    }
+    if (refs.some((ref) => ref.record === record)) records.push(record);
+  };
+
+  const historyBoundary = Math.min(Math.max(0, currentInputStart), inputItems.length);
+  for (let itemIndex = 0; itemIndex < inputItems.length; itemIndex += 1) {
+    const item = inputItems[itemIndex];
+    if (!item || typeof item !== "object") continue;
+    const historical = itemIndex < historyBoundary;
+    const identity = inlineImageIdentity(item);
+    if (identity) {
+      const record = {
+        parts: inputItems,
+        partIndex: itemIndex,
+        kind: "top-level",
+        role: "user",
+        commit: null,
+        usesAnthropicParts: false,
+      };
+      refs.push({ record, partIndex: itemIndex, historical, identity });
+      records.push(record);
+    }
+    if (item.type === "message") {
+      addContainer(item.content, { kind: "message", role: item.role, historical });
+      continue;
+    }
+    const toolOutput = readResponsesToolOutputParts(item);
+    if (toolOutput) {
+      addContainer(toolOutput.parts, {
+        kind: "tool-output",
+        commit: toolOutput.commit,
+        historical,
+        stringified: typeof item.output === "string",
+        originalOutput: item.output,
+      });
+    }
+  }
+  return { records, refs };
+}
+
+function orderedHistoricalImageCandidates(refs) {
+  const seenByKind = new Map();
+  const duplicates = [];
+  for (let index = refs.length - 1; index >= 0; index -= 1) {
+    const { kind, value } = refs[index].identity;
+    let seen = seenByKind.get(kind);
+    if (!seen) {
+      seen = new Set();
+      seenByKind.set(kind, seen);
+    }
+    if (seen.has(value) && refs[index].historical) duplicates.push(index);
+    else seen.add(value);
+  }
+  duplicates.sort((left, right) => left - right);
+  const duplicateSet = new Set(duplicates);
+  const remaining = refs.map((_, index) => index)
+    .filter((index) => refs[index].historical && !duplicateSet.has(index));
+  return [
+    ...duplicates,
+    ...remaining.filter((index) => refs[index].record.kind === "tool-output"),
+    ...remaining.filter((index) => refs[index].record.kind !== "tool-output"),
+  ];
+}
+
+function serializedPartBytes(part, stringified) {
+  const serialized = JSON.stringify(part);
+  return stringified
+    ? Buffer.byteLength(JSON.stringify(serialized)) - 2
+    : Buffer.byteLength(serialized);
+}
+
+function createRecordDropState(record) {
+  if (record.kind === "top-level") {
+    const marker = {
+      type: "message",
+      role: "user",
+      content: [{ type: "input_text", text: IMAGE_OMISSION_TEXT }],
+    };
+    return {
+      currentBytes: Buffer.byteLength(JSON.stringify(record.parts[record.partIndex])),
+      markerBytes: Buffer.byteLength(JSON.stringify(marker)),
+    };
+  }
+
+  const elementBytes = record.parts.map((part) => serializedPartBytes(part, record.stringified));
+  const remainingElementBytes = elementBytes.reduce((sum, bytes) => sum + bytes, 0);
+  const remainingCount = record.parts.length;
+  const baseBytes = record.stringified ? 4 : 2;
+  const compactBytes = baseBytes + remainingElementBytes + Math.max(0, remainingCount - 1);
+  return {
+    baseBytes,
+    currentBytes: record.stringified
+      ? Buffer.byteLength(JSON.stringify(record.originalOutput))
+      : compactBytes,
+    elementBytes,
+    markerElementBytes: serializedPartBytes(imageMarkerPart(record), record.stringified),
+    remainingCount,
+    remainingElementBytes,
+  };
+}
+
+function recordBytesAfterDrop(record, state, partIndex) {
+  if (record.kind === "top-level") return state.markerBytes;
+  const remainingCount = state.remainingCount - 1;
+  if (remainingCount === 0) return state.baseBytes + state.markerElementBytes;
+  const remainingElementBytes = state.remainingElementBytes - state.elementBytes[partIndex];
+  return state.baseBytes + remainingElementBytes + remainingCount - 1;
+}
+
+function selectImageDrops(refs, bodyBytes, targetBytes) {
+  const candidates = orderedHistoricalImageCandidates(refs);
+  const selected = new Set();
+  const byRecord = new Map();
+  let projectedBytes = bodyBytes;
+  for (const index of candidates) {
+    const ref = refs[index];
+    let state = byRecord.get(ref.record);
+    if (!state) {
+      state = createRecordDropState(ref.record);
+      byRecord.set(ref.record, state);
+    }
+    const afterBytes = recordBytesAfterDrop(ref.record, state, ref.partIndex);
+    const savings = state.currentBytes - afterBytes;
+    if (savings <= 0) continue;
+    state.currentBytes = afterBytes;
+    if (ref.record.kind !== "top-level") {
+      state.remainingCount -= 1;
+      state.remainingElementBytes -= state.elementBytes[ref.partIndex];
+    }
+    selected.add(index);
+    projectedBytes -= savings;
+    if (projectedBytes <= targetBytes) break;
+  }
+  return selected;
+}
+
+function applyImageDrops(records, refs, selected) {
+  const byRecord = new Map();
+  for (const index of selected) {
+    const ref = refs[index];
+    let indexes = byRecord.get(ref.record);
+    if (!indexes) {
+      indexes = new Set();
+      byRecord.set(ref.record, indexes);
+    }
+    indexes.add(ref.partIndex);
+  }
+
+  for (const record of records) {
+    const indexes = byRecord.get(record);
+    if (!indexes) continue;
+    if (record.kind === "top-level") {
+      for (const index of indexes) {
+        record.parts[index] = {
+          type: "message",
+          role: "user",
+          content: [{ type: "input_text", text: IMAGE_OMISSION_TEXT }],
+        };
+      }
+      continue;
+    }
+    const kept = record.parts.filter((_, index) => !indexes.has(index));
+    if (!kept.length) kept.push(imageMarkerPart(record));
+    record.parts.splice(0, record.parts.length, ...kept);
+    record.commit?.();
+  }
+}
+
+function omitHistoricalToolOutputs(inputItems, currentInputStart, bodyBytes, targetBytes) {
+  let omitted = 0;
+  let projectedBytes = bodyBytes;
+  const historicalCount = Math.min(Math.max(0, currentInputStart), inputItems.length);
+  for (let itemIndex = 0; itemIndex < historicalCount && projectedBytes > targetBytes; itemIndex += 1) {
+    const item = inputItems[itemIndex];
+    if (!isResponsesToolOutputItem(item) || item.output === undefined) continue;
+    if (typeof item.output === "string" && item.output.startsWith("[CCDX: earlier tool output omitted")) continue;
+    const originalBytes = Buffer.byteLength(JSON.stringify(item.output));
+    const marker = `[CCDX: earlier tool output omitted to fit the upstream request byte budget; original_bytes=${originalBytes}.]`;
+    const markerBytes = Buffer.byteLength(JSON.stringify(marker));
+    if (markerBytes >= originalBytes) continue;
+    item.output = marker;
+    projectedBytes -= originalBytes - markerBytes;
+    omitted += 1;
+  }
+  return omitted;
+}
+
+export function trimResponsesHistoryToByteBudget(reqBody, {
+  currentInputStart = 0,
+  targetBytes,
+  initialBodyText,
+  initialBodyBytes,
+} = {}) {
+  let bodyText = initialBodyText ?? JSON.stringify(reqBody);
+  let bodyBytes = initialBodyBytes ?? Buffer.byteLength(bodyText);
+  const limit = Number.isFinite(targetBytes) && targetBytes > 0 ? Math.floor(targetBytes) : bodyBytes;
+  const inputItems = Array.isArray(reqBody?.input) ? reqBody.input : [];
+  let imagesOmitted = 0;
+  let toolOutputsOmitted = 0;
+
+  while (bodyBytes > limit) {
+    const { records, refs } = collectResponseImages(inputItems, currentInputStart);
+    if (!refs.length) break;
+    const selected = selectImageDrops(refs, bodyBytes, limit);
+    if (!selected.size) break;
+    applyImageDrops(records, refs, selected);
+    imagesOmitted += selected.size;
+    ({ bodyText, bodyBytes } = bodyPayload(reqBody));
+  }
+
+  while (bodyBytes > limit) {
+    const omitted = omitHistoricalToolOutputs(inputItems, currentInputStart, bodyBytes, limit);
+    if (omitted === 0) break;
+    toolOutputsOmitted += omitted;
+    ({ bodyText, bodyBytes } = bodyPayload(reqBody));
+  }
+
+  return {
+    bodyText,
+    bodyBytes,
+    overBudget: bodyBytes > limit,
+    targetBytes: limit,
+    imagesOmitted,
+    toolOutputsOmitted,
+    adapted: imagesOmitted > 0 || toolOutputsOmitted > 0,
+  };
+}
+
+export function enforceResponsesPayloadByteBudget(reqBody, payload) {
+  let finalized = payload;
+  if (payload?.overBudget) {
+    const trimmed = trimResponsesHistoryToByteBudget(reqBody, {
+      currentInputStart: payload.currentInputStart,
+      targetBytes: payload.targetBytes,
+      initialBodyText: payload.bodyText,
+      initialBodyBytes: payload.bodyBytes,
+    });
+    finalized = {
+      ...payload,
+      ...trimmed,
+      adapted: Boolean(payload.adapted || trimmed.adapted),
+      stage: trimmed.adapted ? `${payload.stage}+history` : payload.stage,
+    };
+  }
+  if (!finalized?.overBudget) return finalized;
+
+  const message = `Responses request body is ${finalized.bodyBytes} bytes after ${finalized.stage}; configured upstream limit is ${finalized.targetBytes} bytes`;
+  const error = new Error(message);
+  error.statusCode = 413;
+  error.code = "ccdx_request_body_too_large";
+  error.jsonBody = {
+    error: {
+      message,
+      type: "invalid_request_error",
+      code: error.code,
+      actual_bytes: finalized.bodyBytes,
+      limit_bytes: finalized.targetBytes,
+      stage: finalized.stage,
+    },
+  };
+  throw error;
+}

package/src/responses-chat-payload.mjs

@@ -0,0 +1,128 @@
+import { prepareResponsesPayload } from "./image-optimization.mjs";
+import {
+  enforceResponsesPayloadByteBudget,
+  trimResponsesHistoryToByteBudget,
+} from "./responses-byte-budget.mjs";
+import { responsesToChat } from "./responses-bridge.mjs";
+import { readResponsesImagePart, readResponsesToolOutputParts } from "./responses-content.mjs";
+
+const DEFAULT_MAX_UPSTREAM_BODY_BYTES = 30 * 1024 * 1024;
+
+function positiveInt(value, fallback) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, Number.MAX_SAFE_INTEGER) : fallback;
+}
+
+function configuredBodyLimit(payloadOptions) {
+  const environmentLimit = positiveInt(
+    process.env.CCDX_MAX_UPSTREAM_BODY_BYTES,
+    DEFAULT_MAX_UPSTREAM_BODY_BYTES,
+  );
+  return positiveInt(payloadOptions?.maxBytes, environmentLimit);
+}
+
+function jsonPayload(value) {
+  const bodyText = JSON.stringify(value);
+  return { bodyText, bodyBytes: Buffer.byteLength(bodyText) };
+}
+
+function chatRequest(responsesBody, stream) {
+  const chatReq = responsesToChat(responsesBody);
+  chatReq.stream = Boolean(stream);
+  delete chatReq.max_tokens;
+  return chatReq;
+}
+
+function adjustedResponsesTarget(limit, responsesBytes, chatBytes) {
+  return Math.max(1, limit - (chatBytes - responsesBytes));
+}
+
+function partsHaveInlineImage(parts) {
+  return Array.isArray(parts) && parts.some((part) => Boolean(readResponsesImagePart(part)?.identity));
+}
+
+function bodyHasInlineImage(body) {
+  if (!Array.isArray(body?.input)) return false;
+  for (const item of body.input) {
+    if (readResponsesImagePart(item)?.identity) return true;
+    if (item?.type === "message" && partsHaveInlineImage(item.content)) return true;
+    const toolOutput = readResponsesToolOutputParts(item);
+    if (toolOutput && partsHaveInlineImage(toolOutput.parts)) return true;
+  }
+  return false;
+}
+
+function checkedChatPayload(chatReq, payload, limit, stage, adapted) {
+  enforceResponsesPayloadByteBudget(chatReq, {
+    ...payload,
+    adapted,
+    currentInputStart: 0,
+    overBudget: payload.bodyBytes > limit,
+    stage: stage === "chat" ? stage : `${stage}+chat`,
+    targetBytes: limit,
+  });
+  return { chatReq, ...payload, adapted, stage };
+}
+
+export async function prepareResponsesChatPayload(reqContext, {
+  payloadOptions = {},
+  signal,
+  stream = false,
+} = {}) {
+  const limit = configuredBodyLimit(payloadOptions);
+  let finalChatReq = chatRequest(reqContext.body, stream);
+  let finalChat = jsonPayload(finalChatReq);
+  const hasInlineImage = bodyHasInlineImage(reqContext.body);
+  if (!hasInlineImage && (finalChat.bodyBytes <= limit || !(reqContext.currentInputStart > 0))) {
+    return checkedChatPayload(finalChatReq, finalChat, limit, "chat", false);
+  }
+
+  let responsesPayload = jsonPayload(reqContext.body);
+  let adapted = false;
+  let stage = "chat";
+  if (hasInlineImage) {
+    const prepared = await prepareResponsesPayload(reqContext.body, {
+      ...payloadOptions,
+      currentInputStart: reqContext.currentInputStart,
+      maxBytes: adjustedResponsesTarget(limit, responsesPayload.bodyBytes, finalChat.bodyBytes),
+      signal,
+    });
+    responsesPayload = { bodyText: prepared.bodyText, bodyBytes: prepared.bodyBytes };
+    adapted = prepared.adapted;
+    stage = prepared.stage;
+    finalChatReq = chatRequest(reqContext.body, stream);
+    finalChat = jsonPayload(finalChatReq);
+  }
+
+  while (finalChat.bodyBytes > limit) {
+    if (!(reqContext.currentInputStart > 0)) break;
+    const targetBytes = adjustedResponsesTarget(
+      limit,
+      responsesPayload.bodyBytes,
+      finalChat.bodyBytes,
+    );
+    const bodyBeforeTrim = structuredClone(reqContext.body);
+    const responsesBeforeTrim = responsesPayload;
+    const trimmed = trimResponsesHistoryToByteBudget(reqContext.body, {
+      currentInputStart: reqContext.currentInputStart,
+      targetBytes,
+      initialBodyText: responsesPayload.bodyText,
+      initialBodyBytes: responsesPayload.bodyBytes,
+    });
+    if (!trimmed.adapted) break;
+    const candidateChatReq = chatRequest(reqContext.body, stream);
+    const candidateChat = jsonPayload(candidateChatReq);
+    if (candidateChat.bodyBytes >= finalChat.bodyBytes) {
+      reqContext.body = bodyBeforeTrim;
+      responsesPayload = responsesBeforeTrim;
+      break;
+    }
+    responsesPayload = trimmed;
+    finalChatReq = candidateChatReq;
+    finalChat = candidateChat;
+    adapted = true;
+    if (!stage.endsWith("+history")) stage += "+history";
+  }
+
+  return checkedChatPayload(finalChatReq, finalChat, limit, stage, adapted);
+}

package/src/responses-content.mjs

@@ -0,0 +1,86 @@
+export function isResponsesToolOutputItem(item) {
+  return item?.type === "function_call_output" || item?.type === "custom_tool_call_output";
+}
+
+const INLINE_IMAGE_DATA_URL = /^data:(image\/[a-z+.-]+);base64,(.+)$/i;
+
+export function canonicalInlineImageIdentity(dataUrl) {
+  if (typeof dataUrl !== "string") return null;
+  const match = INLINE_IMAGE_DATA_URL.exec(dataUrl);
+  if (!match) return null;
+  const canonicalMime = match[1].toLowerCase();
+  return match[1] === canonicalMime
+    ? dataUrl
+    : `data:${canonicalMime};base64,${match[2]}`;
+}
+
+function imageUrlAccessor(part) {
+  if (!part || !["input_image", "image_url"].includes(part.type)) return null;
+  if (typeof part.image_url === "string") return { owner: part, key: "image_url" };
+  if (part.image_url && typeof part.image_url === "object" && typeof part.image_url.url === "string") {
+    return { owner: part.image_url, key: "url" };
+  }
+  if (part.type === "image_url" && typeof part.url === "string") return { owner: part, key: "url" };
+  if (part.type === "image_url" && part.url && typeof part.url === "object" && typeof part.url.url === "string") {
+    return { owner: part.url, key: "url" };
+  }
+  return null;
+}
+
+export function readResponsesImagePart(part) {
+  const accessor = imageUrlAccessor(part);
+  if (accessor) {
+    return {
+      get dataUrl() {
+        return accessor.owner[accessor.key];
+      },
+      get identity() {
+        return canonicalInlineImageIdentity(accessor.owner[accessor.key]);
+      },
+      setDataUrl(value) {
+        if (typeof value !== "string" || accessor.owner[accessor.key] === value) return false;
+        accessor.owner[accessor.key] = value;
+        return true;
+      },
+    };
+  }
+
+  if (part?.type !== "image" || part.source?.type !== "base64" || typeof part.source.data !== "string") {
+    return null;
+  }
+  return {
+    get dataUrl() {
+      return `data:${part.source.media_type || "image/png"};base64,${part.source.data}`;
+    },
+    get identity() {
+      return canonicalInlineImageIdentity(`data:${part.source.media_type || "image/png"};base64,${part.source.data}`);
+    },
+    setDataUrl(value) {
+      const match = typeof value === "string" ? INLINE_IMAGE_DATA_URL.exec(value) : null;
+      if (!match) return false;
+      const mediaType = match[1].toLowerCase();
+      const data = match[2];
+      if (part.source.media_type === mediaType && part.source.data === data) return false;
+      part.source.media_type = mediaType;
+      part.source.data = data;
+      return true;
+    },
+  };
+}
+
+export function readResponsesToolOutputParts(item) {
+  if (!isResponsesToolOutputItem(item)) return null;
+  if (Array.isArray(item.output)) return { parts: item.output, commit: null };
+  if (typeof item.output !== "string" || !item.output.trim().startsWith("[")) return null;
+
+  try {
+    const parts = JSON.parse(item.output);
+    if (!Array.isArray(parts)) return null;
+    return {
+      parts,
+      commit: () => { item.output = JSON.stringify(parts); },
+    };
+  } catch {
+    return null;
+  }
+}

package/src/responses-handler.mjs

@@ -13,7 +13,8 @@ import {
   modelSupportsChatCompletions,
   resolveOpenAIModel,
 } from "./models.mjs";
-import { chatToResponses, forwardToChat, responsesToChat } from "./responses-bridge.mjs";
+import { chatToResponses, forwardToChat, responsesBodyUsesCustomTools } from "./responses-bridge.mjs";
+import { prepareResponsesChatPayload } from "./responses-chat-payload.mjs";
 import { proxyCopilotResponses } from "./responses-proxy.mjs";
 import { prepareResponsesRequest, rememberResponseHistory } from "./responses-request.mjs";
 import { status } from "./status.mjs";
@@ -41,11 +42,34 @@ function isResponsesOnlyModel(model) {
   return RESPONSES_ONLY_FALLBACK.has(model);
 }
 
+function cachedModelSupportsResponses(model) {
+  const endpoints = getCachedModelEndpoints(model);
+  return Array.isArray(endpoints)
+    && (endpoints.includes("/responses") || endpoints.includes("/v1/responses"));
+}
+
+function unsupportedCustomToolsError(model) {
+  const message = `Model ${model} has custom tool items that cannot be represented by Chat Completions, and cached endpoint metadata does not confirm Responses support`;
+  const error = new Error(message);
+  error.statusCode = 400;
+  error.code = "ccdx_custom_tools_require_responses";
+  error.jsonBody = {
+    error: {
+      message,
+      type: "invalid_request_error",
+      code: error.code,
+      model,
+    },
+  };
+  return error;
+}
+
 export function createResponsesHandler(options) {
   const {
     acquireRequest,
     chatCompletionsFn,
     openAIModelEnv,
+    responsesPayloadOptions,
     responsesFn,
     streamHandshakeTimeoutMs,
     streamIdleTimeoutMs,
@@ -69,7 +93,12 @@ export function createResponsesHandler(options) {
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
       console.log(status("info", `responses model=${requestedModel}${upstreamLog} stream=${!!parsed.stream}`));
-      if (requestedModel === CODEX_AUTO_REVIEW_MODEL || isResponsesOnlyModel(upstreamModel)) {
+      const usesCustomTools = responsesBodyUsesCustomTools(prepared.body);
+      const useNativeResponses = requestedModel === CODEX_AUTO_REVIEW_MODEL
+        || isResponsesOnlyModel(upstreamModel)
+        || (usesCustomTools && cachedModelSupportsResponses(upstreamModel));
+      if (usesCustomTools && !useNativeResponses) throw unsupportedCustomToolsError(upstreamModel);
+      if (useNativeResponses) {
         await proxyCopilotResponses(prepared, req, res, responsesFn, {
           signal: abort.signal,
           abort,
@@ -77,7 +106,12 @@ export function createResponsesHandler(options) {
           streamIdleTimeoutMs,
         });
       } else {
-        const chatReq = responsesToChat(prepared.body);
+        const chatPayload = await prepareResponsesChatPayload(prepared, {
+          payloadOptions: responsesPayloadOptions,
+          signal: abort.signal,
+          stream: parsed.stream,
+        });
+        const { chatReq, bodyText } = chatPayload;
         if (parsed.stream) {
           await forwardToChat(chatReq, async (event, data) => {
             if (!res.headersSent) res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
@@ -99,12 +133,11 @@ export function createResponsesHandler(options) {
             streamIdleTimeoutMs,
             chatCompletionsFn,
             releaseRequest,
+            bodyText,
           });
         } else {
-          chatReq.stream = false;
-          delete chatReq.max_tokens;
           try {
-            const upstream = await chatCompletionsFn({ ...chatReq, stream: false }, { signal: abort.signal });
+            const upstream = await chatCompletionsFn(chatReq, { signal: abort.signal, bodyText });
             releaseRequest();
             const data = await upstream.text();
             if (!upstream.ok) {