@vellumai/assistant 0.8.3 → 0.8.5

package/src/providers/model-catalog.ts

@@ -45,6 +45,13 @@ export interface CatalogModel {
   supportsVision?: boolean;
   supportsToolUse?: boolean;
   pricing?: CatalogModelPricing;
+  /**
+   * Upper bound for `reasoning_effort` accepted by this model's upstream API.
+   * Used by providers (e.g. Fireworks) to clamp Vellum's `xhigh`/`max` tiers
+   * down to whatever the model documents. Omit to inherit the provider
+   * default.
+   */
+  maxEffort?: "high" | "xhigh" | "max";
   /** When set, this model is only visible when the named feature flag is enabled. */
   featureFlag?: string;
 }
@@ -393,6 +400,21 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       linkLabel: "Open Google AI Studio",
     },
     models: [
+      {
+        id: "gemini-3.5-flash",
+        displayName: "Gemini 3.5 Flash",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 65536,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 1.5,
+          outputPer1mTokens: 9.0,
+          cacheReadPer1mTokens: 0.15,
+        },
+      },
       {
         id: "gemini-3.1-pro-preview",
         displayName: "Gemini 3.1 Pro Preview",
@@ -471,6 +493,21 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.025,
         },
       },
+      {
+        id: "gemini-3.1-flash-lite",
+        displayName: "Gemini 3.1 Flash-Lite",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 65536,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 0.25,
+          outputPer1mTokens: 1.5,
+          cacheReadPer1mTokens: 0.025,
+        },
+      },
       {
         id: "gemini-2.5-flash",
         displayName: "Gemini 2.5 Flash",
@@ -589,6 +626,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         supportsCaching: true,
         supportsVision: true,
         supportsToolUse: true,
+        maxEffort: "high",
         pricing: {
           inputPer1mTokens: 0.95,
           outputPer1mTokens: 4.0,
@@ -636,10 +674,11 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         displayName: "DeepSeek V4 Pro",
         contextWindowTokens: 1040000,
         maxOutputTokens: 131072,
-        supportsThinking: false,
+        supportsThinking: true,
         supportsCaching: false,
         supportsVision: false,
         supportsToolUse: true,
+        maxEffort: "max",
         pricing: { inputPer1mTokens: 1.74, outputPer1mTokens: 3.48 },
       },
     ],
@@ -775,6 +814,17 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         supportsToolUse: true,
         pricing: { inputPer1mTokens: 3, outputPer1mTokens: 15 },
       },
+      {
+        id: "x-ai/grok-4.3",
+        displayName: "Grok 4.3",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 16000,
+        supportsThinking: true,
+        supportsCaching: false,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 1.25, outputPer1mTokens: 2.5 },
+      },
       {
         id: "x-ai/grok-4",
         displayName: "Grok 4",
@@ -1057,6 +1107,18 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         supportsToolUse: true,
         pricing: { inputPer1mTokens: 0.8, outputPer1mTokens: 3.2 },
       },
+      // Owl (OpenRouter first-party)
+      {
+        id: "openrouter/owl-alpha",
+        displayName: "Owl Alpha",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 262144,
+        supportsThinking: false,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 0, outputPer1mTokens: 0 },
+      },
     ],
     defaultModel: "x-ai/grok-4.20-beta",
     apiKeyUrl: "https://openrouter.ai/keys",
@@ -1075,6 +1137,34 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
     models: [],
     defaultModel: "",
   },
+  {
+    id: "minimax",
+    displayName: "MiniMax",
+    subtitle: "MiniMax AI models. Requires a MiniMax API key.",
+    setupMode: "api-key",
+    setupHint: "Enter your MiniMax API key to enable MiniMax models.",
+    envVar: "MINIMAX_API_KEY",
+    credentialsGuide: {
+      description: "Sign in to the MiniMax dashboard and create an API key.",
+      url: "https://platform.minimax.io/",
+      linkLabel: "Open MiniMax Dashboard",
+    },
+    models: [
+      {
+        id: "MiniMax-M2.7",
+        displayName: "MiniMax M2.7",
+        contextWindowTokens: 200000,
+        maxOutputTokens: 16384,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: false,
+        supportsToolUse: true,
+      },
+    ],
+    defaultModel: "MiniMax-M2.7",
+    apiKeyUrl: "https://platform.minimax.io/",
+    apiKeyPlaceholder: "sk-cp-...",
+  },
 ];
 
 export const PROVIDER_CATALOG: ProviderCatalogEntry[] =

package/src/providers/model-intents.ts

@@ -24,7 +24,7 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   },
   gemini: {
     balanced: "gemini-3-flash-preview",
-    "latency-optimized": "gemini-3.1-flash-lite-preview",
+    "latency-optimized": "gemini-3.1-flash-lite",
     "quality-optimized": "gemini-3.1-pro-preview",
     "vision-optimized": "gemini-3-flash-preview",
   },

package/src/providers/openai/chat-completions-provider.ts

@@ -1,6 +1,5 @@
 import OpenAI from "openai";
 
-import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../../prompts/cache-boundary.js";
 import { isAbortReason } from "../../util/abort-reasons.js";
 import { ProviderError } from "../../util/errors.js";
 import { extractRetryAfterMs } from "../../util/retry.js";
@@ -66,34 +65,56 @@ export interface OpenAIChatCompletionsProviderOptions {
   extraCreateParams?: Record<string, unknown>;
   /** Upper bound for `reasoning_effort` sent on the wire. Defaults to "xhigh"
    *  (OpenAI's current ceiling). Compatibility providers whose APIs only
-   *  document `low|medium|high` (e.g. Fireworks) should set this to "high" so
-   *  Vellum's `xhigh`/`max` tiers don't 4xx upstream. */
-  maxReasoningEffort?: "high" | "xhigh";
+   *  document `low|medium|high` should set this to "high" so Vellum's
+   *  `xhigh`/`max` tiers don't 4xx upstream. Set to "max" for providers like
+   *  Fireworks DeepSeek V4 that accept the full effort range. Subclasses can
+   *  override {@link OpenAIChatCompletionsProvider.resolveMaxReasoningEffort}
+   *  for per-model ceilings. */
+  maxReasoningEffort?: "high" | "xhigh" | "max";
   /** Parse `<think>...</think>` tags from the content stream into thinking
    *  blocks. MiniMax and similar providers embed reasoning inside XML-style
    *  tags in the regular content field rather than using `reasoning_content`. */
   parseThinkTags?: boolean;
 }
 
-/** Map our internal effort values to OpenAI's reasoning_effort parameter.
- *  OpenAI caps at "xhigh", so our "max" tier collapses to "xhigh". `"none"` is
- *  passed through explicitly because OpenAI defaults `reasoning_effort` to
- *  "medium" when the field is omitted — the user's opt-out is only honored
- *  when we send it on the wire. */
-export const EFFORT_TO_REASONING_EFFORT: Record<
-  string,
-  NonNullable<
-    OpenAI.Chat.Completions.ChatCompletionCreateParams["reasoning_effort"]
-  >
-> = {
+/** Wire-level reasoning_effort values. The OpenAI SDK type doesn't include
+ *  `"max"`, but Fireworks accepts it for DeepSeek V4; the assignment to
+ *  `params.reasoning_effort` casts through this union. */
+type ReasoningEffortWire = "none" | "low" | "medium" | "high" | "xhigh" | "max";
+
+const REASONING_EFFORT_RANK: Record<ReasoningEffortWire, number> = {
+  none: 0,
+  low: 1,
+  medium: 2,
+  high: 3,
+  xhigh: 4,
+  max: 5,
+};
+
+/** Map our internal effort values to a reasoning_effort wire value. `"max"`
+ *  is emitted raw — providers cap it down to their own ceiling
+ *  ({@link OpenAIChatCompletionsProviderOptions.maxReasoningEffort}) at send
+ *  time. `"none"` is passed through explicitly because OpenAI-compatible APIs
+ *  default `reasoning_effort` to `"medium"` when the field is omitted, so the
+ *  user's opt-out is only honored when we send it on the wire. */
+export const EFFORT_TO_REASONING_EFFORT: Record<string, ReasoningEffortWire> = {
   none: "none",
   low: "low",
   medium: "medium",
   high: "high",
   xhigh: "xhigh",
-  max: "xhigh",
+  max: "max",
 };
 
+export function clampReasoningEffort(
+  value: ReasoningEffortWire,
+  ceiling: "high" | "xhigh" | "max",
+): ReasoningEffortWire {
+  return REASONING_EFFORT_RANK[value] > REASONING_EFFORT_RANK[ceiling]
+    ? ceiling
+    : value;
+}
+
 const OPENAI_SUPPORTED_IMAGE_TYPES = new Set([
   "image/jpeg",
   "image/png",
@@ -122,7 +143,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
   private model: string;
   private streamTimeoutMs: number;
   private extraCreateParams: Record<string, unknown>;
-  private maxReasoningEffort: "high" | "xhigh";
+  private maxReasoningEffort: "high" | "xhigh" | "max";
   private requestHeaders: Record<string, string>;
   private parseThinkTags: boolean;
 
@@ -133,12 +154,16 @@ export class OpenAIChatCompletionsProvider implements Provider {
   ) {
     this.name = options.providerName ?? "openai";
     this.providerLabel = options.providerLabel ?? "OpenAI";
+    this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
+    // Keep the SDK deadline behind our provider stream timeout so
+    // createStreamTimeout owns the user-facing timeout error.
+    const sdkTimeoutMs = this.streamTimeoutMs + 60_000;
     this.client = new OpenAI({
       apiKey,
       baseURL: options.baseURL,
+      timeout: sdkTimeoutMs,
     });
     this.model = model;
-    this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
     this.extraCreateParams = options.extraCreateParams ?? {};
     this.maxReasoningEffort = options.maxReasoningEffort ?? "xhigh";
     this.requestHeaders = options.requestHeaders ?? {};
@@ -187,10 +212,13 @@ export class OpenAIChatCompletionsProvider implements Provider {
         ? EFFORT_TO_REASONING_EFFORT[effort]
         : undefined;
       if (reasoningEffort && typeof nestedReasoningEffort !== "string") {
-        params.reasoning_effort =
-          reasoningEffort === "xhigh" && this.maxReasoningEffort === "high"
-            ? "high"
-            : reasoningEffort;
+        const ceiling = this.resolveMaxReasoningEffort(
+          modelOverride ?? this.model,
+        );
+        params.reasoning_effort = clampReasoningEffort(
+          reasoningEffort,
+          ceiling,
+        ) as OpenAI.Chat.Completions.ChatCompletionCreateParams["reasoning_effort"];
       }
 
       if (tools && tools.length > 0) {
@@ -546,6 +574,18 @@ export class OpenAIChatCompletionsProvider implements Provider {
     return this.extraCreateParams;
   }
 
+  /**
+   * Per-request reasoning_effort ceiling. Defaults to the provider-wide
+   * `maxReasoningEffort` from constructor options. Subclasses (e.g. Fireworks)
+   * override to consult the model catalog so per-model accepted ranges are
+   * respected.
+   */
+  protected resolveMaxReasoningEffort(
+    _model: string,
+  ): "high" | "xhigh" | "max" {
+    return this.maxReasoningEffort;
+  }
+
   /** Convert neutral messages + system prompt to OpenAI message format. */
   private toOpenAIMessages(
     messages: Message[],
@@ -556,7 +596,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
     if (systemPrompt) {
       result.push({
         role: "system",
-        content: systemPrompt.replaceAll(SYSTEM_PROMPT_CACHE_BOUNDARY, "\n"),
+        content: systemPrompt,
       });
     }
 

package/src/providers/openai/codex-models.ts

@@ -0,0 +1,18 @@
+/**
+ * Model IDs accepted by the ChatGPT Codex subscription endpoint
+ * (`https://chatgpt.com/backend-api/codex`).
+ *
+ * `oauth_subscription` OpenAI connections hard-route every request to that
+ * endpoint, which rejects any model outside this set with HTTP 400. The set
+ * gates whether such a connection may serve a given model during auto-
+ * resolution of an "Any active OpenAI connection" profile.
+ */
+export const CODEX_SUBSCRIPTION_MODEL_IDS: ReadonlySet<string> = new Set([
+  "gpt-5.4",
+  "gpt-5.3-codex",
+]);
+
+/** True when `model` is accepted by the Codex subscription endpoint. */
+export function isCodexSubscriptionModel(model: string): boolean {
+  return CODEX_SUBSCRIPTION_MODEL_IDS.has(model);
+}

package/src/providers/openai/responses-provider.ts

@@ -1,8 +1,8 @@
 import OpenAI from "openai";
 
-import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../../prompts/cache-boundary.js";
 import { isAbortReason } from "../../util/abort-reasons.js";
 import { ProviderError } from "../../util/errors.js";
+import { getLogger } from "../../util/logger.js";
 import { extractRetryAfterMs } from "../../util/retry.js";
 import { escapeXmlAttr } from "../../util/xml.js";
 import { createStreamTimeout } from "../stream-timeout.js";
@@ -17,12 +17,17 @@ import type {
 import { ContextOverflowError } from "../types.js";
 import { detectOpenAICompatibleContextOverflow } from "./chat-completions-provider.js";
 
+const log = getLogger("openai-responses");
+
 export interface OpenAIResponsesProviderOptions {
   baseURL?: string;
   providerName?: string;
   providerLabel?: string;
   streamTimeoutMs?: number;
   useNativeWebSearch?: boolean;
+  /** When true, target the Codex subscription endpoint and strip fields it
+   *  rejects (`max_output_tokens`, `reasoning`, `text`, `tools`). */
+  codexSubscription?: boolean;
 }
 
 /** Map our internal effort values to the Responses API reasoning.effort parameter.
@@ -103,6 +108,8 @@ export class OpenAIResponsesProvider implements Provider {
   private model: string;
   private streamTimeoutMs: number;
   private useNativeWebSearch: boolean;
+  private codexSubscription: boolean;
+  private lastCodexErrorBody: string | undefined;
 
   constructor(
     apiKey: string,
@@ -111,12 +118,40 @@ export class OpenAIResponsesProvider implements Provider {
   ) {
     this.name = options.providerName ?? "openai";
     this.providerLabel = options.providerLabel ?? "OpenAI";
+    this.codexSubscription = options.codexSubscription ?? false;
+    this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
+    // Keep the SDK deadline behind our provider stream timeout so
+    // createStreamTimeout owns the user-facing timeout error.
+    const sdkTimeoutMs = this.streamTimeoutMs + 60_000;
     this.client = new OpenAI({
       apiKey,
-      baseURL: options.baseURL,
+      baseURL: this.codexSubscription
+        ? "https://chatgpt.com/backend-api/codex"
+        : options.baseURL,
+      timeout: sdkTimeoutMs,
+      ...(this.codexSubscription
+        ? {
+            fetch: async (url: RequestInfo | URL, init?: RequestInit) => {
+              const res = await globalThis.fetch(url, init);
+              if (!res.ok) {
+                const body = await res.text();
+                this.lastCodexErrorBody = body;
+                log.warn(
+                  { status: res.status, body, url: String(url) },
+                  "Codex endpoint raw error response",
+                );
+                return new Response(body, {
+                  status: res.status,
+                  statusText: res.statusText,
+                  headers: res.headers,
+                });
+              }
+              return res;
+            },
+          }
+        : {}),
     });
     this.model = model;
-    this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
     this.useNativeWebSearch = options.useNativeWebSearch ?? false;
   }
 
@@ -142,36 +177,35 @@ export class OpenAIResponsesProvider implements Provider {
       const params: Record<string, unknown> = {
         model: modelOverride ?? this.model,
         input,
-        store: false,
+        ...(this.codexSubscription ? { store: false } : {}),
       };
 
       if (systemPrompt) {
-        params.instructions = systemPrompt.replaceAll(
-          SYSTEM_PROMPT_CACHE_BOUNDARY,
-          "\n",
-        );
+        params.instructions = systemPrompt;
       }
 
-      if (maxTokens) {
+      if (maxTokens && !this.codexSubscription) {
         params.max_output_tokens = maxTokens;
       }
 
-      const reasoningEffort = effort
-        ? EFFORT_TO_REASONING_EFFORT[effort]
-        : undefined;
-      if (reasoningEffort) {
-        params.reasoning = { effort: reasoningEffort };
-      }
+      if (!this.codexSubscription) {
+        const reasoningEffort = effort
+          ? EFFORT_TO_REASONING_EFFORT[effort]
+          : undefined;
+        if (reasoningEffort) {
+          params.reasoning = { effort: reasoningEffort };
+        }
 
-      if (
-        verbosity &&
-        VALID_VERBOSITIES.has(verbosity) &&
-        modelSupportsVerbosity(modelOverride ?? this.model)
-      ) {
-        params.text = { verbosity };
+        if (
+          verbosity &&
+          VALID_VERBOSITIES.has(verbosity) &&
+          modelSupportsVerbosity(modelOverride ?? this.model)
+        ) {
+          params.text = { verbosity };
+        }
       }
 
-      if (tools && tools.length > 0) {
+      if (tools && tools.length > 0 && !this.codexSubscription) {
         if (
           this.useNativeWebSearch &&
           tools.some((t) => t.name === "web_search")
@@ -404,6 +438,21 @@ export class OpenAIResponsesProvider implements Provider {
           ? signal.reason
           : undefined;
       if (error instanceof OpenAI.APIError) {
+        // Temporary diagnostic: log the raw error shape for Codex 400 debugging
+        if (this.codexSubscription) {
+          log.warn(
+            {
+              status: error.status,
+              message: error.message,
+              code: error.code,
+              type: error.type,
+              param: error.param,
+              errorBody: error.error,
+              headers: Object.fromEntries(error.headers?.entries?.() ?? []),
+            },
+            "Codex subscription API error — raw details",
+          );
+        }
         const overflow = detectOpenAICompatibleContextOverflow(error);
         if (overflow) {
           throw new ContextOverflowError(
@@ -425,8 +474,22 @@ export class OpenAIResponsesProvider implements Provider {
         if (retryAfterMs !== undefined)
           errorOptions.retryAfterMs = retryAfterMs;
         if (abortReason) errorOptions.abortReason = abortReason;
+        let errorDetail = error.message;
+        if (this.lastCodexErrorBody) {
+          try {
+            const parsed = JSON.parse(this.lastCodexErrorBody);
+            if (parsed.detail) errorDetail = parsed.detail;
+          } catch {
+            errorDetail = this.lastCodexErrorBody.slice(0, 200);
+          }
+          this.lastCodexErrorBody = undefined;
+        }
+        const extras = [error.code, error.type, error.param]
+          .filter(Boolean)
+          .join(", ");
+        const extraSuffix = extras ? ` [${extras}]` : "";
         throw new ProviderError(
-          `${this.providerLabel} API error (${error.status}): ${error.message}`,
+          `${this.providerLabel} API error (${error.status}): ${errorDetail}${extraSuffix}`,
           this.name,
           error.status,
           Object.keys(errorOptions).length > 0 ? errorOptions : undefined,

package/src/providers/openrouter/client.ts

@@ -1,6 +1,7 @@
 import { ProviderError } from "../../util/errors.js";
 import { AnthropicProvider } from "../anthropic/client.js";
 import {
+  clampReasoningEffort,
   EFFORT_TO_REASONING_EFFORT,
   OpenAIChatCompletionsProvider,
 } from "../openai/chat-completions-provider.js";
@@ -200,7 +201,10 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
     const summaryOverride = extractReasoningSummaryOverride(config);
     const reasoning: Record<string, unknown> = { enabled: thinkingEnabled };
     if (mappedEffort) {
-      reasoning.effort = mappedEffort;
+      reasoning.effort = clampReasoningEffort(
+        mappedEffort,
+        this.resolveMaxReasoningEffort(this.resolveEffectiveModel(options)),
+      );
     }
     if (thinkingEnabled) {
       reasoning.summary = summaryOverride ?? "detailed";

package/src/providers/provider-send-message.ts

@@ -9,6 +9,7 @@ import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { getDb } from "../memory/db-connection.js";
 import { getLogger } from "../util/logger.js";
+import { isConnectionCompatibleWithModel } from "./connection-model-compat.js";
 import { tryResolveProviderForConnectionName } from "./connection-resolution.js";
 import { listConnections } from "./inference/connections.js";
 import { initializeProviders, listProviders } from "./registry.js";
@@ -126,7 +127,11 @@ export async function resolveConfiguredProvider(
         const candidates = listConnections(getDb(), {
           provider: inferenceProvider,
         });
-        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;
         }
@@ -147,6 +152,7 @@ export async function resolveConfiguredProvider(
     connectionName,
     config,
     inferenceProvider,
+    resolved.model,
   );
   if (!connectionProvider) {
     // Soft credential failure — the connection resolved to no usable

package/src/providers/retry.ts

@@ -47,9 +47,18 @@ const EFFORT_SUPPORTED_PROVIDERS = new Set([
 /**
  * Providers that consume the `thinking` config. Anthropic uses it directly on
  * the wire; OpenRouter either forwards it to its Anthropic-compatible path or
- * translates it into the unified `reasoning` parameter on OpenAI-compat calls.
+ * translates it into the unified `reasoning` parameter on OpenAI-compat calls;
+ * Gemini reads `thinking.level` to populate `thinkingConfig.thinkingLevel`.
  */
-const THINKING_AWARE_PROVIDERS = new Set(["anthropic", "openrouter"]);
+const THINKING_AWARE_PROVIDERS = new Set(["anthropic", "openrouter", "gemini"]);
+
+/**
+ * Providers that consume Gemini-only thinking extras (`level`,
+ * `streamThinking`). For other thinking-aware providers, we scrub these from
+ * the normalized wire payload because Anthropic's SDK rejects unknown keys
+ * inside the `thinking` object with "Extra inputs are not permitted".
+ */
+const THINKING_EXTRA_FIELDS_AWARE_PROVIDERS = new Set(["gemini"]);
 
 /**
  * Providers that consume the `verbosity` config. Currently OpenAI (mapped to
@@ -289,7 +298,8 @@ function normalizeSendMessageOptions(
   }
 
   // thinking is Anthropic-specific on the wire; OpenRouter reads it as a
-  // signal for its unified reasoning parameter. Strip it for other providers.
+  // signal for its unified reasoning parameter; Gemini reads `level` from it.
+  // Strip it for other providers.
   if (
     !THINKING_AWARE_PROVIDERS.has(providerName) &&
     nextConfig.thinking !== undefined
@@ -297,6 +307,27 @@ function normalizeSendMessageOptions(
     delete nextConfig.thinking;
   }
 
+  // Strip Gemini-only extras (`level`, `streamThinking`) from the wire
+  // `thinking` object for providers that don't read them. Anthropic in
+  // particular rejects unknown keys inside `thinking` with "Extra inputs are
+  // not permitted"; the OpenRouter Anthropic-compat path hits the same SDK.
+  if (
+    nextConfig.thinking !== undefined &&
+    !THINKING_EXTRA_FIELDS_AWARE_PROVIDERS.has(providerName) &&
+    typeof nextConfig.thinking === "object" &&
+    nextConfig.thinking !== null
+  ) {
+    const wire = nextConfig.thinking as Record<string, unknown>;
+    if (wire.level !== undefined || wire.streamThinking !== undefined) {
+      const scrubbed: Record<string, unknown> = {};
+      for (const [key, value] of Object.entries(wire)) {
+        if (key === "level" || key === "streamThinking") continue;
+        scrubbed[key] = value;
+      }
+      nextConfig.thinking = scrubbed;
+    }
+  }
+
   // Anthropic (and OpenRouter fronting Anthropic) rejects requests that
   // combine extended thinking with forced tool use (`tool_choice.type` of
   // `"tool"` or `"any"`).  Strip thinking when both are present so the

package/src/providers/thinking-config.ts

@@ -1,20 +1,45 @@
+import { THINKING_LEVELS, type ThinkingLevel } from "../config/schemas/llm.js";
+
 type ThinkingConfigRecord = Record<string, unknown>;
 
+const THINKING_LEVEL_SET: ReadonlySet<string> = new Set(THINKING_LEVELS);
+
 function isRecord(value: unknown): value is ThinkingConfigRecord {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+function pickGeminiExtras(thinking: ThinkingConfigRecord): {
+  level?: ThinkingLevel;
+  streamThinking?: boolean;
+} {
+  const extras: { level?: ThinkingLevel; streamThinking?: boolean } = {};
+  if (
+    typeof thinking.level === "string" &&
+    THINKING_LEVEL_SET.has(thinking.level)
+  ) {
+    extras.level = thinking.level as ThinkingLevel;
+  }
+  if (typeof thinking.streamThinking === "boolean") {
+    extras.streamThinking = thinking.streamThinking;
+  }
+  return extras;
+}
+
 export function normalizeThinkingConfigForWire(
   thinking: unknown,
 ): ThinkingConfigRecord | undefined {
   if (!isRecord(thinking)) return undefined;
 
+  // Already in wire shape — preserve as-is so re-normalization is idempotent
+  // and Gemini-only fields stay attached for the Gemini provider to read.
   if (typeof thinking.type === "string") {
     return thinking;
   }
 
+  const extras = pickGeminiExtras(thinking);
+
   if (thinking.enabled === true) {
-    return { type: "adaptive" };
+    return { type: "adaptive", ...extras };
   }
 
   if (thinking.enabled === false) {