codex-copilot-dx 0.4.41 → 0.4.43

package/src/responses-image-limit.mjs

@@ -0,0 +1,209 @@
+import { readResponsesImagePart, readResponsesToolOutputParts } from "./responses-content.mjs";
+
+export const MAX_UPSTREAM_IMAGES = 50;
+
+function isImagePart(part) {
+  return part && typeof part === "object"
+    && ["input_image", "image", "image_url"].includes(part.type);
+}
+
+function imageIdentity(part) {
+  if (!isImagePart(part)) return null;
+
+  const inlineIdentity = readResponsesImagePart(part)?.identity;
+  if (inlineIdentity) return { kind: "inline:data", value: inlineIdentity };
+
+  if (part.type === "image") {
+    const source = part.source;
+    if (typeof source?.url === "string") {
+      return { kind: `url:${part.detail || ""}`, value: source.url };
+    }
+  }
+
+  const raw = part.image_url ?? part.url;
+  const url = typeof raw === "string" ? raw : raw?.url;
+  if (typeof url === "string") {
+    const detail = part.detail ?? raw?.detail ?? "";
+    return { kind: `url:${detail}`, value: url };
+  }
+  if (typeof part.file_id === "string") {
+    return { kind: "file", value: part.file_id };
+  }
+  return null;
+}
+
+function markerPart(record, maxImages) {
+  const text = `[Earlier image omitted to stay within the upstream ${maxImages}-image request limit.]`;
+  if (record.kind === "message") {
+    return {
+      type: record.role === "assistant" ? "output_text" : "input_text",
+      text,
+    };
+  }
+  return { type: record.usesAnthropicParts ? "text" : "input_text", text };
+}
+
+function addPartContainer(records, refs, parts, options) {
+  if (!Array.isArray(parts)) return;
+  const record = {
+    parts,
+    kind: options.kind,
+    role: options.role,
+    commit: options.commit,
+    usesAnthropicParts: false,
+  };
+  let found = false;
+  for (let partIndex = 0; partIndex < parts.length; partIndex += 1) {
+    const part = parts[partIndex];
+    if (!isImagePart(part)) continue;
+    found = true;
+    if (part.type === "image") record.usesAnthropicParts = true;
+    refs.push({
+      record,
+      partIndex,
+      itemIndex: options.itemIndex,
+      identity: imageIdentity(part),
+    });
+  }
+  if (found) records.push(record);
+}
+
+function collectImages(inputItems) {
+  const records = [];
+  const refs = [];
+  const topLevelRecord = {
+    parts: inputItems,
+    kind: "top-level",
+    role: "user",
+    commit: null,
+    usesAnthropicParts: false,
+  };
+  let hasTopLevelImages = false;
+
+  for (let itemIndex = 0; itemIndex < inputItems.length; itemIndex += 1) {
+    const item = inputItems[itemIndex];
+    if (!item || typeof item !== "object") continue;
+
+    if (isImagePart(item)) {
+      hasTopLevelImages = true;
+      refs.push({
+        record: topLevelRecord,
+        partIndex: itemIndex,
+        itemIndex,
+        identity: imageIdentity(item),
+      });
+    }
+
+    if (item.type === "message") {
+      addPartContainer(records, refs, item.content, {
+        kind: "message",
+        role: item.role,
+        itemIndex,
+      });
+    }
+
+    const toolOutput = readResponsesToolOutputParts(item);
+    if (!toolOutput) continue;
+    addPartContainer(records, refs, toolOutput.parts, {
+      kind: "tool-output",
+      itemIndex,
+      commit: toolOutput.commit,
+    });
+  }
+
+  if (hasTopLevelImages) records.push(topLevelRecord);
+  return { records, refs };
+}
+
+function applyDrops(records, refs, dropped, maxImages) {
+  const droppedByRecord = new Map();
+  for (const refIndex of dropped) {
+    const ref = refs[refIndex];
+    let indexes = droppedByRecord.get(ref.record);
+    if (!indexes) {
+      indexes = new Set();
+      droppedByRecord.set(ref.record, indexes);
+    }
+    indexes.add(ref.partIndex);
+  }
+
+  for (const record of records) {
+    const indexes = droppedByRecord.get(record);
+    if (!indexes) continue;
+    const kept = record.parts.filter((_, index) => !indexes.has(index));
+    if (!kept.length && record.kind !== "top-level") kept.push(markerPart(record, maxImages));
+    record.parts.splice(0, record.parts.length, ...kept);
+    record.commit?.();
+  }
+}
+
+export function enforceResponsesImageLimit(inputItems, {
+  currentInputStart = 0,
+  maxImages = MAX_UPSTREAM_IMAGES,
+  beforeMutate = () => {},
+} = {}) {
+  const limit = Number.isFinite(maxImages) && maxImages > 0
+    ? Math.floor(maxImages)
+    : MAX_UPSTREAM_IMAGES;
+  if (!Array.isArray(inputItems)) {
+    return { total: 0, kept: 0, omitted: 0, duplicates: 0, historicalOmitted: 0, currentOmitted: 0 };
+  }
+
+  const { records, refs } = collectImages(inputItems);
+  if (refs.length <= limit) {
+    return { total: refs.length, kept: refs.length, omitted: 0, duplicates: 0, historicalOmitted: 0, currentOmitted: 0 };
+  }
+
+  const dropped = new Set();
+  const seenByKind = new Map();
+  const duplicateCandidates = [];
+  let kept = refs.length;
+  let duplicates = 0;
+
+  for (let index = refs.length - 1; index >= 0; index -= 1) {
+    const identity = refs[index].identity;
+    if (!identity) continue;
+    let seen = seenByKind.get(identity.kind);
+    if (!seen) {
+      seen = new Set();
+      seenByKind.set(identity.kind, seen);
+    }
+    if (seen.has(identity.value)) {
+      duplicateCandidates.push(index);
+    } else {
+      seen.add(identity.value);
+    }
+  }
+
+  duplicateCandidates.sort((left, right) => left - right);
+  for (const index of duplicateCandidates) {
+    if (kept <= limit) break;
+    dropped.add(index);
+    kept -= 1;
+    duplicates += 1;
+  }
+
+  for (let index = 0; index < refs.length && kept > limit; index += 1) {
+    if (dropped.has(index)) continue;
+    dropped.add(index);
+    kept -= 1;
+  }
+
+  let historicalOmitted = 0;
+  let currentOmitted = 0;
+  for (const index of dropped) {
+    if (refs[index].itemIndex >= currentInputStart) currentOmitted += 1;
+    else historicalOmitted += 1;
+  }
+  beforeMutate({ historicalOmitted, currentOmitted });
+  applyDrops(records, refs, dropped, limit);
+
+  return {
+    total: refs.length,
+    kept,
+    omitted: dropped.size,
+    duplicates,
+    historicalOmitted,
+    currentOmitted,
+  };
+}

package/src/responses-request.mjs

@@ -1,6 +1,8 @@
 import { responses as copilotResponses } from "./copilot.mjs";
 import { httpError } from "./http-transport.mjs";
+import { debugLog } from "./log.mjs";
 import { materializeResponseHistory, rememberResponseHistoryNode } from "./response-history.mjs";
+import { enforceResponsesImageLimit } from "./responses-image-limit.mjs";
 import { status } from "./status.mjs";
 
 function cloneJson(value) {
@@ -29,7 +31,24 @@ export function stripInternalResponsesInputFields(inputItems) {
 
 function responsesOutputItems(output) {
   if (!Array.isArray(output)) return [];
-  return output.filter((item) => item?.type === "message" || item?.type === "function_call");
+  return output.filter((item) => ["message", "function_call", "custom_tool_call"].includes(item?.type));
+}
+
+function isCompactedResponsesOutput(output) {
+  return Array.isArray(output) && output.some((item) => item?.type === "compaction");
+}
+
+function isSuccessfulCompactionResponse(response) {
+  if (!isCompactedResponsesOutput(response?.output)) return false;
+  if (Object.prototype.hasOwnProperty.call(response, "status") && response.status !== "completed") {
+    return false;
+  }
+  return response.object === "response.compaction" || response.status === "completed";
+}
+
+function replayableResponsesOutputItems(output) {
+  if (!Array.isArray(output)) return [];
+  return output.filter((item) => item && typeof item === "object");
 }
 
 function stripEncryptedReasoningValue(value, state) {
@@ -60,16 +79,21 @@ function isEncryptedReasoningInputItem(item) {
 export function sanitizeEncryptedReasoningRequest(reqContext) {
   const state = { changed: false };
   let body = cloneJson(reqContext.body);
+  let currentInputStart = reqContext.currentInputStart;
   if (Array.isArray(body.input)) {
     const input = [];
-    for (const item of body.input) {
+    let retainedBeforeCurrent = 0;
+    for (let index = 0; index < body.input.length; index += 1) {
+      const item = body.input[index];
       if (isEncryptedReasoningInputItem(item)) {
         state.changed = true;
         continue;
       }
       input.push(stripEncryptedReasoningValue(item, state));
+      if (Number.isFinite(currentInputStart) && index < currentInputStart) retainedBeforeCurrent += 1;
     }
     body.input = input;
+    if (Number.isFinite(currentInputStart)) currentInputStart = retainedBeforeCurrent;
   } else {
     body = stripEncryptedReasoningValue(body, state);
   }
@@ -82,6 +106,7 @@ export function sanitizeEncryptedReasoningRequest(reqContext) {
   return {
     ...reqContext,
     body,
+    currentInputStart,
     inputItems: Array.isArray(body.input) ? body.input : reqContext.inputItems,
     historyInputItems,
   };
@@ -127,8 +152,14 @@ export function sanitizeImageNamespaceCollisionRequest(reqContext) {
 export async function openCopilotResponse(reqContext, upstream = copilotResponses, options = {}) {
   let encryptedRetried = false;
   let imageNamespaceRetried = false;
+  let payloadPrepared = false;
   for (let attempt = 0; attempt < 3; attempt += 1) {
-    const resp = await upstream(reqContext.body, { signal: options.signal });
+    const resp = await upstream(reqContext.body, {
+      signal: options.signal,
+      currentInputStart: reqContext.currentInputStart,
+      payloadPrepared,
+    });
+    payloadPrepared = true;
     if (resp.ok) return { resp, reqContext };
 
     const errorText = await resp.text();
@@ -162,14 +193,30 @@ function isBuiltinImageTool(tool) {
 export function prepareResponsesRequest(reqBody, { mutate = false } = {}) {
   const body = mutate ? reqBody : cloneJson(reqBody);
   const currentInputItems = responsesInputItems(body.input, { clone: !mutate });
+  const currentInputRefs = new Set(
+    currentInputItems.filter((item) => item && typeof item === "object"),
+  );
   const previousId = body.previous_response_id;
+  let historyItems = [];
 
   if (previousId !== undefined && previousId !== null) {
-    body.input = [...materializeResponseHistory(previousId), ...currentInputItems];
+    historyItems = materializeResponseHistory(previousId);
+    body.input = [...historyItems, ...currentInputItems];
   } else {
     body.input = currentInputItems;
   }
 
+  let historyInputItems = currentInputItems;
+  const imageLimit = enforceResponsesImageLimit(body.input, {
+    currentInputStart: historyItems.length,
+    beforeMutate: ({ currentOmitted }) => {
+      if (currentOmitted > 0) historyInputItems = cloneJson(currentInputItems);
+    },
+  });
+  if (imageLimit.omitted > 0) {
+    debugLog(`responses image window total=${imageLimit.total} kept=${imageLimit.kept} omitted=${imageLimit.omitted} duplicates=${imageLimit.duplicates} historical=${imageLimit.historicalOmitted} current=${imageLimit.currentOmitted}`);
+  }
+
   delete body.previous_response_id;
   delete body.store;
   if (Array.isArray(body.tools)) {
@@ -177,24 +224,29 @@ export function prepareResponsesRequest(reqBody, { mutate = false } = {}) {
     if (!body.tools.length) delete body.tools;
   }
   stripInternalResponsesInputFields(body.input);
-  stripInternalResponsesInputFields(currentInputItems);
+  stripInternalResponsesInputFields(historyInputItems);
+  const retainedCurrentInputStart = body.input.findIndex((item) => currentInputRefs.has(item));
 
   return {
     body,
     inputItems: body.input,
+    currentInputStart: retainedCurrentInputStart < 0 ? body.input.length : retainedCurrentInputStart,
     historyParentId: previousId ?? null,
-    historyInputItems: currentInputItems,
+    historyInputItems,
     takeHistoryOwnership: mutate,
   };
 }
 
 export function rememberResponseHistory(reqContext, responseJson) {
   if (!responseJson?.id || !Array.isArray(reqContext?.historyInputItems || reqContext?.inputItems)) return;
-  const sourceInputItems = reqContext.historyInputItems || reqContext.inputItems;
-  const sourceOutputItems = responsesOutputItems(responseJson.output);
+  const compacted = isSuccessfulCompactionResponse(responseJson);
+  const sourceInputItems = compacted ? [] : reqContext.historyInputItems || reqContext.inputItems;
+  const sourceOutputItems = compacted
+    ? replayableResponsesOutputItems(responseJson.output)
+    : responsesOutputItems(responseJson.output);
   rememberResponseHistoryNode({
     id: responseJson.id,
-    parentId: reqContext.historyParentId,
+    parentId: compacted ? null : reqContext.historyParentId,
     inputItems: sourceInputItems,
     outputItems: sourceOutputItems,
     takeOwnership: reqContext.takeHistoryOwnership,