@yansigit/opencodex 2.36.1-dev.20260829.39 → 2.36.1-dev.20260829.47

package/src/codex/subagent-model-authority.ts

@@ -0,0 +1,189 @@
+import type { OcxConfig } from "../types";
+import { isEligibleV2SubagentEntry, readCatalog, readCodexCatalogPath } from "./catalog";
+import { catalogEntryEfforts } from "./catalog/effort";
+import type { RawEntry } from "./catalog/parsing";
+import { resolveNativeDefaultState, type NativeDefaultState } from "./subagent-defaults";
+
+export const SUBAGENT_MODEL_AUTHORITY_VERSION = 1 as const;
+
+export interface SubagentModelAuthorityInput {
+  schemaVersion: typeof SUBAGENT_MODEL_AUTHORITY_VERSION;
+  role: string;
+  agentType: string;
+  typedDispatchRequired?: boolean;
+  requestedModel?: string;
+  requestedEffort?: string;
+  spawnAgent: {
+    surface: "v1" | "v2";
+    supportsAgentType: boolean;
+    supportsModel: boolean;
+    supportsEffort: boolean;
+    supportsForkTurns: boolean;
+  };
+  confirmation?: { decision: "approve" | "decline" };
+  interactive?: boolean;
+}
+
+export interface SubagentModelAuthorityHost {
+  catalogState: "fresh" | "stale" | "not_running" | "unknown";
+  nativeDefaultState: NativeDefaultState;
+  preferredModel: string | null;
+  preferredEffort: string | null;
+  executableModels: Array<{ model: string; efforts: string[] }>;
+}
+
+export type SubagentModelAuthorityResult = {
+  schemaVersion: typeof SUBAGENT_MODEL_AUTHORITY_VERSION;
+  decision: "forward" | "omit" | "confirm" | "blocked";
+  requestClassification: "inherit" | "preferred" | "exception";
+  reason: string;
+  spawn?: {
+    agent_type?: string;
+    model?: string;
+    reasoning_effort?: string;
+    fork_turns?: "none";
+  };
+  confirmation?: {
+    role: string;
+    preferredModel: string | null;
+    requestedModel: string;
+    scope: "single spawn";
+  };
+};
+
+export function parseSubagentModelAuthorityInput(value: unknown): SubagentModelAuthorityInput | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const input = value as Record<string, unknown>;
+  const spawn = input.spawnAgent;
+  if (!spawn || typeof spawn !== "object" || Array.isArray(spawn)) return null;
+  const tool = spawn as Record<string, unknown>;
+  if (input.schemaVersion !== SUBAGENT_MODEL_AUTHORITY_VERSION
+    || typeof input.role !== "string"
+    || typeof input.agentType !== "string"
+    || (input.typedDispatchRequired !== undefined && typeof input.typedDispatchRequired !== "boolean")
+    || (input.requestedModel !== undefined && typeof input.requestedModel !== "string")
+    || (input.requestedEffort !== undefined && typeof input.requestedEffort !== "string")
+    || (input.interactive !== undefined && typeof input.interactive !== "boolean")
+    || (tool.surface !== "v1" && tool.surface !== "v2")
+    || ["supportsAgentType", "supportsModel", "supportsEffort", "supportsForkTurns"]
+      .some(key => typeof tool[key] !== "boolean")) return null;
+  if (input.confirmation !== undefined) {
+    if (!input.confirmation || typeof input.confirmation !== "object" || Array.isArray(input.confirmation)) return null;
+    const decision = (input.confirmation as Record<string, unknown>).decision;
+    if (decision !== "approve" && decision !== "decline") return null;
+  }
+  return value as SubagentModelAuthorityInput;
+}
+
+function result(
+  decision: SubagentModelAuthorityResult["decision"],
+  requestClassification: SubagentModelAuthorityResult["requestClassification"],
+  reason: string,
+  extra: Pick<SubagentModelAuthorityResult, "spawn" | "confirmation"> = {},
+): SubagentModelAuthorityResult {
+  return { schemaVersion: SUBAGENT_MODEL_AUTHORITY_VERSION, decision, requestClassification, reason, ...extra };
+}
+
+export function resolveSubagentModelAuthority(
+  input: SubagentModelAuthorityInput,
+  host: SubagentModelAuthorityHost,
+): SubagentModelAuthorityResult {
+  const requestedModel = input.requestedModel?.trim() || undefined;
+  const preferredModel = host.preferredModel?.trim() || undefined;
+  const classification = requestedModel === undefined
+    ? "inherit"
+    : requestedModel === preferredModel ? "preferred" : "exception";
+  if (input.schemaVersion !== SUBAGENT_MODEL_AUTHORITY_VERSION) {
+    return result("blocked", classification, "unsupported authority schema version");
+  }
+  if (!input.role.trim() || !input.agentType.trim()) {
+    return result("blocked", classification, "role and agentType must be non-empty");
+  }
+  if (input.typedDispatchRequired && !input.spawnAgent.supportsAgentType) {
+    return result("blocked", classification, "spawn_agent does not support required agent_type dispatch");
+  }
+  if (host.catalogState === "stale" || host.catalogState === "unknown") {
+    return result("blocked", classification, "OpenCodex model authority is not current; sync or restart Codex and retry");
+  }
+
+  const chosenModel = requestedModel ?? preferredModel;
+  const executable = chosenModel
+    ? host.executableModels.find(candidate => candidate.model === chosenModel)
+    : undefined;
+  if (chosenModel && !executable) {
+    return result("blocked", classification, `model ${JSON.stringify(chosenModel)} is not executable on this collaboration surface`);
+  }
+  if (chosenModel && !input.spawnAgent.supportsModel) {
+    return result("blocked", classification, "spawn_agent does not support model overrides");
+  }
+  const effort = input.requestedEffort?.trim() || (requestedModel ? undefined : host.preferredEffort?.trim()) || undefined;
+  if (effort && !input.spawnAgent.supportsEffort) {
+    return result("blocked", classification, "spawn_agent does not support reasoning_effort overrides");
+  }
+  if (effort && executable && !executable.efforts.includes(effort)) {
+    return result("blocked", classification, `reasoning effort ${JSON.stringify(effort)} is unavailable for ${JSON.stringify(chosenModel)}`);
+  }
+
+  if (classification === "exception") {
+    if (input.confirmation?.decision === "decline") {
+      return result("blocked", classification, "single-spawn model exception was declined");
+    }
+    if (input.confirmation?.decision !== "approve") {
+      if (input.interactive === false) {
+        return result("blocked", classification, "single-spawn model exception requires interactive confirmation");
+      }
+      return result("confirm", classification, "confirm this model exception for one spawn", {
+        confirmation: {
+          role: input.role,
+          preferredModel: preferredModel ?? null,
+          requestedModel: requestedModel!,
+          scope: "single spawn",
+        },
+      });
+    }
+  }
+
+  if (!chosenModel) {
+    return host.nativeDefaultState === "active"
+      ? result("omit", classification, "native OpenCodex defaults are active")
+      : result("blocked", classification, `native OpenCodex defaults are ${host.nativeDefaultState}`);
+  }
+  const spawn: NonNullable<SubagentModelAuthorityResult["spawn"]> = {
+    ...(input.spawnAgent.supportsAgentType ? { agent_type: input.agentType } : {}),
+    model: chosenModel,
+    ...(effort ? { reasoning_effort: effort } : {}),
+    ...((input.spawnAgent.supportsForkTurns && (chosenModel || effort)) ? { fork_turns: "none" as const } : {}),
+  };
+  return result("forward", classification, classification === "exception"
+    ? "single-spawn model exception approved"
+    : "OpenCodex preferred model is executable", { spawn });
+}
+
+function executableModels(entries: readonly RawEntry[], surface: "v1" | "v2"): SubagentModelAuthorityHost["executableModels"] {
+  const seen = new Set<string>();
+  return entries.flatMap(entry => {
+    const model = typeof entry.slug === "string" ? entry.slug.trim() : "";
+    if (!model || seen.has(model) || entry.visibility !== "list" || (surface === "v2" && !isEligibleV2SubagentEntry(entry))) return [];
+    seen.add(model);
+    return [{ model, efforts: catalogEntryEfforts(entry) }];
+  });
+}
+
+export async function resolveOpenCodexSubagentModelAuthority(
+  input: SubagentModelAuthorityInput,
+  config: OcxConfig,
+): Promise<SubagentModelAuthorityResult> {
+  const { collectCodexAppServerCatalogStateForRequest } = await import("./app-server-processes");
+  const catalogState = await collectCodexAppServerCatalogStateForRequest();
+  const models = executableModels(readCatalog(readCodexCatalogPath())?.models ?? [], input.spawnAgent.surface);
+  const configured = config.injectionModel?.trim() || null;
+  const exact = configured ? models.find(candidate => candidate.model === configured)?.model ?? null : null;
+  const host: SubagentModelAuthorityHost = {
+    catalogState: catalogState.state,
+    nativeDefaultState: await resolveNativeDefaultState(config),
+    preferredModel: exact,
+    preferredEffort: config.injectionEffort?.trim() || null,
+    executableModels: models,
+  };
+  return resolveSubagentModelAuthority(input, host);
+}

package/src/generated/compatibility-version.json

@@ -10,7 +10,7 @@
     },
     {
       "path": "package.json",
-      "sha256": "0056c7ad8f06271be7aceee8ea055ad817e2aeeb3ede46fcf21b48e812c1c420"
+      "sha256": "f144c82b1b83fe866cfa13a56819ec264953f5e228c08bf2df632f903a4be07d"
     },
     {
       "path": "scripts/model-metadata.source.json",
@@ -338,7 +338,7 @@
     },
     {
       "path": "src/adapters/openai-responses.ts",
-      "sha256": "76f9243d893c5275cdfafcd51a8d0a4205451ef0668d7608f1320ff926fe5a16"
+      "sha256": "5357d3b799bacbed86917ca68031c3625686ccd32659d7a9bc8167edb0955c57"
     },
     {
       "path": "src/adapters/registry.ts",
@@ -486,7 +486,7 @@
     },
     {
       "path": "src/cli/agent.ts",
-      "sha256": "549c31a1ffe8e856094e0db1eb376e9b82d6b5f3763edd2e410acc403dadb771"
+      "sha256": "3caa13112d1023cafefc56addb66d7e36fcb05b1b71a29caf675a7893d69d574"
     },
     {
       "path": "src/cli/alias.ts",
@@ -614,7 +614,7 @@
     },
     {
       "path": "src/cli/registry.ts",
-      "sha256": "a90b57f449e91d67a409abb89ad8126c97f899b82930de18c205bf5553753f77"
+      "sha256": "66f2c0dad2451db553e7e0ae7905c78c3261e8ce2d76684d358a7148ab1582c9"
     },
     {
       "path": "src/cli/replit-gateway-key-input.ts",
@@ -766,7 +766,7 @@
     },
     {
       "path": "src/codex/catalog.ts",
-      "sha256": "2916321bbfbd26112dc816055a452348251a1b65a2a2535b089c9135c690499a"
+      "sha256": "9e7af66b04e8718f4b7bf822994941a06b4135253a98668963e77bd88c9c3076"
     },
     {
       "path": "src/codex/catalog/account-models.ts",
@@ -898,7 +898,7 @@
     },
     {
       "path": "src/codex/inject.ts",
-      "sha256": "fed0dd2913d0ca07fb8486a91e74411dce65ca96fb8ca989e4fca0984e71f14e"
+      "sha256": "22fe9dc3b8fe3994b921ad619807b899e609834ea69e47c5b9494075327341a2"
     },
     {
       "path": "src/codex/injected-marker.ts",
@@ -1098,7 +1098,11 @@
     },
     {
       "path": "src/codex/subagent-defaults.ts",
-      "sha256": "08e3efa192430891d9d221d41e5124177c2c03656e3eb832087fdfb778a7703e"
+      "sha256": "c2683dd65ab7565c703e6637c5aa6c22c6a937d264e369efabb3eddabe7ba88a"
+    },
+    {
+      "path": "src/codex/subagent-model-authority.ts",
+      "sha256": "09928c56938d711365c324653e5870fc9f7aad021abae20e7d7a7ad870e52053"
     },
     {
       "path": "src/codex/subagent-model-fallback.ts",
@@ -2710,7 +2714,7 @@
     },
     {
       "path": "src/server/management/agent-settings-routes.ts",
-      "sha256": "2ba31a9adb7ba798a7a9fdeada3a2430ad2497205ec3671f4c3a5bfbab68f8c5"
+      "sha256": "8046634493d0317a25b283e5ffa0007cf3a54dadcda5b6e7e7dcf83743f718bc"
     },
     {
       "path": "src/server/management/api-access.ts",
@@ -2934,7 +2938,7 @@
     },
     {
       "path": "src/server/responses/collaboration.ts",
-      "sha256": "c06f21efd00814eb1021b73e4fe16e693a93205768f8f1a55c63e854e657075d"
+      "sha256": "614afac38832befe772e6b59f6dedd3dfd44546a8f48ea2660fdcb0f9f1c089f"
     },
     {
       "path": "src/server/responses/combo-stream-preflight.ts",
@@ -2946,7 +2950,7 @@
     },
     {
       "path": "src/server/responses/core.ts",
-      "sha256": "ff08c82f4289d3227725566fd7637e8f7b382bb0a1f303846f9c2da9c7889acf"
+      "sha256": "f5e37d03f10f99d7000421ef0ec8b0d63d064c67afe87eb24631e502f50fe62f"
     },
     {
       "path": "src/server/responses/empty-completion-guard.ts",

package/src/server/management/agent-settings-routes.ts

@@ -792,6 +792,18 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
   // dynamically injected into the v1 proactive prompt, plus an optional reasoning
   // effort the prompt tells the agent to pass to spawn_agent. GET returns the current
   // picks + available models/efforts; PUT sets or clears them.
+  if (url.pathname === "/api/subagent-model-authority" && req.method === "POST") {
+    let body: unknown;
+    try { body = await readManagementJsonBody(req); } catch (error) {
+      rethrowManagementBodyTooLarge(error);
+      return jsonResponse({ error: "invalid JSON body" }, 400);
+    }
+    const { parseSubagentModelAuthorityInput, resolveOpenCodexSubagentModelAuthority } = await import("../../codex/subagent-model-authority");
+    const input = parseSubagentModelAuthorityInput(body);
+    if (!input) return jsonResponse({ error: "invalid subagent model authority input" }, 400);
+    return jsonResponse(await resolveOpenCodexSubagentModelAuthority(input, config));
+  }
+
   if (url.pathname === "/api/injection-model" && req.method === "GET") {
     const models = await fetchAllModels(config);
     const disabled = new Set(config.disabledModels ?? []);

package/src/server/responses/collaboration.ts

@@ -447,7 +447,7 @@ export async function multiAgentGuidanceText(
       preferredText = ` Preferred sub-agent: model "${preferred.model}"`
         + (injectionEffort ? `, reasoning_effort "${injectionEffort}"` : "")
         + `; nativeDefaultState: ${nativeDefaultState}.`
-        + " — use it unless the user names another.";
+        + " — use it unless the user names another. Confirm a different listed model for one spawn only; do not persist the exception.";
     }
     const specialist = (catalog: string): string =>
       catalog ? ` When spawning, use a named specialist: ${catalog}.` : "";

package/src/server/responses/core.ts

@@ -3502,19 +3502,17 @@ async function handleResponsesInner(
       }
       throw error;
     }
-    if (!isCanonicalOpenAiForwardProvider(route.provider)) {
-      for (const name of request.convertedRoutedCustomToolNames ?? []) {
-        if (
-          toolBridgeMaps.freeformToolNames.has(name)
-          || toolBridgeMaps.toolNsMap.get(name)?.freeform === true
-        ) routedCustomToolNames.add(name);
-      }
-      for (const name of request.routedCustomToolRepairNames ?? []) {
-        if (
-          toolBridgeMaps.freeformToolNames.has(name)
-          || toolBridgeMaps.toolNsMap.get(name)?.freeform === true
-        ) routedCustomToolRepairNames.add(name);
-      }
+    for (const name of request.convertedRoutedCustomToolNames ?? []) {
+      if (
+        toolBridgeMaps.freeformToolNames.has(name)
+        || toolBridgeMaps.toolNsMap.get(name)?.freeform === true
+      ) routedCustomToolNames.add(name);
+    }
+    for (const name of request.routedCustomToolRepairNames ?? []) {
+      if (
+        toolBridgeMaps.freeformToolNames.has(name)
+        || toolBridgeMaps.toolNsMap.get(name)?.freeform === true
+      ) routedCustomToolRepairNames.add(name);
     }
     for (const name of request.convertedRoutedToolSearchNames ?? []) {
       // The adapter already keeps this set empty when tool_choice forbids the private search.