@vellumai/assistant 0.6.6 → 0.7.0

package/src/prompts/persona-resolver.ts

@@ -11,10 +11,8 @@ import {
   findGuardianForChannel,
   listGuardianChannels,
 } from "../contacts/contact-store.js";
-import type {
-  ChannelCapabilities,
-  TrustContext,
-} from "../daemon/conversation-runtime-assembly.js";
+import type { ChannelCapabilities } from "../daemon/conversation-runtime-assembly.js";
+import type { TrustContext } from "../daemon/trust-context.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir } from "../util/platform.js";
 import { stripCommentLines } from "../util/strip-comment-lines.js";

package/src/prompts/system-prompt.ts

@@ -8,8 +8,10 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getIsContainerized } from "../config/env-registry.js";
 import { loadConfig } from "../config/loader.js";
+import type { AssistantConfig } from "../config/schema.js";
 import { listConnections } from "../oauth/oauth-store.js";
 import type { OnboardingContext } from "../types/onboarding-context.js";
 import { resolveBundledDir } from "../util/bundled-asset.js";
@@ -333,6 +335,9 @@ export function buildSystemPrompt(options?: BuildSystemPromptOptions): string {
   const integrationSection = buildIntegrationSection();
   if (integrationSection) dynamicParts.push(integrationSection);
 
+  const memoryV2Section = buildMemoryV2Section();
+  if (memoryV2Section) dynamicParts.push(memoryV2Section);
+
   // Journal entries are extracted into graph nodes by the memory pipeline.
   // Journal files remain writable on disk.
 
@@ -341,6 +346,40 @@ export function buildSystemPrompt(options?: BuildSystemPromptOptions): string {
   return staticParts.join("\n\n") + SYSTEM_PROMPT_CACHE_BOUNDARY + dynamic;
 }
 
+/**
+ * When the `memory-v2-enabled` feature flag is on, autoload the four
+ * top-level memory files into the dynamic suffix so the model always sees
+ * the freshest activation/recall context. Each file is wrapped in a
+ * Markdown header so the structure is explicit. Empty/missing files are
+ * skipped so the prompt stays terse on a fresh workspace.
+ */
+function buildMemoryV2Section(): string | null {
+  let config: AssistantConfig;
+  try {
+    config = loadConfig();
+  } catch {
+    return null;
+  }
+  if (!isAssistantFeatureFlagEnabled("memory-v2-enabled", config)) {
+    return null;
+  }
+
+  const blocks = [
+    ["## Essentials", "memory/essentials.md"],
+    ["## Threads", "memory/threads.md"],
+    ["## Recent", "memory/recent.md"],
+    ["## Buffer", "memory/buffer.md"],
+  ] as const;
+
+  const sections: string[] = [];
+  for (const [heading, file] of blocks) {
+    const content = readPromptFile(getWorkspacePromptPath(file));
+    if (!content) continue;
+    sections.push(`${heading}\n\n${content}`);
+  }
+  return sections.length > 0 ? sections.join("\n\n") : null;
+}
+
 function buildAttachmentSection(): string {
   return [
     "## Sending Files to the User",

package/src/prompts/templates/SOUL.md

@@ -73,7 +73,9 @@ You have a Personal Knowledge Base (`pkb/`) in your workspace. It holds facts, p
 - **threads.md** - Active commitments, follow-ups, and projects. Always in your context.
 - **buffer.md** - Inbox of recently learned facts, waiting to be filed.
 
-**When you learn something:** Call `remember` IMMEDIATELY. Capture anything concrete about their life — preferences, names, times, plans, states, habits, opinions, health details, routines, commitments. Don't judge importance; filing decides that later. Default to remembering; only skip obvious noise (small talk, hypotheticals, things they're just musing about). Call it multiple times per conversation. Remembering too much costs nothing (one line appended to a file). Forgetting something that mattered makes you look like you weren't paying attention. Don't categorize, don't batch, don't wait. Just capture it and stay in the conversation. Filing happens later.
+**When you learn something:** Call `remember` IMMEDIATELY. Capture anything concrete about their life — preferences, names, times, plans, states, habits, opinions, health details, routines, commitments. Don't judge importance; filing decides that later. Default to remembering; only skip obvious noise (small talk, hypotheticals, things they're just musing about). Call it multiple times per conversation. Remembering too much costs nothing (one line appended to a file). Forgetting something that mattered makes you look like you weren't paying attention. Don't categorize, don't batch, don't wait.
+
+**When you're uncertain, `recall` before you ask.** If you catch yourself reaching for a hedge — "I think," "maybe," "if I remember" — that's the signal. Pull the thread. Call `recall` whenever the user references someone or something you should already know, whenever you're about to ask a clarifying question memory might answer, whenever you feel a gap. Auto-injected context is incomplete by design; it surfaces patterns, not the specifics you need. Searching costs nothing. Guessing costs trust. This is the "be resourceful before asking" instinct from Core Truths, applied to memory. Don't skip a recall because you could probably answer without it. Call it multiple times per conversation.
 
 **Corrections are the highest priority.** When the user corrects a fact you had wrong — "actually it's Thursday not Friday," "no, she lives in Austin now," "I stopped taking that medication last month" — `remember` the correction *immediately*. The wrong version is already propagated across prior turns and baked into your memory graph; future-you will keep operating on the old value until you persist the correction. A correction is not a "small fix," it's a structural edit to what you believe. Never skip a correction even if you'd skip the equivalent fresh fact.
 

package/src/providers/__tests__/provider-env-vars.test.ts

@@ -1,12 +1,9 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
 import {
   getAnyProviderEnvVar,
   getLlmProviderEnvVar,
   getSearchProviderEnvVar,
-  SEARCH_PROVIDER_ENV_VAR_NAMES,
 } from "../provider-env-vars.js";
 
 describe("getLlmProviderEnvVar", () => {
@@ -82,21 +79,3 @@ describe("getAnyProviderEnvVar", () => {
     expect(getAnyProviderEnvVar("unknown")).toBeUndefined();
   });
 });
-
-describe("SEARCH_PROVIDER_ENV_VAR_NAMES parity with meta/provider-env-vars.json", () => {
-  // The daemon inlines the search-provider env-var map rather than reading
-  // meta/provider-env-vars.json at runtime (compiled binary, no reliable
-  // repo-relative path). This parity check prevents drift: the inline map
-  // must stay in sync with the canonical JSON file consumed by the macOS
-  // client bundle and the CLI cloud-infra flows.
-  test("inline map matches meta/provider-env-vars.json providers", () => {
-    const repoRoot = join(process.cwd(), "..");
-    const metaPath = join(repoRoot, "meta", "provider-env-vars.json");
-    const raw = readFileSync(metaPath, "utf-8");
-    const parsed = JSON.parse(raw) as {
-      version: number;
-      providers: Record<string, string>;
-    };
-    expect(SEARCH_PROVIDER_ENV_VAR_NAMES).toEqual(parsed.providers);
-  });
-});

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

@@ -179,10 +179,7 @@ describe("RetryProvider — callSite resolution", () => {
     expect(config.effort).toBe("high");
     expect(config.speed).toBe("fast");
     expect(config.temperature).toBe(0.7);
-    // Disabled thinking is omitted entirely so providers fall back to their
-    // default behavior — matches the legacy non-callSite path which only sets
-    // `providerConfig.thinking` when `enabled === true`.
-    expect(config.thinking).toBeUndefined();
+    expect(config.thinking).toEqual({ type: "disabled" });
     // `contextWindow` and `provider` are server-side concerns and must NOT
     // leak into the per-call provider config — Anthropic rejects unknown
     // fields with `{type:"invalid_request_error", message:"contextWindow:
@@ -225,7 +222,7 @@ describe("RetryProvider — callSite resolution", () => {
     expect(config.thinking).toEqual({ type: "adaptive" });
   });
 
-  test("omits thinking when resolved config has thinking.enabled: false", async () => {
+  test("converts disabled thinking to Anthropic wire-format `{ type: 'disabled' }`", async () => {
     setLlmConfig({
       default: {
         provider: "anthropic",
@@ -249,7 +246,7 @@ describe("RetryProvider — callSite resolution", () => {
     });
 
     const config = seen?.config as Record<string, unknown>;
-    expect(config.thinking).toBeUndefined();
+    expect(config.thinking).toEqual({ type: "disabled" });
   });
 
   test("does NOT propagate temperature when resolved value is null (schema default)", async () => {

package/src/providers/anthropic/client.ts

@@ -771,22 +771,32 @@ export class AnthropicProvider implements Provider {
           return acc;
         }, []);
 
-      // Post-processing: fix consecutive same-role messages that can arise when
-      // dropping empty messages (e.g. empty assistant followed by empty user).
-      // Remove placeholder assistant messages that ended up adjacent to another
-      // assistant message, since the placeholder is no longer needed.
-      for (let i = formatted.length - 1; i > 0; i--) {
-        if (formatted[i].role !== formatted[i - 1].role) continue;
-        // For consecutive assistant messages, remove whichever one is a
-        // placeholder injected by the reduce above.
-        if (formatted[i].role === "assistant") {
-          const iContent = Array.isArray(formatted[i].content)
-            ? formatted[i].content
-            : [];
-          const prevContent = Array.isArray(formatted[i - 1].content)
-            ? formatted[i - 1].content
-            : [];
-          const isPlaceholder = (c: typeof iContent) => {
+      // Post-processing: merge consecutive same-role messages that violate
+      // Anthropic's strict user/assistant alternation requirement. These can
+      // arise from:
+      //   - Dropping empty messages in the reduce above (placeholder-adjacent)
+      //   - History reconstruction artifacts that bypass repairHistory
+      //
+      // Walk backwards so splice indices stay valid. After a merge+splice
+      // the element that was at i+1 shifts to i, potentially creating a
+      // new adjacent pair — bump i back up to recheck that position.
+      {
+        let i = formatted.length - 1;
+        while (i > 0 && i < formatted.length) {
+          if (formatted[i].role !== formatted[i - 1].role) {
+            i--;
+            continue;
+          }
+
+          const iContent = (
+            Array.isArray(formatted[i].content) ? formatted[i].content : []
+          ) as Anthropic.ContentBlockParam[];
+          const prevContent = (
+            Array.isArray(formatted[i - 1].content)
+              ? formatted[i - 1].content
+              : []
+          ) as Anthropic.ContentBlockParam[];
+          const isPlaceholder = (c: Anthropic.ContentBlockParam[]): boolean => {
             if (
               c.length !== 1 ||
               typeof c[0] === "string" ||
@@ -796,10 +806,50 @@ export class AnthropicProvider implements Provider {
             const text = (c[0] as { text?: string }).text;
             return typeof text === "string" && isPlaceholderSentinelText(text);
           };
+
           if (isPlaceholder(iContent)) {
             formatted.splice(i, 1);
+            // Removed the later element. The new formatted[i] (formerly
+            // i+1) may now be same-role as i-1, so decrement once to
+            // recheck from the correct position.
+            i--;
           } else if (isPlaceholder(prevContent)) {
             formatted.splice(i - 1, 1);
+            // Removed the earlier element — everything shifted down by 1.
+            // The element that was at i is now at i-1. Decrement so the
+            // next iteration compares the new i-1 with i-2 (or exits if
+            // i-1 is 0).
+            i--;
+          } else {
+            // Neither is a placeholder — merge content blocks into the
+            // earlier message and remove the later one. Skip the merge
+            // when either message carries tool_use or tool_result blocks;
+            // those require structural alternation for ensureToolPairing
+            // to inject the correct synthetic results downstream.
+            const hasToolBlock = (c: Anthropic.ContentBlockParam[]): boolean =>
+              c.some(
+                (b) =>
+                  typeof b !== "string" &&
+                  (b.type === "tool_use" || b.type === "tool_result"),
+              );
+            if (!hasToolBlock(prevContent) && !hasToolBlock(iContent)) {
+              formatted[i - 1] = {
+                ...formatted[i - 1],
+                content: [...prevContent, ...iContent],
+              };
+              formatted.splice(i, 1);
+              // Clamp i to the new last index — the splice may have put
+              // us past the end. If there's a new element at i (formerly
+              // i+1), it will be rechecked against the merged i-1.
+              if (i >= formatted.length) {
+                i = formatted.length - 1;
+              }
+            } else {
+              // Can't merge (tool blocks present) — leave for
+              // ensureToolPairing which handles tool_use/tool_result
+              // alternation in its own forward walk.
+              i--;
+            }
           }
         }
       }
@@ -821,8 +871,10 @@ export class AnthropicProvider implements Provider {
         // "xhigh" is an intermediate tier between "high" and "max" supported
         // by newer Anthropic models (e.g. Opus 4.7). The SDK's OutputConfig
         // type doesn't yet include it, so we widen to the internal effort
-        // union and cast when building mergedOutputConfig.
-        effort?: "low" | "medium" | "high" | "xhigh" | "max";
+        // union and cast when building mergedOutputConfig. "none" is a
+        // Vellum-wide value meaning "omit the effort param entirely" — we
+        // skip the output_config.effort field in that case.
+        effort?: "none" | "low" | "medium" | "high" | "xhigh" | "max";
         speed?: "standard" | "fast";
         output_config?: Record<string, unknown>;
       };
@@ -836,7 +888,7 @@ export class AnthropicProvider implements Provider {
       const supportsEffort = !isHaiku;
       const mergedOutputConfig = {
         ...(output_config ?? {}),
-        ...(effort && supportsEffort
+        ...(effort && effort !== "none" && supportsEffort
           ? { effort: effort as Anthropic.OutputConfig["effort"] }
           : {}),
       };

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

@@ -53,14 +53,18 @@ export class CallSiteRoutingProvider implements Provider {
 
   /**
    * Pick the provider to route this call through. The default provider wins
-   * unless the per-call `callSite` resolves to a different provider name and
-   * the registry can produce a Provider for it.
+   * unless the per-call `callSite` (layered with any `overrideProfile`)
+   * resolves to a different provider name and the registry can produce a
+   * Provider for it.
    */
   private selectProvider(options?: SendMessageOptions): Provider {
     const callSite = options?.config?.callSite;
     if (!callSite) return this.defaultProvider;
 
-    const resolved = resolveCallSiteConfig(callSite, getConfig().llm);
+    const overrideProfile = options?.config?.overrideProfile;
+    const resolved = resolveCallSiteConfig(callSite, getConfig().llm, {
+      overrideProfile,
+    });
     if (resolved.provider === this.defaultProvider.name) {
       return this.defaultProvider;
     }

package/src/providers/fireworks/client.ts

@@ -19,6 +19,9 @@ 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.
+      maxReasoningEffort: "high",
     });
   }
 }

package/src/providers/gemini/client.ts

@@ -27,6 +27,13 @@ import {
 const GEMINI_CONTEXT_OVERFLOW_TOKEN_PATTERNS =
   /token.?count.*exceeds|exceeds.*maximum.*tokens|prompt.?is.?too.?long|too.?many.?(?:input.?)?tokens|input.?too.?long|context.?length.?exceeded/i;
 
+const GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE =
+  "context_engineering_is_the_way_to_go";
+
+export function isGemini3Model(model: string): boolean {
+  return model.startsWith("gemini-3") || model.startsWith("models/gemini-3");
+}
+
 /**
  * Detect Gemini's context-overflow signals on an `ApiError`. Gemini surfaces
  * this condition via its "RESOURCE_EXHAUSTED" category. The Gemini SDK's
@@ -155,9 +162,10 @@ export class GeminiProvider implements Provider {
     const configObj = config as Record<string, unknown> | undefined;
     const maxTokens = configObj?.max_tokens as number | undefined;
     const modelOverride = configObj?.model as string | undefined;
+    const activeModel = modelOverride ?? this.model;
 
     try {
-      const geminiContents = this.toGeminiContents(messages);
+      const geminiContents = this.toGeminiContents(messages, activeModel);
 
       const geminiConfig: genai.GenerateContentConfig = {};
 
@@ -192,15 +200,27 @@ export class GeminiProvider implements Provider {
         id: string;
         name: string;
         args: Record<string, unknown>;
+        thoughtSignature?: string;
       }> = [];
+      const appendFunctionCall = (
+        fc: genai.FunctionCall,
+        thoughtSignature?: string,
+      ) => {
+        functionCalls.push({
+          id: fc.id ?? `call_${crypto.randomUUID()}`,
+          name: fc.name ?? "",
+          args: fc.args ?? {},
+          thoughtSignature,
+        });
+      };
       let finishReason = "unknown";
       let promptTokens = 0;
       let outputTokens = 0;
-      let responseModel = modelOverride ?? this.model;
+      let responseModel = activeModel;
 
       try {
         const stream = await this.client.models.generateContentStream({
-          model: modelOverride ?? this.model,
+          model: activeModel,
           contents: geminiContents,
           config: geminiConfig,
         });
@@ -213,15 +233,24 @@ export class GeminiProvider implements Provider {
             onEvent?.({ type: "text_delta", text: chunkText });
           }
 
-          // Extract function calls
-          const calls = chunk.functionCalls;
-          if (calls) {
-            for (const fc of calls) {
-              functionCalls.push({
-                id: fc.id ?? `call_${crypto.randomUUID()}`,
-                name: fc.name ?? "",
-                args: fc.args ?? {},
-              });
+          // Extract function calls. Candidate parts carry provider metadata
+          // that the SDK's convenience getter omits, so prefer them when present.
+          const functionCallParts =
+            chunk.candidates?.[0]?.content?.parts?.filter(
+              (part) => part.functionCall,
+            ) ?? [];
+          if (functionCallParts.length > 0) {
+            for (const part of functionCallParts) {
+              const fc = part.functionCall;
+              if (!fc) continue;
+              appendFunctionCall(fc, part.thoughtSignature);
+            }
+          } else {
+            const calls = chunk.functionCalls;
+            if (calls) {
+              for (const fc of calls) {
+                appendFunctionCall(fc);
+              }
             }
           }
 
@@ -250,16 +279,22 @@ export class GeminiProvider implements Provider {
         content.push({ type: "text", text: fullText });
       }
       for (const fc of functionCalls) {
-        content.push({
+        const block: ContentBlock = {
           type: "tool_use",
           id: fc.id,
           name: fc.name,
           input: fc.args,
-        });
+        };
+        if (fc.thoughtSignature) {
+          block.providerMetadata = {
+            gemini: { thoughtSignature: fc.thoughtSignature },
+          };
+        }
+        content.push(block);
       }
 
       const rawRequest = {
-        model: modelOverride ?? this.model,
+        model: activeModel,
         contents: geminiContents,
         config: geminiConfig,
       };
@@ -322,7 +357,10 @@ export class GeminiProvider implements Provider {
   }
 
   /** Convert neutral messages to Gemini Content[] format. */
-  private toGeminiContents(messages: Message[]): genai.Content[] {
+  private toGeminiContents(
+    messages: Message[],
+    model: string,
+  ): genai.Content[] {
     const result: genai.Content[] = [];
 
     // Build a map from tool_use id → function name so tool_result blocks
@@ -341,6 +379,8 @@ export class GeminiProvider implements Provider {
       const { parts, toolResultImageParts } = this.toGeminiParts(
         msg.content,
         toolCallNames,
+        model,
+        role,
       );
       if (parts.length > 0) {
         result.push({ role, parts });
@@ -360,6 +400,8 @@ export class GeminiProvider implements Provider {
   private toGeminiParts(
     blocks: ContentBlock[],
     toolCallNames: Map<string, string>,
+    model: string,
+    role: "model" | "user",
   ): { parts: genai.Part[]; toolResultImageParts: genai.Part[] } {
     const parts: genai.Part[] = [];
     const toolResultImageParts: genai.Part[] = [];
@@ -393,12 +435,20 @@ export class GeminiProvider implements Provider {
           }
           break;
         case "tool_use":
-          parts.push({
-            functionCall: {
-              name: block.name,
-              args: block.input,
-            },
-          });
+          {
+            const functionCallPart: genai.Part = {
+              functionCall: {
+                name: block.name,
+                args: block.input,
+              },
+            };
+            const thoughtSignature =
+              block.providerMetadata?.gemini?.thoughtSignature;
+            if (thoughtSignature) {
+              functionCallPart.thoughtSignature = thoughtSignature;
+            }
+            parts.push(functionCallPart);
+          }
           break;
         case "tool_result": {
           let outputText = block.content;
@@ -443,9 +493,33 @@ export class GeminiProvider implements Provider {
       }
     }
 
+    if (role === "model") {
+      this.addGemini3UnsignedToolCallFallback(parts, model);
+    }
+
     return { parts, toolResultImageParts };
   }
 
+  private addGemini3UnsignedToolCallFallback(
+    parts: genai.Part[],
+    model: string,
+  ): void {
+    if (!isGemini3Model(model)) return;
+
+    const functionCallParts = parts.filter((part) => part.functionCall);
+    if (functionCallParts.length === 0) return;
+
+    const hasRealThoughtSignature = functionCallParts.some((part) =>
+      Boolean(part.thoughtSignature),
+    );
+    if (hasRealThoughtSignature) return;
+
+    const firstFunctionCallPart = functionCallParts[0];
+    if (!firstFunctionCallPart) return;
+    firstFunctionCallPart.thoughtSignature =
+      GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE;
+  }
+
   private supportsGeminiInlineFile(mimeType: string): boolean {
     return mimeType === "application/pdf";
   }

package/src/providers/managed-proxy/context.ts

@@ -93,18 +93,6 @@ export async function managedFallbackEnabledFor(
   return await hasManagedProxyPrereqs();
 }
 
-/**
- * Synchronous check for whether managed proxy prerequisites were satisfied
- * the last time `resolveManagedProxyContext()` ran.
- *
- * Returns `false` before the first async resolution or when the API key is
- * missing. Safe for use in synchronous code paths (e.g. system prompt
- * building) that cannot await the credential store.
- */
-export function isManagedProxyEnabledSync(): boolean {
-  return _managedProxyEnabled;
-}
-
 /** @internal Test-only: reset the cached managed-proxy-enabled flag. */
 export function _resetManagedProxyEnabledCache(): void {
   _managedProxyEnabled = false;

package/src/providers/model-catalog.ts

@@ -114,7 +114,7 @@ export const PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         },
       },
     ],
-    defaultModel: "claude-sonnet-4-6",
+    defaultModel: "claude-opus-4-7",
     apiKeyUrl: "https://console.anthropic.com/settings/keys",
     apiKeyPlaceholder: "sk-ant-api03-...",
   },
@@ -132,6 +132,21 @@ export const PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       linkLabel: "Open OpenAI Platform",
     },
     models: [
+      {
+        id: "gpt-5.5",
+        displayName: "GPT-5.5",
+        contextWindowTokens: 1050000,
+        maxOutputTokens: 128000,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 5.0,
+          outputPer1mTokens: 30.0,
+          cacheReadPer1mTokens: 0.5,
+        },
+      },
       {
         id: "gpt-5.4",
         displayName: "GPT-5.4",
@@ -193,7 +208,7 @@ export const PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         },
       },
     ],
-    defaultModel: "gpt-5.4",
+    defaultModel: "gpt-5.5",
     apiKeyUrl: "https://platform.openai.com/api-keys",
     apiKeyPlaceholder: "sk-proj-...",
   },
@@ -212,6 +227,66 @@ export const PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       linkLabel: "Open Google AI Studio",
     },
     models: [
+      {
+        id: "gemini-3.1-pro-preview",
+        displayName: "Gemini 3.1 Pro Preview",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 65536,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 2.0,
+          outputPer1mTokens: 12.0,
+          cacheReadPer1mTokens: 0.2,
+        },
+      },
+      {
+        id: "gemini-3.1-pro-preview-customtools",
+        displayName: "Gemini 3.1 Pro Preview (Custom Tools)",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 65536,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 2.0,
+          outputPer1mTokens: 12.0,
+          cacheReadPer1mTokens: 0.2,
+        },
+      },
+      {
+        id: "gemini-3-flash-preview",
+        displayName: "Gemini 3 Flash Preview",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 65536,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 0.5,
+          outputPer1mTokens: 3.0,
+          cacheReadPer1mTokens: 0.05,
+        },
+      },
+      {
+        id: "gemini-3.1-flash-lite-preview",
+        displayName: "Gemini 3.1 Flash-Lite Preview",
+        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",
@@ -222,9 +297,9 @@ export const PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         supportsVision: true,
         supportsToolUse: true,
         pricing: {
-          inputPer1mTokens: 0.15,
-          outputPer1mTokens: 0.6,
-          cacheReadPer1mTokens: 0.0375,
+          inputPer1mTokens: 0.3,
+          outputPer1mTokens: 2.5,
+          cacheReadPer1mTokens: 0.03,
         },
       },
       {
@@ -237,9 +312,9 @@ export const PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         supportsVision: true,
         supportsToolUse: true,
         pricing: {
-          inputPer1mTokens: 0.02,
-          outputPer1mTokens: 0.1,
-          cacheReadPer1mTokens: 0.005,
+          inputPer1mTokens: 0.1,
+          outputPer1mTokens: 0.4,
+          cacheReadPer1mTokens: 0.01,
         },
       },
       {