@bitkyc08/opencodex 2.55.0 → 2.57.0

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/kiro-retry.ts

@@ -1,4 +1,5 @@
 import type { AdapterFetchContext, AdapterRequest } from "./base";
+import type { AttemptRecoveryKind } from "../usage/log";
 import { classifyKiroHttpError, safeKiroHttpErrorMessage } from "./kiro-errors";
 import { normalizeUpstreamHttpErrorResponse } from "./upstream-http-error";
 import { readBoundedResponseBody } from "../lib/bounded-body";
@@ -159,6 +160,7 @@ async function fetchWithResetRecovery(
   url: string,
   ctx: AdapterFetchContext,
   timeoutMs: number,
+  notePhysicalSend: (reset: boolean) => void,
 ): Promise<Response> {
   let lastError: unknown;
   for (let attempt = 0; attempt < RESET_ATTEMPTS; attempt++) {
@@ -170,6 +172,9 @@ async function fetchWithResetRecovery(
     if (decision && (!decision.allowed || !decision.permit.use())) {
       throw new SendBudgetExhaustedError(url);
     }
+    // Reported after admission and before dispatch, so a refused send is never counted and an
+    // admitted one is counted exactly once whichever way the fetch below settles.
+    notePhysicalSend(attempt > 0);
     try {
       const headers = new Headers(request.headers);
       const recovered = attempt > 0;
@@ -252,14 +257,15 @@ async function fetchKiroAttempt(
   request: AdapterRequest,
   ctx: AdapterFetchContext,
   timeoutMs: number,
+  notePhysicalSend: (reset: boolean) => void,
 ): Promise<Response> {
   const legacy = legacyUrl(request.url);
   let response: Response;
   try {
-    response = await fetchWithResetRecovery(request, request.url, ctx, timeoutMs);
+    response = await fetchWithResetRecovery(request, request.url, ctx, timeoutMs, notePhysicalSend);
   } catch (error) {
     if (!legacy || !endpointConnectFailure(error)) throw error;
-    return fetchWithResetRecovery(request, legacy, ctx, timeoutMs);
+    return fetchWithResetRecovery(request, legacy, ctx, timeoutMs, notePhysicalSend);
   }
 
   if (legacy && !response.ok) {
@@ -267,7 +273,7 @@ async function fetchKiroAttempt(
     response = inspected.response;
     if (inspected.fallback) {
       cancelResponseBodyBestEffort(response);
-      response = await fetchWithResetRecovery(request, legacy, ctx, timeoutMs);
+      response = await fetchWithResetRecovery(request, legacy, ctx, timeoutMs, notePhysicalSend);
     }
   }
   return response;
@@ -281,12 +287,25 @@ async function fetchKiroAttempt(
 export async function fetchKiroWithRetry(request: AdapterRequest, ctx: AdapterFetchContext = {}): Promise<Response> {
   const timeoutMs = ctx.timeoutMs ?? 200_000;
   let probeToken: symbol | undefined;
+  // One ordinal sequence for the whole call, across the throttle loop, the endpoint fallback
+  // and the reset ladder nested inside it. The caller records ordinal 1 itself, so this is what
+  // turns "one adapter call" back into the physical count the request actually made.
+  let physicalSends = 0;
+  let throttleRound = 0;
+  const notePhysicalSend = (reset: boolean): void => {
+    physicalSends += 1;
+    const recovery: AttemptRecoveryKind | undefined = reset
+      ? "connection-reset"
+      : throttleRound > 0 ? "rate-limit-429" : undefined;
+    ctx.onPhysicalSend?.({ ordinal: physicalSends, ...(recovery ? { recovery } : {}) });
+  };
   try {
     for (let attempt = 0; attempt < THROTTLE_ATTEMPTS; attempt++) {
+      throttleRound = attempt;
       if (!probeToken) probeToken = await enterKiroThrottleGate(ctx.abortSignal);
       else await waitForKiroCooldown(ctx.abortSignal);
 
-      const response = await fetchKiroAttempt(request, ctx, timeoutMs);
+      const response = await fetchKiroAttempt(request, ctx, timeoutMs, notePhysicalSend);
       const throttle = await inspectKiroThrottle(response, ctx.abortSignal);
       if (!throttle || !throttle.transient) {
         releaseKiroThrottleProbe(probeToken);

package/src/adapters/openai-chat/errors.ts

@@ -0,0 +1,116 @@
+import { isCyberPolicyCode } from "../../lib/errors";
+import { redactSecretString } from "../../lib/redact";
+import type { AdapterEvent, OcxUsage } from "../../types";
+
+// 260715 (issue #126): surface upstream error detail through the web-search sidecar loop.
+// loop.ts only appends a suffix to "Provider error N" when the adapter exposes
+// formatErrorBody; without it, strict OpenAI-compatible backends (NVIDIA NIM pydantic
+// validation, "This model only supports single tool-calls at once!", etc.) were reduced
+// to a bare status code. JSON-only extraction: recognized string fields are returned,
+// HTML/non-JSON bodies yield "" so raw markup is never echoed to the client.
+export function formatOpenAIChatErrorBody(status: number, _headers: Headers, payloadText: string): string {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(payloadText);
+  } catch {
+    return "";
+  }
+  const detail = extractErrorDetail(parsed);
+  if (!detail) return "";
+  return redactSecretString(detail).slice(0, 400);
+}
+
+function extractErrorDetail(parsed: unknown): string | undefined {
+  if (typeof parsed === "string") return parsed.trim() || undefined;
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
+  const obj = parsed as Record<string, unknown>;
+  const err = obj.error;
+  if (typeof err === "string" && err.trim()) return err.trim();
+  if (err !== null && typeof err === "object" && !Array.isArray(err)) {
+    const msg = (err as Record<string, unknown>).message;
+    if (typeof msg === "string" && msg.trim()) return msg.trim();
+  }
+  const det = obj.detail;
+  if (typeof det === "string" && det.trim()) return det.trim();
+  if (Array.isArray(det)) {
+    const msgs = det
+      .map(item => (item !== null && typeof item === "object" && typeof (item as Record<string, unknown>).msg === "string"
+        ? ((item as Record<string, unknown>).msg as string).trim()
+        : ""))
+      .filter(m => m.length > 0);
+    if (msgs.length > 0) return msgs.join("; ");
+  }
+  if (typeof obj.message === "string" && obj.message.trim()) return obj.message.trim();
+  if (typeof obj.title === "string" && obj.title.trim()) return obj.title.trim();
+  return undefined;
+}
+
+export function unwrapChatCompletionPayload(json: Record<string, unknown>): Record<string, unknown> {
+  if ((json.error !== undefined && json.error !== null) || Array.isArray(json.choices)) return json;
+  const data = json.data;
+  return data !== null && typeof data === "object" && !Array.isArray(data)
+    ? data as Record<string, unknown>
+    : json;
+}
+
+export interface OpenAIChatError {
+  message?: unknown;
+  code?: unknown;
+  type?: unknown;
+  status?: unknown;
+  metadata?: unknown;
+}
+
+export function safeUpstreamRequestId(metadata: unknown): string | undefined {
+  if (metadata === null || typeof metadata !== "object" || Array.isArray(metadata)) return undefined;
+  const record = metadata as Record<string, unknown>;
+  const value = record.request_id ?? record.requestId;
+  if (typeof value !== "string") return undefined;
+  const requestId = value.trim();
+  return /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(requestId)
+    && redactSecretString(requestId) === requestId
+    ? requestId
+    : undefined;
+}
+
+export function upstreamErrorEvent(
+  error: unknown,
+  usage?: OcxUsage,
+): Extract<AdapterEvent, { type: "error" }> {
+  const details = error !== null && typeof error === "object" && !Array.isArray(error)
+    ? error as OpenAIChatError
+    : undefined;
+  const rawMessage = typeof error === "string"
+    ? error.trim() || "upstream error"
+    : typeof details?.message === "string" ? details.message : "upstream error";
+  const safeMessage = redactSecretString(rawMessage);
+  const requestId = safeUpstreamRequestId(details?.metadata);
+  const message = requestId !== undefined && !safeMessage.includes(requestId)
+    ? `${safeMessage} (request ID: ${requestId})`
+    : safeMessage;
+  const code = typeof details?.code === "string"
+    ? details.code
+    : typeof details?.code === "number" && Number.isFinite(details.code) && Number.isInteger(details.code)
+      ? String(details.code)
+      : undefined;
+  const errorType = typeof details?.type === "string" ? details.type : undefined;
+  const codeStatus = typeof details?.code === "number"
+    && Number.isInteger(details.code)
+    && details.code >= 100
+    && details.code <= 599
+    ? details.code
+    : undefined;
+  const status = isCyberPolicyCode(code)
+    ? 400
+    : typeof details?.status === "number" && Number.isInteger(details.status)
+      ? details.status
+      : codeStatus;
+  return {
+    type: "error",
+    message,
+    ...(usage !== undefined ? { usage } : {}),
+    ...(code !== undefined ? { code } : {}),
+    ...(errorType !== undefined ? { errorType } : {}),
+    ...(status !== undefined ? { status } : {}),
+  };
+}