@vellumai/assistant 0.8.3 → 0.8.5

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";
@@ -537,6 +536,55 @@ function formatOrphanedWebSearchResultAsText(block: {
  *
  * Builds a fresh result array without mutating the input.
  */
+/**
+ * Find the start index of the active tool-use continuation span at the tail
+ * of the formatted message array. Messages from this index onward may contain
+ * thinking blocks that must be preserved for Anthropic's tool-use protocol.
+ *
+ * The active span is the trailing sequence of alternating
+ * assistant(tool_use) → user(tool_result) messages. Everything before it is
+ * a completed historical turn whose thinking blocks can be safely stripped.
+ *
+ * Returns `messages.length` when there is no active tool-use continuation
+ * (i.e. all messages are historical — strip thinking from everything).
+ */
+function findActiveToolUseContinuationStart(
+  messages: Anthropic.MessageParam[],
+): number {
+  // Walk backwards from the end. The tail pattern we're looking for is:
+  //   ... assistant(tool_use) user(tool_result) [assistant(tool_use) user(tool_result)]* ...
+  // The last message is typically a user message (the new prompt), so if it
+  // doesn't contain tool_result blocks, there's no active continuation.
+  let i = messages.length - 1;
+
+  while (i >= 0) {
+    const msg = messages[i];
+    if (msg.role === "user") {
+      const content = Array.isArray(msg.content) ? msg.content : [];
+      const hasToolResult = content.some(
+        (b) => typeof b !== "string" && isToolResultBlock(b),
+      );
+      if (!hasToolResult) break;
+      // This user message has tool_result — the preceding assistant message
+      // should have the matching tool_use and its thinking blocks preserved.
+      i--;
+    } else if (msg.role === "assistant") {
+      const content = Array.isArray(msg.content) ? msg.content : [];
+      const hasToolUse = content.some(
+        (b) => typeof b !== "string" && isToolUseBlock(b),
+      );
+      if (!hasToolUse) break;
+      // This assistant message has tool_use — it's part of the active span.
+      // Check if the preceding user message continues the chain.
+      i--;
+    } else {
+      break;
+    }
+  }
+
+  return i + 1;
+}
+
 function ensureToolPairing(
   messages: Anthropic.MessageParam[],
 ): Anthropic.MessageParam[] {
@@ -770,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
@@ -925,10 +982,29 @@ export class AnthropicProvider implements Provider {
         }
       }
 
-      // Thinking blocks are stripped at rest by DB migration 209 so
-      // historical messages are clean when loaded. Within a turn,
-      // assistant messages have original thinking with valid signatures
-      // — the API accepts them. No provider-side stripping needed.
+      // Strip thinking/redacted_thinking blocks from completed historical
+      // assistant turns. Anthropic only requires these blocks for active
+      // tool-use continuation (the tail span where assistant tool_use is
+      // 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);
+      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(
+          (b) =>
+            typeof b === "string" ||
+            (b.type !== "thinking" && b.type !== "redacted_thinking"),
+        );
+        if (stripped.length === 0) {
+          stripped.push({
+            type: "text" as const,
+            text: PLACEHOLDER_BLOCKS_OMITTED,
+          });
+        }
+        formatted[i] = { ...msg, content: stripped };
+      }
 
       sentMessages = ensureToolPairing(
         repairOrphanedServerToolBlocks(formatted),
@@ -938,6 +1014,7 @@ export class AnthropicProvider implements Provider {
         speed,
         output_config,
         cacheTtl: _cacheTtl,
+        disableTurnStartCache: _disableTurnStartCache,
         max_tokens: callerMaxTokens,
         usageAttributionHeaders,
         ...restConfig
@@ -994,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) {
@@ -1089,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
@@ -1101,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);
       }
@@ -1114,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) {
@@ -1136,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.
@@ -1274,6 +1311,19 @@ export class AnthropicProvider implements Provider {
         let lastInputJsonEmitMs = 0;
         let pendingInputJsonFlush: ReturnType<typeof setTimeout> | undefined;
 
+        // Anthropic streams `server_tool_use` block input via `input_json_delta`
+        // events (the block's own `input` field is `{}` at content_block_start).
+        // We accumulate the JSON separately from regular `tool_use` blocks so
+        // the daemon can read the resolved query when the paired
+        // `web_search_tool_result` arrives — without this, downstream activity
+        // metadata sees an empty query.
+        let currentServerToolUseId: string | undefined;
+        let accumulatedServerToolInputJson = "";
+        const resolvedServerToolInputs = new Map<
+          string,
+          Record<string, unknown>
+        >();
+
         stream.on("streamEvent", (event) => {
           // Reset the text sentinel buffer at each content-block boundary.
           // A new block starts fresh; at the end of a block, flush any
@@ -1300,6 +1350,8 @@ export class AnthropicProvider implements Provider {
             event.type === "content_block_start" &&
             event.content_block.type === "server_tool_use"
           ) {
+            currentServerToolUseId = event.content_block.id;
+            accumulatedServerToolInputJson = "";
             onEvent?.({
               type: "server_tool_start",
               name: event.content_block.name,
@@ -1315,11 +1367,21 @@ export class AnthropicProvider implements Provider {
           ) {
             const block = event.content_block as {
               tool_use_id: string;
-              content?: { type: "web_search_tool_result_error" } | unknown[];
+              content?:
+                | { type: "web_search_tool_result_error"; error_code?: string }
+                | unknown[];
             };
             const isError =
               !Array.isArray(block.content) &&
               block.content?.type === "web_search_tool_result_error";
+            const errorCode =
+              isError && !Array.isArray(block.content)
+                ? block.content?.error_code
+                : undefined;
+            const resolvedInput = resolvedServerToolInputs.get(
+              block.tool_use_id,
+            );
+            resolvedServerToolInputs.delete(block.tool_use_id);
             onEvent?.({
               type: "server_tool_complete",
               toolUseId: block.tool_use_id,
@@ -1327,6 +1389,8 @@ export class AnthropicProvider implements Provider {
               ...(Array.isArray(block.content)
                 ? { content: block.content }
                 : {}),
+              ...(resolvedInput ? { resolvedInput } : {}),
+              ...(errorCode ? { errorCode } : {}),
             });
           }
           if (event.type === "content_block_stop") {
@@ -1345,6 +1409,25 @@ export class AnthropicProvider implements Provider {
             currentStreamingToolName = undefined;
             currentStreamingToolUseId = undefined;
             accumulatedInputJson = "";
+            // Finalize the resolved input for a `server_tool_use` block (e.g.
+            // the actual web-search query) so the paired `web_search_tool_result`
+            // emits `server_tool_complete` with `resolvedInput` populated.
+            if (currentServerToolUseId && accumulatedServerToolInputJson) {
+              try {
+                const parsed = JSON.parse(accumulatedServerToolInputJson);
+                if (parsed && typeof parsed === "object") {
+                  resolvedServerToolInputs.set(
+                    currentServerToolUseId,
+                    parsed as Record<string, unknown>,
+                  );
+                }
+              } catch {
+                // Malformed partial JSON — drop silently; downstream falls
+                // back to whatever was captured at server_tool_start.
+              }
+            }
+            currentServerToolUseId = undefined;
+            accumulatedServerToolInputJson = "";
             // Flush residual text buffer unless it's exactly a sentinel.
             if (textBuffer.length > 0 && !isCompleteSentinel(textBuffer)) {
               onEvent?.({ type: "text_delta", text: textBuffer });
@@ -1354,6 +1437,13 @@ export class AnthropicProvider implements Provider {
         });
 
         stream.on("inputJson", (partialJson) => {
+          if (currentServerToolUseId) {
+            // Server-tool input (e.g. `web_search` query) — accumulate without
+            // emitting `input_json_delta`; the daemon only consumes the
+            // finalized value from `server_tool_complete.resolvedInput`.
+            accumulatedServerToolInputJson += partialJson;
+            return;
+          }
           if (!currentStreamingToolName) return;
           accumulatedInputJson += partialJson;
           const now = Date.now();
@@ -1544,6 +1634,9 @@ export class AnthropicProvider implements Provider {
       case "text":
         return { type: "text", text: block.text };
       case "thinking":
+        if (!block.signature) {
+          return null;
+        }
         return {
           type: "thinking",
           thinking: block.thinking,

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,
   );
 }

package/src/providers/fireworks/client.ts

@@ -1,3 +1,4 @@
+import { PROVIDER_CATALOG } from "../model-catalog.js";
 import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
 
 export interface FireworksProviderOptions {
@@ -8,6 +9,15 @@ export interface FireworksProviderOptions {
 
 const DEFAULT_FIREWORKS_BASE_URL = "https://api.fireworks.ai/inference/v1";
 
+const FIREWORKS_MODEL_EFFORT_CEILINGS: ReadonlyMap<
+  string,
+  "high" | "xhigh" | "max"
+> = new Map(
+  PROVIDER_CATALOG.find((p) => p.id === "fireworks")?.models.flatMap((m) =>
+    m.maxEffort ? ([[m.id, m.maxEffort]] as const) : [],
+  ) ?? [],
+);
+
 export class FireworksProvider extends OpenAIChatCompletionsProvider {
   constructor(
     apiKey: string,
@@ -19,9 +29,17 @@ export class FireworksProvider extends OpenAIChatCompletionsProvider {
       providerName: "fireworks",
       providerLabel: "Fireworks",
       streamTimeoutMs: options.streamTimeoutMs,
-      // Fireworks' OpenAI-compatible chat-completions API documents only
-      // low|medium|high for reasoning_effort; sending "xhigh" 4xxs upstream.
+      // Fallback for models not declared in the catalog. Most Fireworks
+      // chat-completions models only document `low|medium|high`; per-model
+      // overrides (e.g. DeepSeek V4 → "max") come from
+      // {@link resolveMaxReasoningEffort}.
       maxReasoningEffort: "high",
     });
   }
+
+  protected override resolveMaxReasoningEffort(
+    model: string,
+  ): "high" | "xhigh" | "max" {
+    return FIREWORKS_MODEL_EFFORT_CEILINGS.get(model) ?? "high";
+  }
 }

package/src/providers/gemini/client.ts

@@ -1,7 +1,6 @@
 import type * as genai from "@google/genai";
-import { ApiError, GoogleGenAI } from "@google/genai";
+import { ApiError, GoogleGenAI, ThinkingLevel } from "@google/genai";
 
-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";
@@ -34,6 +33,47 @@ function isGemini3Model(model: string): boolean {
   return model.startsWith("gemini-3") || model.startsWith("models/gemini-3");
 }
 
+const THINKING_LEVEL_BY_NAME: Record<string, ThinkingLevel> = {
+  minimal: ThinkingLevel.MINIMAL,
+  low: ThinkingLevel.LOW,
+  medium: ThinkingLevel.MEDIUM,
+  high: ThinkingLevel.HIGH,
+};
+
+/**
+ * Translate the resolved wire-shape `thinking` config into Gemini's
+ * `thinkingConfig`. Returns `undefined` when no thinking config was supplied,
+ * which lets Google's per-model default apply (e.g. `gemini-3.5-flash`
+ * defaults to dynamic medium-level thinking).
+ *
+ * `enabled: false` maps to `thinkingLevel: MINIMAL` because Gemini 3.x cannot
+ * fully disable thinking — `"minimal"` is the floor. `includeThoughts` is
+ * gated on `streamThinking` so callers that opted out of streaming thoughts
+ * don't pay for thought tokens in the response.
+ */
+function buildThinkingConfig(
+  thinking: Record<string, unknown> | undefined,
+): genai.ThinkingConfig | undefined {
+  if (!thinking) return undefined;
+  if (thinking.type === "disabled") {
+    return {
+      thinkingLevel: ThinkingLevel.MINIMAL,
+      includeThoughts: false,
+    };
+  }
+  if (thinking.type !== "adaptive") return undefined;
+
+  const result: genai.ThinkingConfig = {};
+  if (typeof thinking.level === "string") {
+    const mapped = THINKING_LEVEL_BY_NAME[thinking.level];
+    if (mapped) result.thinkingLevel = mapped;
+  }
+  if (typeof thinking.streamThinking === "boolean") {
+    result.includeThoughts = thinking.streamThinking;
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
 function stripGeminiHttpOptions(
   config: genai.GenerateContentConfig,
 ): genai.GenerateContentConfig {
@@ -175,6 +215,9 @@ 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;
 
     try {
@@ -183,14 +226,14 @@ export class GeminiProvider implements Provider {
       const geminiConfig: genai.GenerateContentConfig = {};
 
       if (systemPrompt) {
-        geminiConfig.systemInstruction = systemPrompt.replaceAll(
-          SYSTEM_PROMPT_CACHE_BOUNDARY,
-          "\n",
-        );
+        geminiConfig.systemInstruction = systemPrompt;
       }
       if (maxTokens) {
         geminiConfig.maxOutputTokens = maxTokens;
       }
+      if (thinkingConfig) {
+        geminiConfig.thinkingConfig = thinkingConfig;
+      }
       if (tools && tools.length > 0) {
         geminiConfig.tools = [
           {