codex-copilot-dx 0.4.42 → 0.4.44

package/src/responses-bridge.mjs

@@ -2,11 +2,42 @@ import { randomUUID } from "node:crypto";
 import { chatCompletions } from "./copilot.mjs";
 import { webStreamLines } from "./stream.mjs";
 import { abortErrorStatusCode, isAbortLikeError } from "./http-transport.mjs";
+import {
+  incompleteUpstreamStream,
+  invalidUpstreamStream,
+  requireUpstreamEventStream,
+  ToolArgumentDeltaGuard,
+  upstreamChatStreamError,
+  withChatStreamUsage,
+} from "./stream-contract.mjs";
+import { isChatOutputDelta, markFirstOutput, markOutputTokens } from "./stream-performance.mjs";
 
 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 +50,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 +68,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 +143,13 @@ export function chatToResponses(chatResp, model) {
 
 export async function forwardToChat(chatReq, emitEvent, onDone, onError, options = {}) {
   delete chatReq.max_tokens;
+  const upstreamReq = withChatStreamUsage(chatReq);
+  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?.();
     }
@@ -130,9 +159,16 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
     return;
   }
   if (!resp.ok) {
-    await onError(resp.status, await resp.text());
+    await onError(resp.status, await resp.text(), undefined, resp);
     return;
   }
+  try {
+    await requireUpstreamEventStream(resp);
+  } catch (error) {
+    await onError(error.statusCode, error.message, error);
+    return;
+  }
+  options.onUpstreamResponse?.(resp);
   options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
   const respId = `resp_${uid()}`;
   let actualModel = chatReq.model || "unknown";
@@ -141,6 +177,13 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
   let nextOutputIndex = 0;
   let usage = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
   const toolCalls = new Map();
+  const toolArgumentGuard = new ToolArgumentDeltaGuard();
+  let performanceOutputSeen = false;
+  const markPerformanceOutput = () => {
+    if (performanceOutputSeen) return;
+    performanceOutputSeen = true;
+    markFirstOutput();
+  };
 
   await emitEvent("response.created", { response: { id: respId, object: "response", status: "in_progress", model: actualModel, output: [] } });
 
@@ -238,7 +281,16 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
       const data = line.slice(6).trim();
       if (data === "[DONE]") { await emitCompleted(); onDone(); return; }
       let parsed;
-      try { parsed = JSON.parse(data); } catch { continue; }
+      try {
+        parsed = JSON.parse(data);
+      } catch {
+        throw invalidUpstreamStream(
+          "Upstream Chat Completions SSE event contained invalid JSON",
+          "upstream_stream_json_invalid",
+        );
+      }
+      const upstreamError = upstreamChatStreamError(parsed);
+      if (upstreamError) throw upstreamError;
       if (parsed.model) actualModel = parsed.model;
       if (parsed.usage) {
         usage = {
@@ -248,9 +300,11 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
         };
         const cached = parsed.usage.prompt_tokens_details?.cached_tokens;
         if (cached) usage.input_tokens_details = { cached_tokens: cached };
+        markOutputTokens(usage.output_tokens);
       }
       const delta = parsed.choices?.[0]?.delta;
       if (!delta) continue;
+      if (isChatOutputDelta(delta)) markPerformanceOutput();
       if (delta.content) {
         const message = await ensureMessageItem();
         fullText += delta.content;
@@ -261,22 +315,24 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
           const { tool, created } = await ensureToolCall(tc);
           if (tc.id) tool.callId = tc.id;
           if (!created && tc.function?.name) tool.name += tc.function.name;
-          if (tc.function?.arguments) {
-            tool.arguments += tc.function.arguments;
+          const argumentDelta = tc.function?.arguments;
+          toolArgumentGuard.observe(tool.outputIndex, argumentDelta);
+          if (argumentDelta) {
+            tool.arguments += argumentDelta;
             await emitEvent("response.function_call_arguments.delta", {
               output_index: tool.outputIndex,
               item_id: tool.id,
-              delta: tc.function.arguments,
+              delta: argumentDelta,
             });
           }
         }
       }
     }
   } catch (e) {
-    const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(options.abort?.reason) : 502;
-    await onError(statusCode, e?.message || "upstream stream error");
+    const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(options.abort?.reason) : (e?.statusCode || 502);
+    await onError(statusCode, e?.message || "upstream stream error", e);
     return;
   }
-  await emitCompleted();
-  onDone();
+  const error = incompleteUpstreamStream("[DONE]");
+  await onError(error.statusCode, error.message, error);
 }

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,129 @@
+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";
+import { withChatStreamUsage } from "./stream-contract.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 stream ? withChatStreamUsage(chatReq) : 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);
+}