@bitkyc08/opencodex 2.83.0 → 2.86.0

package/src/server/request-log.ts

@@ -96,6 +96,8 @@ import type {
 
 const CACHE_DIAGNOSTIC_HOOK = Symbol.for("opencodex.cache-diagnostic.v1");
 interface CacheDiagnosticHooks {
+  /** Whether inbound bodies are actually recorded; the hook is registered at import either way. */
+  enabled(): boolean;
   observeInbound(body: unknown, headers: Headers, source: PromptCacheKeySource): CacheDiagnosticDraft;
   rebind(body: unknown, draft: CacheDiagnosticDraft | undefined): void;
   finalize(facts: CacheDiagnosticFinalFacts): void;
@@ -104,6 +106,11 @@ function cacheDiagnosticHooks(): CacheDiagnosticHooks | undefined {
   return (globalThis as Record<symbol, CacheDiagnosticHooks | undefined>)[CACHE_DIAGNOSTIC_HOOK];
 }
 
+/** Whether the cache diagnostic recorder will record inbound bodies (`OPENCODEX_CACHE_DEBUG=1`). */
+export function cacheDiagnosticsObserving(): boolean {
+  return cacheDiagnosticHooks()?.enabled() === true;
+}
+
 export interface RequestLogContext extends UpstreamErrorDiagnostics {
   model: string;
   provider: string;

package/src/server/responses/adapter-continuation.ts

@@ -30,6 +30,8 @@ import {
   isNonReplayableResponse,
   prepareSameTarget429Wait,
 } from "../../lib/upstream-retry";
+import { unwrapUpstreamRetryEvidenceError } from "../../codex/auth-context";
+import { AdmissionModelDeniedError, MODEL_NOT_ALLOWED_FOR_KEY } from "../admission-model-scope";
 import { redactSecretString } from "../../lib/redact";
 import { resolveWireProtocolOverride } from "../adapter-resolve";
 import { bindRouteReasoningReplayScope } from "./core-replay";
@@ -146,6 +148,22 @@ export function createAdapterContinuations(
     sendBudgetExhausted,
   } = sendBudgetState;
 
+  const continuationFailureEvent = (error: unknown): Extract<AdapterEvent, { type: "error" }> => {
+    if (options.abortSignal?.aborted || upstream.signal.aborted) {
+      return { type: "error", message: "client closed request during terminal continuation", status: 499 };
+    }
+    const refusal = unwrapUpstreamRetryEvidenceError(error);
+    if (refusal instanceof AdmissionModelDeniedError) {
+      return {
+        type: "error", message: refusal.message, status: 403,
+        errorType: MODEL_NOT_ALLOWED_FOR_KEY, code: MODEL_NOT_ALLOWED_FOR_KEY, retryable: false,
+      };
+    }
+    return {
+      type: "error",
+      message: `Provider continuation failed: ${redactSecretString(error instanceof Error ? error.message : String(error))}`,
+    };
+  };
 
   // One bounded internal continuation re-ask for clean end_turn turns that announced an edit
   // without emitting a tool call. Anthropic gets this by default; openai-chat providers opt in
@@ -304,12 +322,7 @@ export function createAdapterContinuations(
           kiroRefusalPendingReplay = undefined;
           kiroReplaySetupFailed = true;
         } else {
-        if (options.abortSignal?.aborted || upstream.signal.aborted) {
-          yield { type: "error", message: "client closed request during terminal continuation", status: 499 };
-        } else {
-          yield { type: "error", message: `Provider continuation failed: ${redactSecretString(error instanceof Error ? error.message : String(error))}` };
-        }
-        return;
+        yield continuationFailureEvent(error); return;
         }
       }
 
@@ -360,12 +373,7 @@ export function createAdapterContinuations(
         try {
           response = await fetchContinuation("rate-limit-429");
         } catch (error) {
-          if (options.abortSignal?.aborted || upstream.signal.aborted) {
-            yield { type: "error", message: "client closed request during terminal continuation", status: 499 };
-          } else {
-            yield { type: "error", message: `Provider continuation failed: ${redactSecretString(error instanceof Error ? error.message : String(error))}` };
-          }
-          return;
+          yield continuationFailureEvent(error); return;
         }
       }
 
@@ -381,9 +389,7 @@ export function createAdapterContinuations(
           route.provider = rotated;
           try { await transportState.resolveCopilotSelection(nextParsed); }
           catch (error) {
-            yield { type: "error", message: `Provider continuation failed: ${redactSecretString(error instanceof Error ? error.message : String(error))}`,
-              ...(options.abortSignal?.aborted || upstream.signal.aborted ? { status: 499 } : {}) };
-            return;
+            yield continuationFailureEvent(error); return;
           }
           invalidateSameTargetRequest();
           transportState.activeAdapter = resolveSelectionAdapter(
@@ -630,13 +636,17 @@ export function createAdapterContinuations(
               nextContinuationRecoveryKind = "oauth-account-429";
               continue;
             }
-          } catch {
+          } catch (error) {
             // Everything in this try runs before the replay: the send happens on the next
             // iteration, after `continue`. A throw here therefore leaves a reservation that
             // never dispatched, and holding it would refuse a later recovery in this same
             // request for a send that never left the process.
             hop.permit?.release();
-            // fall through to emit continuation error below
+            if (unwrapUpstreamRetryEvidenceError(error) instanceof AdmissionModelDeniedError) {
+              yield continuationFailureEvent(error);
+              return;
+            }
+            // Other negotiation failures preserve the original provider refusal.
           }
         }
       }
@@ -717,7 +727,7 @@ export function createAdapterContinuations(
 
   const fetchGuardedEmptyCompletionRetry = (): AsyncIterable<AdapterEvent> => {
     const retryEvents = fetchTerminalGuardContinuation(parsed, "empty-completion", true);
-    return terminalGuardEnabled
+    const terminalGuardedRetry = terminalGuardEnabled
       ? guardTerminalEventStream({
           parsed,
           firstEvents: retryEvents,
@@ -726,6 +736,13 @@ export function createAdapterContinuations(
           continuation: next => fetchTerminalGuardContinuation(next, undefined, !parsed.stream),
         })
       : retryEvents;
+    return parsed._advisorGuard
+      ? parsed._advisorGuard({
+          parsed,
+          firstEvents: terminalGuardedRetry,
+          continuation: fetchTerminalGuardContinuation,
+        })
+      : terminalGuardedRetry;
   };
 
   return {

package/src/server/responses/adapter-delivery.ts

@@ -113,16 +113,28 @@ export async function deliverAdapterResponse(
           continuation: next => fetchTerminalGuardContinuation(next, undefined, !parsed.stream),
         })
       : initialEventStream;
+    // Optional advisor guard (registered per request by the sidecar planner; absent unless the
+    // user enabled the advisor): holds synthetic `advisor` tool calls, consults the configured
+    // expert model, and re-dispatches the worker. Sits inside the empty-completion guard so an
+    // advisor-only turn never reads as an empty completion, and outside the bridge so the
+    // synthetic call never reaches the client.
+    const advisorStream = parsed._advisorGuard
+      ? parsed._advisorGuard({
+          parsed,
+          firstEvents: eventStream,
+          continuation: fetchTerminalGuardContinuation,
+        })
+      : eventStream;
     // The empty-completion guard sits OUTSIDE the terminal guard: a completed
     // turn with no text and no tool call is retried with the IDENTICAL request
     // (fetchTerminalGuardContinuation(parsed) replays the cached byte-identical
     // request — same body, same headers, same signal).
     const guardedEventStream = emptyCompletionGuardEnabled
       ? guardEmptyCompletionEventStream({
-          firstEvents: eventStream,
+          firstEvents: advisorStream,
           continuation: fetchGuardedEmptyCompletionRetry,
         })
-      : eventStream;
+      : advisorStream;
     const { toolNsMap, declaredToolNames, toolParameterSchemas, freeformToolNames, bareCustomToolNames, toolSearchToolNames } = toolBridgeMaps;
     // One completion owner for both deliveries: the bridge calls it from its terminal, the
     // direct client encoder from the fold of the same events.
@@ -240,6 +252,16 @@ export async function deliverAdapterResponse(
       } else {
         guardedEvents = initialEvents;
       }
+      // Optional advisor guard — same semantics as the streaming branch above.
+      if (parsed._advisorGuard) {
+        const advisorEvents: AdapterEvent[] = [];
+        for await (const event of parsed._advisorGuard({
+          parsed,
+          firstEvents: (async function* () { yield* guardedEvents; })(),
+          continuation: fetchTerminalGuardContinuation,
+        })) advisorEvents.push(event);
+        guardedEvents = advisorEvents;
+      }
       if (emptyCompletionGuardEnabled) {
         events = [];
         for await (const event of guardEmptyCompletionEventStream({