@vellumai/assistant 0.8.4 → 0.8.5

package/src/providers/__tests__/connection-model-compat.test.ts

@@ -0,0 +1,234 @@
+/**
+ * Tests for the Codex-subscription model-compatibility gate on auto-resolved
+ * provider connections.
+ *
+ * When a profile uses "Any active OpenAI connection" (no `provider_connection`
+ * pinned), the daemon auto-picks an active OpenAI connection. An
+ * `oauth_subscription` (ChatGPT Codex) connection hard-routes to the Codex
+ * endpoint, which rejects non-Codex models with HTTP 400. The gate skips such
+ * a connection during auto-resolution unless the model is Codex-compatible.
+ *
+ * Two layers are covered:
+ *   1. `isConnectionCompatibleWithModel` — the pure predicate.
+ *   2. `getConfiguredProvider` — the auto-resolution path that uses the
+ *      predicate as an additional `.find()` filter, plus the pinned-connection
+ *      path which bypasses the gate entirely.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { isConnectionCompatibleWithModel } from "../connection-model-compat.js";
+import type { Auth } from "../inference/auth.js";
+
+// ---------------------------------------------------------------------------
+// Pure predicate tests — no mocking required.
+// ---------------------------------------------------------------------------
+
+const apiKeyAuth: Auth = { type: "api_key", credential: "credential/x" };
+const platformAuth: Auth = { type: "platform" };
+const oauthAuth: Auth = {
+  type: "oauth_subscription",
+  credential: "credential/x",
+};
+
+describe("isConnectionCompatibleWithModel", () => {
+  test("api_key connection is compatible with any model", () => {
+    const conn = { auth: apiKeyAuth };
+    expect(isConnectionCompatibleWithModel(conn, "gpt-5")).toBe(true);
+    expect(isConnectionCompatibleWithModel(conn, "gpt-5.4")).toBe(true);
+  });
+
+  test("platform connection is compatible with any model", () => {
+    const conn = { auth: platformAuth };
+    expect(isConnectionCompatibleWithModel(conn, "gpt-5.4-nano")).toBe(true);
+  });
+
+  test("oauth_subscription connection is incompatible with a non-Codex model", () => {
+    const conn = { auth: oauthAuth };
+    expect(isConnectionCompatibleWithModel(conn, "gpt-5")).toBe(false);
+    expect(isConnectionCompatibleWithModel(conn, "gpt-5.5")).toBe(false);
+    expect(isConnectionCompatibleWithModel(conn, "gpt-5.4-nano")).toBe(false);
+  });
+
+  test("oauth_subscription connection is compatible with a Codex model", () => {
+    const conn = { auth: oauthAuth };
+    expect(isConnectionCompatibleWithModel(conn, "gpt-5.4")).toBe(true);
+    expect(isConnectionCompatibleWithModel(conn, "gpt-5.3-codex")).toBe(true);
+  });
+
+  test("undefined model applies no gating (compatible)", () => {
+    const conn = { auth: oauthAuth };
+    expect(isConnectionCompatibleWithModel(conn, undefined)).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Integration tests through `getConfiguredProvider` — module mocks below must
+// be declared before the import-under-test.
+// ---------------------------------------------------------------------------
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+let mockLlmConfig: Record<string, unknown> = {};
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({
+    llm: mockLlmConfig,
+    services: { inference: { mode: "your-own" } },
+  }),
+}));
+
+const mockDbSentinel = { __mock: "db" };
+mock.module("../../memory/db-connection.js", () => ({
+  getDb: () => mockDbSentinel,
+}));
+
+type Connection = {
+  name: string;
+  provider: string;
+  status: string;
+  auth: { type: string; credential?: string };
+};
+
+// Ordered list the mocked `listConnections` returns. `.find()` walks it in
+// order, so insertion order is meaningful for these tests.
+let fakeConnectionList: Connection[] = [];
+const fakeConnectionsByName = new Map<string, Connection>();
+
+mock.module("../inference/connections.js", () => ({
+  getConnection: (_db: unknown, name: string) =>
+    fakeConnectionsByName.get(name) ?? null,
+  listConnections: (_db: unknown, filter?: { provider?: string }) =>
+    filter?.provider
+      ? fakeConnectionList.filter((c) => c.provider === filter.provider)
+      : fakeConnectionList,
+}));
+
+// Records the connection name handed to the resolver so tests can assert
+// which connection auto-resolution selected.
+const resolveProviderCalls: Connection[] = [];
+
+mock.module("../registry.js", () => ({
+  getProvider: (name: string) => {
+    throw new Error(`legacy getProvider should not be called: ${name}`);
+  },
+  initializeProviders: async () => {},
+  listProviders: () => [{ name: "stub" }],
+  resolveProviderFromConnection: async (connection: Connection) => {
+    resolveProviderCalls.push(connection);
+    return { name: connection.provider, tag: connection.name };
+  },
+}));
+
+import { getConfiguredProvider } from "../provider-send-message.js";
+
+function registerConnections(connections: Connection[]): void {
+  fakeConnectionList = connections;
+  for (const c of connections) fakeConnectionsByName.set(c.name, c);
+}
+
+function reset(): void {
+  resolveProviderCalls.length = 0;
+  fakeConnectionList = [];
+  fakeConnectionsByName.clear();
+  mockLlmConfig = {};
+}
+
+const OPENAI_KEY: Connection = {
+  name: "openai-key",
+  provider: "openai",
+  status: "active",
+  auth: { type: "api_key", credential: "credential/openai" },
+};
+const OPENAI_CODEX: Connection = {
+  name: "openai-codex",
+  provider: "openai",
+  status: "active",
+  auth: {
+    type: "oauth_subscription",
+    credential: "credential/openai-codex/access_token",
+  },
+};
+
+describe("auto-resolution skips oauth_subscription connections for non-Codex models", () => {
+  beforeEach(reset);
+
+  test("non-Codex model picks the api_key connection over a (first-listed) oauth_subscription one", async () => {
+    // oauth_subscription listed FIRST — without the gate, insertion order
+    // would have selected it and misrouted gpt-5 to the Codex endpoint.
+    registerConnections([OPENAI_CODEX, OPENAI_KEY]);
+    setOpenAiProfile("gpt-5");
+
+    const result = await getConfiguredProvider("mainAgent", {
+      overrideProfile: "openai-any",
+    });
+
+    expect(result).not.toBeNull();
+    expect(resolveProviderCalls.length).toBe(1);
+    expect(resolveProviderCalls[0].name).toBe("openai-key");
+  });
+
+  test("Codex model can select the oauth_subscription connection", async () => {
+    registerConnections([OPENAI_CODEX, OPENAI_KEY]);
+    setOpenAiProfile("gpt-5.4");
+
+    const result = await getConfiguredProvider("mainAgent", {
+      overrideProfile: "openai-any",
+    });
+
+    expect(result).not.toBeNull();
+    expect(resolveProviderCalls.length).toBe(1);
+    expect(resolveProviderCalls[0].name).toBe("openai-codex");
+  });
+
+  test("non-Codex model with only an oauth_subscription connection resolves to null (no misroute)", async () => {
+    // Pure-predicate gate: the lone oauth_subscription connection is filtered
+    // out, so auto-resolution finds nothing and the call site falls back
+    // gracefully rather than dispatching gpt-5 to the Codex endpoint.
+    registerConnections([OPENAI_CODEX]);
+    setOpenAiProfile("gpt-5");
+
+    const result = await getConfiguredProvider("mainAgent", {
+      overrideProfile: "openai-any",
+    });
+
+    expect(result).toBeNull();
+    expect(resolveProviderCalls.length).toBe(0);
+  });
+
+  test("explicitly pinned oauth_subscription connection is used regardless of model", async () => {
+    registerConnections([OPENAI_CODEX, OPENAI_KEY]);
+    mockLlmConfig = {
+      default: { provider: "anthropic", model: "claude-opus-4-7" },
+      profiles: {
+        "openai-pinned": {
+          provider: "openai",
+          model: "gpt-5",
+          provider_connection: "openai-codex",
+        },
+      },
+    };
+
+    const result = await getConfiguredProvider("mainAgent", {
+      overrideProfile: "openai-pinned",
+    });
+
+    // The pinned connection bypasses the auto-resolution gate entirely.
+    expect(result).not.toBeNull();
+    expect(resolveProviderCalls.length).toBe(1);
+    expect(resolveProviderCalls[0].name).toBe("openai-codex");
+  });
+});
+
+function setOpenAiProfile(model: string): void {
+  mockLlmConfig = {
+    default: { provider: "anthropic", model: "claude-opus-4-7" },
+    profiles: {
+      // "Any active OpenAI connection" — provider set, no provider_connection.
+      "openai-any": { provider: "openai", model },
+    },
+  };
+}

package/src/providers/__tests__/retry-callsite.test.ts

@@ -425,7 +425,7 @@ describe("RetryProvider — callSite resolution", () => {
     expect(config.temperature).toBe(0.5);
   });
 
-  test("strips effort/speed/thinking for providers that don't support them", async () => {
+  test("strips effort/speed for providers that don't support them (e.g. fireworks)", async () => {
     setLlmConfig({
       default: {
         provider: "anthropic",
@@ -434,14 +434,14 @@ describe("RetryProvider — callSite resolution", () => {
         speed: "fast",
       },
       callSites: {
-        memoryRetrieval: { thinking: { enabled: true } },
+        memoryRetrieval: { thinking: { enabled: false } },
       },
     });
 
     let seen: SendMessageOptions | undefined;
-    // gemini does not support effort/speed/thinking — they must be stripped.
+    // fireworks does not support speed or thinking — they must be stripped.
     const wrapped = new RetryProvider(
-      makeProvider("gemini", (options) => {
+      makeProvider("fireworks", (options) => {
         seen = options;
       }),
     );
@@ -451,13 +451,93 @@ describe("RetryProvider — callSite resolution", () => {
     });
 
     const config = seen?.config as Record<string, unknown>;
-    expect(config.effort).toBeUndefined();
     expect(config.speed).toBeUndefined();
     expect(config.thinking).toBeUndefined();
     // Model still comes through.
     expect(config.model).toBe("claude-opus-4-7");
   });
 
+  test("preserves thinking + level for Gemini provider", async () => {
+    setLlmConfig({
+      default: {
+        provider: "gemini",
+        model: "gemini-3.5-flash",
+        thinking: { enabled: true, streamThinking: true, level: "high" },
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("gemini", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { callSite: "mainAgent" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.thinking).toEqual({
+      type: "adaptive",
+      level: "high",
+      streamThinking: true,
+    });
+  });
+
+  test("Gemini disabled thinking carries the wire `disabled` discriminator", async () => {
+    setLlmConfig({
+      default: {
+        provider: "gemini",
+        model: "gemini-3.5-flash",
+        thinking: { enabled: false, streamThinking: false },
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("gemini", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { callSite: "mainAgent" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.thinking).toEqual({ type: "disabled" });
+  });
+
+  test("scrubs Gemini-only thinking extras (level, streamThinking) for Anthropic", async () => {
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        thinking: { enabled: true, streamThinking: true, level: "high" },
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("anthropic", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { callSite: "mainAgent" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    // Anthropic's SDK rejects unknown keys inside the `thinking` object with
+    // "Extra inputs are not permitted" — must be exactly `{ type }`.
+    expect(config.thinking).toEqual({ type: "adaptive" });
+  });
+
   test("explicit per-call config.model wins over resolved callSite model", async () => {
     setLlmConfig({
       default: { provider: "anthropic", model: "resolved-model" },

package/src/providers/anthropic/client.ts

@@ -1,6 +1,5 @@
 import Anthropic from "@anthropic-ai/sdk";
 
-import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../../prompts/system-prompt.js";
 import { isAbortReason } from "../../util/abort-reasons.js";
 import { ProviderError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
@@ -819,6 +818,15 @@ export class AnthropicProvider implements Provider {
       ((config as Record<string, unknown> | undefined)?.cacheTtl as
         | "5m"
         | "1h") ?? "1h";
+    // Opt-out for callers (e.g. the memory router) that send a single
+    // user message per call with content that changes every time. The
+    // turn-start cache breakpoint below is only useful when the same
+    // prefix is re-sent on a subsequent call (typical for the main agent
+    // loop's tool-use iterations); one-shot callers pay cache_creation
+    // cost without a future hit.
+    const disableTurnStartCache =
+      (config as Record<string, unknown> | undefined)?.disableTurnStartCache ===
+      true;
     let sentMessages: Anthropic.MessageParam[] | undefined;
     const startedAt = Date.now();
     // Hoisted so the catch block can distinguish our inner stream timeout
@@ -980,14 +988,11 @@ export class AnthropicProvider implements Provider {
       // followed by user tool_result). Replaying stale thinking blocks from
       // earlier turns causes 400 errors when the signature is no longer
       // valid (e.g. after a provider/model/profile switch).
-      const activeToolUseStart =
-        findActiveToolUseContinuationStart(formatted);
+      const activeToolUseStart = findActiveToolUseContinuationStart(formatted);
       for (let i = 0; i < activeToolUseStart; i++) {
         const msg = formatted[i];
         if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
-        const stripped = (
-          msg.content as Anthropic.ContentBlockParam[]
-        ).filter(
+        const stripped = (msg.content as Anthropic.ContentBlockParam[]).filter(
           (b) =>
             typeof b === "string" ||
             (b.type !== "thinking" && b.type !== "redacted_thinking"),
@@ -1009,6 +1014,7 @@ export class AnthropicProvider implements Provider {
         speed,
         output_config,
         cacheTtl: _cacheTtl,
+        disableTurnStartCache: _disableTurnStartCache,
         max_tokens: callerMaxTokens,
         usageAttributionHeaders,
         ...restConfig
@@ -1065,38 +1071,17 @@ export class AnthropicProvider implements Provider {
       };
 
       if (systemPrompt) {
-        const boundaryIdx = systemPrompt.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-        if (boundaryIdx >= 0) {
-          // Split into two cache blocks: static instructions (stable across
-          // turns) and dynamic workspace content (changes when files are
-          // edited).  The static prefix stays cached even when workspace
-          // files change, saving ~8-10K tokens of cache creation per turn.
-          // Both blocks use 1-hour cache TTL to avoid repeated cache misses
-          // for conversations with turn gaps exceeding the default 5-minute
-          // window.
-          const staticBlock = systemPrompt.slice(0, boundaryIdx);
-          const dynamicBlock = systemPrompt.slice(
-            boundaryIdx + SYSTEM_PROMPT_CACHE_BOUNDARY.length,
-          );
-          const systemBlocks = [staticBlock, dynamicBlock]
-            .filter((text) => text.length > 0)
-            .map((text) => ({
-              type: "text" as const,
-              text,
-              cache_control: cacheControl,
-            }));
-          if (systemBlocks.length > 0) {
-            params.system = systemBlocks;
-          }
-        } else {
-          params.system = [
-            {
-              type: "text" as const,
-              text: systemPrompt,
-              cache_control: cacheControl,
-            },
-          ];
-        }
+        // The whole system prompt is rendered as a single cached
+        // block.  A 1-hour cache TTL is used (when supported by the
+        // model) so the breakpoint survives turn gaps that exceed the
+        // default 5-minute window.
+        params.system = [
+          {
+            type: "text" as const,
+            text: systemPrompt,
+            cache_control: cacheControl,
+          },
+        ];
       }
 
       if (tools && tools.length > 0) {
@@ -1160,7 +1145,9 @@ export class AnthropicProvider implements Provider {
         }
       };
       const turnStartIdx = findUserTextMsgIdx(msgs.length - 1);
-      if (turnStartIdx >= 0) applyCacheControlToLastBlock(turnStartIdx);
+      if (turnStartIdx >= 0 && !disableTurnStartCache) {
+        applyCacheControlToLastBlock(turnStartIdx);
+      }
 
       // Previous-turn anchor: when this request is the first of a new turn
       // (turn-start is the very last message — no tool-use loop yet), also
@@ -1172,9 +1159,8 @@ export class AnthropicProvider implements Provider {
       // cache_creation tokens per new turn). Skipped during tool-use loops
       // where the current turn-start already covers the same prefix and a
       // second anchor would blow the 4-breakpoint budget.
-      let prevTurnAnchorIdx = -1;
       if (turnStartIdx === msgs.length - 1 && turnStartIdx > 0) {
-        prevTurnAnchorIdx = findUserTextMsgIdx(turnStartIdx - 1);
+        const prevTurnAnchorIdx = findUserTextMsgIdx(turnStartIdx - 1);
         if (prevTurnAnchorIdx >= 0)
           applyCacheControlToLastBlock(prevTurnAnchorIdx);
       }
@@ -1185,7 +1171,6 @@ export class AnthropicProvider implements Provider {
       // cheaply without conflicting with the 1h breakpoints above.
       // Skip thinking/redacted_thinking blocks — Anthropic doesn't allow
       // cache_control on those types.
-      let tailBreakpointApplied = false;
       if (turnStartIdx >= 0 && turnStartIdx < sentMessages.length - 1) {
         const lastMsg = sentMessages[sentMessages.length - 1];
         if (Array.isArray(lastMsg.content) && lastMsg.content.length > 0) {
@@ -1207,34 +1192,15 @@ export class AnthropicProvider implements Provider {
           if (tailBlock && typeof tailBlock !== "string") {
             (tailBlock as unknown as Record<string, unknown>).cache_control =
               tailCacheControl;
-            tailBreakpointApplied = true;
           }
         }
       }
 
-      // Enforce Anthropic API maximum of 4 cache_control blocks.
-      // With the system prompt boundary split into 2 cached blocks AND
-      // tools + turn-start + (tail OR prev-turn-anchor), we'd have 5.
-      // Drop the static system block's breakpoint — it's small (<1K
-      // tokens) so the re-read cost is negligible, while the dynamic
-      // block (workspace context) rarely changes mid-session and
-      // benefits more from caching. Tail and prev-turn-anchor are
-      // mutually exclusive (prev-turn-anchor only fires when turn-start
-      // is the last message, which is the exact condition that suppresses
-      // the tail), so we never exceed 5.
-      const hasToolCacheBreakpoint =
-        params.tools?.some(
-          (t) => "cache_control" in t && t.cache_control != null,
-        ) ?? false;
-      if (
-        (tailBreakpointApplied || prevTurnAnchorIdx >= 0) &&
-        Array.isArray(params.system) &&
-        params.system.length === 2 &&
-        hasToolCacheBreakpoint
-      ) {
-        delete (params.system[0] as unknown as Record<string, unknown>)
-          .cache_control;
-      }
+      // Cache-breakpoint accounting: system(1) + tools(1) + turn-start(1) +
+      // (tail OR prev-turn-anchor)(1) = 4 — exactly Anthropic's per-request
+      // cap.  Tail and prev-turn-anchor are mutually exclusive (the latter
+      // only fires when turn-start is the last message, which suppresses
+      // the tail), so the total can't drift past 4.
 
       // Strip orphaned UTF-16 surrogates so the Anthropic JSON parser never
       // sees invalid strings produced by upstream surrogate-splitting `.slice()` calls.

package/src/providers/call-site-routing.ts

@@ -24,6 +24,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import { getDb } from "../memory/db-connection.js";
+import { isConnectionCompatibleWithModel } from "./connection-model-compat.js";
 import {
   ConnectionResolutionError,
   tryResolveProviderForConnectionName,
@@ -73,10 +74,15 @@ export class CallSiteRoutingProvider implements Provider {
      * `expectedProvider` is the provider name the resolved profile
      * declared. The hook verifies the connection's provider matches
      * and throws on mismatch.
+     *
+     * `model` is the resolved call-site model, threaded through so the
+     * connection lookup can gate `oauth_subscription` (Codex) connections
+     * by model compatibility.
      */
     private readonly resolveByConnection: (
       connectionName: string,
       expectedProvider: string,
+      model: string | undefined,
     ) => Promise<Provider | null>,
   ) {
     this.tokenEstimationProvider = defaultProvider.tokenEstimationProvider;
@@ -155,7 +161,11 @@ export class CallSiteRoutingProvider implements Provider {
         const candidates = listConnections(getDb(), {
           provider: resolved.provider,
         });
-        const active = candidates.find((c) => c.status === "active");
+        const active = candidates.find(
+          (c) =>
+            c.status === "active" &&
+            isConnectionCompatibleWithModel(c, resolved.model),
+        );
         if (active) {
           connectionName = active.name;
         }
@@ -168,6 +178,7 @@ export class CallSiteRoutingProvider implements Provider {
       const connectionProvider = await this.resolveByConnection(
         connectionName,
         resolved.provider,
+        resolved.model,
       );
       if (connectionProvider) return connectionProvider;
       return this.defaultProvider;
@@ -200,11 +211,12 @@ export function wrapWithCallSiteRouting(
 ): Provider {
   return new CallSiteRoutingProvider(
     base,
-    (connectionName, expectedProvider) =>
+    (connectionName, expectedProvider, model) =>
       tryResolveProviderForConnectionName(
         connectionName,
         config,
         expectedProvider,
+        model,
       ),
   );
 }

package/src/providers/connection-model-compat.ts

@@ -0,0 +1,38 @@
+/**
+ * Model-compatibility gate for auto-resolved provider connections.
+ *
+ * When a profile uses "Any active <provider> connection" (no
+ * `provider_connection` pinned), the daemon auto-picks an active connection
+ * for the provider. `oauth_subscription` connections (ChatGPT Codex) hard-
+ * route every request to the Codex endpoint, which rejects non-Codex models
+ * with HTTP 400. This helper lets the auto-resolution sites skip such a
+ * connection when the requested model is not Codex-compatible.
+ */
+
+import type { ProviderConnection } from "./inference/auth.js";
+import { isCodexSubscriptionModel } from "./openai/codex-models.js";
+
+/**
+ * Whether `connection` can serve a request for `model` during
+ * auto-resolution.
+ *
+ * `oauth_subscription` connections route through the ChatGPT Codex endpoint,
+ * so they are only compatible with Codex models. Every other auth type
+ * imposes no model restriction and is always compatible.
+ *
+ * `model` may be undefined when the call site has no resolved model; in that
+ * case no model gating is applied (returns true) so resolution behaviour is
+ * unchanged.
+ *
+ * This gate applies to auto-resolution only — an explicitly pinned
+ * `provider_connection` bypasses connection selection entirely and is used
+ * regardless of model.
+ */
+export function isConnectionCompatibleWithModel(
+  connection: Pick<ProviderConnection, "auth">,
+  model: string | undefined,
+): boolean {
+  if (connection.auth.type !== "oauth_subscription") return true;
+  if (!model) return true;
+  return isCodexSubscriptionModel(model);
+}

package/src/providers/connection-resolution.ts

@@ -30,6 +30,7 @@
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getDb } from "../memory/db-connection.js";
 import { getLogger } from "../util/logger.js";
+import { isConnectionCompatibleWithModel } from "./connection-model-compat.js";
 import { getConnection, listConnections } from "./inference/connections.js";
 import type { ProvidersConfig } from "./registry.js";
 import { resolveProviderFromConnection } from "./registry.js";
@@ -79,11 +80,16 @@ export class ConnectionResolutionError extends Error {
  * `expectedProvider` is the provider name the resolving profile declared.
  * Pass `undefined` to skip the mismatch check (callers that don't yet
  * know the expected provider).
+ *
+ * `model` is the resolved call-site model. It gates the `provider_mismatch`
+ * auto-recovery below so a non-Codex model is never rerouted onto an
+ * `oauth_subscription` (ChatGPT Codex) connection.
  */
 export async function tryResolveProviderForConnectionName(
   connectionName: string,
   config: ProvidersConfig,
   expectedProvider?: string,
+  model?: string,
 ): Promise<Provider | null> {
   let connection;
   try {
@@ -113,7 +119,10 @@ export async function tryResolveProviderForConnectionName(
     try {
       const db = getDb();
       const candidates = listConnections(db, { provider: expectedProvider });
-      const active = candidates.find((c) => c.status === "active");
+      const active = candidates.find(
+        (c) =>
+          c.status === "active" && isConnectionCompatibleWithModel(c, model),
+      );
       if (active) {
         log.info(
           {
@@ -192,7 +201,11 @@ export async function resolveDefaultProvider(
         const candidates = listConnections(getDb(), {
           provider: resolved.provider,
         });
-        const active = candidates.find((c) => c.status === "active");
+        const active = candidates.find(
+          (c) =>
+            c.status === "active" &&
+            isConnectionCompatibleWithModel(c, resolved.model),
+        );
         if (active) {
           log.info(
             { provider: resolved.provider, resolvedConnection: active.name },
@@ -216,5 +229,6 @@ export async function resolveDefaultProvider(
     connectionName,
     config,
     resolved.provider,
+    resolved.model,
   );
 }