@opengeni/runtime 0.6.1 → 0.7.0

package/src/history-sanitizer.ts

@@ -84,7 +84,10 @@ function callIdOf(item: unknown): string | undefined {
   // (mirrors the SDK's getToolSearchProviderCallId: providerData.call_id ??
   // providerData.callId ?? call_id ?? callId). Harmless for other item kinds —
   // their ids never live there.
-  const provider = record.providerData as { call_id?: unknown; callId?: unknown } | null | undefined;
+  const provider = record.providerData as
+    | { call_id?: unknown; callId?: unknown }
+    | null
+    | undefined;
   if (provider && typeof provider === "object") {
     if (typeof provider.call_id === "string" && provider.call_id.length > 0) {
       return provider.call_id;
@@ -96,6 +99,98 @@ function callIdOf(item: unknown): string | undefined {
   return undefined;
 }
 
+/**
+ * Return the normalized local path from a sandbox `view_image` function call.
+ * Invalid/partial calls are deliberately ignored: the filter below only
+ * removes fully-paired calls whose replacement is known to be valid.
+ */
+function viewImagePathOf(item: unknown): string | undefined {
+  if (!item || typeof item !== "object") {
+    return undefined;
+  }
+  const record = item as { type?: unknown; name?: unknown; arguments?: unknown };
+  if (
+    record.type !== "function_call" ||
+    record.name !== "view_image" ||
+    typeof record.arguments !== "string"
+  ) {
+    return undefined;
+  }
+  try {
+    const parsed = JSON.parse(record.arguments) as { path?: unknown };
+    return typeof parsed.path === "string" && parsed.path.length > 0 ? parsed.path : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Remove superseded `view_image` call/result pairs for the SAME local path,
+ * retaining the newest fully-paired observation. A `view_image` result can be
+ * hundreds of kilobytes of base64. When a model re-opens the same attachment,
+ * replaying every older copy on each subsequent model call grows input
+ * quadratically and can trap a turn in context-compaction/requeue recovery.
+ *
+ * This is state-based rather than count-based: every distinct path is kept,
+ * and an older observation is removed only after a newer successful pair for
+ * that exact path exists. The reasoning items immediately attached to a
+ * removed call are removed with it, preserving Responses API item validity.
+ */
+export function elideSupersededViewImagePairs<T extends HistoryItem>(items: readonly T[]): T[] {
+  if (items.length === 0) {
+    return [];
+  }
+
+  const callIndexById = new Map<string, number>();
+  const resultIndexById = new Map<string, number>();
+  items.forEach((item, index) => {
+    const callId = callIdOf(item);
+    if (!callId) {
+      return;
+    }
+    if (itemType(item) === "function_call") {
+      callIndexById.set(callId, index);
+    } else if (
+      itemType(item) === "function_call_result" ||
+      itemType(item) === "function_call_output"
+    ) {
+      resultIndexById.set(callId, index);
+    }
+  });
+
+  const pairedByPath = new Map<string, Array<{ callIndex: number; resultIndex: number }>>();
+  for (const [callId, callIndex] of callIndexById) {
+    const path = viewImagePathOf(items[callIndex]);
+    const resultIndex = resultIndexById.get(callId);
+    if (!path || resultIndex === undefined || resultIndex <= callIndex) {
+      continue;
+    }
+    const pairs = pairedByPath.get(path) ?? [];
+    pairs.push({ callIndex, resultIndex });
+    pairedByPath.set(path, pairs);
+  }
+
+  const dropped = new Set<number>();
+  for (const pairs of pairedByPath.values()) {
+    if (pairs.length < 2) {
+      continue;
+    }
+    pairs.sort((left, right) => left.callIndex - right.callIndex);
+    for (const pair of pairs.slice(0, -1)) {
+      dropped.add(pair.callIndex);
+      dropped.add(pair.resultIndex);
+      for (let index = pair.callIndex - 1; index >= 0; index -= 1) {
+        if (itemType(items[index]) !== "reasoning") {
+          break;
+        }
+        dropped.add(index);
+      }
+    }
+  }
+
+  return dropped.size === 0 ? items.slice() : items.filter((_item, index) => !dropped.has(index));
+}
+
 /**
  * Sanitize a replayed history item list into a sequence the Responses API
  * accepts. Pure: returns a new array of the same item references in order,
@@ -220,9 +315,56 @@ export function sanitizeHistoryItemsForModel<T extends HistoryItem>(items: reado
   }
 
   if (dropped.size === 0) {
-    return items.slice();
+    return items.map(stripInternalResumeMarker);
+  }
+  return items.filter((_item, index) => !dropped.has(index)).map(stripInternalResumeMarker);
+}
+
+/**
+ * Internal marker stamping machine-generated resume/continuation messages
+ * (turn-resumed notices, goal continuations) so compaction housekeeping can
+ * recognize them in STORED history. Lives here (not context-compaction, which
+ * imports from this module) so the wire sanitizer below can strip it without
+ * an import cycle; context-compaction re-exports it.
+ */
+export const INTERNAL_RESUME_MESSAGE_MARKER = "opengeni_internal_resume";
+
+/**
+ * Remove the {@link INTERNAL_RESUME_MESSAGE_MARKER} providerData key from a
+ * single item before it reaches ANY model wire. Pure + non-mutating; returns
+ * the SAME reference when there is nothing to strip (keeping the common path
+ * byte-identical, mirroring {@link stripReasoningEncryptedContent}).
+ *
+ * WHY. The @openai/agents SDK serializes providerData keys verbatim into the
+ * request item, and strict Responses backends reject unknown per-item fields —
+ * observed in production as `400 Unknown parameter:
+ * 'input[N].opengeni_internal_resume'`, which deterministically failed every
+ * turn whose replayed history contained a marked resume message (the marker is
+ * durable in conversation truth, so retries could never succeed). Detection
+ * (isInternalResumeMessage) reads STORED items and also keeps a text-prefix
+ * fallback, so stripping at the wire degrades housekeeping gracefully and
+ * never the turn.
+ */
+export function stripInternalResumeMarker<T extends HistoryItem>(item: T): T {
+  const providerData = (item as Record<string, unknown>).providerData;
+  if (
+    !providerData ||
+    typeof providerData !== "object" ||
+    !(INTERNAL_RESUME_MESSAGE_MARKER in (providerData as Record<string, unknown>))
+  ) {
+    return item;
+  }
+  const { [INTERNAL_RESUME_MESSAGE_MARKER]: _dropped, ...rest } = providerData as Record<
+    string,
+    unknown
+  >;
+  const next: Record<string, unknown> = { ...(item as Record<string, unknown>) };
+  if (Object.keys(rest).length > 0) {
+    next.providerData = rest;
+  } else {
+    delete next.providerData;
   }
-  return items.filter((_item, index) => !dropped.has(index));
+  return next as T;
 }
 
 /**
@@ -263,9 +405,11 @@ export function stripReasoningEncryptedContent<T extends HistoryItem>(item: T):
   }
   const record = item as Record<string, unknown>;
   const providerData = record.providerData;
-  const providerHasBlob = !!providerData && typeof providerData === "object"
-    && ("encryptedContent" in (providerData as Record<string, unknown>)
-      || "encrypted_content" in (providerData as Record<string, unknown>));
+  const providerHasBlob =
+    !!providerData &&
+    typeof providerData === "object" &&
+    ("encryptedContent" in (providerData as Record<string, unknown>) ||
+      "encrypted_content" in (providerData as Record<string, unknown>));
   const topLevelHasBlob = "encrypted_content" in record;
   if (!providerHasBlob && !topLevelHasBlob) {
     // Nothing encrypted to strip — return the same reference (byte-identical).
@@ -290,9 +434,8 @@ export function stripReasoningEncryptedContent<T extends HistoryItem>(item: T):
  * a parse failure or a no-op returns the SAME string reference (so an unchanged
  * or non-codex run-state replays byte-for-byte).
  *
- * WHY (HOLE C — the run-state REPLAY paths). The approval-decision resume and the
- * items-mode run-state fallback replay the serialized RunState blob verbatim. That
- * blob round-trips `reasoning.encrypted_content` minted by the ChatGPT/Codex
+ * WHY (HOLE C — approval replay). An approval decision resumes the serialized
+ * RunState blob. That blob round-trips `reasoning.encrypted_content` minted by the ChatGPT/Codex
  * backend (bound to the freezing account/org — a foreign account 400s it) AND the
  * foreign `rs_…` reasoning ids the Responses backend validates (rejected once the
  * blob is gone). Unlike `session_history_items`, the blob carries NO per-item
@@ -368,7 +511,11 @@ export function stripReasoningIdentityFromSerializedRunState(serialized: string)
   //    protocol reasoning shape under `rawItem`.
   if (Array.isArray(root.generatedItems)) {
     for (const wrapper of root.generatedItems) {
-      if (wrapper && typeof wrapper === "object" && "rawItem" in (wrapper as Record<string, unknown>)) {
+      if (
+        wrapper &&
+        typeof wrapper === "object" &&
+        "rawItem" in (wrapper as Record<string, unknown>)
+      ) {
         scrubReasoning((wrapper as Record<string, unknown>).rawItem);
       }
     }
@@ -452,7 +599,11 @@ export function neutralizeToolSearchItemsInSerializedRunState(serialized: string
   neutralizeArray(root.originalInput);
   if (Array.isArray(root.generatedItems)) {
     for (const wrapper of root.generatedItems) {
-      if (wrapper && typeof wrapper === "object" && "rawItem" in (wrapper as Record<string, unknown>)) {
+      if (
+        wrapper &&
+        typeof wrapper === "object" &&
+        "rawItem" in (wrapper as Record<string, unknown>)
+      ) {
         neutralize((wrapper as Record<string, unknown>).rawItem);
       }
     }
@@ -490,7 +641,7 @@ export function neutralizeToolSearchItemsInSerializedRunState(serialized: string
  * call carrying `action:{type:"screenshot"}` AND `actions:[{type:"screenshot"}]`).
  *
  * Which singular do we keep? LIVE-PROVEN against the deployed Azure deployment
- * (gpt-5.5-2026-04-24): for gpt-5.5 the SDK serializes the GA computer tool as
+ * (gpt-5.6-sol-2026-04-24): for gpt-5.6-sol the SDK serializes the GA computer tool as
  * `{type:"computer"}` (not the legacy `computer_use_preview`), and that GA tool
  * accepts ONLY the batched plural `actions`. Probing all three shapes:
  *   - `action`-only  -> 400 "exactly one of action or actions" (STILL rejected)
@@ -538,7 +689,7 @@ export function normalizeComputerCallActions<T extends HistoryItem>(items: reado
  * payload from the item: when `actions` is present it emits BOTH
  * `{action: ..., actions: [...]}`, and when only `action` is present it emits
  * `action`-only. It can NEVER emit actions-only. Probed live against the
- * deployed Azure gpt-5.5-2026-04-24 GA computer tool (`{type:"computer"}`):
+ * deployed Azure gpt-5.6-sol-2026-04-24 GA computer tool (`{type:"computer"}`):
  *   - `action`-only  -> 400 "Computer call input must include exactly one of
  *                       `action` or `actions`." (rejected)
  *   - both           -> 400 same message (rejected)
@@ -573,12 +724,13 @@ export function rewriteComputerCallsToActionsOnly(body: unknown): boolean {
     if (record.type !== "computer_call") {
       continue;
     }
-    const existingActions = Array.isArray(record.actions) && (record.actions as unknown[]).length > 0
-      ? (record.actions as unknown[])
-      : undefined;
-    const actions = existingActions ?? (
-      record.action !== undefined && record.action !== null ? [record.action] : undefined
-    );
+    const existingActions =
+      Array.isArray(record.actions) && (record.actions as unknown[]).length > 0
+        ? (record.actions as unknown[])
+        : undefined;
+    const actions =
+      existingActions ??
+      (record.action !== undefined && record.action !== null ? [record.action] : undefined);
     if (actions === undefined) {
       // Neither action nor actions present: nothing to normalize.
       continue;
@@ -700,7 +852,7 @@ export function computerCallNormalizingFetch(base: FetchLike): FetchLike {
     // Match any request that mentions either `computer_call` (the action call) or
     // `computer_call_output` (the output/result item). Both strings begin with
     // `"computer_call` so a single prefix-substring check covers both.
-    if (init && typeof init.body === "string" && init.body.includes("\"computer_call")) {
+    if (init && typeof init.body === "string" && init.body.includes('"computer_call')) {
       try {
         const parsed = JSON.parse(init.body) as unknown;
         const changed1 = rewriteComputerCallsToActionsOnly(parsed);