@bitkyc08/opencodex 2.56.0 → 2.58.0

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/google.ts

@@ -796,14 +796,14 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       // body, URL or credential.
       const requestedTextFormat = parsed.options.textFormat;
       if (requestedTextFormat) {
-        if (provider.googleMode === "cloud-code-assist") {
-          // Not implemented or verified by opencodex for the Cloud Code Assist envelope,
-          // including Claude models served through it. This is not a claim that the
-          // upstream cannot do it — silence would return unconstrained prose as success,
-          // which is the failure this fix exists to remove.
+        if (provider.googleMode === "cloud-code-assist" && !parsed.modelId.startsWith("gemini-")) {
+          // Not implemented by opencodex for non-Gemini models (including Claude)
+          // served through the Cloud Code Assist envelope. This is not a claim that
+          // the upstream cannot do it — silence would return unconstrained prose as success,
+          // which is the failure this refusal exists to prevent.
           throw new Error(
-            "google cloud-code-assist structured output is not implemented by opencodex — "
-            + "remove response_format or route this model through AI Studio or Vertex",
+            "google cloud-code-assist structured output is not implemented by opencodex for non-Gemini models — "
+            + "remove response_format or route this model through a direct provider",
           );
         }
         if (isImageCapableModel(parsed.modelId)) {

package/src/adapters/kiro/payload.ts

@@ -38,7 +38,12 @@ import {
   validateKiroConversationState,
   type KiroTurn,
 } from "./conversation";
-import { injectKiroThinkingTags, kiroNativeEffortField, KIRO_NATIVE_EFFORTS } from "./reasoning";
+import {
+  injectKiroThinkingTags,
+  kiroNativeEffortField,
+  kiroReasoningContent,
+  KIRO_NATIVE_EFFORTS,
+} from "./reasoning";
 import { kiroPayloadMessages, userContentText } from "./usage";
 import {
   kiroToolWireNames,
@@ -388,7 +393,11 @@ export function buildKiroPayload(
         assistantResponseMessage: {
           content: turn.content,
           ...(turn.toolUses.length > 0 ? { toolUses: turn.toolUses } : {}),
-          ...(turn.redactedReasoning ? { reasoningContent: { redactedContent: turn.redactedReasoning } } : {}),
+          // Replayed on the field it was received on: the GPT-5.6 signature is not base64 and is
+          // rejected when sent as `redactedContent`.
+          ...(turn.redactedReasoning
+            ? { reasoningContent: kiroReasoningContent(turn.redactedReasoning) }
+            : {}),
         },
       }
     : {
@@ -447,7 +456,12 @@ export function buildKiroPayload(
     if (!KIRO_NATIVE_EFFORTS.includes(effort)) {
       throw new Error(`Kiro ${normalizeKiroModelId(parsed.modelId)} does not support reasoning effort ${JSON.stringify(effort)}`);
     }
-    payload.additionalModelRequestFields = { [effortField]: { effort } };
+    // Model eligibility still owns unsupported-effort validation above; wire eligibility
+    // is narrower for luna/terra, whose unverified rungs retain the thinking-tag path.
+    const verifiedEffortField = kiroNativeEffortField(parsed.modelId, effort);
+    if (verifiedEffortField) {
+      payload.additionalModelRequestFields = { [verifiedEffortField]: { effort } };
+    }
   }
   if (profileArn) payload.profileArn = profileArn;
   return { payload, nameMap, conversationId, completionMode };

package/src/adapters/kiro/reasoning.ts

@@ -4,21 +4,46 @@ import type { OcxParsedRequest } from "../../types";
 export type KiroReasoningMode = "native" | "emulated";
 
 // Kiro takes a verified native effort field for these models, and each model family names it
-// differently: the Sol-only `reasoning.effort` versus the Claude-specific `output_config.effort`.
-// Models absent from this table fall back to emulated thinking instructions.
+// differently: the GPT-5.6 family's `reasoning.effort` versus the Claude-specific
+// `output_config.effort`. Models absent from this table fall back to emulated thinking
+// instructions.
+//
+// The GPT-5.6 entries are measured against the live runtime rather than inferred from the vendor
+// schema: the field is accepted (HTTP 200) and the encrypted reasoning blob that comes back grows
+// with the effort. On one fixed hard prompt — a primality search plus a 20-bit recurrence count —
+// luna's blob measured 5,130 chars at `low`, 16,686 at `medium`, 30,670 at `high` and 48,594 at
+// `max`, against 13,118 with no effort signal at all; terra's measured 34,590 and 38,106 at native
+// `max` against 11,758 and 17,598 bare, two repetitions each. The channel this replaces — the
+// emulated `<thinking_mode>` tag block, which was all those models used to receive — measured
+// 21,202 (`low`) and 28,302 (`max`) for luna, i.e. between that model's native `medium` and
+// `high`, never reaching native `max`. `gpt-5.6-sol`'s native `max` cross-checked at 30,498 on the
+// same prompt. Terra's absence from this table was therefore an omission rather than a capability
+// difference: what the earlier Sol-only scope recorded was not reproducible here.
 export const KIRO_NATIVE_EFFORT_FIELDS: Record<string, "reasoning" | "output_config"> = {
   "gpt-5.6-sol": "reasoning",
+  "gpt-5.6-terra": "reasoning",
+  "gpt-5.6-luna": "reasoning",
   "claude-opus-5": "output_config",
 };
 
 export const KIRO_NATIVE_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
 
-export function kiroNativeEffortField(modelId: string): "reasoning" | "output_config" | undefined {
-  return KIRO_NATIVE_EFFORT_FIELDS[normalizeKiroModelId(modelId)];
+// The newly enabled models have evidence for these rungs only. Keep the previous
+// emulation for xhigh, and never widen their native wire when the shared ladder grows.
+const KIRO_LUNA_TERRA_NATIVE_EFFORTS = new Set(["low", "medium", "high", "max"]);
+
+export function kiroNativeEffortField(
+  modelId: string,
+  effort?: string,
+): "reasoning" | "output_config" | undefined {
+  const model = normalizeKiroModelId(modelId);
+  if ((model === "gpt-5.6-luna" || model === "gpt-5.6-terra")
+    && effort !== undefined && !KIRO_LUNA_TERRA_NATIVE_EFFORTS.has(effort)) return undefined;
+  return KIRO_NATIVE_EFFORT_FIELDS[model];
 }
 
-export function kiroReasoningMode(modelId: string): KiroReasoningMode {
-  return kiroNativeEffortField(modelId) ? "native" : "emulated";
+export function kiroReasoningMode(modelId: string, effort?: string): KiroReasoningMode {
+  return kiroNativeEffortField(modelId, effort) ? "native" : "emulated";
 }
 
 export function kiroThinkingBudget(parsed: OcxParsedRequest): number | undefined {
@@ -38,7 +63,7 @@ export function kiroThinkingBudget(parsed: OcxParsedRequest): number | undefined
 }
 
 export function injectKiroThinkingTags(content: string, parsed: OcxParsedRequest): string {
-  if (kiroReasoningMode(parsed.modelId) !== "emulated") return content;
+  if (kiroReasoningMode(parsed.modelId, parsed.options.reasoning) !== "emulated") return content;
   const budget = kiroThinkingBudget(parsed);
   if (!budget) return content;
   const instruction = [
@@ -54,3 +79,41 @@ export function injectKiroThinkingTags(content: string, parsed: OcxParsedRequest
     content,
   ].join("\n");
 }
+
+/**
+ * The blob from a Kiro `reasoningContentEvent` has two possible homes on a replayed assistant
+ * turn, and the wire validates the SHAPE of each rather than its content: `signature` takes the
+ * emitted string verbatim, while `redactedContent` is a base64 member. The `.KTR~~…` value every
+ * GPT-5.6 capture returns is NOT valid base64, which is exactly why replaying it as
+ * `redactedContent` — what this proxy did before the field was measured — came back as
+ * REQUEST_BODY_INVALID ("Improperly formed request").
+ *
+ * The blob travels as ONE opaque string: adapter event, `ocxr1:` reasoning envelope, then
+ * `OcxAssistantMessage.kiroRedactedReasoning`. The field it arrived on therefore rides that same
+ * string, instead of a second parallel value that could drift from it. Provider data cannot forge
+ * the tag: the other channel is base64, whose alphabet has no colon.
+ */
+export const KIRO_REASONING_SIGNATURE_TAG = "signature:";
+
+export function tagKiroReasoningBlob(field: "signature" | "redactedContent", data: string): string {
+  return field === "signature" ? KIRO_REASONING_SIGNATURE_TAG + data : data;
+}
+
+/** The wire field a stored blob arrived on, and its untagged value. */
+export function splitKiroReasoningBlob(value: string): { field: "signature" | "redactedContent"; data: string } {
+  return value.startsWith(KIRO_REASONING_SIGNATURE_TAG)
+    ? { field: "signature", data: value.slice(KIRO_REASONING_SIGNATURE_TAG.length) }
+    : { field: "redactedContent", data: value };
+}
+
+/**
+ * The `reasoningContent` object on an `assistantResponseMessage`. Exactly one member is set: the
+ * wire validates the shape, so the two cannot be substituted for each other.
+ */
+export type KiroReasoningContent = { signature: string } | { redactedContent: string };
+
+/** `reasoningContent` for a replayed `assistantResponseMessage`, carrying the blob verbatim. */
+export function kiroReasoningContent(value: string): KiroReasoningContent {
+  const { field, data } = splitKiroReasoningBlob(value);
+  return field === "signature" ? { signature: data } : { redactedContent: data };
+}

package/src/adapters/kiro/stream.ts

@@ -19,6 +19,7 @@ import { noteKiroTransientThrottle } from "../kiro-retry";
 import { KiroThinkingParser } from "../kiro-thinking";
 import { isCompleteKiroToolInput, kiroTruncationErrorMessage } from "../kiro-truncation";
 import { isValidKiroConversationId } from "../kiro-wire";
+import { tagKiroReasoningBlob } from "./reasoning";
 import { estimateKiroTokens, kiroUpstreamContextWindow } from "./usage";
 
 // Stream parsing (shared by parseStream + parseResponse)
@@ -633,8 +634,13 @@ async function* parseKiroAttemptEvents(
           if (ev.data) {
             yield* emitRetained(stage({ type: "reasoning_raw_delta", text: ev.data }));
           }
-          if (ev.redactedContent) {
-            yield* emitRetained(stage({ type: "kiro_redacted_reasoning", data: ev.redactedContent }));
+          // The blob is replayed on the field it arrived on, so remember that field here — this is
+          // the only place that still knows it. See kiro/reasoning.ts for why the distinction is
+          // load-bearing rather than cosmetic.
+          if (ev.signature) {
+            yield* emitRetained(stage({ type: "kiro_redacted_reasoning", data: tagKiroReasoningBlob("signature", ev.signature) }));
+          } else if (ev.redactedContent) {
+            yield* emitRetained(stage({ type: "kiro_redacted_reasoning", data: tagKiroReasoningBlob("redactedContent", ev.redactedContent) }));
           }
           break;
         case "context_usage":

package/src/adapters/kiro/wire.ts

@@ -1,5 +1,6 @@
 import type { OcxProviderConfig } from "../../types";
 import type { KiroImage } from "../kiro-images";
+import type { KiroReasoningContent } from "./reasoning";
 
 export const AMZ_TARGET = "AmazonCodeWhispererStreamingService.GenerateAssistantResponse";
 export const SDK_VERSION = "1.0.27";
@@ -51,7 +52,7 @@ export interface KiroHistoryEntry {
   assistantResponseMessage?: {
     content: string;
     toolUses?: KiroToolUse[];
-    reasoningContent?: { redactedContent: string };
+    reasoningContent?: KiroReasoningContent;
   };
 }
 

package/src/adapters/kiro-events.ts

@@ -3,7 +3,7 @@ import { kiroTruncationReason } from "./kiro-truncation";
 
 export type ParsedKiroEvent =
   | { type: "content"; data?: string; modelId?: string }
-  | { type: "reasoning"; data?: string; redactedContent?: string }
+  | { type: "reasoning"; data?: string; signature?: string; redactedContent?: string }
   | { type: "context_usage"; contextUsagePercentage: number }
   | { type: "tool"; name?: string; toolUseId?: string; input?: string; stop?: boolean }
   | { type: "truncation"; data: string }
@@ -138,18 +138,26 @@ export function parseKiroEvent(eventType: string, payload: Uint8Array): ParsedKi
           : {}),
       };
     case "reasoningContentEvent":
-      // `text` is plaintext reasoning; `redactedContent` is the encrypted blob the GPT-5.6 family
-      // (sol/terra/luna) actually returns — they never send `text`. Keyed off the wire field, not
-      // the model id. Both may be absent on a bare event.
-      return {
-        type: "reasoning",
-        ...(optionalString(eventType, parsed, "text") !== undefined
-          ? { data: optionalString(eventType, parsed, "text") }
-          : {}),
-        ...(optionalString(eventType, parsed, "redactedContent") !== undefined
-          ? { redactedContent: optionalString(eventType, parsed, "redactedContent") }
-          : {}),
-      };
+      // `text` is plaintext reasoning; the GPT-5.6 family (sol/terra/luna) instead returns an
+      // encrypted blob, and the field it arrives on has to be replayed unchanged (see
+      // kiro/reasoning.ts): `signature` carries the `.KTR~~…` value verbatim and is what every
+      // capture of those models sent, while `redactedContent` — the base64 shape a capture has
+      // never shown — stays accepted for any model that sends it. Keyed off the wire field, not the
+      // model id. Any of the three may be absent on a bare event.
+      {
+        const text = optionalString(eventType, parsed, "text");
+        const signature = optionalString(eventType, parsed, "signature");
+        const redacted = optionalString(eventType, parsed, "redactedContent");
+        return {
+          type: "reasoning",
+          ...(text !== undefined ? { data: text } : {}),
+          ...(signature !== undefined
+            ? { signature }
+            : redacted !== undefined
+              ? { redactedContent: redacted }
+              : {}),
+        };
+      }
     case "toolUseEvent":
       return {
         type: "tool",

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;

package/src/adapters/ollama-native.ts

@@ -306,17 +306,37 @@ function buildNativeMessages(
   // owned by this adapter/request lifecycle rather than process-global state.
   reservedToolCallIds.clear();
   let pending: PendingToolBatch | undefined;
+  // Codex records mid-turn injections (a PostToolUse hook verdict, a context notice) between an
+  // assistant tool call and that call's own tool result. Native Ollama needs the call and its
+  // results adjacent, so those conversational messages wait here instead of closing the batch
+  // early. The openai-chat adapter defers them the same way; refusing the replay killed the turn.
+  let deferred: OllamaNativeMessage[] = [];
+
+  const releaseDeferred = (): void => {
+    if (deferred.length === 0) return;
+    messages.push(...deferred);
+    deferred = [];
+  };
 
   const flushPending = (): void => {
     if (!pending) return;
     for (const call of pending.calls) {
       if (!call.result) {
-        throw new Error(`ollama-native tool call ${call.id} is missing its tool result; refusing interrupted replay`);
+        // No result exists anywhere in the replayed history: the turn was interrupted, or the
+        // result never reached it. State exactly that instead of inventing an outcome, and keep
+        // the conversation replayable.
+        messages.push({
+          role: "tool",
+          tool_call_id: call.id,
+          tool_name: call.wireName,
+          // Same marker text as the chat adapter (openai-chat/messages.ts), so both adapters read
+          // the same in an operator's log. The name is this wire's flattened tool name, which is
+          // what the assistant turn above it carries.
+          content: `[ocx] no tool result was recorded for "${call.wireName}"; execution status unknown — do not treat this as success, failure, or user-provided input.`,
+        });
+        continue;
       }
-    }
-    for (const call of pending.calls) {
-      const result = call.result!;
-      const translated = contentToNative(result.content, "tool result");
+      const translated = contentToNative(call.result.content, "tool result");
       messages.push({
         role: "tool",
         tool_call_id: call.id,
@@ -326,6 +346,7 @@ function buildNativeMessages(
       });
     }
     pending = undefined;
+    releaseDeferred();
   };
 
   for (const message of parsed.context.messages) {
@@ -347,9 +368,22 @@ function buildNativeMessages(
       continue;
     }
 
-    // Native Ollama requires the whole assistant tool-call turn followed by its tool results.  A
-    // new conversational message is a hard boundary; unresolved calls are never fabricated.
-    if (pending) flushPending();
+    // Native Ollama requires the whole assistant tool-call turn followed by its tool results. A
+    // conversational message that arrives while the batch is still open is held aside instead of
+    // closing it, so the call keeps its results adjacent; it is released right after the batch
+    // flushes. Anything else (a new assistant turn) settles the batch first.
+    if (pending) {
+      if (message.role === "user" || message.role === "developer") {
+        const translated = message.role === "user"
+          ? contentToNative(message.content, "user")
+          : contentToNative(message.content, "developer", false);
+        deferred.push(message.role === "user"
+          ? { role: "user", content: translated.content, ...(translated.images ? { images: translated.images } : {}) }
+          : { role: "system", content: translated.content });
+        continue;
+      }
+      flushPending();
+    }
 
     switch (message.role) {
       case "user": {