@bitkyc08/opencodex 2.84.0 → 2.86.0

package/src/server/management/sibling-guard.ts

@@ -30,6 +30,7 @@ export const SIBLING_REFUSED_MANAGEMENT_PATHS: readonly { readonly path: string;
   { path: "/api/client-integrations", children: true },
   { path: "/api/native-integrations", children: true },
   { path: "/api/claude-desktop", children: true },
+  { path: "/api/codex/desktop-compatibility", children: true },
   { path: "/api/claude-code", children: false },
   { path: "/api/grok/apply", children: false },
   { path: "/api/grok/selection", children: false },

package/src/server/management-api.ts

@@ -79,6 +79,9 @@ import { handleCodexPromptRoutes } from "./management/codex-prompt-routes";
 import { handleIntegrationRoutes } from "./management/integration-routes";
 import { handleNativeIntegrationRoutes } from "./management/native-integration-routes";
 import { handleClaudeDesktopPickerRoutes } from "./management/claude-desktop-picker-routes";
+import { handleDesktopCompatibilityRoutes } from "./management/desktop-compatibility-routes";
+import { handleDesktopCompatibilityRuntimeRoutes } from "./management/desktop-compatibility-runtime-routes";
+import { handleDesktopCompatibilitySettingsRoutes } from "./management/desktop-compatibility-settings-routes";
 import { handleCursorIntegrationRoutes } from "./management/cursor-integration-routes";
 import type { ManagementContext } from "./management/context";
 import type { ManagementPrincipal, ManagementSessionControl } from "./management-auth";
@@ -360,6 +363,9 @@ export async function handleManagementAPI(
     ??     (await handleNativeIntegrationRoutes(ctx))
     ??     (await handleCursorIntegrationRoutes(ctx))
     ??     (await handleClaudeDesktopPickerRoutes(ctx))
+    ??     (await handleDesktopCompatibilityRoutes(ctx))
+    ??     (await handleDesktopCompatibilityRuntimeRoutes(ctx))
+    ??     (await handleDesktopCompatibilitySettingsRoutes(ctx))
     ??     (await handleAgentSettingsRoutes(ctx))
     ??     (await handleCodexPromptRoutes(ctx))
     ??     (await handleOauthAccountRoutes(ctx))

package/src/server/messages-antigravity-direct.ts

@@ -0,0 +1,195 @@
+/**
+ * The Antigravity direct lane for the Messages ingress (`protocols.rollout.antigravityDirect`).
+ *
+ * The Messages ingress translates before it routes: the route is decided on the translated body's
+ * resolved model. So the lane is planned ahead of translation on the settings-only body
+ * (`anthropicSettingsTranslation`), whose model is that same resolved model, against a preview of
+ * the route; the conversation is decoded straight into the IR only when that preview is an
+ * eligible Antigravity route. The ingress then routes the settings-only body as usual and keeps
+ * the lane only if the settled route is still the one the plan was made for; otherwise it builds
+ * the full bridge translation, as it would have without the switch.
+ *
+ * Refusals stay the bridge's by construction: a settings error, or an undecodable proxy envelope
+ * (which the bridge retries through the native projection), returns no plan and the ingress takes
+ * its ordinary translation path, which answers exactly as before. Any other decode error is one
+ * the translator's walk raises with the same message at the same point
+ * (`tests/responses/protocol-messages-ir-parity.test.ts`).
+ */
+import { anthropicSettingsTranslation, AnthropicRequestError, type ClaudeCacheKeySource } from "../claude/inbound";
+import { messagesToResponsesTranslation } from "../protocols/codecs/messages";
+import {
+  MALFORMED_REASONING_SIGNATURE,
+  messagesConversationToIr,
+  messagesRouteEvidence,
+  withDirectMessagesConversation,
+  type MessagesIrConversation,
+} from "../protocols/codecs/messages-ir";
+import { resolveProtocolSettings } from "../protocols/settings";
+import type { TranslatorBudget, TranslatorBufferKind } from "../lib/translator-budget";
+import type { PolicyRequestEvidence } from "../routing/evaluator";
+import { previewRouteModel, type RouteResult } from "../router";
+import type { OcxClaudeCodeConfig, OcxConfig } from "../types";
+import { antigravityMessagesDeclineReason, type AntigravityDirectDeclineReason } from "./antigravity-direct-eligibility";
+import { cacheDiagnosticsObserving } from "./request-log";
+import type { DirectRequestOption } from "./responses/core-options";
+
+type Rec = Record<string, unknown>;
+
+export interface MessagesDirectPlan {
+  /** The concrete route the plan was made for. */
+  providerName: string;
+  modelId: string;
+  /** The settings-only Responses body the core receives, and its prompt-cache key provenance. */
+  settingsBody: Rec;
+  cacheKeySource: ClaudeCacheKeySource;
+  conversation: MessagesIrConversation;
+  /** What the core would have read from the bridge body for policy routing. */
+  evidence: PolicyRequestEvidence;
+  /**
+   * Release the retained charges the plan's decode made. The ingress calls it when it abandons
+   * the plan for the full translation, which charges the same reasoning copies again.
+   */
+  releaseDecodeCharges(): void;
+}
+
+/**
+ * The request budget, with the retained charges made through it recorded so a decode the ingress
+ * abandons can hand them back. Without that, the bridge translation that follows would be held to
+ * a budget already spent on a copy nobody keeps, and could answer 413 where the bridge alone fits.
+ */
+function recordingBudget(budget: TranslatorBudget): { budget: TranslatorBudget; release(): void } {
+  const charged = new Map<TranslatorBufferKind, number>();
+  const recording: TranslatorBudget = {
+    openCall: id => budget.openCall(id),
+    closeCall: id => budget.closeCall(id),
+    reserveTransient: (bytes, scope) => budget.reserveTransient(bytes, scope),
+    chargeRetained: (delta, scope) => {
+      budget.chargeRetained(delta, scope);
+      charged.set(scope.kind, (charged.get(scope.kind) ?? 0) + delta);
+    },
+    releaseRetained: (bytes, scope) => {
+      budget.releaseRetained(bytes, scope);
+      charged.set(scope.kind, (charged.get(scope.kind) ?? 0) - bytes);
+    },
+    observeAcceptedRequestCopy: bytes => budget.observeAcceptedRequestCopy(bytes),
+    observeExternallyCapped: (kind, bytes) => budget.observeExternallyCapped(kind, bytes),
+    snapshot: () => budget.snapshot(),
+    dispose: () => budget.dispose(),
+  };
+  return {
+    budget: recording,
+    release: () => {
+      for (const [kind, bytes] of charged) if (bytes > 0) budget.releaseRetained(bytes, { kind });
+      charged.clear();
+    },
+  };
+}
+
+/**
+ * Plan the direct lane for a Messages body, or return `undefined` to translate as before. Throws
+ * only what the translator's conversation walk throws for the same body.
+ */
+export function planMessagesAntigravityDirect(
+  body: unknown,
+  cc: OcxClaudeCodeConfig | undefined,
+  config: OcxConfig,
+  budget: TranslatorBudget,
+): MessagesDirectPlan | undefined {
+  if (!resolveProtocolSettings(config).rollout.antigravityDirect) return undefined;
+  if (!body || typeof body !== "object" || Array.isArray(body)) return undefined;
+  let settings: ReturnType<typeof anthropicSettingsTranslation>;
+  let route: RouteResult;
+  try {
+    settings = anthropicSettingsTranslation(body, cc);
+    route = previewRouteModel(config, settings.body.model as string);
+  } catch {
+    return undefined;
+  }
+  const model = settings.body.model as string;
+  if (!messagesDirectRouteHolds(route, body as Rec, model, config)) return undefined;
+  const recorded = recordingBudget(budget);
+  let conversation: MessagesIrConversation;
+  try {
+    conversation = messagesConversationToIr(body, cc, recorded.budget, model);
+  } catch (err) {
+    if (err instanceof AnthropicRequestError && err.message === MALFORMED_REASONING_SIGNATURE) {
+      // The bridge retries this body through the native projection; give it the whole budget.
+      recorded.release();
+      return undefined;
+    }
+    throw err;
+  }
+  return {
+    providerName: route.providerName,
+    modelId: route.modelId,
+    settingsBody: settings.body,
+    cacheKeySource: settings.cacheKeySource,
+    conversation,
+    evidence: messagesRouteEvidence(body),
+    releaseDecodeCharges: recorded.release,
+  };
+}
+
+/** Whether a route may carry this body on the direct lane, judged as the ingress judges it. */
+export function messagesDirectRouteHolds(
+  route: Pick<RouteResult, "providerName" | "modelId" | "provider" | "combo" | "routeKind">,
+  body: Rec,
+  model: string,
+  config: OcxConfig,
+): boolean {
+  return antigravityMessagesDeclineReason(route, body, model, config, { cacheDiagnostics: cacheDiagnosticsObserving() }) === undefined;
+}
+
+/** Whether the route the ingress settled is still the one `plan` was made for, and still eligible. */
+export function messagesDirectPlanHolds(plan: MessagesDirectPlan, route: RouteResult, body: Rec, config: OcxConfig): boolean {
+  return route.providerName === plan.providerName && route.modelId === plan.modelId
+    && messagesDirectRouteHolds(route, body, plan.settingsBody.model as string, config);
+}
+
+/**
+ * The lane's decline for a bridged request's trace, when it says something about this route: with
+ * the switch off or a non-Antigravity target the path already explains the bridge.
+ */
+export function messagesDirectTraceDecline(
+  route: RouteResult,
+  body: unknown,
+  model: string,
+  config: OcxConfig,
+): AntigravityDirectDeclineReason | undefined {
+  if (!body || typeof body !== "object" || Array.isArray(body)) return undefined;
+  const reason = antigravityMessagesDeclineReason(route, body as Rec, model, config, { cacheDiagnostics: cacheDiagnosticsObserving() });
+  return reason === "rollout-disabled" || reason === "not-migrated" ? undefined : reason;
+}
+
+/**
+ * The core option for a planned request. The bridge conversation is translated at most once, and
+ * only if the core asks for it (a reroute, or an ambiguous-reset judgment).
+ */
+export function messagesDirectRequestOption(
+  plan: MessagesDirectPlan,
+  body: unknown,
+  cc: OcxClaudeCodeConfig | undefined,
+  budget: TranslatorBudget,
+): DirectRequestOption {
+  let bridge: Rec | undefined;
+  return {
+    protocol: "messages",
+    providerName: plan.providerName,
+    modelId: plan.modelId,
+    evidence: plan.evidence,
+    decode: base => withDirectMessagesConversation(
+      base,
+      plan.conversation,
+      modelId => messagesConversationToIr(body, cc, budget, modelId),
+    ),
+    bridgeConversation: () => {
+      bridge ??= messagesToResponsesTranslation(body, cc, budget).body;
+      return {
+        input: bridge.input,
+        ...(bridge.instructions !== undefined ? { instructions: bridge.instructions } : {}),
+        ...(bridge.tools !== undefined ? { tools: bridge.tools } : {}),
+      };
+    },
+  };
+}
+

package/src/server/messages-native.ts

@@ -82,6 +82,7 @@ import { preservesPhysicalComboProvider, resolveComboId } from "../combos";
 import { captureRouteStaticPolicy, routedProviderConfig, routeModel, type RouteResult } from "../router";
 import { POLICY_NAMESPACE, resolvePolicyProfileId } from "../routing/profile";
 import type { AnthropicClientIdentity } from "../adapters/anthropic/client-identity";
+import { logDroppedAnthropicBetas } from "../adapters/anthropic/beta-allowlist";
 import type { OcxConfig, OcxProviderConfig, OcxUsage } from "../types";
 import { resolveWireProtocolOverride } from "./adapter-resolve";
 import {
@@ -469,7 +470,10 @@ export async function handleNativeMessages(options: HandleNativeMessagesOptions)
       clientIdentity: options.clientIdentity,
     });
     if (built.strippedOpaqueState && rejectUnrepresentable) throw new NativeOpaqueStateRefusal();
-    if (built.droppedBetas) addProtocolEntryReason(logCtx, "anthropic-beta-dropped");
+    if (built.droppedBetas) {
+      addProtocolEntryReason(logCtx, "anthropic-beta-dropped");
+      logDroppedAnthropicBetas({ droppedNames: built.droppedBetaNames, droppedUnrecognized: built.droppedUnrecognizedBetas });
+    }
     if (built.strippedOpaqueState) addProtocolEntryReason(logCtx, "opaque-state-stripped");
     return built;
   };

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({

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

@@ -112,6 +112,7 @@ import { mapCodexAuthContextErrorToResponse } from "./codex-auth-error";
 import { chargeWorkflowSends } from "../../lib/workflow-budget";
 import { isAntigravityValidationRefusal } from "./antigravity-validation-refusal";
 import { unboundPoolSpendRefusalResponse } from "../workflow-refusal";
+import { AdmissionModelDeniedError, admissionModelDeniedResponse } from "../admission-model-scope";
 
 /** One responsibility of the Responses request pipeline; state owners are explicit. */
 export async function prepareAdapterExchange(
@@ -225,8 +226,13 @@ export async function prepareAdapterExchange(
 
 
   let selfContainedJudgment: boolean | undefined;
+  // On the Antigravity direct lane the raw body carries only settings; judge the body the bridge
+  // would have sent, built only if an ambiguous reset actually asks.
+  const directRequest = options.directRequest;
   const requestIsSelfContained = (): boolean =>
-    selfContainedJudgment ??= selfContainedResponsesBody(parsed._rawBody);
+    selfContainedJudgment ??= selfContainedResponsesBody(directRequest
+      ? { ...(parsed._rawBody as Record<string, unknown>), ...directRequest.bridgeConversation() }
+      : parsed._rawBody);
   const claimPreHeaderResend = (): boolean => authorizeResendForRecovery(
     "pre-header", "connection-reset",
     ambiguousResendAllowanceFor(route.provider, requestIsSelfContained, claimAmbiguousResend),
@@ -541,6 +547,10 @@ export async function prepareAdapterExchange(
       return storageRefusal;
     }
     const refusal = err instanceof UpstreamRetryEvidenceError ? err.cause : err;
+    if (refusal instanceof AdmissionModelDeniedError) {
+      releaseCodexAuthContextProbeLease(admissionState.authCtx);
+      return admissionModelDeniedResponse(refusal);
+    }
     const codexRefusal = mapCodexAuthContextErrorToResponse(unwrapUpstreamRetryEvidenceError(err), {
       now: Date.now(), accountSelector: route.codexAccountNamespace,
     });
@@ -810,6 +820,13 @@ export async function prepareAdapterExchange(
           releaseCodexAuthContextProbeLease(admissionState.authCtx);
           return { failed: storageRefusal };
         }
+        const scopeRefusal = unwrapUpstreamRetryEvidenceError(err);
+        if (!options.abortSignal?.aborted && scopeRefusal instanceof AdmissionModelDeniedError) {
+          cleanupUpstreamAbort();
+          upstream.abort();
+          releaseCodexAuthContextProbeLease(admissionState.authCtx);
+          return { failed: admissionModelDeniedResponse(scopeRefusal) };
+        }
         const codexRefusal = !options.abortSignal?.aborted && mapCodexAuthContextErrorToResponse(unwrapUpstreamRetryEvidenceError(err), {
           now: Date.now(), accountSelector: route.codexAccountNamespace,
         });
@@ -1539,7 +1556,17 @@ export async function prepareAdapterExchange(
           // The hop's permit is already settled by the dispatch boundary above; continuing
           // only skips the remaining arms, it does not abandon a reservation.
           if (isNonReplayableResponse(upstreamResponse)) continue recovery;
-       } catch {
+       } catch (err) {
+          // A local admission denial is terminal for the whole request: rotating to another
+          // account cannot re-scope the key, so the refusal answers in place of the 429.
+          const scopeRefusal = unwrapUpstreamRetryEvidenceError(err);
+          if (!options.abortSignal?.aborted && scopeRefusal instanceof AdmissionModelDeniedError) {
+            hop.permit?.release();
+            cleanupUpstreamAbort();
+            upstream.abort();
+            releaseCodexAuthContextProbeLease(admissionState.authCtx);
+            return admissionModelDeniedResponse(scopeRefusal);
+          }
          // A throw before the send — snapshot fetch, credential application, adapter
           // resolution — must hand the reservation back. Without this the ladder charges the
           // request for a send it never made, and a later recovery in the same request is

package/src/server/responses/advisor-plan-slot.ts

@@ -0,0 +1,27 @@
+/** Core-owned, config-scoped registration. An inactive install has no Advisor factory. */
+import type { OcxConfig, OcxParsedRequest, OcxTool } from "../../types";
+
+export interface AdvisorPlanInput {
+  config: OcxConfig;
+  workerIdentity: string;
+  workerModelId: string;
+  abortSignal?: AbortSignal;
+}
+
+export interface RegisteredAdvisorPlan {
+  tool: OcxTool;
+  preflightInject(parsed: OcxParsedRequest): Promise<boolean>;
+  attachGuard(parsed: OcxParsedRequest): void;
+}
+
+type AdvisorPlanFactory = (input: AdvisorPlanInput) => Promise<RegisteredAdvisorPlan | null>;
+const factories = new WeakMap<OcxConfig, AdvisorPlanFactory>();
+
+export function setAdvisorPlanFactory(config: OcxConfig, factory: AdvisorPlanFactory | null): void {
+  if (factory) factories.set(config, factory);
+  else factories.delete(config);
+}
+
+export function createRegisteredAdvisorPlan(input: AdvisorPlanInput): Promise<RegisteredAdvisorPlan | null> | null {
+  return factories.get(input.config)?.(input) ?? null;
+}