@bitkyc08/opencodex 2.57.0 → 2.58.0

package/src/adapters/cursor/text-toolcall.ts

@@ -0,0 +1,230 @@
+/**
+ * Quarantine textual pseudo tool-call markers that Cursor models emit inside
+ * `textDelta` instead of (or in addition to) real `toolCall*` frames.
+ *
+ * `#2305` only rewrote the display alias *inside* `[TOOL_CALL]…[ARGS]`. The
+ * marker still reached Codex/Claude as assistant text, which few-shot-mimics
+ * later calls as inert text and stalls multi-tool turns. This drain strips
+ * every complete marker from visible text and yields the parsed calls so the
+ * protobuf mapper can promote advertised names onto the real tool-call path.
+ *
+ * Incomplete markers (split across streaming deltas) stay in `pending` until
+ * the JSON object closes. Once the retained prefix exceeds the byte cap, the
+ * parser switches to a constant-space suppressed scan until the object closes.
+ */
+import { debugProviderDiagnostic } from "../../lib/debug";
+import { normalizeCursorWireName } from "./tool-naming";
+
+export const MAX_PENDING_TEXT_TOOLCALL_BYTES = 64 * 1024;
+const TOOL_CALL_OPEN = /\[TOOL_CALL\]/gi;
+
+export interface DrainedTextToolCall {
+  readonly name: string;
+  readonly args: string;
+}
+
+export interface SuppressedTextToolCallScan {
+  phase: "args-tag" | "json-start" | "json";
+  argsTagProgress: number;
+  depth: number;
+  inString: boolean;
+  escape: boolean;
+}
+
+export interface DrainTextToolCallsResult {
+  readonly text: string;
+  readonly pending: string;
+  readonly calls: readonly DrainedTextToolCall[];
+  readonly suppressed?: SuppressedTextToolCallScan;
+}
+
+function findJsonObjectEnd(source: string, start: number): number | undefined {
+  if (source[start] !== "{") return undefined;
+  let depth = 0;
+  let inString = false;
+  let escape = false;
+  for (let i = start; i < source.length; i++) {
+    const ch = source[i];
+    if (inString) {
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escape = true;
+        continue;
+      }
+      if (ch === "\"") inString = false;
+      continue;
+    }
+    if (ch === "\"") {
+      inString = true;
+      continue;
+    }
+    if (ch === "{") depth += 1;
+    else if (ch === "}") {
+      depth -= 1;
+      if (depth === 0) return i + 1;
+    }
+  }
+  return undefined;
+}
+
+function byteLength(text: string): number {
+  return new TextEncoder().encode(text).byteLength;
+}
+
+function newSuppressedScan(): SuppressedTextToolCallScan {
+  return {
+    phase: "args-tag",
+    argsTagProgress: 0,
+    depth: 0,
+    inString: false,
+    escape: false,
+  };
+}
+
+const ARGS_TAG = "[args]";
+
+function consumeSuppressedScan(
+  state: SuppressedTextToolCallScan,
+  source: string,
+  start = 0,
+): { readonly state?: SuppressedTextToolCallScan; readonly resumeAt: number } {
+  for (let i = start; i < source.length; i++) {
+    const ch = source[i] ?? "";
+    if (state.phase === "args-tag") {
+      const lower = ch.toLowerCase();
+      if (lower === ARGS_TAG[state.argsTagProgress]) {
+        state.argsTagProgress += 1;
+        if (state.argsTagProgress === ARGS_TAG.length) {
+          state.phase = "json-start";
+          state.argsTagProgress = 0;
+        }
+      } else {
+        state.argsTagProgress = lower === ARGS_TAG[0] ? 1 : 0;
+      }
+      continue;
+    }
+    if (state.phase === "json-start") {
+      if (/\s/.test(ch)) continue;
+      if (ch !== "{") {
+        debugProviderDiagnostic("cursor", "text-toolcall-invalid-arguments", {
+          reason: "arguments-did-not-start-with-object",
+        });
+        return { resumeAt: source.length };
+      }
+      state.phase = "json";
+      state.depth = 1;
+      continue;
+    }
+    if (state.inString) {
+      if (state.escape) {
+        state.escape = false;
+      } else if (ch === "\\") {
+        state.escape = true;
+      } else if (ch === "\"") {
+        state.inString = false;
+      }
+      continue;
+    }
+    if (ch === "\"") state.inString = true;
+    else if (ch === "{") state.depth += 1;
+    else if (ch === "}") {
+      state.depth -= 1;
+      if (state.depth === 0) return { resumeAt: i + 1 };
+    }
+  }
+  return { state, resumeAt: source.length };
+}
+
+function holdOrSuppress(hold: string, afterOpen: number): Pick<DrainTextToolCallsResult, "pending" | "suppressed"> {
+  if (byteLength(hold) <= MAX_PENDING_TEXT_TOOLCALL_BYTES) return { pending: hold };
+  const suppressed = newSuppressedScan();
+  const scanned = consumeSuppressedScan(suppressed, hold, afterOpen);
+  return scanned.state ? { pending: "", suppressed: scanned.state } : { pending: "" };
+}
+
+/**
+ * Fold `pending + chunk`, emit surrounding prose, and extract every complete
+ * `[TOOL_CALL]name[ARGS]{…}` block. Names are folded through
+ * `normalizeCursorWireName` so `mcp_opencodex-responses_*` display aliases
+ * become the advertised wire name before promotion.
+ */
+export function drainCursorTextToolCalls(
+  pending: string,
+  chunk: string,
+  suppressed?: SuppressedTextToolCallScan,
+): DrainTextToolCallsResult {
+  let combined = pending + chunk;
+  if (suppressed) {
+    const scanned = consumeSuppressedScan(suppressed, chunk);
+    if (scanned.state) return { text: "", pending: "", calls: [], suppressed: scanned.state };
+    combined = chunk.slice(scanned.resumeAt);
+  }
+  let cursor = 0;
+  let text = "";
+  const calls: DrainedTextToolCall[] = [];
+  const opener = new RegExp(TOOL_CALL_OPEN.source, TOOL_CALL_OPEN.flags);
+
+  while (cursor < combined.length) {
+    opener.lastIndex = cursor;
+    const match = opener.exec(combined);
+    if (!match || match.index === undefined) {
+      text += combined.slice(cursor);
+      return { text, pending: "", calls };
+    }
+
+    text += combined.slice(cursor, match.index);
+    const afterOpen = match.index + match[0].length;
+    const rest = combined.slice(afterOpen);
+    const argsTag = rest.match(/^([^\[\]]*)\[ARGS\]/i);
+    if (!argsTag) {
+      const hold = combined.slice(match.index);
+      return { text, calls, ...holdOrSuppress(hold, afterOpen - match.index) };
+    }
+
+    const name = argsTag[1]?.trim() ?? "";
+    let jsonStart = afterOpen + argsTag[0].length;
+    while (jsonStart < combined.length && /\s/.test(combined[jsonStart] ?? "")) jsonStart += 1;
+    if (jsonStart >= combined.length) {
+      const hold = combined.slice(match.index);
+      return { text, calls, ...holdOrSuppress(hold, afterOpen - match.index) };
+    }
+    if (combined[jsonStart] !== "{") {
+      debugProviderDiagnostic("cursor", "text-toolcall-invalid-arguments", {
+        reason: "arguments-did-not-start-with-object",
+        ...(name ? { toolName: normalizeCursorWireName(name) } : {}),
+      });
+      // No delimiter identifies where a non-JSON payload ends. Resume marker
+      // scanning after `[ARGS]`, while suppressing the malformed payload itself.
+      opener.lastIndex = jsonStart;
+      const nextMarker = opener.exec(combined);
+      if (!nextMarker || nextMarker.index === undefined) return { text, pending: "", calls };
+      cursor = nextMarker.index;
+      continue;
+    }
+
+    const jsonEnd = findJsonObjectEnd(combined, jsonStart);
+    if (jsonEnd === undefined) {
+      const hold = combined.slice(match.index);
+      return { text, calls, ...holdOrSuppress(hold, afterOpen - match.index) };
+    }
+
+    const args = combined.slice(jsonStart, jsonEnd);
+    try {
+      JSON.parse(args);
+      if (name.length > 0) {
+        calls.push({ name: normalizeCursorWireName(name), args });
+      }
+    } catch {
+      debugProviderDiagnostic("cursor", "text-toolcall-invalid-arguments", {
+        reason: "arguments-json-parse-failed",
+        ...(name ? { toolName: normalizeCursorWireName(name) } : {}),
+      });
+    }
+    cursor = jsonEnd;
+  }
+
+  return { text, pending: "", calls };
+}

package/src/adapters/cursor/thread-continuity.ts

@@ -158,3 +158,70 @@ export function cursorOverflowRemintCountForTests(): number {
   pruneOverflowRemints(now());
   return overflowRemintByScope.size;
 }
+
+/** Max next-turn conversation-id rotations after incomplete client-tool streams per retained scope. */
+export const CURSOR_INCOMPLETE_TOOL_REMINT_MAX = 3;
+export const CURSOR_INCOMPLETE_TOOL_REMINT_TTL_MS = CURSOR_OVERFLOW_REMINT_TTL_MS;
+export const CURSOR_INCOMPLETE_TOOL_REMINT_MAX_ENTRIES = CURSOR_OVERFLOW_REMINT_MAX_ENTRIES;
+
+type IncompleteToolRemintState = {
+  remintCount: number;
+  updatedAt: number;
+};
+
+const incompleteToolRemintByScope = new Map<string, IncompleteToolRemintState>();
+
+function pruneIncompleteToolRemints(at: number): void {
+  for (const [scopeKey, entry] of incompleteToolRemintByScope) {
+    if (at - entry.updatedAt > CURSOR_INCOMPLETE_TOOL_REMINT_TTL_MS) {
+      incompleteToolRemintByScope.delete(scopeKey);
+    }
+  }
+  while (incompleteToolRemintByScope.size > CURSOR_INCOMPLETE_TOOL_REMINT_MAX_ENTRIES) {
+    const oldest = incompleteToolRemintByScope.keys().next().value;
+    if (oldest === undefined) break;
+    incompleteToolRemintByScope.delete(oldest);
+  }
+}
+
+/** Incomplete-tool and overflow recovery share ownership scope, but keep independent budgets. */
+export function cursorIncompleteToolRemintScopeKey(
+  threadOwner: string | undefined,
+  identityScope?: string,
+): string | null {
+  return cursorOverflowRemintScopeKey(threadOwner, identityScope);
+}
+
+/** Record one incomplete-tool remint; returns false when the independent cap is exhausted. */
+export function recordCursorIncompleteToolRemint(scopeKey: string): boolean {
+  const at = now();
+  pruneIncompleteToolRemints(at);
+  const existing = incompleteToolRemintByScope.get(scopeKey);
+  if (existing && existing.remintCount >= CURSOR_INCOMPLETE_TOOL_REMINT_MAX) {
+    existing.updatedAt = at;
+    incompleteToolRemintByScope.delete(scopeKey);
+    incompleteToolRemintByScope.set(scopeKey, existing);
+    return false;
+  }
+  const entry = existing ?? { remintCount: 0, updatedAt: at };
+  entry.remintCount += 1;
+  entry.updatedAt = at;
+  incompleteToolRemintByScope.delete(scopeKey);
+  incompleteToolRemintByScope.set(scopeKey, entry);
+  pruneIncompleteToolRemints(at);
+  return true;
+}
+
+/** A clean turn replenishes this recovery without changing the overflow retry budget. */
+export function clearCursorIncompleteToolRemint(scopeKey: string): void {
+  incompleteToolRemintByScope.delete(scopeKey);
+}
+
+export function clearCursorIncompleteToolRemintForTests(): void {
+  incompleteToolRemintByScope.clear();
+}
+
+export function cursorIncompleteToolRemintCountForTests(): number {
+  pruneIncompleteToolRemints(now());
+  return incompleteToolRemintByScope.size;
+}

package/src/adapters/cursor/types.ts

@@ -11,6 +11,11 @@ export interface CursorRequestedModelParameter {
 
 export interface CursorRunRequest {
   modelId: string;
+  /**
+   * Normalized Cursor identity scope carried from request parsing so checkpoint
+   * observations stay scope-local. Transport metadata only; never serialized on the wire.
+   */
+  _cursorIdentityScope?: string;
   /** Cursor model-picker parameters encoded through AgentRunRequest.requested_model. */
   requestedModelParameters?: readonly CursorRequestedModelParameter[];
   /** Cursor Router optimization parameter; valid only while modelId is the `default` wire model. */

package/src/adapters/cursor.ts

@@ -3,7 +3,7 @@ import type { AdapterEvent, OcxProviderConfig } from "../types";
 import type { ProviderAdapter } from "./base";
 import { isTranslatorBudgetExceededError } from "../lib/translator-budget";
 import { cursorExecDeniedMessage, cursorRequestDeclaresFullAccess } from "./cursor/exec-policy";
-import { isCursorBenignCancelError, isCursorInvalidArgumentError, isCursorOverflowRemintCandidate, isCursorRootEnvelopeError, safeCursorErrorMessage, type CursorSizeContext } from "./cursor/cursor-errors";
+import { isCursorBenignCancelError, isCursorIncompleteToolCallMessage, isCursorInvalidArgumentError, isCursorOverflowRemintCandidate, isCursorRootEnvelopeError, safeCursorErrorMessage, type CursorSizeContext } from "./cursor/cursor-errors";
 import { cursorCheckpointModelAffinityId, inferCursorContextWindow, isCursorExternalWireModel } from "./cursor/discovery";
 import { createCursorKvStore, type CursorKvStore } from "./cursor/kv-store";
 import { mapCursorServerMessage } from "./cursor/message-mapper";
@@ -32,8 +32,11 @@ import { isDebugEnabled } from "../lib/debug-settings";
 import { createAdapterTierMetadata } from "../providers/fastwire";
 import { estimateTokens } from "../lib/token-estimate";
 import {
+  clearCursorIncompleteToolRemint,
+  cursorIncompleteToolRemintScopeKey,
   cursorOverflowRemintScopeKey,
   markCursorOverflowSurfaced,
+  recordCursorIncompleteToolRemint,
   recordCursorOverflowRemint,
   rememberCursorThreadConversation,
   shouldSkipCursorOverflowRemint,
@@ -99,11 +102,20 @@ function safeCursorTransportError(err: unknown, sizeContext?: CursorSizeContext)
  * estimate over the outgoing text vs the model's context window. Only used to keep
  * SMALL requests on the 429 class — unknown/large stays on the overflow mapping.
  */
-function cursorRequestSizeContext(request: { modelId: string; system: string[]; messages: { content: string }[] }): CursorSizeContext {
+function cursorRequestSizeContext(request: {
+  modelId: string;
+  _cursorIdentityScope?: string;
+  system: string[];
+  messages: { content: string }[];
+}): CursorSizeContext {
   const text = [...request.system, ...request.messages.map(message => message.content)].join("\n");
   return {
     estimatedInputTokens: estimateTokens(text, request.modelId),
-    contextWindow: inferCursorContextWindow(request.modelId),
+    // Prefers this identity scope's checkpoint `maxTokens` over the id heuristic
+    // so a plan-gated ceiling participates in the 0.5-window overflow vs 429 prior.
+    contextWindow: inferCursorContextWindow(request.modelId, {
+      identityScope: request._cursorIdentityScope,
+    }),
   };
 }
 
@@ -171,7 +183,10 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
         }
         const inheritedCheckpointRef = _parsed._providerContinuation?.cursor?.checkpointRef;
         const previousConversationId = _parsed._cursorConversationId;
-        let request = createCursorRequest(_parsed);
+        let request = {
+          ...createCursorRequest(_parsed),
+          _cursorIdentityScope: _parsed._cursorIdentityScope?.trim() || "local",
+        };
         requestSizeContext = cursorRequestSizeContext(request);
         // The builder may derive a stable provider id from the client thread when Responses state
         // is unavailable. Rekey only existing state; there is nothing to migrate on a fresh turn,
@@ -190,6 +205,7 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
         let completedNormally = false;
         let lastTransport: { captured?: Uint8Array } | undefined;
         let emittedClientTool = false;
+        let sawIncompleteToolCall = false;
         // Ordering proof for tool-suspended checkpoints: true only when the newest captured
         // checkpoint bytes arrived AFTER the turn emitted a client tool call, i.e. upstream
         // serialized its suspended-on-tool-call state. Only that snapshot can safely resume
@@ -332,6 +348,9 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
                },
              });
              for (const event of events) {
+                if (event.type === "error" && isCursorIncompleteToolCallMessage(event.message)) {
+                  sawIncompleteToolCall = true;
+                }
                 if (!guardsSettled()) {
                   if (event.type === "text_delta") {
                     guardHeld.push(event);
@@ -413,7 +432,10 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
         const remintConversationId = (failedConversationId: string) => {
           lastTransport = undefined;
           _parsed._cursorConversationId = undefined;
-          const next = createCursorRequest(_parsed, { forceFreshConversation: true });
+          const next = {
+            ...createCursorRequest(_parsed, { forceFreshConversation: true }),
+            _cursorIdentityScope: _parsed._cursorIdentityScope?.trim() || "local",
+          };
           rekeyContextUsage(failedConversationId, next.conversationId);
           _parsed._cursorConversationId = next.conversationId;
           // Persist recovery for store:false clients that send any stable Cursor thread owner, so
@@ -514,6 +536,34 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
             }
           }
         }
+        const incompleteToolRemintScopeKey =
+          _parsed._cursorIsolateConversation !== true
+          && request.contextUsageStoreCheckpoints !== false
+            ? cursorIncompleteToolRemintScopeKey(
+                cursorClientThreadOwner(_parsed),
+                _parsed._cursorIdentityScope,
+              )
+            : null;
+        // Incomplete-tool errors are streamed, not thrown. Do not retry this turn; rotate only
+        // the next turn's id. request-prepare currently isolates compaction, but adapter callers
+        // can bypass that upstream invariant, so checkpoint storage is the local isolation boundary.
+        if (sawIncompleteToolCall && incompleteToolRemintScopeKey) {
+          if (recordCursorIncompleteToolRemint(incompleteToolRemintScopeKey)) {
+            if (inheritedCheckpointRef) invalidateCursorCheckpoint(inheritedCheckpointRef);
+            debugProviderDiagnostic("cursor", "incomplete-tool-remint", {
+              wireModel: request.modelId,
+              conversationHash: request.conversationId.slice(0, 16),
+            });
+            remintConversationId(request.conversationId);
+          } else {
+            debugProviderDiagnostic("cursor", "incomplete-tool-remint-exhausted", {
+              wireModel: request.modelId,
+              conversationHash: request.conversationId.slice(0, 16),
+            });
+          }
+        } else if (!sawIncompleteToolCall && completedNormally && incompleteToolRemintScopeKey) {
+          clearCursorIncompleteToolRemint(incompleteToolRemintScopeKey);
+        }
         if (
           request.checkpointInvalidationReason
           && request.checkpointInvalidationReason !== "missing_ref"

package/src/adapters/google-http.ts

@@ -1,4 +1,7 @@
 import type { AdapterFetchContext, AdapterRequest } from "./base";
+import { createAdapterPhysicalSend } from "./physical-send";
+import type { SendClass } from "../lib/request-execution-budget";
+import type { AttemptRecoveryKind } from "../usage/log";
 import { isQuotaExhaustedBody, retryableGoogleStatus, safeGoogleHttpErrorMessage } from "./google-errors";
 import { repairGoogleInvalidRequestBody } from "./google-wire-compiler";
 import { normalizeUpstreamHttpErrorResponse, readDisplaySafeErrorPayloadText } from "./upstream-http-error";
@@ -8,6 +11,8 @@ import {
   fetchWithAttemptDeadline,
   retryBackoffDelayMs,
   sleepWithAbort,
+  SendBudgetExhaustedError,
+  isConnectionResetError,
 } from "../lib/upstream-retry";
 
 const GOOGLE_RETRY_ATTEMPTS = 3;
@@ -41,18 +46,30 @@ export async function fetchGoogleWithRetry(
 ): Promise<Response> {
   const repairInvalid400 = opts.repairInvalid400 ?? true;
   const timeoutMs = ctx.timeoutMs ?? 200_000;
-  const executor = ctx.executor ?? globalThis.fetch;
+  const send = createAdapterPhysicalSend(ctx);
   let lastError: unknown;
   let activeRequest = request;
   let compatibilityReplayUsed = false;
+  let pendingResponse: Response | undefined;
+  let retryDelayMs = 0;
+  let sendClass: SendClass = "transient";
+  let recovery: AttemptRecoveryKind | undefined;
   for (let attempt = 0; attempt < GOOGLE_RETRY_ATTEMPTS; attempt++) {
     if (ctx.abortSignal?.aborted) throw abortError(ctx.abortSignal);
     try {
-      const res = await fetchWithAttemptDeadline(activeRequest.url, {
-        method: activeRequest.method,
-        headers: activeRequest.headers,
-        body: activeRequest.body,
-      }, timeoutMs, ctx.abortSignal, ctx.stream, executor);
+      const res = await send({ url: activeRequest.url, sendClass, recovery,
+        beforeDispatch: async () => {
+          if (retryDelayMs > 0) await sleepWithAbort(retryDelayMs, ctx.abortSignal);
+          if (pendingResponse) cancelResponseBodyBestEffort(pendingResponse);
+          pendingResponse = undefined;
+        },
+        dispatch: executor => fetchWithAttemptDeadline(activeRequest.url, {
+          method: activeRequest.method, headers: activeRequest.headers, body: activeRequest.body,
+        }, timeoutMs, ctx.abortSignal, ctx.stream, executor),
+      });
+      retryDelayMs = 0;
+      sendClass = "transient";
+      recovery = undefined;
       if (res.status === 400 && repairInvalid400 && !compatibilityReplayUsed) {
         let payloadText = "";
         try {
@@ -64,7 +81,8 @@ export async function fetchGoogleWithRetry(
         if (repairedBody !== undefined) {
           compatibilityReplayUsed = true;
           activeRequest = { ...activeRequest, body: repairedBody };
-          cancelResponseBodyBestEffort(res);
+          pendingResponse = res;
+          sendClass = "repair";
           attempt--; // The changed-request replay is separate from transient retry accounting.
           continue;
         }
@@ -75,7 +93,7 @@ export async function fetchGoogleWithRetry(
       // A 429 may be a transient rate limit (retry) or hard quota exhaustion (do NOT retry —
       // it won't recover for hours and burns retries). Peek the body to tell them apart.
       if (res.status === 429) {
-        const peekTarget = ctx.returnRawErrors ? res.clone() : res;
+        const peekTarget = res.clone();
         const peek = await readDisplaySafeErrorPayloadText(peekTarget, ctx.abortSignal);
         if (isQuotaExhaustedBody(peek)) {
           return ctx.returnRawErrors ? res : normalizeUpstreamHttpErrorResponse(res, {
@@ -84,20 +102,27 @@ export async function fetchGoogleWithRetry(
           });
         }
       }
-      cancelResponseBodyBestEffort(res);
-      await sleepWithAbort(retryBackoffDelayMs(attempt, {
+      pendingResponse = res;
+      recovery = res.status === 429 ? "rate-limit-429" : "transient-5xx";
+      retryDelayMs = retryBackoffDelayMs(attempt, {
         baseDelayMs: GOOGLE_RETRY_BASE_MS,
         maxDelayMs: GOOGLE_RETRY_MAX_MS,
         headers: res.headers,
-      }), ctx.abortSignal);
+      });
     } catch (err) {
       if (ctx.abortSignal?.aborted) throw err;
+      if (err instanceof SendBudgetExhaustedError) {
+        if (pendingResponse) return ctx.returnRawErrors ? pendingResponse : normalizeFinalGoogleError(label, pendingResponse, ctx.abortSignal);
+        throw err;
+      }
       lastError = err;
       if (attempt === GOOGLE_RETRY_ATTEMPTS - 1) throw err;
-      await sleepWithAbort(retryBackoffDelayMs(attempt, {
+      sendClass = "transient";
+      recovery = isConnectionResetError(err) ? "connection-reset" : undefined;
+      retryDelayMs = retryBackoffDelayMs(attempt, {
         baseDelayMs: GOOGLE_RETRY_BASE_MS,
         maxDelayMs: GOOGLE_RETRY_MAX_MS,
-      }), ctx.abortSignal);
+      });
     }
   }
   throw lastError ?? new Error(`${label} fetch failed`);

package/src/adapters/mimo-free.ts

@@ -6,6 +6,8 @@ import { recordOwnedConfigPath } from "../lib/config-ownership";
 import type { OcxProviderConfig, OcxParsedRequest } from "../types";
 import { createOpenAIChatAdapter } from "./openai-chat";
 import type { ProviderAdapter, AdapterRequest, IncomingMeta } from "./base";
+import { createAdapterPhysicalSend } from "./physical-send";
+import { SendBudgetExhaustedError } from "../lib/upstream-retry";
 
 const BOOTSTRAP_URL = "https://api.xiaomimimo.com/api/free-ai/bootstrap";
 export const MIMO_CHAT_URL = "https://api.xiaomimimo.com/api/free-ai/openai/chat";
@@ -248,33 +250,46 @@ export function createMimoFreeAdapter(provider: OcxProviderConfig): ProviderAdap
     },
 
     async fetchResponse(request: AdapterRequest, ctx): Promise<Response> {
-      const response = await fetch(request.url, {
+      const send = createAdapterPhysicalSend(ctx);
+      const response = await send({ url: request.url, dispatch: executor => executor(request.url, {
         method: request.method,
         redirect: "manual",
         headers: request.headers as Record<string, string>,
         body: request.body,
         signal: ctx?.abortSignal,
-      });
+      }) });
 
       // Retry predicate: 401 (expired/invalid JWT) retries ONCE with a fresh token.
       // 403 is NOT retried — Xiaomi uses it for anti-abuse "Illegal access" and there is
       // no documented token-expiry signature that would mark a 403 as retryable.
       if (response.status === 401) {
-        // Drain the first response body before issuing the retry.
-        try { await response.body?.cancel(); } catch { /* already consumed */ }
-        resetMimoJwtCache();
-        const freshJwt = await getMimoJwt(ctx?.abortSignal);
-        const retryHeaders = {
-          ...(request.headers as Record<string, string>),
-          "Authorization": `Bearer ${freshJwt}`,
-        };
-        return fetch(request.url, {
-          method: request.method,
-          redirect: "manual",
-          headers: retryHeaders,
-          body: request.body,
-          signal: ctx?.abortSignal,
-        });
+        let retryHeaders = request.headers;
+        try {
+          return await send({ url: request.url, sendClass: "auth-recovery", recovery: "oauth-401",
+            beforeDispatch: async () => {
+              // Drain the first response body and refresh the JWT only after admission: a
+              // refused replay still returns THIS response to the caller, body intact.
+              // Draining comes first within the block because getMimoJwt issues its own
+              // network call and may throw, and the 401 body would then never be released.
+              try { void response.body?.cancel().catch(() => {}); } catch { /* already consumed */ }
+              resetMimoJwtCache();
+              const freshJwt = await getMimoJwt(ctx?.abortSignal);
+              retryHeaders = {
+                ...(request.headers as Record<string, string>),
+                "Authorization": `Bearer ${freshJwt}`,
+              };
+            },
+            dispatch: executor => executor(request.url, {
+              method: request.method,
+              redirect: "manual",
+              headers: retryHeaders,
+              body: request.body,
+              signal: ctx?.abortSignal,
+            }) });
+        } catch (error) {
+          if (error instanceof SendBudgetExhaustedError) return response;
+          throw error;
+        }
       }
 
       return response;