npm - @bitkyc08/opencodex - Versions diffs - 2.56.0 → 2.57.0 - Mend

@bitkyc08/opencodex 2.56.0 → 2.57.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (145) hide show

package/bin/ocx.mjs +10 -0
package/gui/dist/assets/{index-BBOZWGB6.css → index-C5-RdDmD.css} +1 -1
package/gui/dist/assets/{index-D4zuyIxQ.js → index-Cz7CLdif.js} +21 -21
package/gui/dist/index.html +2 -2
package/package.json +3 -3
package/src/adapters/codebuddy/adapter.ts +2 -1
package/src/adapters/codebuddy/scaffold-guard.ts +248 -0
package/src/adapters/command-code.ts +1 -1
package/src/adapters/cursor/envelope-echo.ts +8 -2
package/src/adapters/google.ts +7 -7
package/src/adapters/kiro/payload.ts +17 -3
package/src/adapters/kiro/reasoning.ts +70 -7
package/src/adapters/kiro/stream.ts +8 -2
package/src/adapters/kiro/wire.ts +2 -1
package/src/adapters/kiro-events.ts +21 -13
package/src/adapters/openai-chat/tool-name-registry.ts +166 -0
package/src/adapters/openai-chat/tool-schema.ts +25 -7
package/src/adapters/openai-chat.ts +8 -8
package/src/adapters/openai-responses/passthrough.ts +32 -1
package/src/bridge/errors.ts +26 -2
package/src/bridge/response-json.ts +7 -1
package/src/bridge/sse.ts +19 -1
package/src/claude/desktop-profile.ts +66 -9
package/src/claude/outbound.ts +18 -0
package/src/cli/account-main.ts +1 -1
package/src/cli/capabilities.ts +2 -2
package/src/cli/combo.ts +10 -1
package/src/cli/index.ts +48 -5
package/src/cli/registry.ts +2 -1
package/src/cli/system-command.ts +4 -4
package/src/clients/config-export.ts +7 -3
package/src/codex/account-label.ts +14 -3
package/src/codex/account-store.ts +113 -26
package/src/codex/account-usability.ts +21 -0
package/src/codex/auth-api/login-flow.ts +14 -2
package/src/codex/auth-api/reset-credit-service.ts +11 -2
package/src/codex/auth-context.ts +157 -7
package/src/codex/catalog/aggregation.ts +80 -1
package/src/codex/catalog/model-visibility.ts +1 -0
package/src/codex/catalog/remote.ts +30 -0
package/src/codex/catalog/retained-sync.ts +9 -1
package/src/codex/catalog/routed-gather.ts +38 -1
package/src/codex/cli-install-provenance.ts +7 -1
package/src/codex/convergence.ts +7 -2
package/src/codex/desktop-app/types.ts +11 -2
package/src/codex/desktop-app/windows.ts +5 -5
package/src/codex/inject/restore.ts +29 -2
package/src/codex/inject.ts +9 -9
package/src/codex/model-entitlements.ts +152 -15
package/src/codex/pool-refresh-backoff.ts +12 -3
package/src/codex/quota-rejection.ts +104 -15
package/src/codex/routing/cache-affinity.ts +70 -0
package/src/codex/routing/cooldown-math.ts +10 -0
package/src/codex/routing/selection.ts +79 -2
package/src/codex/routing/thread-affinity.ts +50 -2
package/src/codex/routing/transient-hold-dispatch.ts +141 -0
package/src/codex/routing.ts +29 -49
package/src/codex/warmup.ts +1 -1
package/src/combos/failover.ts +85 -0
package/src/combos/request.ts +17 -10
package/src/combos/types.ts +23 -2
package/src/config/pending-teardown.ts +31 -0
package/src/generated/compatibility-version.json +163 -135
package/src/images/loop.ts +1 -1
package/src/lib/errors.ts +17 -0
package/src/lib/request-execution-budget.ts +147 -21
package/src/lib/spend-reservation-ledger.ts +18 -0
package/src/lib/state-store-registrations.ts +6 -2
package/src/lib/test-home-guard.ts +85 -1
package/src/lib/upstream-retry.ts +77 -10
package/src/lib/windows-elevation.ts +76 -14
package/src/oauth/index.ts +2 -2
package/src/oauth/key-providers.ts +2 -2
package/src/providers/kiro-models.ts +4 -3
package/src/providers/label.ts +19 -1
package/src/providers/model-discovery.ts +16 -0
package/src/providers/registry/entries-core.ts +7 -0
package/src/providers/registry/entries-extended.ts +9 -0
package/src/providers/registry/model-seeds.ts +4 -0
package/src/responses/reasoning-envelope.ts +6 -3
package/src/routing/identity-domains.ts +21 -14
package/src/routing/probe-lease.ts +103 -1
package/src/server/chat-completions.ts +3 -1
package/src/server/chat-native.ts +37 -9
package/src/server/index/live-sideband.ts +37 -1
package/src/server/index/websocket-handler.ts +6 -2
package/src/server/index.ts +5 -5
package/src/server/inspection-tee.ts +107 -0
package/src/server/live.ts +46 -1
package/src/server/management/combo-routes.ts +10 -1
package/src/server/relay-eager.ts +2 -0
package/src/server/relay.ts +14 -19
package/src/server/request-log.ts +127 -3
package/src/server/response-log-body.ts +153 -0
package/src/server/responses/account-change-state.ts +74 -0
package/src/server/responses/adapter-continuation.ts +33 -7
package/src/server/responses/adapter-delivery.ts +5 -11
package/src/server/responses/adapter-dispatch.ts +84 -13
package/src/server/responses/codex-ws-wire.ts +5 -0
package/src/server/responses/collaboration.ts +74 -4
package/src/server/responses/combo-session-recall.ts +68 -8
package/src/server/responses/compact.ts +54 -13
package/src/server/responses/core-auth.ts +2 -0
package/src/server/responses/core-codex-account.ts +51 -3
package/src/server/responses/core-combo.ts +103 -23
package/src/server/responses/core-errors.ts +18 -0
package/src/server/responses/core-replay.ts +105 -32
package/src/server/responses/core.ts +3 -3
package/src/server/responses/encrypted-payload.ts +0 -1
package/src/server/responses/input-admission.ts +126 -6
package/src/server/responses/passthrough-delivery.ts +19 -6
package/src/server/responses/passthrough-dispatch.ts +28 -10
package/src/server/responses/passthrough-error.ts +38 -2
package/src/server/responses/request-prepare.ts +132 -22
package/src/server/responses/request-send-budget.ts +97 -2
package/src/server/responses/request-spend.ts +147 -0
package/src/server/responses/request-transport.ts +62 -3
package/src/server/responses/run-turn-execution.ts +59 -31
package/src/server/responses/sidecar-execution.ts +7 -13
package/src/server/responses/terminal-guard.ts +65 -4
package/src/server/responses-undeclared-tool-guard.ts +9 -5
package/src/service/windows-ops.ts +210 -16
package/src/service/windows-scheduler.ts +28 -21
package/src/service.ts +1 -1
package/src/types/config.ts +4 -1
package/src/types/request.ts +8 -5
package/src/types/tools.ts +24 -0
package/src/types.ts +2 -0
package/src/update/index.ts +10 -0
package/src/update/stop-contract.d.mts +1 -0
package/src/update/stop-contract.mjs +19 -0
package/src/update/stop-decision.d.mts +1 -1
package/src/update/stop-decision.mjs +12 -3
package/src/usage/log.ts +1 -1
package/src/vision/anthropic-describe.ts +1 -1
package/src/vision/describe.ts +5 -5
package/src/web-search/anthropic-executor.ts +1 -1
package/src/web-search/exa-executor.ts +1 -1
package/src/web-search/executor.ts +1 -1
package/src/web-search/gemini-executor.ts +1 -1
package/src/web-search/loop.ts +1 -1
package/src/web-search/ollama-executor.ts +1 -1
package/src/web-search/parse.ts +67 -14
package/src/web-search/passthrough-bridge.ts +64 -31
package/src/web-search/xai-executor.ts +1 -1

package/gui/dist/index.html CHANGED Viewed

@@ -16,8 +16,8 @@
         } catch (e) {}
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-D4zuyIxQ.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BBOZWGB6.css">
+    <script type="module" crossorigin src="/assets/index-Cz7CLdif.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-C5-RdDmD.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@bitkyc08/opencodex",
-  "version": "2.56.0",
+  "version": "2.57.0",
   "description": "Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code",
   "type": "module",
   "main": "./bin/package-main.mjs",
@@ -76,11 +76,11 @@
     "@bufbuild/protobuf": "^2.14.0",
     "@modelcontextprotocol/sdk": "^1.30.0",
     "@napi-rs/keyring": "1.3.0",
-    "bun": "1.4.2",
+    "bun": "1.4.0",
     "zod": "4.4.3"
   },
   "devDependencies": {
-    "@types/bun": "1.4.2",
+    "@types/bun": "1.4.0",
     "typescript": "7.0.2"
   },
   "overrides": {

package/src/adapters/codebuddy/adapter.ts CHANGED Viewed

@@ -4,6 +4,7 @@ import { mapReasoningEffort } from "../../reasoning-effort";
 import { buildSystemPrompt } from "../coding-agent/protocol";
 import { baseScopedEnv, runCodingAgentTurn, type CodingAgentDeps, type SpawnFn } from "../coding-agent/turn";
 import { CODEBUDDY_PROFILES, type CodeBuddyProfile } from "./profiles";
+import { guardCodeBuddyScaffolding } from "./scaffold-guard";
 export type { SpawnFn } from "../coding-agent/turn";
 export type CodeBuddyAdapterDeps = CodingAgentDeps;
@@ -75,7 +76,7 @@ export function createCodeBuddyAdapter(provider: OcxProviderConfig, deps: CodeBu
         provider,
         parsed,
         incoming,
-        emit,
+        emit: guardCodeBuddyScaffolding(emit),
         buildArgs: (resolved, req, prov) => buildArgs(resolved as CodeBuddyProfile, req, prov),
         buildEnv: (resolved, apiKey) => buildChildEnv(resolved as CodeBuddyProfile, apiKey),
         deps,

package/src/adapters/codebuddy/scaffold-guard.ts ADDED Viewed

@@ -0,0 +1,248 @@
+import type { AdapterEvent } from "../../types";
+/** Error code for a CodeBuddy turn whose output contains vendor agent scaffolding. */
+export const CODEBUDDY_SCAFFOLD_ERROR_CODE = "vendor_scaffold_detected";
+// The observed control protocol uses FULLWIDTH VERTICAL LINE (U+FF5C). Detection stays
+// deliberately narrower than the marker spelling: a calls control line must be followed by an
+// invoke line for a functions.* tool. That distinguishes an agent scaffold from prose quoting or
+// discussing one tag.
+const DSML_CALLS_LINE = "<｜｜dsml｜｜ calls>";
+const DSML_INVOKE_PREFIX = "<｜｜dsml｜｜ invoke name=\"functions.";
+export interface CodeBuddyScaffoldFilterResult {
+  /** Bytes released from a suffix withheld by an earlier event on this channel. */
+  releasedPending: string;
+  /** Safe bytes belonging to the event currently being processed. */
+  text: string;
+  /** The earlier pending event still owns the extended candidate. */
+  pendingContinues: boolean;
+  fail: boolean;
+}
+interface ScanResult {
+  safe: string;
+  held: string;
+  fail: boolean;
+  fence: "`" | "~" | null;
+  lineStart: boolean;
+}
+function prefixAtEnd(text: string, at: number, expected: string): boolean {
+  const rest = text.slice(at).toLowerCase();
+  return rest.length < expected.length && expected.startsWith(rest);
+}
+/**
+ * Scan complete bytes and retain only a bounded suffix that can still become a control sequence.
+ *
+ * Control tags are recognized only at column zero and outside fenced Markdown. Inline code,
+ * quoted strings, blockquotes, indented source, and prose all add syntax before the tag and are
+ * therefore forwarded unchanged. A calls line alone is harmless; refusal requires the observed
+ * two-line calls-plus-functions-invoke grammar.
+ */
+function scan(
+  text: string,
+  initialFence: "`" | "~" | null,
+  initialLineStart: boolean,
+): ScanResult {
+  let fence = initialFence;
+  let lineStart = initialLineStart;
+  let index = 0;
+  while (index < text.length) {
+    if (lineStart) {
+      const fenceMarkers = fence ? [fence.repeat(3)] : ["```", "~~~"];
+      const completeFence = fenceMarkers.find(marker => text.startsWith(marker, index));
+      if (completeFence) {
+        fence = fence ? null : (completeFence[0] as "`" | "~");
+        index += completeFence.length;
+        lineStart = false;
+        continue;
+      }
+      if (fenceMarkers.some(marker => prefixAtEnd(text, index, marker))) {
+        return { safe: text.slice(0, index), held: text.slice(index), fail: false, fence, lineStart };
+      }
+      if (!fence) {
+        const lowered = text.slice(index).toLowerCase();
+        if (lowered.startsWith(DSML_CALLS_LINE)) {
+          const afterCalls = index + DSML_CALLS_LINE.length;
+          let invokeAt = -1;
+          if (text[afterCalls] === "\n") invokeAt = afterCalls + 1;
+          else if (text[afterCalls] === "\r" && text[afterCalls + 1] === "\n") invokeAt = afterCalls + 2;
+          else if (afterCalls === text.length || (text[afterCalls] === "\r" && afterCalls + 1 === text.length)) {
+            return { safe: text.slice(0, index), held: text.slice(index), fail: false, fence, lineStart };
+          }
+          if (invokeAt >= 0) {
+            const invokeRest = text.slice(invokeAt).toLowerCase();
+            if (invokeRest.startsWith(DSML_INVOKE_PREFIX)) {
+              return { safe: text.slice(0, index), held: "", fail: true, fence, lineStart };
+            }
+            if (invokeRest.length === 0 || DSML_INVOKE_PREFIX.startsWith(invokeRest)) {
+              return { safe: text.slice(0, index), held: text.slice(index), fail: false, fence, lineStart };
+            }
+          }
+        } else if (prefixAtEnd(text, index, DSML_CALLS_LINE)) {
+          return { safe: text.slice(0, index), held: text.slice(index), fail: false, fence, lineStart };
+        }
+      }
+    }
+    const char = text[index]!;
+    index += 1;
+    lineStart = char === "\n";
+  }
+  return { safe: text, held: "", fail: false, fence, lineStart };
+}
+/** Streaming DSML control-sequence filter for one text or reasoning channel. */
+export class CodeBuddyScaffoldFilter {
+  private pending = "";
+  private failed = false;
+  private fence: "`" | "~" | null = null;
+  private lineStart = true;
+  /** True while an earlier event owns an unresolved marker or fence prefix. */
+  hasPending(): boolean {
+    return this.pending.length > 0;
+  }
+  push(chunk: string): CodeBuddyScaffoldFilterResult {
+    if (this.failed) {
+      return { releasedPending: "", text: "", pendingContinues: false, fail: false };
+    }
+    if (!chunk) {
+      return {
+        releasedPending: "",
+        text: "",
+        pendingContinues: this.hasPending(),
+        fail: false,
+      };
+    }
+    const priorPending = this.pending;
+    const result = scan(priorPending + chunk, this.fence, this.lineStart);
+    this.pending = result.held;
+    this.fence = result.fence;
+    this.lineStart = result.lineStart;
+    this.failed = result.fail;
+    const releasedLength = Math.min(priorPending.length, result.safe.length);
+    return {
+      releasedPending: result.safe.slice(0, releasedLength),
+      text: result.safe.slice(releasedLength),
+      pendingContinues: priorPending.length > 0 && result.safe.length === 0 && result.held.length > 0,
+      fail: result.fail,
+    };
+  }
+  /** Release a suffix that never completed the two-line control grammar. */
+  flush(): CodeBuddyScaffoldFilterResult {
+    if (this.failed) {
+      return { releasedPending: "", text: "", pendingContinues: false, fail: false };
+    }
+    const text = this.pending;
+    this.pending = "";
+    return { releasedPending: text, text: "", pendingContinues: false, fail: false };
+  }
+}
+function codeBuddyScaffoldErrorMessage(): string {
+  return "CodeBuddy CLI emitted vendor tool-call markup in an assistant output channel. This route"
+    + " runs the CLI with its own tools and MCP servers disabled and Codex owns tool control, so"
+    + " the turn was refused rather than forwarding or executing vendor agent scaffolding.";
+}
+/** Guard both streamed channels while preserving event order around withheld marker prefixes. */
+export function guardCodeBuddyScaffolding(emit: (event: AdapterEvent) => void): (event: AdapterEvent) => void {
+  const textFilter = new CodeBuddyScaffoldFilter();
+  const thinkingFilter = new CodeBuddyScaffoldFilter();
+  type PendingChannel = "text" | "thinking";
+  type EventSlot = { resolved: boolean; event?: AdapterEvent };
+  const eventQueue: EventSlot[] = [];
+  const pendingSlots = new Map<PendingChannel, EventSlot>();
+  let closed = false;
+  const channelEvent = (channel: PendingChannel, text: string): AdapterEvent => channel === "text"
+    ? { type: "text_delta", text }
+    : { type: "thinking_delta", thinking: text };
+  const drainResolved = (): void => {
+    while (eventQueue[0]?.resolved) {
+      const slot = eventQueue.shift()!;
+      if (slot.event) emit(slot.event);
+    }
+  };
+  const enqueueResolved = (event: AdapterEvent): void => {
+    eventQueue.push({ resolved: true, event });
+    drainResolved();
+  };
+  const resolvePendingSlot = (channel: PendingChannel, text: string): void => {
+    const slot = pendingSlots.get(channel);
+    if (!slot) return;
+    slot.resolved = true;
+    if (text) slot.event = channelEvent(channel, text);
+    pendingSlots.delete(channel);
+    drainResolved();
+  };
+  const enqueuePendingSlot = (channel: PendingChannel): void => {
+    const slot: EventSlot = { resolved: false };
+    eventQueue.push(slot);
+    pendingSlots.set(channel, slot);
+  };
+  const flushAllPending = (): void => {
+    for (const channel of ["text", "thinking"] as const) {
+      if (!pendingSlots.has(channel)) continue;
+      const filter = channel === "text" ? textFilter : thinkingFilter;
+      resolvePendingSlot(channel, filter.flush().releasedPending);
+    }
+    drainResolved();
+  };
+  const refuse = (): void => {
+    if (closed) return;
+    flushAllPending();
+    closed = true;
+    emit({
+      type: "error",
+      message: codeBuddyScaffoldErrorMessage(),
+      status: 502,
+      errorType: "upstream_error",
+      code: CODEBUDDY_SCAFFOLD_ERROR_CODE,
+      retryable: false,
+    });
+  };
+  return (event: AdapterEvent): void => {
+    if (closed) return;
+    if (event.type === "text_delta" || event.type === "thinking_delta") {
+      const channel: PendingChannel = event.type === "text_delta" ? "text" : "thinking";
+      const filter = channel === "text" ? textFilter : thinkingFilter;
+      const hadPending = filter.hasPending();
+      const cleaned = filter.push(event.type === "text_delta" ? event.text : event.thinking);
+      if (hadPending && !cleaned.pendingContinues) resolvePendingSlot(channel, cleaned.releasedPending);
+      if (cleaned.text) {
+        enqueueResolved(event.type === "text_delta"
+          ? { ...event, text: cleaned.text }
+          : { ...event, thinking: cleaned.text });
+      }
+      if (filter.hasPending() && !cleaned.pendingContinues) enqueuePendingSlot(channel);
+      if (cleaned.fail) refuse();
+      return;
+    }
+    if (event.type === "done" || event.type === "error" || event.type === "incomplete") {
+      flushAllPending();
+      closed = true;
+      emit(event);
+      return;
+    }
+    enqueueResolved(event);
+  };
+}

package/src/adapters/command-code.ts CHANGED Viewed

@@ -469,7 +469,7 @@ async function fetchCommandCode(request: AdapterRequest, ctx: AdapterFetchContex
   const timer = setTimeout(() => timeout.abort(new DOMException("Timeout elapsed", "TimeoutError")), ctx?.timeoutMs ?? 200_000);
   const callerSignal = ctx?.abortSignal ?? new AbortController().signal;
   try {
-    return await executor(request.url, {
+    return await (ctx?.executor ?? executor)(request.url, {
       method: request.method,
       headers: request.headers,
       body: request.body,

package/src/adapters/cursor/envelope-echo.ts CHANGED Viewed

@@ -217,7 +217,13 @@ export type RoutingCommentaryDecision =
   | { kind: "flush" }
   | { kind: "hallucination" };
-const ROUTING_NATIVE_TOOL_NAME = /\b(shell|read|grep|list|bash)\b/giu;
+// The Korean alternative is deliberately asymmetric: it has a left boundary and no right one.
+// Korean attaches particles directly to the noun, so the real sentences this detector exists to
+// catch read "네이티브 셸이 차단되어..." and "네이티브 셸과 Read가...". A mirrored
+// (?![\p{L}\p{M}\p{N}_]) lookahead would see the 이/과 particle as a letter and stop matching
+// every one of them, which is why the negative cases below only probe the left side. Adding the
+// right boundary looks like an obvious fix and disables the check; do not.
+const ROUTING_NATIVE_TOOL_NAME = /\b(shell|read|grep|list|bash)\b|(?<![\p{L}\p{M}\p{N}_])네이티브\s*(?:셸|쉘)/giu;
 const ROUTING_TOOL_HINT =
   /(?:\b(?:shell|read|grep|list|bash)\b|exec_command|shell_command|브리지|네이티브\s*(?:셸|쉘))/iu;
 const ROUTING_FAILURE_CLAIM =
@@ -276,7 +282,7 @@ export class CursorRoutingCommentarySniffer {
   private matchesHallucination(): boolean {
     if (!ROUTING_FAILURE_CLAIM.test(this.buffered)) return false;
     const nativeTools = new Set(
-      [...this.buffered.matchAll(ROUTING_NATIVE_TOOL_NAME)].map(match => match[1]?.toLowerCase()),
+      [...this.buffered.matchAll(ROUTING_NATIVE_TOOL_NAME)].map(match => match[1]?.toLowerCase() ?? "shell"),
     );
     if (nativeTools.size === 0) return false;
     return ROUTING_REDIRECT_CLAIM.test(this.buffered) || nativeTools.size >= 2;

package/src/adapters/google.ts CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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",