@opengeni/codex 0.2.2 → 0.2.5

package/dist/index.js

@@ -26,7 +26,7 @@ import {
   CODEX_RESPONSES_BASE,
   CODEX_TOKEN_URL,
   CODEX_WHAM_BASE
-} from "./chunk-KKKJKW6M.js";
+} from "./chunk-AMRVHBCD.js";
 
 // src/billing.ts
 function isCodexBilledModel(model) {
@@ -636,14 +636,18 @@ async function bufferCodexErrorResponse(res) {
   if (errorType === CODEX_USAGE_LIMIT_ERROR_TYPE) {
     headers.set("x-should-retry", "false");
   }
-  return new Response(bodyText, { status: res.status, statusText: res.statusText, headers });
+  return new Response(bodyText, {
+    status: res.status,
+    statusText: res.statusText,
+    headers
+  });
 }
 async function sseToJsonResponse(res) {
   const text = await res.text();
   let final = null;
+  let terminalError = null;
   const items = [];
-  for (const block of text.split("\n\n")) {
-    const data = block.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim()).join("\n");
+  for (const data of sseDataPayloads(text)) {
     if (!data || data === "[DONE]") {
       continue;
     }
@@ -651,12 +655,64 @@ async function sseToJsonResponse(res) {
       const ev = JSON.parse(data);
       if (ev.type === "response.output_item.done" && ev.item !== void 0) {
         items.push(ev.item);
-      } else if (ev.type === "response.completed" || ev.type === "response.done" || ev.type === "response.incomplete") {
+      } else if (ev.type === "response.failed") {
+        terminalError = codexSseFailureResponse(
+          res,
+          ev.response?.error,
+          "response_failed",
+          "The Codex response failed",
+          {
+            eventType: ev.type,
+            responseId: ev.response?.id,
+            responseStatus: ev.response?.status
+          }
+        );
+      } else if (ev.type === "error" || ev.type === "response.error") {
+        terminalError = codexSseFailureResponse(
+          res,
+          ev.error ?? ev.response?.error ?? ev,
+          "response_error",
+          "The Codex response stream reported an error",
+          {
+            eventType: ev.type,
+            responseId: ev.response?.id,
+            responseStatus: ev.response?.status
+          }
+        );
+      } else if (ev.type === "response.incomplete") {
+        const details = ev.response?.incomplete_details;
+        const reason = details && typeof details === "object" ? details.reason : void 0;
+        terminalError = codexSseFailureResponse(
+          res,
+          {
+            code: "response_incomplete",
+            message: typeof reason === "string" && reason.length > 0 ? `The Codex response was incomplete (${reason})` : "The Codex response was incomplete"
+          },
+          "response_incomplete",
+          "The Codex response was incomplete",
+          {
+            eventType: ev.type,
+            responseId: ev.response?.id,
+            responseStatus: ev.response?.status
+          }
+        );
+      } else if (ev.type === "response.completed" || ev.type === "response.done") {
         final = ev.response ?? null;
       }
     } catch {
     }
   }
+  if (terminalError) {
+    return terminalError;
+  }
+  if (!final) {
+    return codexSseFailureResponse(
+      res,
+      null,
+      "invalid_sse_terminal",
+      "The Codex response stream ended without a terminal response"
+    );
+  }
   if (final && items.length > 0) {
     final = { ...final, output: items };
   }
@@ -668,64 +724,331 @@ async function sseToJsonResponse(res) {
   const headers = new Headers(res.headers);
   headers.set("content-type", "application/json");
   headers.delete("content-length");
-  return new Response(JSON.stringify(final ?? {}), { status: 200, headers });
+  return new Response(JSON.stringify(final), { status: 200, headers });
+}
+var NON_RETRYABLE_SSE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "bio_policy",
+  "context_length_exceeded",
+  "cyber_policy",
+  "insufficient_quota",
+  "invalid_prompt",
+  "usage_limit_reached"
+]);
+function sseDataPayloads(text) {
+  const payloads = [];
+  let dataLines = [];
+  const dispatch = () => {
+    if (dataLines.length > 0) payloads.push(dataLines.join("\n"));
+    dataLines = [];
+  };
+  for (const line of text.split(/\r\n|\r|\n/)) {
+    if (line === "") {
+      dispatch();
+      continue;
+    }
+    if (line === "data") {
+      dataLines.push("");
+      continue;
+    }
+    if (!line.startsWith("data:")) continue;
+    const value = line.slice(5);
+    dataLines.push(value.startsWith(" ") ? value.slice(1) : value);
+  }
+  dispatch();
+  return payloads;
+}
+var CODEX_TERMINAL_ERROR_FIELD_MAX_BYTES = 256;
+var CODEX_TERMINAL_ERROR_MESSAGE_MAX_BYTES = 4 * 1024;
+var CODEX_TERMINAL_ERROR_TRUNCATION_MARKER = "\u2026 [truncated]";
+function boundedTerminalErrorField(value, maxBytes) {
+  if (typeof value !== "string") return { truncated: false };
+  const encoder = new TextEncoder();
+  const encoded = encoder.encode(value);
+  if (encoded.byteLength <= maxBytes) return { value, truncated: false };
+  const markerBytes = encoder.encode(CODEX_TERMINAL_ERROR_TRUNCATION_MARKER).byteLength;
+  let prefixEnd = Math.max(0, maxBytes - markerBytes);
+  while (prefixEnd > 0 && (encoded[prefixEnd] & 192) === 128) {
+    prefixEnd -= 1;
+  }
+  return {
+    value: `${new TextDecoder().decode(encoded.subarray(0, prefixEnd))}${CODEX_TERMINAL_ERROR_TRUNCATION_MARKER}`,
+    truncated: true
+  };
+}
+function codexSseFailureResponse(source, rawError, fallbackCode, fallbackMessage, metadata = {}) {
+  const projection = codexSseFailureProjection(
+    source,
+    rawError,
+    fallbackCode,
+    fallbackMessage,
+    metadata
+  );
+  return new Response(JSON.stringify({ error: projection.error }), {
+    status: projection.status,
+    headers: projection.headers
+  });
+}
+function codexSseFailureProjection(source, rawError, fallbackCode, fallbackMessage, metadata = {}) {
+  const record = rawError && typeof rawError === "object" && !Array.isArray(rawError) ? rawError : {};
+  const typeField = boundedTerminalErrorField(record.type, CODEX_TERMINAL_ERROR_FIELD_MAX_BYTES);
+  const codeField = boundedTerminalErrorField(record.code, CODEX_TERMINAL_ERROR_FIELD_MAX_BYTES);
+  const messageField = boundedTerminalErrorField(
+    record.message ?? (typeof rawError === "string" ? rawError : void 0),
+    CODEX_TERMINAL_ERROR_MESSAGE_MAX_BYTES
+  );
+  const paramField = boundedTerminalErrorField(record.param, CODEX_TERMINAL_ERROR_FIELD_MAX_BYTES);
+  const eventTypeField = boundedTerminalErrorField(
+    metadata.eventType,
+    CODEX_TERMINAL_ERROR_FIELD_MAX_BYTES
+  );
+  const responseIdField = boundedTerminalErrorField(
+    metadata.responseId,
+    CODEX_TERMINAL_ERROR_FIELD_MAX_BYTES
+  );
+  const responseStatusField = boundedTerminalErrorField(
+    metadata.responseStatus,
+    CODEX_TERMINAL_ERROR_FIELD_MAX_BYTES
+  );
+  const providerType = typeField.value === "error" || typeField.value === "response.error" || typeField.value === "response.failed" ? void 0 : typeField.value;
+  const code = (codeField.value?.length ? codeField.value : void 0) ?? (providerType?.length ? providerType : void 0) ?? fallbackCode;
+  const diagnosticTruncated = typeField.truncated || codeField.truncated || messageField.truncated || paramField.truncated || eventTypeField.truncated || responseIdField.truncated || responseStatusField.truncated || Object.keys(record).some((key) => !["type", "code", "message", "param"].includes(key)) || rawError !== null && rawError !== void 0 && typeof rawError !== "string" && (typeof rawError !== "object" || Array.isArray(rawError));
+  const error = {
+    type: providerType?.length ? providerType : code,
+    code,
+    message: messageField.value?.length ? messageField.value : fallbackMessage,
+    ...paramField.value?.length ? { param: paramField.value } : {},
+    ...eventTypeField.value?.length ? { event_type: eventTypeField.value } : {},
+    ...responseIdField.value?.length ? { response_id: responseIdField.value } : {},
+    ...responseStatusField.value?.length ? { response_status: responseStatusField.value } : {},
+    ...diagnosticTruncated ? { diagnostic_truncated: true } : {}
+  };
+  const status = code === "rate_limit_exceeded" || code === "usage_limit_reached" || code === "insufficient_quota" ? 429 : NON_RETRYABLE_SSE_ERROR_CODES.has(code) ? 400 : 502;
+  const headers = new Headers(source.headers);
+  headers.set("content-type", "application/json");
+  headers.set(CODEX_TRANSPORT_ERROR_HEADER, "1");
+  headers.set("x-should-retry", "false");
+  headers.delete("content-length");
+  headers.delete("content-encoding");
+  return { status, error, headers };
+}
+var CodexStreamingTerminalError = class extends Error {
+  status;
+  code;
+  type;
+  eventType;
+  responseId;
+  responseStatus;
+  headers;
+  error;
+  constructor(projection, publicMessage) {
+    super(publicMessage);
+    this.name = "CodexStreamingTerminalError";
+    this.status = projection.status;
+    this.code = projection.error.code;
+    this.type = projection.error.type;
+    if (projection.error.event_type !== void 0) {
+      this.eventType = projection.error.event_type;
+    }
+    if (projection.error.response_id !== void 0) {
+      this.responseId = projection.error.response_id;
+    }
+    if (projection.error.response_status !== void 0) {
+      this.responseStatus = projection.error.response_status;
+    }
+    this.headers = projection.headers;
+    this.error = {
+      type: projection.error.type,
+      code: projection.error.code,
+      ...projection.error.event_type ? { event_type: projection.error.event_type } : {},
+      ...projection.error.response_id ? { response_id: projection.error.response_id } : {},
+      ...projection.error.response_status ? { response_status: projection.error.response_status } : {},
+      ...projection.error.diagnostic_truncated ? { diagnostic_truncated: true } : {}
+    };
+  }
+};
+function codexSseFailureError(source, rawError, fallbackCode, publicMessage, metadata = {}) {
+  return new CodexStreamingTerminalError(
+    codexSseFailureProjection(source, rawError, fallbackCode, publicMessage, metadata),
+    publicMessage
+  );
 }
 function repairCodexStream(res) {
   if (!res.body) {
-    return res;
+    const error = codexSseFailureError(
+      res,
+      null,
+      "invalid_sse_terminal",
+      "The Codex response stream ended without a terminal response"
+    );
+    const body = new ReadableStream({
+      start(controller) {
+        controller.error(error);
+      }
+    });
+    const headers2 = new Headers(res.headers);
+    headers2.delete("content-length");
+    return new Response(body, {
+      status: res.status,
+      statusText: res.statusText,
+      headers: headers2
+    });
   }
   const items = [];
   const decoder = new TextDecoder();
   const encoder = new TextEncoder();
   let buffer = "";
+  let successfulTerminalSeen = false;
+  const emitCompleteBlocks = (controller, final) => {
+    let boundary = findSseBlockBoundary(buffer, final);
+    while (boundary) {
+      const block = buffer.slice(0, boundary.start);
+      const separator = buffer.slice(boundary.start, boundary.end);
+      buffer = buffer.slice(boundary.end);
+      const patched = patchSseBlock(block, items, res);
+      successfulTerminalSeen ||= patched.successfulTerminal;
+      controller.enqueue(encoder.encode(`${patched.block}${separator}`));
+      boundary = findSseBlockBoundary(buffer, final);
+    }
+  };
   const transform = new TransformStream({
     transform(chunk, controller) {
       buffer += decoder.decode(chunk, { stream: true });
-      let idx = buffer.indexOf("\n\n");
-      while (idx !== -1) {
-        const block = buffer.slice(0, idx);
-        buffer = buffer.slice(idx + 2);
-        controller.enqueue(encoder.encode(`${patchSseBlock(block, items)}
-
-`));
-        idx = buffer.indexOf("\n\n");
-      }
+      emitCompleteBlocks(controller, false);
     },
     flush(controller) {
+      buffer += decoder.decode();
+      emitCompleteBlocks(controller, true);
       if (buffer.length > 0) {
-        controller.enqueue(encoder.encode(patchSseBlock(buffer, items)));
+        const patched = patchSseBlock(buffer, items, res);
+        successfulTerminalSeen ||= patched.successfulTerminal;
+        controller.enqueue(encoder.encode(patched.block));
+        buffer = "";
+      }
+      if (!successfulTerminalSeen) {
+        throw codexSseFailureError(
+          res,
+          null,
+          "invalid_sse_terminal",
+          "The Codex response stream ended without a terminal response"
+        );
       }
     }
   });
   const headers = new Headers(res.headers);
   headers.delete("content-length");
-  return new Response(res.body.pipeThrough(transform), { status: res.status, headers });
+  return new Response(res.body.pipeThrough(transform), {
+    status: res.status,
+    headers
+  });
+}
+function findSseBlockBoundary(value, final) {
+  for (let index = 0; index < value.length; index += 1) {
+    const firstEnd = sseLineEndingEnd(value, index, final);
+    if (firstEnd === null) continue;
+    const secondEnd = sseLineEndingEnd(value, firstEnd, final);
+    if (secondEnd !== null) {
+      return { start: index, end: secondEnd };
+    }
+    index = firstEnd - 1;
+  }
+  return null;
+}
+function sseLineEndingEnd(value, index, final) {
+  const current = value[index];
+  if (current === "\n") return index + 1;
+  if (current !== "\r") return null;
+  if (index + 1 < value.length) {
+    return value[index + 1] === "\n" ? index + 2 : index + 1;
+  }
+  return final ? index + 1 : null;
 }
-function patchSseBlock(block, items) {
-  const lines = block.split("\n");
+function patchSseBlock(block, items, source) {
+  const lines = block.split(/\r\n|\r|\n/);
   const dataStr = lines.filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim()).join("\n");
   if (!dataStr || dataStr === "[DONE]") {
-    return block;
+    return { block, successfulTerminal: false };
   }
   let ev;
   try {
     ev = JSON.parse(dataStr);
   } catch {
-    return block;
+    return { block, successfulTerminal: false };
   }
   if (ev.type === "response.output_item.done" && ev.item !== void 0) {
     items.push(ev.item);
-    return block;
+    return { block, successfulTerminal: false };
   }
-  if ((ev.type === "response.completed" || ev.type === "response.done" || ev.type === "response.incomplete") && ev.response) {
+  if (ev.type === "response.failed") {
+    throw codexSseFailureError(
+      source,
+      ev.response?.error,
+      "response_failed",
+      "The Codex response failed",
+      {
+        eventType: ev.type,
+        responseId: ev.response?.id,
+        responseStatus: ev.response?.status
+      }
+    );
+  }
+  if (ev.type === "error" || ev.type === "response.error") {
+    throw codexSseFailureError(
+      source,
+      ev.error ?? ev.response?.error ?? ev,
+      "response_error",
+      "The Codex response stream reported an error",
+      {
+        eventType: ev.type,
+        responseId: ev.response?.id,
+        responseStatus: ev.response?.status
+      }
+    );
+  }
+  if (ev.type === "response.incomplete") {
+    const details = ev.response?.incomplete_details;
+    const reason = details && typeof details === "object" ? details.reason : void 0;
+    throw codexSseFailureError(
+      source,
+      {
+        code: "response_incomplete",
+        message: typeof reason === "string" && reason.length > 0 ? `The Codex response was incomplete (${reason})` : "The Codex response was incomplete"
+      },
+      "response_incomplete",
+      "The Codex response was incomplete",
+      {
+        eventType: ev.type,
+        responseId: ev.response?.id,
+        responseStatus: ev.response?.status
+      }
+    );
+  }
+  if ((ev.type === "response.completed" || ev.type === "response.done") && ev.response) {
+    if (ev.response.status === "failed" || ev.response.status === "incomplete" || ev.response.error !== null && ev.response.error !== void 0) {
+      throw codexSseFailureError(
+        source,
+        ev.response.error,
+        ev.response.status === "incomplete" ? "response_incomplete" : "response_failed",
+        ev.response.status === "incomplete" ? "The Codex response was incomplete" : "The Codex response failed",
+        {
+          eventType: ev.type,
+          responseId: ev.response.id,
+          responseStatus: ev.response.status
+        }
+      );
+    }
     const out = ev.response.output;
     if ((!Array.isArray(out) || out.length === 0) && items.length > 0) {
       ev.response = { ...ev.response, output: items };
       const nonData = lines.filter((l) => !l.startsWith("data:"));
-      return [...nonData, `data: ${JSON.stringify(ev)}`].join("\n");
+      const lineEnding = block.match(/\r\n|\r|\n/)?.[0] ?? "\n";
+      return {
+        block: [...nonData, `data: ${JSON.stringify(ev)}`].join(lineEnding),
+        successfulTerminal: true
+      };
     }
+    return { block, successfulTerminal: true };
   }
-  return block;
+  return { block, successfulTerminal: false };
 }
 
 // src/mcp-sanitize.ts
@@ -894,6 +1217,412 @@ function codexAppsSanitizingFetch(base = globalThis.fetch, namespaceSink) {
     return new Response(sanitized, { status: res.status, statusText: res.statusText, headers });
   };
 }
+
+// src/oversized-image-card.ts
+var MODEL_TOOL_OUTPUT_OVERSIZED_IMAGE_CARD_DATA_URL = "data:image/png;base64,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";
+
+// src/model-output-truncation.ts
+var CODEX_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS = 1e4;
+var CODEX_TOOL_OUTPUT_SERIALIZATION_ALLOWANCE = 1.2;
+var DEFAULT_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS = CODEX_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS;
+var APPROX_BYTES_PER_TOKEN = 4;
+var TOKEN_TRUNCATION_MARKER = /…\d{1,12} tokens truncated…/u;
+var TOOL_RESULT_TYPES = /* @__PURE__ */ new Set([
+  "function_call_result",
+  "function_call_output",
+  "computer_call_result",
+  "custom_tool_call_output",
+  "shell_call_output",
+  "apply_patch_call_output"
+]);
+var STRUCTURAL_STRING_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "role",
+  "status",
+  "name",
+  "id",
+  "callId",
+  "call_id",
+  "namespace",
+  "detail",
+  "mimeType",
+  "media_type"
+]);
+var MODEL_TOOL_OUTPUT_MAX_DEPTH = 12;
+var MODEL_TOOL_OUTPUT_MAX_CONTAINER_ENTRIES = 255;
+var MODEL_TOOL_OUTPUT_MAX_TOTAL_ENTRIES = 2048;
+var MODEL_TOOL_OUTPUT_MAX_PROPERTY_KEY_BYTES = 256;
+var MODEL_TOOL_OUTPUT_MAX_STRUCTURAL_STRING_TOKENS = 64;
+var MODEL_TOOL_OUTPUT_STRUCTURAL_STRING_BUDGET_TOKENS = 1024;
+var MODEL_TOOL_OUTPUT_OPAQUE_PAYLOAD_MAX_BYTES = 8 * 1024 * 1024;
+var DEPTH_OMISSION_MARKER = "[OpenGeni omitted subtree: maximum structured tool-output depth exceeded]";
+var CYCLE_OMISSION_MARKER = "[OpenGeni omitted subtree: cyclic tool output]";
+var STRUCTURAL_STRING_OMISSION_MARKER = "[OpenGeni omitted structural string: structural budget exhausted]";
+var TEXT_FIELD_OMISSION_MARKER = /^\[omitted text field \d+ \.\.\.\]$/u;
+var TEXT_ITEMS_OMISSION_MARKER = /^\[omitted \d+ text items \.\.\.\]$/u;
+var STRUCTURAL_ENTRIES_OMISSION_MARKER = /^\[OpenGeni omitted \d+ structured (?:array items|object properties)\]$/u;
+var OPAQUE_PAYLOAD_OMISSION_MARKER = /^\[OpenGeni omitted (?:image|file|encrypted) payload: \d+ bytes exceeded the bounded model-input allowance\]$/u;
+var STRUCTURAL_PROPERTIES_MARKER_KEY = "__opengeni_omitted_properties__";
+function modelToolOutputSerializationBudgetTokens(policyTokens = DEFAULT_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS) {
+  return Math.ceil(Math.max(0, policyTokens) * CODEX_TOOL_OUTPUT_SERIALIZATION_ALLOWANCE);
+}
+function approximateTokenCount(value) {
+  return Math.ceil(Buffer.byteLength(value, "utf8") / APPROX_BYTES_PER_TOKEN);
+}
+function truncateMiddleWithTokenBudget(value, maxTokens) {
+  if (value.length === 0) return value;
+  const maxBytes = Math.max(0, maxTokens) * APPROX_BYTES_PER_TOKEN;
+  const valueBytes = Buffer.byteLength(value, "utf8");
+  if (maxTokens > 0 && valueBytes <= maxBytes) return value;
+  const existingMarker = value.match(TOKEN_TRUNCATION_MARKER)?.[0];
+  if (existingMarker && valueBytes <= maxBytes + Buffer.byteLength(existingMarker, "utf8")) {
+    return value;
+  }
+  if (maxBytes === 0) {
+    return `\u2026${approximateTokenCount(value)} tokens truncated\u2026`;
+  }
+  const leftBudget = Math.floor(maxBytes / 2);
+  const rightBudget = maxBytes - leftBudget;
+  const bytes = Buffer.from(value, "utf8");
+  let leftEnd = Math.min(leftBudget, bytes.length);
+  while (leftEnd > 0 && leftEnd < bytes.length && isUtf8ContinuationByte(bytes[leftEnd])) {
+    leftEnd -= 1;
+  }
+  let rightStart = Math.max(0, bytes.length - rightBudget);
+  while (rightStart < bytes.length && isUtf8ContinuationByte(bytes[rightStart])) {
+    rightStart += 1;
+  }
+  const left = bytes.subarray(0, leftEnd).toString("utf8");
+  const right = bytes.subarray(rightStart).toString("utf8");
+  const removedBytes = Math.max(0, valueBytes - maxBytes);
+  const removedTokens = Math.ceil(removedBytes / APPROX_BYTES_PER_TOKEN);
+  return `${left}\u2026${removedTokens} tokens truncated\u2026${right}`;
+}
+function isUtf8ContinuationByte(value) {
+  return (value & 192) === 128;
+}
+function boundModelToolOutputItem(item, policyTokens = DEFAULT_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS) {
+  const type = typeof item.type === "string" ? item.type : "";
+  if (!TOOL_RESULT_TYPES.has(type)) return item;
+  const budget = modelToolOutputSerializationBudgetTokens(policyTokens);
+  const boundedOutput = boundToolOutputValue(item.output, budget);
+  return boundedOutput === item.output ? item : { ...item, output: boundedOutput };
+}
+function boundModelToolOutputItems(items, policyTokens = DEFAULT_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS) {
+  return items.map((item) => boundModelToolOutputItem(item, policyTokens));
+}
+function boundToolOutputValue(output, budgetTokens) {
+  const state = modelOutputBoundState(budgetTokens);
+  if (typeof output === "string") {
+    if (isGeneratedModelOutputMarker(output)) {
+      observeGeneratedMarkerBudget(output, state);
+      return output;
+    }
+    if (isImageDataUrl(output)) return boundOpaqueProtocolString(output, state, "image");
+    return truncateMiddleWithTokenBudget(output, budgetTokens);
+  }
+  if (Array.isArray(output)) {
+    const isProtocolContent = isResponsesProtocolContentPrefix(output);
+    return isProtocolContent ? boundStructuredOutputItems(output, state) : boundTextLeaves(output, state);
+  }
+  if (!output || typeof output !== "object") return output;
+  const record = output;
+  return boundTextLeaves(record, state);
+}
+function modelOutputBoundState(budgetTokens) {
+  return {
+    remaining: Math.max(0, budgetTokens),
+    remainingStructural: MODEL_TOOL_OUTPUT_STRUCTURAL_STRING_BUDGET_TOKENS,
+    remainingEntries: MODEL_TOOL_OUTPUT_MAX_TOTAL_ENTRIES,
+    remainingOpaqueBytes: MODEL_TOOL_OUTPUT_OPAQUE_PAYLOAD_MAX_BYTES,
+    opaqueOmissions: 0,
+    lastOpaqueOmissionMarker: null,
+    omitted: 0,
+    seen: /* @__PURE__ */ new WeakSet()
+  };
+}
+function boundStructuredOutputItems(items, state) {
+  let omitted = 0;
+  let changed = false;
+  const out = [];
+  let processed = 0;
+  const terminalStructuralMarker = items.length <= MODEL_TOOL_OUTPUT_MAX_CONTAINER_ENTRIES + 1 && isTypedStructuralArrayOmissionMarker(items.at(-1)) ? items.at(-1) : null;
+  let preservedTerminalStructuralMarker = false;
+  for (let index = 0; index < items.length; index += 1) {
+    const item = items[index];
+    if (processed >= MODEL_TOOL_OUTPUT_MAX_CONTAINER_ENTRIES || state.remainingEntries <= 0) {
+      if (terminalStructuralMarker && index <= items.length - 1) {
+        out.push(terminalStructuralMarker);
+        preservedTerminalStructuralMarker = true;
+      }
+      break;
+    }
+    processed += 1;
+    state.remainingEntries -= 1;
+    const record = item;
+    if (record.type === "input_text" && isGeneratedModelOutputMarker(record.text)) {
+      const bounded2 = boundTextLeaves(item, state, 1);
+      out.push(bounded2);
+      if (item === terminalStructuralMarker) preservedTerminalStructuralMarker = true;
+      if (bounded2 !== item) changed = true;
+      continue;
+    }
+    if (record.type === "input_text" && state.remaining === 0) {
+      omitted += 1;
+      changed = true;
+      continue;
+    }
+    const bounded = boundResponsesProtocolContentItem(record, state);
+    out.push(bounded);
+    if (item === terminalStructuralMarker) preservedTerminalStructuralMarker = true;
+    if (bounded !== item) changed = true;
+  }
+  if (omitted > 0) {
+    out.push({
+      type: "input_text",
+      text: `[omitted ${omitted} text items ...]`
+    });
+  }
+  const structurallyOmitted = preservedTerminalStructuralMarker ? 0 : items.length - processed;
+  if (structurallyOmitted > 0) {
+    out.push(typedStructuredArrayOmissionMarker(structurallyOmitted));
+    changed = true;
+  }
+  return changed ? out : items;
+}
+function boundResponsesProtocolContentItem(item, state) {
+  const opaqueOmissionsBefore = state.opaqueOmissions;
+  const bounded = boundTextLeaves(item, state, 1);
+  if (item.type === "input_image" && state.opaqueOmissions > opaqueOmissionsBefore) {
+    return {
+      type: "input_image",
+      imageUrl: MODEL_TOOL_OUTPUT_OVERSIZED_IMAGE_CARD_DATA_URL
+    };
+  }
+  if (item.type === "input_file" && state.opaqueOmissions > opaqueOmissionsBefore) {
+    return typedProtocolTextMarker(
+      state.lastOpaqueOmissionMarker ?? "[OpenGeni omitted file payload: 0 bytes exceeded the bounded model-input allowance]"
+    );
+  }
+  return bounded;
+}
+function boundTextLeaves(value, state, depth = 0, opaqueKind = null) {
+  if (typeof value === "string") {
+    if (isGeneratedModelOutputMarker(value)) {
+      observeGeneratedMarkerBudget(value, state);
+      return value;
+    }
+    if (opaqueKind || isImageDataUrl(value)) {
+      return boundOpaqueProtocolString(value, state, opaqueKind ?? "image");
+    }
+    if (state.remaining === 0) {
+      state.omitted += 1;
+      return `[omitted text field ${state.omitted} ...]`;
+    }
+    const cost = approximateTokenCount(value);
+    if (cost <= state.remaining) {
+      state.remaining -= cost;
+      return value;
+    }
+    const bounded = truncateMiddleWithTokenBudget(value, state.remaining);
+    state.remaining = 0;
+    return bounded;
+  }
+  if (!value || typeof value !== "object") return value;
+  if (depth >= MODEL_TOOL_OUTPUT_MAX_DEPTH) return DEPTH_OMISSION_MARKER;
+  if (state.seen.has(value)) return CYCLE_OMISSION_MARKER;
+  state.seen.add(value);
+  if (Array.isArray(value)) {
+    const out2 = [];
+    let processed2 = 0;
+    let changed2 = false;
+    for (let index = 0; index < value.length; index += 1) {
+      const entry = value[index];
+      if (processed2 >= MODEL_TOOL_OUTPUT_MAX_CONTAINER_ENTRIES || state.remainingEntries <= 0) {
+        if (index === value.length - 1 && typeof entry === "string" && STRUCTURAL_ENTRIES_OMISSION_MARKER.test(entry)) {
+          out2.push(entry);
+        }
+        break;
+      }
+      processed2 += 1;
+      state.remainingEntries -= 1;
+      const bounded = boundTextLeaves(entry, state, depth + 1, opaqueKind);
+      out2.push(bounded);
+      if (bounded !== entry) changed2 = true;
+    }
+    const omitted2 = value.length - out2.length;
+    if (omitted2 > 0) {
+      out2.push(structuredEntriesOmissionMarker(omitted2, "array"));
+      changed2 = true;
+    }
+    state.seen.delete(value);
+    return changed2 ? out2 : value;
+  }
+  const record = value;
+  const recordOpaqueKind = nonTextProtocolKind(record.type) ?? opaqueKind;
+  const entries = Object.entries(record);
+  const out = {};
+  let processed = 0;
+  let omitted = 0;
+  let changed = false;
+  for (let index = 0; index < entries.length; index += 1) {
+    const [key, entry] = entries[index];
+    if (processed >= MODEL_TOOL_OUTPUT_MAX_CONTAINER_ENTRIES || state.remainingEntries <= 0) {
+      if (index === entries.length - 1 && isGeneratedStructuralMarkerProperty(key, entry)) {
+        out[key] = entry;
+        break;
+      }
+      omitted += entries.length - index;
+      break;
+    }
+    processed += 1;
+    state.remainingEntries -= 1;
+    if (Buffer.byteLength(key, "utf8") > MODEL_TOOL_OUTPUT_MAX_PROPERTY_KEY_BYTES) {
+      omitted += 1;
+      changed = true;
+      continue;
+    }
+    const childOpaqueKind = opaqueKindForChild(recordOpaqueKind, key);
+    if (typeof entry === "string" && childOpaqueKind) {
+      const bounded2 = boundTextLeaves(entry, state, depth + 1, childOpaqueKind);
+      out[key] = bounded2;
+      if (bounded2 !== entry) changed = true;
+      continue;
+    }
+    if (typeof entry === "string" && STRUCTURAL_STRING_KEYS.has(key)) {
+      const bounded2 = boundStructuralString(entry, state);
+      out[key] = bounded2;
+      if (bounded2 !== entry) changed = true;
+      continue;
+    }
+    const bounded = boundTextLeaves(entry, state, depth + 1, childOpaqueKind);
+    out[key] = bounded;
+    if (bounded !== entry) changed = true;
+  }
+  if (omitted > 0) {
+    out[uniqueStructuralMarkerKey(out)] = structuredEntriesOmissionMarker(omitted, "object");
+    changed = true;
+  }
+  state.seen.delete(value);
+  return changed ? out : value;
+}
+function boundStructuralString(value, state) {
+  if (isGeneratedModelOutputMarker(value)) {
+    observeGeneratedMarkerBudget(value, state);
+    return value;
+  }
+  if (state.remainingStructural === 0) return STRUCTURAL_STRING_OMISSION_MARKER;
+  const cost = approximateTokenCount(value);
+  const allowance = Math.min(
+    MODEL_TOOL_OUTPUT_MAX_STRUCTURAL_STRING_TOKENS,
+    state.remainingStructural
+  );
+  if (cost <= allowance) {
+    state.remainingStructural -= cost;
+    return value;
+  }
+  state.remainingStructural -= allowance;
+  return truncateMiddleWithTokenBudget(value, allowance);
+}
+function boundOpaqueProtocolString(value, state, kind) {
+  if (kind === "image" && value === MODEL_TOOL_OUTPUT_OVERSIZED_IMAGE_CARD_DATA_URL) {
+    state.remainingOpaqueBytes = 0;
+    return value;
+  }
+  const bytes = Buffer.byteLength(value, "utf8");
+  if (bytes <= state.remainingOpaqueBytes) {
+    state.remainingOpaqueBytes -= bytes;
+    return value;
+  }
+  state.remainingOpaqueBytes = 0;
+  if (kind === "image") {
+    state.opaqueOmissions += 1;
+    return MODEL_TOOL_OUTPUT_OVERSIZED_IMAGE_CARD_DATA_URL;
+  }
+  const marker = `[OpenGeni omitted ${kind} payload: ${bytes} bytes exceeded the bounded model-input allowance]`;
+  state.opaqueOmissions += 1;
+  state.lastOpaqueOmissionMarker = marker;
+  return marker;
+}
+function nonTextProtocolKind(value) {
+  if (value === "image" || value === "input_image" || value === "computer_screenshot") {
+    return "image";
+  }
+  if (value === "file" || value === "input_file") return "file";
+  if (value === "encrypted_content") return "encrypted";
+  return null;
+}
+function opaqueKindForChild(kind, key) {
+  if (!kind) return null;
+  const opaqueKeys = kind === "image" ? ["image", "image_url", "imageUrl", "file_id", "fileId", "id", "data", "url", "source"] : kind === "file" ? [
+    "file",
+    "file_data",
+    "fileData",
+    "file_url",
+    "fileUrl",
+    "file_id",
+    "fileId",
+    "id",
+    "data",
+    "url",
+    "content",
+    "source"
+  ] : ["encrypted_content", "content", "data"];
+  return opaqueKeys.includes(key) ? kind : null;
+}
+function structuredEntriesOmissionMarker(count, container) {
+  return `[OpenGeni omitted ${count} structured ${container === "array" ? "array items" : "object properties"}]`;
+}
+function typedProtocolTextMarker(text) {
+  return { type: "input_text", text };
+}
+function typedStructuredArrayOmissionMarker(count) {
+  return typedProtocolTextMarker(structuredEntriesOmissionMarker(count, "array"));
+}
+function isTypedStructuralArrayOmissionMarker(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return record.type === "input_text" && typeof record.text === "string" && STRUCTURAL_ENTRIES_OMISSION_MARKER.test(record.text) && record.text.includes("structured array items");
+}
+function isGeneratedModelOutputMarker(value) {
+  return typeof value === "string" && (value === DEPTH_OMISSION_MARKER || value === CYCLE_OMISSION_MARKER || value === STRUCTURAL_STRING_OMISSION_MARKER || TEXT_FIELD_OMISSION_MARKER.test(value) || TEXT_ITEMS_OMISSION_MARKER.test(value) || STRUCTURAL_ENTRIES_OMISSION_MARKER.test(value) || OPAQUE_PAYLOAD_OMISSION_MARKER.test(value));
+}
+function observeGeneratedMarkerBudget(value, state) {
+  if (TEXT_FIELD_OMISSION_MARKER.test(value) || TEXT_ITEMS_OMISSION_MARKER.test(value)) {
+    state.remaining = 0;
+  }
+  if (value === STRUCTURAL_STRING_OMISSION_MARKER) state.remainingStructural = 0;
+  if (OPAQUE_PAYLOAD_OMISSION_MARKER.test(value)) state.remainingOpaqueBytes = 0;
+}
+function isGeneratedStructuralMarkerProperty(key, value) {
+  return key.startsWith(STRUCTURAL_PROPERTIES_MARKER_KEY) && typeof value === "string" && STRUCTURAL_ENTRIES_OMISSION_MARKER.test(value);
+}
+function uniqueStructuralMarkerKey(record) {
+  let key = STRUCTURAL_PROPERTIES_MARKER_KEY;
+  let suffix = 1;
+  while (Object.hasOwn(record, key)) {
+    key = `${STRUCTURAL_PROPERTIES_MARKER_KEY}_${suffix}`;
+    suffix += 1;
+  }
+  return key;
+}
+function isResponsesProtocolContentPrefix(output) {
+  if (output.length === 0) return false;
+  const retainedPrefixLength = Math.min(output.length, MODEL_TOOL_OUTPUT_MAX_CONTAINER_ENTRIES);
+  for (let index = 0; index < retainedPrefixLength; index += 1) {
+    const item = output[index];
+    if (!item || typeof item !== "object" || Array.isArray(item)) return false;
+    const record = item;
+    if (record.type === "input_text" && typeof record.text === "string") continue;
+    if (record.type === "input_image") continue;
+    if (record.type === "input_file") continue;
+    return false;
+  }
+  return true;
+}
+function isImageDataUrl(value) {
+  return /^data:image\/[a-z0-9.+-]+;base64,/i.test(value);
+}
 export {
   CODEX_APPS_MCP_SERVER_ID,
   CODEX_APPS_MCP_SERVER_NAME,
@@ -915,6 +1644,7 @@ export {
   CODEX_MODEL_CONTEXT_WINDOW_TOKENS,
   CODEX_MODEL_EFFECTIVE_CONTEXT_WINDOW_TOKENS,
   CODEX_MODEL_ID_PREFIX,
+  CODEX_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS,
   CODEX_ORIGINATOR,
   CODEX_PROVIDER_BASE_URL,
   CODEX_PROVIDER_ID,
@@ -922,6 +1652,7 @@ export {
   CODEX_REFRESH_WINDOW_MS,
   CODEX_RESPONSES_BASE,
   CODEX_TOKEN_URL,
+  CODEX_TOOL_OUTPUT_SERIALIZATION_ALLOWANCE,
   CODEX_TRANSPORT_ERROR_HEADER,
   CODEX_USAGE_LIMIT_ERROR_TYPE,
   CODEX_WEEKLY_WINDOW_SECONDS,
@@ -929,8 +1660,15 @@ export {
   CodexDeviceError,
   CodexRefreshTransient,
   CodexReloginRequired,
+  CodexStreamingTerminalError,
+  DEFAULT_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS,
+  MODEL_TOOL_OUTPUT_OPAQUE_PAYLOAD_MAX_BYTES,
+  MODEL_TOOL_OUTPUT_OVERSIZED_IMAGE_CARD_DATA_URL,
   ToolNameMapper,
   accessTokenExpiry,
+  approximateTokenCount,
+  boundModelToolOutputItem,
+  boundModelToolOutputItems,
   buildCodexUsageWindowFromCache,
   buildModelResolver,
   classifyCodexUsageLimitError,
@@ -943,6 +1681,7 @@ export {
   fetchCodexUsage,
   isCodexBilledModel,
   isCodexTransportError,
+  modelToolOutputSerializationBudgetTokens,
   normalizeCodexRequestBody,
   normalizeCodexUsage,
   parseCodexUsageHeaders,
@@ -952,6 +1691,7 @@ export {
   remapToolCallRequestBody,
   sanitizeMcpJsonBody,
   sanitizeMcpSseBody,
-  startDeviceCode
+  startDeviceCode,
+  truncateMiddleWithTokenBudget
 };
 //# sourceMappingURL=index.js.map