@vellumai/assistant 0.6.6 → 0.7.1

package/src/config/schemas/call-site-catalog.ts

@@ -0,0 +1,271 @@
+import { type LLMCallSite } from "./llm.js";
+
+export const CALL_SITE_DOMAINS = [
+  { id: "agentLoop", displayName: "Agent Loop" },
+  { id: "memory", displayName: "Memory" },
+  { id: "workspace", displayName: "Workspace" },
+  { id: "ui", displayName: "UI" },
+  { id: "notifications", displayName: "Notifications" },
+  { id: "skills", displayName: "Skills" },
+] as const;
+
+export type CallSiteDomainId = (typeof CALL_SITE_DOMAINS)[number]["id"];
+
+export interface CallSiteDomainEntry {
+  id: CallSiteDomainId;
+  displayName: string;
+}
+
+export interface CallSiteEntry {
+  id: LLMCallSite;
+  displayName: string;
+  description: string;
+  domain: CallSiteDomainId;
+}
+
+/**
+ * Keyed by every member of LLMCallSite. TypeScript enforces exhaustiveness:
+ * adding or removing a value from LLMCallSiteEnum without updating this object
+ * is a compile error — no runtime drift guard needed.
+ */
+type CatalogRecord = {
+  [K in LLMCallSite]: {
+    id: K;
+    displayName: string;
+    description: string;
+    domain: CallSiteDomainId;
+  };
+};
+
+const CATALOG_RECORD: CatalogRecord = {
+  // agentLoop
+  mainAgent: {
+    id: "mainAgent",
+    displayName: "Main Agent",
+    description: "The primary conversation agent that handles user messages.",
+    domain: "agentLoop",
+  },
+  subagentSpawn: {
+    id: "subagentSpawn",
+    displayName: "Subagent Spawn",
+    description: "Spawns a subagent to handle a delegated subtask.",
+    domain: "agentLoop",
+  },
+  heartbeatAgent: {
+    id: "heartbeatAgent",
+    displayName: "Heartbeat Agent",
+    description: "Runs background tasks and proactive checks on a schedule.",
+    domain: "agentLoop",
+  },
+  filingAgent: {
+    id: "filingAgent",
+    displayName: "Filing Agent",
+    description:
+      "Files memories and updates the knowledge base after conversations.",
+    domain: "agentLoop",
+  },
+  compactionAgent: {
+    id: "compactionAgent",
+    displayName: "Compaction Agent",
+    description: "Compacts conversation history to stay within context limits.",
+    domain: "agentLoop",
+  },
+  analyzeConversation: {
+    id: "analyzeConversation",
+    displayName: "Analyze Conversation",
+    description: "Analyzes conversation content for summaries and insights.",
+    domain: "agentLoop",
+  },
+  callAgent: {
+    id: "callAgent",
+    displayName: "Call Agent",
+    description: "Handles voice call conversations.",
+    domain: "agentLoop",
+  },
+
+  // memory
+  memoryExtraction: {
+    id: "memoryExtraction",
+    displayName: "Memory Extraction",
+    description: "Extracts memorable facts from conversation turns.",
+    domain: "memory",
+  },
+  memoryConsolidation: {
+    id: "memoryConsolidation",
+    displayName: "Memory Consolidation",
+    description: "Merges and deduplicates related memories.",
+    domain: "memory",
+  },
+  memoryRetrieval: {
+    id: "memoryRetrieval",
+    displayName: "Memory Retrieval",
+    description: "Retrieves relevant memories to augment the agent context.",
+    domain: "memory",
+  },
+  memoryV2Migration: {
+    id: "memoryV2Migration",
+    displayName: "Memory V2 Migration",
+    description: "One-time migration of memories to the V2 storage format.",
+    domain: "memory",
+  },
+  memoryV2Sweep: {
+    id: "memoryV2Sweep",
+    displayName: "Memory V2 Sweep",
+    description: "Background sweep pass for V2 memory maintenance.",
+    domain: "memory",
+  },
+  recall: {
+    id: "recall",
+    displayName: "Recall",
+    description: "Searches memory to answer a specific question during a turn.",
+    domain: "memory",
+  },
+  narrativeRefinement: {
+    id: "narrativeRefinement",
+    displayName: "Narrative Refinement",
+    description: "Refines the autobiographical narrative stored in memory.",
+    domain: "memory",
+  },
+  patternScan: {
+    id: "patternScan",
+    displayName: "Pattern Scan",
+    description: "Scans memories for recurring behavioral patterns.",
+    domain: "memory",
+  },
+
+  // workspace
+  conversationSummarization: {
+    id: "conversationSummarization",
+    displayName: "Conversation Summarization",
+    description: "Generates a summary of a completed conversation.",
+    domain: "workspace",
+  },
+  commitMessage: {
+    id: "commitMessage",
+    displayName: "Commit Message",
+    description: "Generates a git commit message for staged changes.",
+    domain: "workspace",
+  },
+
+  // ui
+  conversationStarters: {
+    id: "conversationStarters",
+    displayName: "Conversation Starters",
+    description:
+      "Generates suggested conversation openers for the home screen.",
+    domain: "ui",
+  },
+  conversationTitle: {
+    id: "conversationTitle",
+    displayName: "Conversation Title",
+    description: "Generates a title for a conversation from its content.",
+    domain: "ui",
+  },
+  identityIntro: {
+    id: "identityIntro",
+    displayName: "Identity Intro",
+    description: "Generates the assistant's introductory identity text.",
+    domain: "ui",
+  },
+  emptyStateGreeting: {
+    id: "emptyStateGreeting",
+    displayName: "Empty State Greeting",
+    description: "Generates a greeting shown on the empty conversation screen.",
+    domain: "ui",
+  },
+  guardianQuestionCopy: {
+    id: "guardianQuestionCopy",
+    displayName: "Guardian Question Copy",
+    description: "Generates copy for guardian onboarding questions.",
+    domain: "ui",
+  },
+  approvalCopy: {
+    id: "approvalCopy",
+    displayName: "Approval Copy",
+    description: "Generates copy for tool approval prompts shown to the user.",
+    domain: "ui",
+  },
+  approvalConversation: {
+    id: "approvalConversation",
+    displayName: "Approval Conversation",
+    description: "Handles conversational approval flows.",
+    domain: "ui",
+  },
+  feedEventCopy: {
+    id: "feedEventCopy",
+    displayName: "Feed Event Copy",
+    description: "Generates copy for home feed event cards.",
+    domain: "ui",
+  },
+  trustRuleSuggestion: {
+    id: "trustRuleSuggestion",
+    displayName: "Trust Rule Suggestion",
+    description:
+      "Suggests a trust rule pattern when the user creates a new rule.",
+    domain: "ui",
+  },
+
+  // notifications
+  notificationDecision: {
+    id: "notificationDecision",
+    displayName: "Notification Decision",
+    description:
+      "Decides whether a background event warrants sending a notification.",
+    domain: "notifications",
+  },
+  preferenceExtraction: {
+    id: "preferenceExtraction",
+    displayName: "Preference Extraction",
+    description:
+      "Extracts notification and communication preferences from messages.",
+    domain: "notifications",
+  },
+
+  // skills
+  interactionClassifier: {
+    id: "interactionClassifier",
+    displayName: "Interaction Classifier",
+    description: "Classifies the type of interaction to route it correctly.",
+    domain: "skills",
+  },
+  styleAnalyzer: {
+    id: "styleAnalyzer",
+    displayName: "Style Analyzer",
+    description: "Analyzes the user's communication style for personalization.",
+    domain: "skills",
+  },
+  inviteInstructionGenerator: {
+    id: "inviteInstructionGenerator",
+    displayName: "Invite Instruction Generator",
+    description: "Generates setup instructions for new skill invites.",
+    domain: "skills",
+  },
+  skillCategoryInference: {
+    id: "skillCategoryInference",
+    displayName: "Skill Category Inference",
+    description: "Infers the category of a skill from its description.",
+    domain: "skills",
+  },
+  meetConsentMonitor: {
+    id: "meetConsentMonitor",
+    displayName: "Meet Consent Monitor",
+    description: "Monitors meeting consent signals during live calls.",
+    domain: "skills",
+  },
+  meetChatOpportunity: {
+    id: "meetChatOpportunity",
+    displayName: "Meet Chat Opportunity",
+    description: "Identifies opportunities to engage in meeting chat.",
+    domain: "skills",
+  },
+  inference: {
+    id: "inference",
+    displayName: "Inference",
+    description: "General-purpose LLM inference call site for skill use.",
+    domain: "skills",
+  },
+};
+
+// Source of truth for call-site display metadata. API responses and usage
+// display paths should reuse this catalog instead of defining separate labels.
+export const CALL_SITE_CATALOG: CallSiteEntry[] = Object.values(CATALOG_RECORD);

package/src/config/schemas/calls.ts

@@ -5,7 +5,7 @@ export const VALID_CALLER_IDENTITY_MODES = [
   "assistant_number",
   "user_number",
 ] as const;
-export const CallsDisclosureConfigSchema = z
+const CallsDisclosureConfigSchema = z
   .object({
     enabled: z
       .boolean({ error: "calls.disclosure.enabled must be a boolean" })
@@ -26,7 +26,7 @@ export const CallsDisclosureConfigSchema = z
     "Controls whether and how the assistant discloses its nature at the start of a phone call",
   );
 
-export const CallsSafetyConfigSchema = z
+const CallsSafetyConfigSchema = z
   .object({
     denyCategories: z
       .array(
@@ -41,7 +41,7 @@ export const CallsSafetyConfigSchema = z
   })
   .describe("Safety guardrails for phone calls");
 
-export const CallsVoiceConfigSchema = z
+const CallsVoiceConfigSchema = z
   .object({
     language: z
       .string({ error: "calls.voice.language must be a string" })
@@ -65,7 +65,7 @@ export const CallsVoiceConfigSchema = z
   })
   .describe("Voice and speech settings for phone calls");
 
-export const CallerIdentityConfigSchema = z
+const CallerIdentityConfigSchema = z
   .object({
     allowPerCallOverride: z
       .boolean({
@@ -82,7 +82,7 @@ export const CallerIdentityConfigSchema = z
   })
   .describe("Controls which phone number is shown as the caller ID");
 
-export const CallsVerificationConfigSchema = z
+const CallsVerificationConfigSchema = z
   .object({
     enabled: z
       .boolean({ error: "calls.verification.enabled must be a boolean" })

package/src/config/schemas/filing.ts

@@ -14,6 +14,18 @@ export const FilingConfigSchema = z
       .positive("filing.intervalMs must be a positive integer")
       .default(4 * 3_600_000)
       .describe("Time between filing runs in milliseconds"),
+    compactionEnabled: z
+      .boolean({ error: "filing.compactionEnabled must be a boolean" })
+      .default(true)
+      .describe(
+        "Whether the daily PKB compaction job is enabled — audits file sizes, splits oversized files, consolidates duplicates, and prunes stale threads",
+      ),
+    compactionIntervalMs: z
+      .number({ error: "filing.compactionIntervalMs must be a number" })
+      .int("filing.compactionIntervalMs must be an integer")
+      .positive("filing.compactionIntervalMs must be a positive integer")
+      .default(24 * 3_600_000)
+      .describe("Time between compaction runs in milliseconds"),
     activeHoursStart: z
       .number({ error: "filing.activeHoursStart must be a number" })
       .int("filing.activeHoursStart must be an integer")

package/src/config/schemas/host-browser.ts

@@ -12,7 +12,7 @@ import { z } from "zod";
  * skips the probe for subsequent calls until the cooldown expires. This bounds
  * the per-call latency penalty to `probeTimeoutMs` once per cooldown window.
  */
-export const DesktopAutoCdpInspectConfigSchema = z
+const DesktopAutoCdpInspectConfigSchema = z
   .object({
     enabled: z
       .boolean({
@@ -49,7 +49,7 @@ export type DesktopAutoCdpInspectConfig = z.infer<
  * (e.g. `chrome://inspect`-style remote debugging) as an alternative to the
  * extension or local Playwright backend.
  */
-export const HostBrowserCdpInspectConfigSchema = z
+const HostBrowserCdpInspectConfigSchema = z
   .object({
     enabled: z
       .boolean({ error: "hostBrowser.cdpInspect.enabled must be a boolean" })

package/src/config/schemas/inference.ts

@@ -6,8 +6,6 @@ const VALID_LATEST_TURN_COMPRESSION_POLICIES = [
   "drop",
 ] as const;
 
-export { VALID_LATEST_TURN_COMPRESSION_POLICIES };
-
 export const ThinkingConfigSchema = z
   .object({
     enabled: z
@@ -100,7 +98,7 @@ export const ContextWindowConfigSchema = z
       .positive("contextWindow.maxInputTokens must be a positive integer")
       .default(200000)
       .describe(
-        "Conservative cap on input tokens allowed in the context window. Acts as an override that further constrains the model's catalog `contextWindow`; the effective budget is `min(catalog.contextWindow, maxInputTokens)`. Leave at the default to use the model's full native window.",
+        "Conservative cap on input tokens allowed in the context window. Acts as an override that further constrains the model's catalog `contextWindow`; the effective budget is `min(catalog.contextWindow, maxInputTokens)`. Increase this value to opt into larger model-native windows where supported.",
       ),
     targetBudgetRatio: z
       .number({ error: "contextWindow.targetBudgetRatio must be a number" })

package/src/config/schemas/ingress.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-export const IngressWebhookConfigSchema = z
+const IngressWebhookConfigSchema = z
   .object({
     secret: z
       .string({ error: "ingress.webhook.secret must be a string" })
@@ -39,7 +39,7 @@ export const IngressWebhookConfigSchema = z
   })
   .describe("Webhook configuration for ingress event delivery");
 
-export const IngressRateLimitConfigSchema = z
+const IngressRateLimitConfigSchema = z
   .object({
     maxRequestsPerMinute: z
       .number({

package/src/config/schemas/llm.ts

@@ -13,7 +13,7 @@ import { z } from "zod";
 // Provider enum
 // ---------------------------------------------------------------------------
 
-export const LLMProvider = z.enum([
+const LLMProvider = z.enum([
   "anthropic",
   "openai",
   "gemini",
@@ -21,7 +21,7 @@ export const LLMProvider = z.enum([
   "fireworks",
   "openrouter",
 ]);
-export type LLMProvider = z.infer<typeof LLMProvider>;
+type LLMProvider = z.infer<typeof LLMProvider>;
 
 // ---------------------------------------------------------------------------
 // Call-site enum
@@ -39,11 +39,15 @@ export const LLMCallSiteEnum = z.enum([
   "subagentSpawn",
   "heartbeatAgent",
   "filingAgent",
+  "compactionAgent",
   "analyzeConversation",
   "callAgent",
   "memoryExtraction",
   "memoryConsolidation",
   "memoryRetrieval",
+  "memoryV2Migration",
+  "memoryV2Sweep",
+  "recall",
   "narrativeRefinement",
   "patternScan",
   "conversationSummarization",
@@ -65,19 +69,41 @@ export const LLMCallSiteEnum = z.enum([
   "meetChatOpportunity",
   "inference",
   "feedEventCopy",
+  "trustRuleSuggestion",
 ]);
 export type LLMCallSite = z.infer<typeof LLMCallSiteEnum>;
 
 // ---------------------------------------------------------------------------
-// Effort & Speed
+// Effort, Speed & Verbosity
 // ---------------------------------------------------------------------------
 
-export const EffortEnum = z.enum(["low", "medium", "high", "xhigh", "max"]);
+/**
+ * Reasoning/thinking effort tier. `"none"` is a Vellum-specific value meaning
+ * "the user has opted out of provider-side reasoning". Each provider
+ * translates it however actually disables reasoning on that wire format:
+ * OpenAI Responses sends `reasoning.effort: "none"` and Chat Completions
+ * sends `reasoning_effort: "none"` explicitly, because omitting the field
+ * causes OpenAI to default to `"medium"`; Anthropic omits
+ * `output_config.effort` entirely, which is the documented opt-out there.
+ * When adding a new provider, pick whichever encoding actually disables
+ * reasoning on that wire format — do not assume omission is universally safe.
+ * All other values map to provider-specific tiers via each provider's own
+ * mapping table.
+ */
+const EffortEnum = z.enum(["none", "low", "medium", "high", "xhigh", "max"]);
 export type Effort = z.infer<typeof EffortEnum>;
 
 export const SpeedEnum = z.enum(["standard", "fast"]);
 export type Speed = z.infer<typeof SpeedEnum>;
 
+/**
+ * Response verbosity. Currently consumed by OpenAI's Responses API as
+ * `text.verbosity` (low|medium|high). Providers that don't support this knob
+ * are stripped in `retry.ts` normalization.
+ */
+const VerbosityEnum = z.enum(["low", "medium", "high"]);
+export type Verbosity = z.infer<typeof VerbosityEnum>;
+
 // ---------------------------------------------------------------------------
 // Leaf primitives (shared between LLMConfigBase and LLMConfigFragment)
 //
@@ -120,7 +146,7 @@ const TemperatureSchema = z.number().min(0).max(2).nullable();
 const ThinkingEnabledSchema = z.boolean();
 const ThinkingStreamThinkingSchema = z.boolean();
 
-export const ThinkingSchema = z.object({
+const ThinkingSchema = z.object({
   enabled: ThinkingEnabledSchema.default(true),
   streamThinking: ThinkingStreamThinkingSchema.default(true),
 });
@@ -167,14 +193,18 @@ const ContextOverflowRecoveryFragmentSchema = z.object({
 
 // Leaf primitives for context-window fields.
 const ContextEnabledSchema = z.boolean();
+export const DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS = 200000;
+
 const ContextMaxInputTokensSchema = z.number().int().positive();
 const ContextTargetBudgetRatioSchema = z.number().finite().gt(0).lte(1);
 const ContextCompactThresholdSchema = z.number().finite().gt(0).lte(1);
 const ContextSummaryBudgetRatioSchema = z.number().finite().gt(0).lte(1);
 
-export const ContextWindowSchema = z.object({
+const ContextWindowSchema = z.object({
   enabled: ContextEnabledSchema.default(true),
-  maxInputTokens: ContextMaxInputTokensSchema.default(200000),
+  maxInputTokens: ContextMaxInputTokensSchema.default(
+    DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS,
+  ),
   targetBudgetRatio: ContextTargetBudgetRatioSchema.default(0.3),
   compactThreshold: ContextCompactThresholdSchema.default(0.8),
   summaryBudgetRatio: ContextSummaryBudgetRatioSchema.default(0.05),
@@ -210,7 +240,7 @@ const ContextWindowDeepPartialSchema = z.object({
 
 const OpenRouterOnlyItemSchema = z.string().min(1);
 
-export const OpenRouterSchema = z.object({
+const OpenRouterSchema = z.object({
   only: z.array(OpenRouterOnlyItemSchema).default([]),
 });
 export type OpenRouter = z.infer<typeof OpenRouterSchema>;
@@ -219,11 +249,22 @@ const OpenRouterDeepPartialSchema = z.object({
   only: z.array(OpenRouterOnlyItemSchema).optional(),
 });
 
+// ---------------------------------------------------------------------------
+// Profile metadata
+// ---------------------------------------------------------------------------
+
+/**
+ * Distinguishes daemon-managed profiles (overwritten on every startup) from
+ * user-created ones (never touched by the daemon).
+ */
+export const ProfileSource = z.enum(["managed", "user"]);
+export type ProfileSource = z.infer<typeof ProfileSource>;
+
 // ---------------------------------------------------------------------------
 // Pricing overrides
 // ---------------------------------------------------------------------------
 
-export const PricingOverrideSchema = z.object({
+const PricingOverrideSchema = z.object({
   provider: z.string(),
   modelPattern: z.string(),
   inputPer1M: z.number().nonnegative(),
@@ -243,10 +284,11 @@ export type PricingOverride = z.infer<typeof PricingOverrideSchema>;
  */
 export const LLMConfigBase = z.object({
   provider: LLMProvider.default("anthropic"),
-  model: ModelSchema.default("claude-sonnet-4-6"),
+  model: ModelSchema.default("claude-opus-4-7"),
   maxTokens: MaxTokensSchema.default(64000),
   effort: EffortEnum.default("max"),
   speed: SpeedEnum.default("standard"),
+  verbosity: VerbosityEnum.default("medium"),
   temperature: TemperatureSchema.default(null),
   thinking: ThinkingSchema.default(ThinkingSchema.parse({})),
   contextWindow: ContextWindowSchema.default(ContextWindowSchema.parse({})),
@@ -266,6 +308,7 @@ export const LLMConfigFragment = z.object({
   maxTokens: MaxTokensSchema.optional(),
   effort: EffortEnum.optional(),
   speed: SpeedEnum.optional(),
+  verbosity: VerbosityEnum.optional(),
   temperature: TemperatureSchema.optional(),
   thinking: ThinkingFragmentSchema.optional(),
   contextWindow: ContextWindowDeepPartialSchema.optional(),
@@ -273,12 +316,25 @@ export const LLMConfigFragment = z.object({
 });
 export type LLMConfigFragment = z.infer<typeof LLMConfigFragment>;
 
+/**
+ * A named profile entry: an `LLMConfigFragment` augmented with
+ * presentation/ownership metadata. These fields are intentionally kept off
+ * `LLMConfigFragment` so they don't leak into `LLMCallSiteConfig` or the
+ * resolver's deep-merge output.
+ */
+export const ProfileEntry = LLMConfigFragment.extend({
+  source: ProfileSource.optional(),
+  label: z.string().min(1).optional(),
+  description: z.string().optional(),
+});
+export type ProfileEntry = z.infer<typeof ProfileEntry>;
+
 /**
  * Per-call-site config: a fragment plus an optional `profile` reference.
  * The resolver merges in the named profile (if any) before applying
  * call-site-level overrides.
  */
-export const LLMCallSiteConfig = LLMConfigFragment.extend({
+const LLMCallSiteConfig = LLMConfigFragment.extend({
   profile: z.string().min(1).optional(),
 });
 export type LLMCallSiteConfig = z.infer<typeof LLMCallSiteConfig>;
@@ -290,7 +346,10 @@ export type LLMCallSiteConfig = z.infer<typeof LLMCallSiteConfig>;
 export const LLMSchema = z
   .object({
     default: LLMConfigBase.default(LLMConfigBase.parse({})),
-    profiles: z.record(z.string().min(1), LLMConfigFragment).default({}),
+    profiles: z.record(z.string().min(1), ProfileEntry).default({}),
+    // Presentation-only order for named profiles. The resolver ignores this;
+    // clients use it to render profile pickers consistently.
+    profileOrder: z.array(z.string().min(1)).default([]),
     // `partialRecord` (vs `record`) makes call-site keys optional while still
     // rejecting keys that aren't members of `LLMCallSiteEnum` — exactly the
     // behavior we want (typo detection without requiring callers to declare
@@ -298,6 +357,7 @@ export const LLMSchema = z
     // are seeded into the user's on-disk config by migration 040, not at
     // schema level, so `LLMSchema.parse({})` yields an empty map.
     callSites: z.partialRecord(LLMCallSiteEnum, LLMCallSiteConfig).default({}),
+    activeProfile: z.string().min(1).optional(),
     pricingOverrides: z.array(PricingOverrideSchema).default([]),
   })
   .superRefine((config, ctx) => {
@@ -312,6 +372,16 @@ export const LLMSchema = z
         });
       }
     }
+    if (
+      config.activeProfile != null &&
+      !profileNames.has(config.activeProfile)
+    ) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["activeProfile"],
+        message: `Profile "${config.activeProfile}" referenced by llm.activeProfile is not defined in llm.profiles`,
+      });
+    }
   });
 
 export type LLMConfig = z.infer<typeof LLMSchema>;

package/src/config/schemas/memory-retrieval.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-export const MemoryDynamicBudgetConfigSchema = z
+const MemoryDynamicBudgetConfigSchema = z
   .object({
     enabled: z
       .boolean({
@@ -271,7 +271,7 @@ const MemoryPerTurnInjectionSchema = z
   })
   .describe("Memory injection limits for mid-conversation turns");
 
-export const MemoryInjectionConfigSchema = z
+const MemoryInjectionConfigSchema = z
   .object({
     contextLoad: MemoryContextLoadInjectionSchema.default(
       MemoryContextLoadInjectionSchema.parse({}),

package/src/config/schemas/memory-storage.ts

@@ -38,7 +38,7 @@ export const MemoryEmbeddingsConfigSchema = z
       .describe("Model name for the OpenAI embedding provider"),
     geminiModel: z
       .string({ error: "memory.embeddings.geminiModel must be a string" })
-      .default("gemini-embedding-2-preview")
+      .default("gemini-embedding-2")
       .describe("Model name for the Gemini embedding provider"),
     geminiTaskType: z
       .enum(