@vellumai/assistant 0.8.5 → 0.8.6

package/src/prompts/system-prompt.ts

@@ -21,25 +21,12 @@ import {
 } from "../util/platform.js";
 import { stripCommentLines } from "../util/strip-comment-lines.js";
 import { cleanupBootstrapFiles } from "./bootstrap-cleanup.js";
-import {
-  resolveGuardianPersona,
-  resolveUserSlug,
-} from "./persona-resolver.js";
+import { resolveGuardianPersona, resolveUserSlug } from "./persona-resolver.js";
 import { renderWorkspaceSections } from "./sections.js";
 import { isTemplateContent } from "./template-detection.js";
 
 export { isTemplateContent };
 
-/**
- * Maps onboarding cohort identifiers to their cohort-specific bootstrap
- * template filenames.  When a cohort key is present in OnboardingContext,
- * `maybeReseedBootstrapForCohort` swaps the generic BOOTSTRAP.md with the
- * cohort-specific variant — but only if the workspace file is still pristine.
- */
-const COHORT_BOOTSTRAP_TEMPLATES: Record<string, string> = {
-  "content-automation": "BOOTSTRAP-CONTENT-AUTOMATION.md",
-};
-
 const log = getLogger("system-prompt");
 
 const PROMPT_FILES = ["IDENTITY.md", "SOUL.md"] as const;
@@ -215,23 +202,34 @@ export function ensurePromptFiles(): void {
 
 /**
  * One-shot swap: if the workspace BOOTSTRAP.md is still the unmodified generic
- * template AND a cohort-specific template exists, overwrite the workspace file
- * with the cohort variant.  No-op when BOOTSTRAP.md has been deleted, modified,
- * or the cohort has no mapped template.
+ * template AND a matching template file exists in the bundled templates dir,
+ * overwrite the workspace file with the specified variant.  No-op when
+ * BOOTSTRAP.md has been deleted, modified, or the template file is missing.
  */
-export function maybeReseedBootstrapForCohort(cohort: string): void {
-  const templateFileName = COHORT_BOOTSTRAP_TEMPLATES[cohort];
-  if (!templateFileName) return;
+export function maybeReseedBootstrap(templateFileName: string): void {
+  // Path traversal guard: reject filenames containing directory separators or
+  // parent-directory references, and require a `.md` extension.
+  if (
+    templateFileName.includes("/") ||
+    templateFileName.includes("..") ||
+    !templateFileName.endsWith(".md")
+  ) {
+    log.warn(
+      { templateFileName },
+      "Rejected bootstrap template filename: invalid characters or extension",
+    );
+    return;
+  }
 
   const bootstrapPath = getWorkspacePromptPath("BOOTSTRAP.md");
   if (!existsSync(bootstrapPath)) return;
 
   const currentContent = readPromptFile(bootstrapPath);
-  // Compare against the GENERIC "BOOTSTRAP.md" template, not the cohort-
-  // specific one.  After the swap, the workspace content no longer matches
-  // the generic template, so this guard returns false on subsequent calls —
-  // making the swap idempotent.  Do NOT change the comparison target to the
-  // cohort template filename; that would re-swap on every prompt build.
+  // Compare against the GENERIC "BOOTSTRAP.md" template, not the specified
+  // one.  After the swap, the workspace content no longer matches the generic
+  // template, so this guard returns false on subsequent calls — making the
+  // swap idempotent.  Do NOT change the comparison target to the provided
+  // template filename; that would re-swap on every prompt build.
   if (!isTemplateContent(currentContent, "BOOTSTRAP.md")) return;
 
   const templatesDir = resolveBundledDir(
@@ -239,26 +237,26 @@ export function maybeReseedBootstrapForCohort(cohort: string): void {
     "templates",
     "templates",
   );
-  const cohortTemplatePath = join(templatesDir, templateFileName);
-  if (!existsSync(cohortTemplatePath)) {
+  const templatePath = join(templatesDir, templateFileName);
+  if (!existsSync(templatePath)) {
     log.warn(
-      { cohort, templateFileName },
-      "Cohort bootstrap template not found, keeping generic BOOTSTRAP.md",
+      { templateFileName },
+      "Bootstrap template not found, keeping generic BOOTSTRAP.md",
     );
     return;
   }
 
   try {
-    const cohortContent = readFileSync(cohortTemplatePath, "utf-8");
-    writeFileSync(bootstrapPath, cohortContent, "utf-8");
+    const templateContent = readFileSync(templatePath, "utf-8");
+    writeFileSync(bootstrapPath, templateContent, "utf-8");
     log.info(
-      { cohort, templateFileName },
-      "Replaced generic BOOTSTRAP.md with cohort-specific template",
+      { templateFileName },
+      "Replaced generic BOOTSTRAP.md with specified template",
     );
   } catch (err) {
     log.warn(
-      { err, cohort, templateFileName },
-      "Failed to reseed BOOTSTRAP.md for cohort",
+      { err, templateFileName },
+      "Failed to reseed BOOTSTRAP.md with template",
     );
   }
 }
@@ -280,11 +278,11 @@ export interface BuildSystemPromptOptions {
  * file-backed bodies, and runtime-computed transforms.
  */
 export function buildSystemPrompt(options?: BuildSystemPromptOptions): string {
-  // One-shot cohort swap: if the user has a cohort and BOOTSTRAP.md is still
-  // the generic template, replace it with the cohort-specific variant before
-  // the prompt reads the file.
-  if (options?.onboardingContext?.cohort) {
-    maybeReseedBootstrapForCohort(options.onboardingContext.cohort);
+  // One-shot bootstrap swap: if the onboarding context specifies a bootstrap
+  // template and BOOTSTRAP.md is still the generic template, replace it with
+  // the specified variant before the prompt reads the file.
+  if (options?.onboardingContext?.bootstrapTemplate) {
+    maybeReseedBootstrap(options.onboardingContext.bootstrapTemplate);
   }
 
   // Slugs used by the persona sections (`10-user-persona`,

package/src/prompts/template-detection.ts

@@ -6,9 +6,15 @@ import { stripCommentLines } from "../util/strip-comment-lines.js";
 
 /**
  * Returns true when the prompt file content is still the unmodified template
- * shipped with the daemon.  Compares the stripped workspace content against
- * the stripped bundled template source so the check stays accurate even if
- * templates are edited in future releases.
+ * shipped with the daemon.  Comment-strips BOTH the workspace content and the
+ * bundled template source before comparing, so the check stays accurate even
+ * if templates are edited in future releases — and regardless of whether the
+ * caller passes raw or already-stripped content.  Most callers pre-strip via
+ * `readPromptFile`/`stripCommentLines`, but the `08-identity` section
+ * transform receives the raw workspace body (comment-stripping happens after
+ * the transform in `renderSection`); stripping here keeps detection correct
+ * for both.  `stripCommentLines` is idempotent, so pre-stripped callers are
+ * unaffected.
  *
  * Kept in a leaf module so the bundled section registry can depend on it
  * without forming a cycle through `system-prompt.ts → sections.ts →
@@ -30,7 +36,7 @@ export function isTemplateContent(
     const templateContent = stripCommentLines(
       readFileSync(templatePath, "utf-8"),
     );
-    return content === templateContent;
+    return stripCommentLines(content) === templateContent;
   } catch {
     return false;
   }

package/src/prompts/templates/BOOTSTRAP.md

@@ -36,19 +36,17 @@ Match their energy, not just their format. Lowercase and terse gets lowercase an
 
 Don't present options and ask what they'd prefer. That reads as hedging. Given what you know, pick the most useful path and say why. Wrong is recoverable. Vague isn't.
 
-### Google scan (when connected)
+### Gmail scan (when connected)
 
-If the First-Run User Context says "Google connected: yes" and the user asks you to scan, you MUST actually call the `subagent_spawn` tool three times — once per service. Do not simulate, summarize, or render progress components without making real tool calls. The scan requires live API access; you cannot know the results without executing the tools.
+If the First-Run User Context says "Google connected: yes" and lists Gmail access, and the user asks you to scan Gmail, you MUST actually call the `subagent_spawn` tool. Do not simulate, summarize, or render progress components without making a real tool call. The scan requires live API access; you cannot know the results without executing the tool.
 
-Call `subagent_spawn` three times with these parameters. Each subagent must produce two clearly separated sections in its output — `## Profile Signals` (structured facts for user modeling) and `## Action Briefing` (narrative, prioritized, noise-filtered):
+Call `subagent_spawn` with `label: "gmail-scan"` and this objective. The subagent must produce two clearly separated sections — `## Profile Signals` (structured facts for user modeling) and `## Action Briefing` (narrative, prioritized, noise-filtered):
 
-1. `label: "gmail-scan"`, `objective: "Scan my Gmail from the last 7 days. Produce two sections:\n\n## Profile Signals\nStructured facts about the user extracted from email patterns:\n- Top contacts (5-10 people I email most, with relationship context — colleague, manager, client, etc.)\n- Dominant domains/companies appearing in my inbox\n- Initiate-vs-respond ratio (do I start threads or mostly reply?)\n- Recurring topics or threads\n- Role indicators (e.g. manages people, IC, external-facing, sales, engineering)\n\n## Action Briefing\nEmails that need a human response from me, ordered by urgency. Skip marketing, automated notifications, and newsletters entirely. For each actionable email: who sent it, subject, why it needs my attention, and how urgent it is. If nothing needs action, say so — an empty inbox is a valid signal."`
-2. `label: "calendar-scan"`, `objective: "Scan my Google Calendar — 7 days back and 7 days forward. Produce two sections:\n\n## Profile Signals\nStructured facts about the user extracted from calendar patterns:\n- Recurring meeting rhythm (daily standups, weekly 1:1s, bi-weekly syncs, etc.)\n- Meeting type ratio: 1:1 vs group vs external\n- Most-frequent attendees (top 5-10 people)\n- Role signals from meeting patterns (e.g. has direct reports if lots of 1:1s, cross-functional if diverse attendee pools, manager if in skip-levels)\n\n## Action Briefing\nNext 72 hours: prep-worthy meetings (what to prepare, who's attending, context from recent related meetings), scheduling conflicts, and back-to-backs worth noting. Past 7 days: recent meetings with likely pending follow-ups or unresolved action items. Prioritize — don't just list every event."`
-3. `label: "drive-scan"`, `objective: "Scan my Google Drive — focus on shared-with-me activity and folder structure rather than just recently modified files. Produce two sections:\n\n## Profile Signals\nStructured facts about the user extracted from Drive patterns:\n- Top-level folder organization (what categories/projects exist)\n- File type distribution (docs, sheets, slides, etc.)\n- Shared drives and team folders the user belongs to\n- Files shared by others in the last 30 days (who shared them and what types)\n\n## Action Briefing\nFiles shared with me in the last 7 days I haven't opened yet, docs with outstanding comments or suggestions directed at me, and any docs where I'm tagged but haven't responded. If Drive activity is low, say so explicitly — 'not much Drive activity this period' is a valid and useful signal, not something to pad with filler."`
+`objective: "Scan my Gmail from the last 7 days. Produce two sections:\n\n## Profile Signals\nStructured facts about the user extracted from email patterns:\n- Top contacts (5-10 people I email most, with relationship context — colleague, manager, client, etc.)\n- Dominant domains/companies appearing in my inbox\n- Initiate-vs-respond ratio (do I start threads or mostly reply?)\n- Recurring topics or threads\n- Role indicators (e.g. manages people, IC, external-facing, sales, engineering)\n\n## Action Briefing\nEmails that need a human response from me, ordered by urgency. Skip marketing, automated notifications, and newsletters entirely. For each actionable email: who sent it, subject, why it needs my attention, and how urgent it is. If nothing needs action, say so — an empty inbox is a valid signal."`
 
-After spawning, tell the user the scans are running in the background and continue the conversation normally. Do not wait or poll — you will be notified automatically when each subagent completes.
+After spawning, tell the user the scan is running in the background and continue the conversation normally. Do not wait or poll — you will be notified automatically when the subagent completes.
 
-When subagent completion notifications arrive, use `subagent_read` to get results, then synthesize — don't just list. First, merge the `## Profile Signals` sections from all completed scans into an initial picture of the user: their role, key people, work patterns, and communication style. Use this to calibrate your tone and what you reference going forward. Then lead with 1–3 actionable insights from the `## Action Briefing` sections that connect dots across sources, and offer to do something concrete about each one. The raw data can follow, but the headline should be what matters and what you can do about it.
+When the subagent completion notification arrives, use `subagent_read` to get results, then synthesize — don't just list. First, use `## Profile Signals` to form an initial picture of the user: their role, key people, work patterns, and communication style. Use this to calibrate your tone and what you reference going forward. Then lead with 1–3 actionable insights from `## Action Briefing` and offer to do something concrete about each one. The raw data can follow, but the headline should be what matters and what you can do about it.
 
 If the user doesn't ask for a scan, don't offer it again. The greeting already mentioned it.
 
@@ -120,9 +118,7 @@ If nothing comes up, don't force it.
 
 ## Assistant migration
 
-If the First-Run User Context lists prior AI assistants, gently mention — after the initial greeting and rapport, not as an opener — that you can help bring over anything they built with their previous assistant: memory, skills, workflows, integrations. Frame it as an offer, not a push: "I noticed you've used [X] before — if you've built anything there you'd like to bring over, I can help with that whenever you're ready." Only proceed if the user expresses interest. Do not load or activate the assistant-migration skill preemptively.
-
-If no prior assistants are listed, skip this entirely.
+Help first: do the user's actual first task before pivoting to this — the migration offer must never derail or precede real work. Then, at the first natural opening, offer it. This applies to every new assistant, whether onboarding was full, condensed, or absent: land it early in the first conversation, at the first lull or seam, even when the user came in task-first. Keep it to one light offer, a useful shortcut and not an upsell: "If you've already built context, prompts, skills, or workflows somewhere else, I can help port them over." Prior context may live in ChatGPT, Claude, OpenClaw, Hermes, or another assistant or harness — name those when it helps. If they decline, drop it and don't re-offer. Only if they opt in, use the `assistant-migration` skill to inventory and port that context; do not load or activate migration-related skills preemptively.
 
 ## Wrap up
 

package/src/prompts/templates/IDENTITY.md

@@ -2,8 +2,6 @@ _ Lines starting with _ are comments - they won't appear in the system prompt
 
 # IDENTITY.md
 
-This file is yours. Add sections, restructure it, make it reflect who you are. Name, Emoji, Role, Personality are parsed by the app - keep their `- **Label:**` format. Everything else is freeform.
-
 - **Name:** _(not yet chosen)_
 - **Emoji:** _(not yet chosen)_
 - **Nature:** _(not yet established)_

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

@@ -46,13 +46,15 @@ describe("isConnectionCompatibleWithModel", () => {
   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);
+    expect(isConnectionCompatibleWithModel(conn, "gpt-5.5-pro")).toBe(false);
   });
 
   test("oauth_subscription connection is compatible with a Codex model", () => {
     const conn = { auth: oauthAuth };
+    expect(isConnectionCompatibleWithModel(conn, "gpt-5.5")).toBe(true);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.4")).toBe(true);
+    expect(isConnectionCompatibleWithModel(conn, "gpt-5.4-mini")).toBe(true);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.3-codex")).toBe(true);
   });
 
@@ -89,7 +91,6 @@ mock.module("../../memory/db-connection.js", () => ({
 type Connection = {
   name: string;
   provider: string;
-  status: string;
   auth: { type: string; credential?: string };
 };
 
@@ -140,13 +141,11 @@ function reset(): void {
 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",

package/src/providers/__tests__/registry-native-web-search.test.ts

@@ -0,0 +1,122 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { type LLMConfigBase, LLMSchema } from "../../config/schemas/llm.js";
+import type { ProviderConnection } from "../inference/auth.js";
+import type { ProvidersConfig } from "../registry.js";
+
+const adapterCalls: Array<{
+  connection: ProviderConnection;
+  opts: { model: string; useNativeWebSearch?: boolean };
+}> = [];
+
+mock.module("../inference/resolve-auth.js", () => ({
+  resolveAuth: async () => ({
+    ok: true,
+    resolved: {
+      kind: "header",
+      headers: { Authorization: "Bearer test-provider-key" },
+    },
+  }),
+}));
+
+mock.module("../inference/adapter-factory.js", () => ({
+  buildProviderAdapter: () => null,
+  createAdapterFromConnection: (
+    connection: ProviderConnection,
+    _resolvedAuth: unknown,
+    opts: { model: string; useNativeWebSearch?: boolean },
+  ) => {
+    adapterCalls.push({ connection, opts });
+    return {
+      name: connection.provider,
+      sendMessage: async () => ({
+        content: [],
+        model: opts.model,
+        usage: { inputTokens: 0, outputTokens: 0 },
+        stopReason: "stop",
+      }),
+    };
+  },
+}));
+
+import {
+  clearConnectionProviderCache,
+  resolveProviderFromConnection,
+} from "../registry.js";
+
+function makeConfig(): ProvidersConfig {
+  const baseLlm = LLMSchema.parse({});
+  return {
+    services: {
+      inference: {},
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+      "web-search": {
+        mode: "managed",
+        provider: "inference-provider-native",
+      },
+    },
+    llm: {
+      ...baseLlm,
+      default: {
+        ...baseLlm.default,
+        provider: "openrouter" as LLMConfigBase["provider"],
+        model: "x-ai/grok-4.20-beta",
+      },
+    },
+  };
+}
+
+const openRouterConnection: ProviderConnection = {
+  name: "openrouter-personal",
+  provider: "openrouter",
+  auth: { type: "api_key", credential: "credential/openrouter/api_key" },
+  label: "OpenRouter",
+  baseUrl: null,
+  models: null,
+  createdAt: 1,
+  updatedAt: 1,
+  isManaged: false,
+};
+
+describe("resolveProviderFromConnection native web search selection", () => {
+  beforeEach(() => {
+    adapterCalls.length = 0;
+    clearConnectionProviderCache();
+  });
+
+  test("uses the routed OpenRouter Anthropic model when enabling native web search", async () => {
+    await resolveProviderFromConnection(openRouterConnection, makeConfig(), {
+      model: "anthropic/claude-opus-4-7",
+    });
+
+    expect(adapterCalls).toHaveLength(1);
+    expect(adapterCalls[0].opts).toMatchObject({
+      model: "anthropic/claude-opus-4-7",
+      useNativeWebSearch: true,
+    });
+  });
+
+  test("keeps OpenRouter native web search model-specific across cached connections", async () => {
+    await resolveProviderFromConnection(openRouterConnection, makeConfig(), {
+      model: "x-ai/grok-4.20-beta",
+    });
+    await resolveProviderFromConnection(openRouterConnection, makeConfig(), {
+      model: "anthropic/claude-opus-4-7",
+    });
+
+    expect(adapterCalls.map((call) => call.opts)).toEqual([
+      expect.objectContaining({
+        model: "x-ai/grok-4.20-beta",
+        useNativeWebSearch: false,
+      }),
+      expect.objectContaining({
+        model: "anthropic/claude-opus-4-7",
+        useNativeWebSearch: true,
+      }),
+    ]);
+  });
+});

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

@@ -24,7 +24,10 @@ 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 {
+  describeSubscriptionModelIncompatibility,
+  isConnectionCompatibleWithModel,
+} from "./connection-model-compat.js";
 import {
   ConnectionResolutionError,
   tryResolveProviderForConnectionName,
@@ -146,25 +149,32 @@ export class CallSiteRoutingProvider implements Provider {
     if (!callSite) return this.defaultProvider;
 
     const overrideProfile = options?.config?.overrideProfile;
+    // Forward the per-conversation mix seed so transport selection picks the
+    // same mix arm as wire-param normalization in `retry.ts` — otherwise a mix
+    // spanning providers could route the transport to a different arm than the
+    // request params.
+    const selectionSeed = options?.config?.selectionSeed;
     const resolved = resolveCallSiteConfig(callSite, getConfig().llm, {
       overrideProfile,
+      selectionSeed,
     });
 
     let connectionName = resolved.provider_connection;
 
     // When no connection is set and the provider differs from the default,
-    // auto-resolve to an active connection for the provider (handles the
-    // "Any active X connection" case where the profile set provider but
-    // not provider_connection, and the merge didn't inherit one).
+    // auto-resolve a connection for the provider (handles the case where the
+    // profile set provider but not provider_connection, and the merge didn't
+    // inherit one).
+    let autoResolveCandidates:
+      | import("./inference/auth.js").ProviderConnection[]
+      | undefined;
     if (!connectionName && resolved.provider !== this.defaultProvider.name) {
       try {
-        const candidates = listConnections(getDb(), {
+        autoResolveCandidates = listConnections(getDb(), {
           provider: resolved.provider,
         });
-        const active = candidates.find(
-          (c) =>
-            c.status === "active" &&
-            isConnectionCompatibleWithModel(c, resolved.model),
+        const active = autoResolveCandidates.find((c) =>
+          isConnectionCompatibleWithModel(c, resolved.model),
         );
         if (active) {
           connectionName = active.name;
@@ -188,6 +198,20 @@ export class CallSiteRoutingProvider implements Provider {
       return this.defaultProvider;
     }
 
+    if (autoResolveCandidates) {
+      const incompatMsg = describeSubscriptionModelIncompatibility(
+        autoResolveCandidates,
+        resolved.model,
+      );
+      if (incompatMsg) {
+        throw new ConnectionResolutionError(
+          "<resolved-callsite>",
+          "model_incompatible",
+          incompatMsg,
+        );
+      }
+    }
+
     throw new ConnectionResolutionError(
       "<resolved-callsite>",
       "missing_connection",

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

@@ -36,3 +36,26 @@ export function isConnectionCompatibleWithModel(
   if (!model) return true;
   return isCodexSubscriptionModel(model);
 }
+
+/**
+ * When auto-resolution found candidates but none were model-compatible,
+ * return a user-facing explanation if the incompatibility is specifically
+ * due to all candidates being `oauth_subscription` (ChatGPT) connections.
+ *
+ * Returns `null` when the incompatibility has a different cause (callers
+ * should fall through to their existing generic error).
+ */
+export function describeSubscriptionModelIncompatibility(
+  candidates: Pick<ProviderConnection, "auth">[],
+  model: string | undefined,
+): string | null {
+  if (!model || candidates.length === 0) return null;
+  if (candidates.some((c) => isConnectionCompatibleWithModel(c, model))) {
+    return null;
+  }
+  const allSubscription = candidates.every(
+    (c) => c.auth.type === "oauth_subscription",
+  );
+  if (!allSubscription) return null;
+  return `Model "${model}" isn't available through your ChatGPT subscription. Select a supported model or add an OpenAI API key connection.`;
+}

package/src/providers/connection-resolution.ts

@@ -30,7 +30,10 @@
 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 {
+  describeSubscriptionModelIncompatibility,
+  isConnectionCompatibleWithModel,
+} from "./connection-model-compat.js";
 import { getConnection, listConnections } from "./inference/connections.js";
 import type { ProvidersConfig } from "./registry.js";
 import { resolveProviderFromConnection } from "./registry.js";
@@ -52,7 +55,8 @@ export class ConnectionResolutionError extends Error {
       | "lookup_failed"
       | "not_found"
       | "provider_mismatch"
-      | "missing_connection",
+      | "missing_connection"
+      | "model_incompatible",
     message: string,
     public readonly cause?: unknown,
   ) {
@@ -116,12 +120,12 @@ export async function tryResolveProviderForConnectionName(
     // "anthropic-managed" leaked through). Try to find an active connection
     // for the expected provider before giving up.
     let resolved = false;
+    let mismatchCandidates: import("./inference/auth.js").ProviderConnection[] | undefined;
     try {
       const db = getDb();
-      const candidates = listConnections(db, { provider: expectedProvider });
-      const active = candidates.find(
-        (c) =>
-          c.status === "active" && isConnectionCompatibleWithModel(c, model),
+      mismatchCandidates = listConnections(db, { provider: expectedProvider });
+      const active = mismatchCandidates.find((c) =>
+        isConnectionCompatibleWithModel(c, model),
       );
       if (active) {
         log.info(
@@ -130,7 +134,7 @@ export async function tryResolveProviderForConnectionName(
             resolvedConnection: active.name,
             expectedProvider,
           },
-          "Auto-resolved stale provider_connection to matching active connection",
+          "Auto-resolved stale provider_connection to matching connection",
         );
         connection = active;
         resolved = true;
@@ -139,6 +143,16 @@ export async function tryResolveProviderForConnectionName(
       // DB not available — fall through to the original error.
     }
     if (!resolved) {
+      const incompatMsg = mismatchCandidates
+        ? describeSubscriptionModelIncompatibility(mismatchCandidates, model)
+        : null;
+      if (incompatMsg) {
+        throw new ConnectionResolutionError(
+          connectionName,
+          "model_incompatible",
+          incompatMsg,
+        );
+      }
       throw new ConnectionResolutionError(
         connectionName,
         "provider_mismatch",
@@ -146,13 +160,6 @@ export async function tryResolveProviderForConnectionName(
       );
     }
   }
-  if (connection.status === "disabled") {
-    log.debug(
-      { connectionName, provider: connection.provider },
-      "provider_connection is disabled — returning null",
-    );
-    return null;
-  }
   // `resolveProviderFromConnection` reaches into auth resolution (credential
   // reads, managed-proxy context). A transient failure there is a soft
   // miss — log and return null so the caller can treat it the same as
@@ -160,7 +167,7 @@ export async function tryResolveProviderForConnectionName(
   // catch is specifically for in-flight failures that should not take
   // dispatch offline.
   try {
-    return await resolveProviderFromConnection(connection, config);
+    return await resolveProviderFromConnection(connection, config, { model });
   } catch (err) {
     log.warn(
       { err, connectionName },
@@ -196,15 +203,14 @@ export async function resolveDefaultProvider(
     // provider without a connection ("Any active" selection), and the merge
     // cleared or failed to inherit one. Try to find an active connection
     // for the provider before giving up.
+    let autoResolveCandidates: import("./inference/auth.js").ProviderConnection[] | undefined;
     if (resolved.provider) {
       try {
-        const candidates = listConnections(getDb(), {
+        autoResolveCandidates = listConnections(getDb(), {
           provider: resolved.provider,
         });
-        const active = candidates.find(
-          (c) =>
-            c.status === "active" &&
-            isConnectionCompatibleWithModel(c, resolved.model),
+        const active = autoResolveCandidates.find((c) =>
+          isConnectionCompatibleWithModel(c, resolved.model),
         );
         if (active) {
           log.info(
@@ -218,6 +224,19 @@ export async function resolveDefaultProvider(
       }
     }
     if (!connectionName) {
+      const incompatMsg = autoResolveCandidates
+        ? describeSubscriptionModelIncompatibility(
+            autoResolveCandidates,
+            resolved.model,
+          )
+        : null;
+      if (incompatMsg) {
+        throw new ConnectionResolutionError(
+          "<llm.default>",
+          "model_incompatible",
+          incompatMsg,
+        );
+      }
       throw new ConnectionResolutionError(
         "<llm.default>",
         "missing_connection",

package/src/providers/fireworks/client.ts

@@ -34,6 +34,7 @@ export class FireworksProvider extends OpenAIChatCompletionsProvider {
       // overrides (e.g. DeepSeek V4 → "max") come from
       // {@link resolveMaxReasoningEffort}.
       maxReasoningEffort: "high",
+      assistantReasoningField: "reasoning_content",
     });
   }
 

package/src/providers/gemini/client.ts

@@ -4,6 +4,7 @@ import { ApiError, GoogleGenAI, ThinkingLevel } from "@google/genai";
 import { isAbortReason } from "../../util/abort-reasons.js";
 import { ProviderError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
+import { PROVIDER_CATALOG } from "../model-catalog.js";
 import { createStreamTimeout } from "../stream-timeout.js";
 import type {
   ContentBlock,
@@ -74,6 +75,24 @@ function buildThinkingConfig(
   return Object.keys(result).length > 0 ? result : undefined;
 }
 
+/**
+ * Whether the active Gemini model accepts a `thinkingConfig`. Non-thinking
+ * models (e.g. `gemini-2.5-flash-lite`) reject thinking params, and gemini is
+ * in `THINKING_AWARE_PROVIDERS` so `providers/retry.ts` no longer strips them —
+ * so we gate on the catalog's `supportsThinking` capability here. Unknown or
+ * uncatalogued models default to allowing thinking config (preserving prior
+ * behavior); only an explicit `supportsThinking: false` suppresses it.
+ */
+function geminiModelSupportsThinking(model: string): boolean {
+  const normalized = model.startsWith("models/")
+    ? model.slice("models/".length)
+    : model;
+  const catalogModel = PROVIDER_CATALOG.find(
+    (provider) => provider.id === "gemini",
+  )?.models.find((m) => m.id === normalized);
+  return catalogModel?.supportsThinking !== false;
+}
+
 function stripGeminiHttpOptions(
   config: genai.GenerateContentConfig,
 ): genai.GenerateContentConfig {
@@ -215,10 +234,12 @@ export class GeminiProvider implements Provider {
     const usageAttributionHeaders = configObj?.usageAttributionHeaders as
       | Record<string, string>
       | undefined;
-    const thinkingConfig = buildThinkingConfig(
-      configObj?.thinking as Record<string, unknown> | undefined,
-    );
     const activeModel = modelOverride ?? this.model;
+    const thinkingConfig = geminiModelSupportsThinking(activeModel)
+      ? buildThinkingConfig(
+          configObj?.thinking as Record<string, unknown> | undefined,
+        )
+      : undefined;
 
     try {
       const geminiContents = this.toGeminiContents(messages, activeModel);