@coseung2/opencodex 2.8.0-cs.15 → 2.8.0-cs.17

package/src/server/responses/core.ts

@@ -9,12 +9,14 @@ import {
 import { parseRequest } from "../../responses/parser";
 import { buildCompactV1Output, COMPACT_PROMPT, decodeCompactionSummary, extractCompactUserMessages } from "../../responses/compaction";
 import { FORWARD_HEADERS, sanitizeReasoningInputContent } from "../../adapters/openai-responses";
+import { XaiToolSchemaCompatibilityError } from "../../adapters/xai-tool-schema";
 import {
   expandPreviousResponseInput,
   previousResponseProviderState,
   previousResponseReplayFailure,
   rememberResponseState,
 } from "../../responses/state";
+import { bindTurnTerminationScope, rememberDeliveredFinalAnswer } from "../../responses/turn-termination";
 import { routeModel, type RouteResult } from "../../router";
 import {
   advanceComboAfterFailure,
@@ -100,11 +102,17 @@ import { resolveAdapter, resolveWireProtocolOverride } from "../adapter-resolve"
 import type { InboundWire } from "../../providers/registry";
 import { hasKeyPoolFailover, rotateProviderTransportOn429 } from "../../providers/key-failover";
 import { shouldAttemptImageTierRetry } from "../image-retry";
-import { resolveProviderTransport } from "../../providers/xai-transport";
+import { isXaiResponsesDestination, resolveProviderTransport } from "../../providers/xai-transport";
+import { isOpenCodeMuseResponses, resolveOpenCodeGoTransport } from "../../providers/opencode-go-transport";
+import { declaredNamespaceAliases } from "../../responses/namespace-aliases";
 import type { WsData } from "../ws-bridge";
 import { trackActiveTurnLease, trackStreamLifetime } from "../lifecycle";
 import { redactSecretString } from "../../lib/redact";
 import { readBoundedResponseBody } from "../../lib/bounded-body";
+import {
+  isRateLimitOrQuotaFailureMessage,
+  upstreamErrorMessageFromPayload,
+} from "../../lib/errors";
 import type { AdmissionLease } from "../../lib/admission";
 import { supportedLadderFor } from "../effort-policy";
 import { isThreadSpawnRequest } from "../effort-policy";
@@ -130,6 +138,7 @@ import {
 import {
   conversationIdFromResponsesRequest,
   normalizeLogConversationId,
+  sessionLaneIdFromRequest,
   sessionIdHeaderFromRequest,
 } from "../request-log-conversation";
 import type { AttemptRecoveryKind } from "../../usage/log";
@@ -152,12 +161,18 @@ import {
   createResponsesItemIdPayloadRewrite,
   hasResponsesItemIdRepair,
 } from "../responses-item-id-repair";
+import { createGrokResponsesSparseTerminalPayloadRewrite } from "../grok-responses-snapshot-repair";
 import {
   createImageGenCallRestoreRewrite,
   imageGenToolCallAliases,
   restoreImageGenCallsInJson,
 } from "../responses-image-gen-repair";
 import { composeSsePayloadRewrites, relaySseWithPayloadRewrite } from "../sse-payload-rewrite";
+import {
+  createXaiCustomToolPayloadRewrite,
+  restoreXaiCustomCallsInJson,
+  xaiResponsesCustomToolNames,
+} from "../../responses/xai-custom-tool-compat";
 import type { EffectiveSubagentRoster, SpawnAgentSurface } from "../../codex/catalog";
 
 import { buildToolBridgeMaps, collabSurface, injectDeveloperMessage, multiAgentGuidanceText } from "./collaboration";
@@ -252,8 +267,40 @@ async function shouldRetryCodexPoolAccountModel400(
 }
 
 /** Pre-stream quota/billing rejections that warrant one alternate-account attempt (#584). */
-function shouldRetryCodexPoolAccountQuota(response: Response): boolean {
-  return response.status === 429 || response.status === 402;
+function codexQuotaFailureMessage(body: string): string | undefined {
+  try {
+    const payload = JSON.parse(body) as unknown;
+    const canonical = upstreamErrorMessageFromPayload(payload);
+    if (canonical !== undefined) return canonical;
+    if (typeof payload === "string") return payload;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) return undefined;
+    const record = payload as Record<string, unknown>;
+    if (typeof record.message === "string") return record.message;
+    return typeof record.error === "string" ? record.error : undefined;
+  } catch {
+    // Plain-text gateways remain supported. Valid JSON is inspected only at recognized
+    // message fields so echoed request content elsewhere cannot trigger account cooldown.
+    return body;
+  }
+}
+
+export async function shouldRetryCodexPoolAccountQuota(
+  response: Response,
+  signal?: AbortSignal,
+): Promise<boolean> {
+  if (response.status === 402 || response.status === 429) return true;
+  if (response.status < 500 || response.status >= 600) return false;
+  try {
+    // Reject malformed UTF-8 instead of matching quota words around replacement characters.
+    const body = await readBoundedResponseBody(response.clone(), { signal, fatalUtf8: true });
+    const message = body.displaySafe && !body.truncated
+      ? codexQuotaFailureMessage(body.text)
+      : undefined;
+    return message !== undefined
+      && isRateLimitOrQuotaFailureMessage(message);
+  } catch {
+    return false;
+  }
 }
 
 interface CodexPoolAccountRetryArgs {
@@ -351,6 +398,19 @@ async function retryCodexPoolOnAlternateAccount(
     ) throw error;
   }
   if (retryAuthCtx?.kind !== "pool" && retryAuthCtx?.kind !== "main-pool") {
+    // A body-confirmed quota response may arrive under HTTP 5xx. Without an alternate,
+    // the ordinary terminal recorder sees only that wire status and would misclassify it
+    // as transient, leaving the exhausted account immediately selectable next turn.
+    if (outcomeStatus !== firstResponse.status && (outcomeStatus === 429 || outcomeStatus === 402)) {
+      recordCodexUpstreamOutcome(config, firstAuthCtx.accountId, outcomeStatus, {
+        ...codexQuotaOutcomeMeta(firstResponse),
+        threadId: req.headers.get("x-codex-parent-thread-id"),
+        modelId: route.modelId,
+        probeLeaseId: codexProbeLeaseId(firstAuthCtx),
+        probeQuotaScope: codexProbeQuotaScope(firstAuthCtx),
+        writerGeneration: firstAuthCtx.writerGeneration,
+      });
+    }
     return { kind: "no-alternate" };
   }
 
@@ -826,6 +886,7 @@ async function applyFinalRouteRequestNormalization(args: {
   }
   // Settle the wire once so logging, fast-mode, auth, and sidecars read the adapter
   // this request will actually use (#404).
+  route.provider = resolveOpenCodeGoTransport(route.provider, sessionLaneIdFromRequest(req.headers));
   route.provider = resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire);
   logCtx.model = route.modelId;
   logCtx.provider = route.providerName;
@@ -837,8 +898,11 @@ async function applyFinalRouteRequestNormalization(args: {
   // Virtual model rewriting: Pro aliases → base model + reasoning.mode="pro".
   applyOpenAiVirtualModel(parsed, route, logCtx);
 
-  // Fast mode override for OpenAI-routed models.
-  if (config.fastMode !== undefined && route.provider.adapter === "openai-responses") {
+  // Fast mode override for OpenAI-shaped routes. xAI OAuth's subscription Responses lane has no
+  // caller-owned Priority/Fast contract, so switching Grok to its native wire must not make a
+  // global OpenAI fastMode leak service_tier upstream.
+  const callerFastTierAllowed = !(route.providerName === "xai" && route.provider.authMode === "oauth");
+  if (config.fastMode !== undefined && route.provider.adapter === "openai-responses" && callerFastTierAllowed) {
     const tier = config.fastMode ? "priority" : undefined;
     if (parsed._rawBody && typeof parsed._rawBody === "object") {
       if (tier) (parsed._rawBody as Record<string, unknown>).service_tier = tier;
@@ -1278,6 +1342,7 @@ async function handleResponsesInner(
       cursorConversationId: parsed._cursorConversationId,
     });
   }
+  bindTurnTerminationScope(parsed, logCtx.conversationId);
   logCtx.requestedModel = parsed.modelId;
   logCtx.requestedEffort = parsed.options.reasoning;
   logCtx.requestedServiceTier = parsed.options.serviceTier;
@@ -1584,9 +1649,6 @@ async function handleResponsesInner(
   }
 
   if ("passthrough" in adapter && adapter.passthrough && !routedCompaction) {
-    const imageGenCallAliases = route.provider.authMode === "forward"
-      ? new Map<string, { namespace: string; name: string }>()
-      : imageGenToolCallAliases(toolBridgeMaps.toolNsMap, parsed._rawBody, translatorBudget);
     // Local continuation cache for the ChatGPT passthrough. Codex WS turns chain with
     // previous_response_id, ocx converts them to internal HTTP requests, and the ChatGPT Codex
     // REST backend rejects the parameter — the adapter strips it in forward mode, so the ONLY
@@ -1608,7 +1670,27 @@ async function handleResponsesInner(
         + `(model ${parsed.modelId}); forwarding without it — earlier turns may be missing from this request`,
       );
     }
-    let request = await adapter.buildRequest(parsed, { headers: selectedForwardHeaders, translatorBudget });
+    let request: Awaited<ReturnType<typeof adapter.buildRequest>>;
+    try {
+      request = await adapter.buildRequest(parsed, { headers: selectedForwardHeaders, translatorBudget });
+    } catch (error) {
+      releaseCodexAuthContextProbeLease(authCtx);
+      if (error instanceof XaiToolSchemaCompatibilityError) {
+        return formatErrorResponse(400, "invalid_request_error", redactSecretString(error.message));
+      }
+      throw error;
+    }
+    const xaiCustomToolNames = isXaiResponsesDestination(route.provider)
+      ? xaiResponsesCustomToolNames(parsed._rawBody)
+      : new Set<string>();
+    // Reuse the existing client-only namespace rewrite and its bounded SSE relay. The
+    // inspection/cache branch retains raw names for continuation replay. Resolve all
+    // declaration ownership before admitting a Muse dotted alias.
+    const imageGenCallAliases = route.provider.authMode === "forward"
+      ? new Map<string, { namespace: string; name: string }>()
+      : isOpenCodeMuseResponses(parsed.modelId, request.url)
+        ? declaredNamespaceAliases(parsed.context.tools ?? [], translatorBudget)
+        : imageGenToolCallAliases(toolBridgeMaps.toolNsMap, parsed._rawBody, translatorBudget);
     recordAdapterReasoning(logCtx, request);
     const passthroughEstimate = typeof request.usageLog?.inputTokens === "number"
       ? request.usageLog.inputTokens
@@ -1663,6 +1745,66 @@ async function handleResponsesInner(
       request.releaseBodyObservation?.();
     }
 
+    // Native Responses providers return from this passthrough branch before the generic recovery
+    // loop below. Preserve the same OAuth contract here: one pre-stream 401 forces one credential
+    // refresh and one rebuilt replay. This is required for xAI now that Grok 4.6/4.5 subscription
+    // traffic uses the provider's native Responses wire.
+    if (upstreamResponse.status === 401 && isOAuth401ReplayProvider && sentOAuthSnapshot) {
+      try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* already consumed */ }
+      let refreshed: OAuthAccessSnapshot;
+      try {
+        refreshed = await forceRefreshOAuthAccessSnapshot(sentOAuthSnapshot);
+      } catch (err) {
+        upstream.abort();
+        releaseCodexAuthContextProbeLease(authCtx);
+        return formatErrorResponse(401, "authentication_error", publicOAuthAuthenticationErrorMessage(err));
+      }
+      sentOAuthSnapshot = refreshed;
+      if (route.providerName === "kiro") parsed._kiroAuthContext = { ...(refreshed.kiro ?? {}) };
+      const refreshedProvider = resolveProviderTransport(
+        route.providerName,
+        { ...route.provider, apiKey: refreshed.accessToken },
+        parsed.options.promptCacheKey,
+        route.providerName === "github-copilot" ? getOAuthCredentialApiBaseUrl(route.providerName) : undefined,
+      );
+      route.provider = refreshedProvider;
+      const refreshedAdapter = resolveAdapter(
+        resolveWireProtocolOverride(route.providerName, route.modelId, refreshedProvider, inboundWire),
+        config.cacheRetention,
+      );
+      if (!("passthrough" in refreshedAdapter) || !refreshedAdapter.passthrough) {
+        upstream.abort();
+        return formatErrorResponse(502, "upstream_error", "OAuth refresh changed the provider wire unexpectedly");
+      }
+      logCtx.providerAdapter = refreshedAdapter.name;
+      sealRequestAttemptIdentity(logCtx.activeAttempt, logCtx.provider, refreshedAdapter.name, logCtx.accountLogLabel);
+      try {
+        request = await refreshedAdapter.buildRequest(parsed, { headers: selectedForwardHeaders, translatorBudget });
+        recordAdapterReasoning(logCtx, request);
+      } catch (err) {
+        upstream.abort();
+        if (options.abortSignal?.aborted) return clientCancelledResponse();
+        return formatErrorResponse(400, "invalid_request_error", redactSecretString(err instanceof Error ? err.message : String(err)));
+      }
+      try {
+        upstreamResponse = await fetchWithTransientRetry(
+          recovery => {
+            noteAttemptSend(logCtx.activeAttempt, passthroughEstimate, recovery ?? "oauth-401");
+            return fetchWithHeaderTimeout(request.url, applyUpstreamRecoveryInit({
+              method: request.method,
+              headers: request.headers,
+              body: request.body,
+            }, recovery), upstream.signal, connectMs, parsed.stream, providerFetch(route.provider, options.codexWsRuntimeIdentity));
+          },
+          { abortSignal: upstream.signal, label: safeHostLabel(request.url) },
+        );
+      } catch (err) {
+        return transportFailureResponse(err);
+      } finally {
+        request.releaseBodyObservation?.();
+      }
+    }
+
     if (usesCodexForwardPoolAuth(authCtx, route.provider) && !authCtx.fixedAccount) {
       let poolRetryOutcome: number | undefined;
       if (await shouldRetryCodexPoolAccountModel400(
@@ -1671,9 +1813,14 @@ async function handleResponsesInner(
         options.abortSignal,
       )) {
         poolRetryOutcome = 400;
-      } else if (shouldRetryCodexPoolAccountQuota(upstreamResponse)) {
+      } else if (!authCtx.fixedAccount && await shouldRetryCodexPoolAccountQuota(
+        upstreamResponse,
+        options.abortSignal,
+      )) {
         // Pre-stream only: once SSE has begun, mid-stream quota stays terminal.
-        poolRetryOutcome = upstreamResponse.status;
+        // ChatGPT sometimes wraps quota exhaustion in a generic 5xx. Normalize only
+        // body-confirmed cases to quota evidence so cooldown and rotation both apply.
+        poolRetryOutcome = upstreamResponse.status >= 500 ? 429 : upstreamResponse.status;
       }
 
       if (poolRetryOutcome !== undefined) {
@@ -1808,10 +1955,20 @@ async function handleResponsesInner(
     // The bundled known-bad runtime remains on tee by default on both platforms.
     if (isEventStream && upstreamResponse.body) {
       const repairConfig = route.provider.responsesItemIdRepair;
-      const needsClientRewrite = imageGenCallAliases.size > 0 || hasResponsesItemIdRepair(repairConfig);
-      // Compose opt-in payload rewrites into one parse/stringify pass (image-gen restore first).
+      const xaiCustomToolRewrite = createXaiCustomToolPayloadRewrite(xaiCustomToolNames);
+      const grokSparseTerminalRewrite = logCtx.surface === "grok"
+        ? createGrokResponsesSparseTerminalPayloadRewrite(translatorBudget)
+        : undefined;
+      const needsClientRewrite = imageGenCallAliases.size > 0
+        || hasResponsesItemIdRepair(repairConfig)
+        || xaiCustomToolRewrite !== undefined
+        || grokSparseTerminalRewrite !== undefined;
+      // Compose opt-in payload rewrites into one parse/stringify pass. Provider-shape restoration
+      // runs before generic item-id repair so the client sees the correct custom-tool identity.
       const payloadRewrites = [
         createImageGenCallRestoreRewrite(imageGenCallAliases),
+        xaiCustomToolRewrite,
+        grokSparseTerminalRewrite,
         hasResponsesItemIdRepair(repairConfig)
           ? createResponsesItemIdPayloadRewrite(repairConfig!, translatorBudget)
           : undefined,
@@ -1974,7 +2131,8 @@ async function handleResponsesInner(
           rememberPassthroughResponse(JSON.parse(text) as { id?: unknown; output?: unknown; status?: unknown });
         } catch { /* non-JSON despite content-type; recording is best-effort */ }
       }
-      return new Response(restoreImageGenCallsInJson(text, imageGenCallAliases), {
+      const restoredCustomTools = restoreXaiCustomCallsInJson(text, xaiCustomToolNames);
+      return new Response(restoreImageGenCallsInJson(restoredCustomTools, imageGenCallAliases), {
         status: upstreamResponse.status,
         statusText: upstreamResponse.statusText,
         headers,
@@ -2333,6 +2491,62 @@ async function handleResponsesInner(
     return new Response(JSON.stringify(json), { headers: { "Content-Type": "application/json" } });
   }
 
+  // Some adapter inputs already contain the completed answer and require no inference at all.
+  // Kiro uses this for replayed history ending in a delivered final answer. Keep this OUTSIDE the
+  // ordinary empty-completion path: an outputless done is intentional here and must never trigger
+  // another request for the closed task.
+  const localTerminal = adapter.localTerminal?.(parsed);
+  if (localTerminal) {
+    const terminalEvents: AdapterEvent[] = [{
+      type: "done",
+      endTurn: true,
+      usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+    }];
+    const { toolNsMap, freeformToolNames, toolSearchToolNames } = toolBridgeMaps;
+    if (parsed.stream) {
+      const localSse = bridgeToResponsesSSE(
+        (async function* () { yield* terminalEvents; })(),
+        parsed.modelId,
+        toolNsMap,
+        freeformToolNames,
+        toolSearchToolNames,
+        undefined,
+        2_000,
+        {
+          translatorBudget,
+          ...(options.forceEmptyResponseId ? { responseId: "" } : {}),
+          ...(options.onFirstOutput ? { onFirstOutput: options.onFirstOutput } : {}),
+          onUsage: usage => {
+            logCtx.usageFromBridge = true;
+            if (usage) {
+              logCtx.usage = usage;
+              if (logCtx.activeAttempt) logCtx.activeAttempt.usage = usage;
+            }
+          },
+        },
+      );
+      const localTurnAc = new AbortController();
+      const tracked = trackStreamLifetime(localSse, localTurnAc, undefined, options.turnAdmissionLease);
+      return new Response(tracked, {
+        headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive", "X-Accel-Buffering": "no" },
+      });
+    }
+    const json = buildResponseJSON(terminalEvents, parsed.modelId, {
+      translatorBudget,
+      toolNsMap,
+      freeformToolNames,
+      toolSearchToolNames,
+      onUsage: usage => {
+        logCtx.usageFromBridge = true;
+        if (usage) {
+          logCtx.usage = usage;
+          if (logCtx.activeAttempt) logCtx.activeAttempt.usage = usage;
+        }
+      },
+    });
+    return new Response(JSON.stringify(json), { headers: { "Content-Type": "application/json" } });
+  }
+
   const upstream = new AbortController();
   const cleanupUpstreamAbort = linkAbortSignal(upstream, options.abortSignal);
   const connectMs = config.connectTimeoutMs ?? 200_000;
@@ -2821,13 +3035,15 @@ async function handleResponsesInner(
         // PRE-compaction history, and a later previous_response_id expansion would rehydrate the
         // giant stale chain Codex just replaced.
         ...(routedCompaction ? {} : {
-          onCompletedResponse: (response: Record<string, unknown>, providerState?: OcxProviderContinuationState) =>
+          onCompletedResponse: (response: Record<string, unknown>, providerState?: OcxProviderContinuationState) => {
+            if (activeAdapter.name === "kiro") rememberDeliveredFinalAnswer(parsed, response);
             rememberResponseState(
               parsed._rawBody,
               response,
               continuationStateForResponse(providerState),
               activeAdapter.name === "kiro" ? { force: true } : undefined,
-            ),
+            );
+          },
         }),
       },
     );
@@ -2887,6 +3103,7 @@ async function handleResponsesInner(
     });
     // See the streaming branch: compaction turns skip the continuation cache.
     if (!routedCompaction) {
+      if (activeAdapter.name === "kiro") rememberDeliveredFinalAnswer(parsed, json);
       rememberResponseState(
         parsed._rawBody,
         json,

package/src/server/responses-image-gen-repair.ts

@@ -60,7 +60,7 @@ export function imageGenToolCallAliases(
   return aliases;
 }
 
-/** Recursively restore only exact image-gen function-call aliases in a parsed Responses payload. */
+/** Restore exact client tool identities. Callers own destination-scoped alias admission. */
 function restoreImageGenCalls(
   value: unknown,
   aliases: ReadonlyMap<string, NamespacedTool>,
@@ -86,7 +86,7 @@ function restoreImageGenCalls(
 
   const name = typeof value.name === "string" ? value.name : undefined;
   const target = value.type === "function_call" && name ? aliases.get(name) : undefined;
-  if (target) {
+  if (target && (value.namespace === undefined || value.namespace === target.namespace)) {
     restored.name = target.name;
     restored.namespace = target.namespace;
     changed = true;

package/src/server/sse-payload-rewrite.ts

@@ -7,7 +7,7 @@ import type { TranslatorBudget } from "../lib/translator-budget";
  * parse/stringify pass so a tee'd stream is not re-framed twice per event.
  */
 
-export type SsePayloadRewrite = (payload: string) => string;
+export type SsePayloadRewrite = ((payload: string) => string) & { dispose?: () => void };
 
 /** Split one complete SSE event block while retaining its original blank-line delimiter. */
 export function nextSseBlock(buffer: string): { block: string; delimiter: string; rest: string } | null {
@@ -54,11 +54,19 @@ export function replaceSseDataPayload(block: string, payload: string): string {
 export function composeSsePayloadRewrites(...rewrites: SsePayloadRewrite[]): SsePayloadRewrite {
   if (rewrites.length === 0) return (payload) => payload;
   if (rewrites.length === 1) return rewrites[0]!;
-  return (payload) => {
+  const composed = ((payload: string) => {
     let next = payload;
     for (const rewrite of rewrites) next = rewrite(next);
     return next;
-  };
+  }) as SsePayloadRewrite;
+  if (rewrites.some(rewrite => rewrite.dispose !== undefined)) {
+    composed.dispose = () => {
+      for (const rewrite of rewrites) {
+        try { rewrite.dispose?.(); } catch { /* rewrite teardown is best-effort */ }
+      }
+    };
+  }
+  return composed;
 }
 
 /**
@@ -122,6 +130,12 @@ export function relaySseWithPayloadRewrite(
     buffer = "";
     bufferBytes = 0;
   };
+  let rewriteDisposed = false;
+  const disposeRewrite = (): void => {
+    if (rewriteDisposed) return;
+    rewriteDisposed = true;
+    try { rewrite.dispose?.(); } catch { /* stream teardown must not throw */ }
+  };
 
   const emitProcessedBlocks = (
     controller: ReadableStreamDefaultController<Uint8Array>,
@@ -156,6 +170,7 @@ export function relaySseWithPayloadRewrite(
           appendBuffer(decoder.decode());
           emitProcessedBlocks(controller, true);
           releaseBuffer();
+          disposeRewrite();
           controller.close();
           return;
         }
@@ -163,12 +178,14 @@ export function relaySseWithPayloadRewrite(
         emitProcessedBlocks(controller);
       } catch (error) {
         releaseBuffer();
+        disposeRewrite();
         try { await reader.cancel(error); } catch { /* already closed */ }
         controller.error(error);
       }
     },
     cancel(reason) {
       releaseBuffer();
+      disposeRewrite();
       reader.cancel(reason).catch(() => {});
     },
   });

package/src/types.ts

@@ -28,7 +28,7 @@ export interface OcxParsedRequest {
    */
   _cursorIsolateConversation?: boolean;
   /** Account-scoped, non-secret Kiro request metadata selected with the OAuth access token. */
-  _kiroAuthContext?: Pick<KiroOAuthMetadata, "profileArn" | "apiRegion" | "ssoRegion">;
+  _kiroAuthContext?: Pick<KiroOAuthMetadata, "profileArn" | "apiRegion" | "ssoRegion" | "authType">;
   /** Provider-private continuation metadata resolved from the Responses previous_response_id chain. */
   _providerContinuation?: OcxProviderContinuationState;
   /**
@@ -85,6 +85,12 @@ export interface OcxAssistantMessage {
   phase?: OcxMessagePhase;
   model?: string;
   timestamp: number;
+  /**
+   * Kiro `reasoningContent.redactedContent` for THIS assistant turn — an opaque encrypted blob
+   * Kiro replays to preserve model reasoning across turns. Provider-specific and unrenderable, so
+   * it rides the message rather than a content part: any other adapter simply ignores it.
+   */
+  kiroRedactedReasoning?: string;
 }
 
 export interface OcxDeveloperMessage {
@@ -254,6 +260,9 @@ export type AdapterEvent =
   // opaque redacted_thinking blocks. Both must be replayed verbatim or tool-use turns 400.
   | { type: "thinking_signature"; signature: string }
   | { type: "redacted_thinking"; data: string }
+  // Kiro reasoning round-trip: the encrypted `redactedContent` blob for the CURRENT assistant turn.
+  // Never rendered — it only rides the reasoning item's envelope so the next request can replay it.
+  | { type: "kiro_redacted_reasoning"; data: string }
   | { type: "reasoning_raw_delta"; text: string }
   | { type: "tool_call_start"; id: string; name: string }
   | { type: "tool_call_delta"; arguments: string }

package/src/usage/expected-prices.ts

@@ -29,6 +29,9 @@ export interface ExpectedPriceOverlay {
   status: ExpectedPriceStatus;
 }
 
+const GPT6_ASTRA: Cost4 = { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 };
+const ASTRA_API_PRICING = "https://developers.openai.com/api/docs/models/gpt-6-astra";
+
 const GEMINI_31_PRO: Cost4 = { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 0 };
 const GEMINI_36_FLASH: Cost4 = { input: 1.5, output: 7.5, cacheRead: 0.15, cacheWrite: 0 };
 const MINIMAX_M21_HIGHSPEED: Cost4 = { input: 0.6, output: 2.4, cacheRead: 0.03, cacheWrite: 0.375 };
@@ -59,6 +62,9 @@ const KIMI_PRICING = "https://platform.kimi.ai/docs/pricing (official table; cac
 const QWEN38_ROUTEWAY_PRICING = "https://routeway.ai/models/qwen3.8-max-preview (temporary reseller proxy; NOT Alibaba Token Plan billing; cacheWrite unpublished -> 0)";
 
 export const EXPECTED_PRICE_OVERLAYS: readonly ExpectedPriceOverlay[] = [
+  { provider: "openai-apikey", modelId: "gpt-6-astra", cost4: GPT6_ASTRA, source: ASTRA_API_PRICING, verifiedAt: "2026-09-07", status: "verified" },
+  // Dollar display is an API-reference comparison, not a conversion of subscription credits.
+  { provider: "openai", modelId: "gpt-6-astra", cost4: GPT6_ASTRA, source: `API-reference comparison estimate: ${ASTRA_API_PRICING}`, verifiedAt: "2026-09-07", status: "verified-derived" },
   // claude-opus-5 is exposed by three providers but absent from the jawcode bundle, so
   // cost resolution returned null and the Logs `~$` column rendered an em dash. The
   // model-level vendor fallback only searches jawcode metadata, never overlays, so one
@@ -150,6 +156,7 @@ export function findExpectedPriceOverlay(
  * Models not listed here fall back to 1× (no multiplier).
  */
 export const PRIORITY_MULTIPLIERS: Readonly<Record<string, number>> = {
+  "gpt-6-astra": 2,
   "gpt-5.6-sol": 2,
   "gpt-5.6-terra": 1.6,
   "gpt-5.6-luna": 0.4,

package/src/usage/log.ts

@@ -147,8 +147,7 @@ export function usageTotalTokens(usage: OcxUsage | undefined): number | undefine
  * fallback for paths that only know the configured provider name (e.g. "cursor-mykey").
  */
 function isEstimatedUsageProvider(providerOrAdapter: string): boolean {
-  return providerOrAdapter === "kiro" || providerOrAdapter.startsWith("kiro-")
-    || providerOrAdapter === "cursor" || providerOrAdapter.startsWith("cursor-");
+  return providerOrAdapter === "cursor" || providerOrAdapter.startsWith("cursor-");
 }
 
 export function usageForFinalLog(provider: string, usage: OcxUsage | undefined): OcxUsage | undefined {