@vellumai/assistant 0.6.3 → 0.6.5

package/src/config/schemas/llm.ts

@@ -0,0 +1,318 @@
+import { z } from "zod";
+
+/**
+ * Unified LLM configuration schema.
+ *
+ * Defines the shape of the top-level `llm` config block that consolidates
+ * provider/model/effort/speed/thinking/contextWindow/pricingOverrides for all
+ * call sites in the assistant. Wired into `AssistantConfigSchema` as the `llm`
+ * field and consumed by `resolveCallSiteConfig` in `llm-resolver.ts`.
+ */
+
+// ---------------------------------------------------------------------------
+// Provider enum
+// ---------------------------------------------------------------------------
+
+export const LLMProvider = z.enum([
+  "anthropic",
+  "openai",
+  "gemini",
+  "ollama",
+  "fireworks",
+  "openrouter",
+]);
+export type LLMProvider = z.infer<typeof LLMProvider>;
+
+// ---------------------------------------------------------------------------
+// Call-site enum
+// ---------------------------------------------------------------------------
+
+/**
+ * The complete set of LLM call-site identifiers the assistant emits.
+ *
+ * Each ID corresponds to a logical place in the codebase that produces an LLM
+ * request. Adding or removing a call site is a config-schema change — keep
+ * this list in sync with the resolver and registry (introduced in PR 2).
+ */
+export const LLMCallSiteEnum = z.enum([
+  "mainAgent",
+  "subagentSpawn",
+  "heartbeatAgent",
+  "filingAgent",
+  "analyzeConversation",
+  "callAgent",
+  "memoryExtraction",
+  "memoryConsolidation",
+  "memoryRetrieval",
+  "narrativeRefinement",
+  "patternScan",
+  "conversationSummarization",
+  "conversationStarters",
+  "conversationTitle",
+  "commitMessage",
+  "identityIntro",
+  "emptyStateGreeting",
+  "notificationDecision",
+  "preferenceExtraction",
+  "guardianQuestionCopy",
+  "approvalCopy",
+  "approvalConversation",
+  "watchCommentary",
+  "watchSummary",
+  "interactionClassifier",
+  "styleAnalyzer",
+  "inviteInstructionGenerator",
+  "skillCategoryInference",
+  "meetConsentMonitor",
+  "meetChatOpportunity",
+  "inference",
+]);
+export type LLMCallSite = z.infer<typeof LLMCallSiteEnum>;
+
+// ---------------------------------------------------------------------------
+// Effort & Speed
+// ---------------------------------------------------------------------------
+
+export const EffortEnum = z.enum(["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>;
+
+// ---------------------------------------------------------------------------
+// Leaf primitives (shared between LLMConfigBase and LLMConfigFragment)
+//
+// Each primitive is a Zod schema with no defaults attached. `LLMConfigBase`
+// composes them with `.default(...)` so `LLMConfigBase.parse({})` returns a
+// fully-defaulted object; `LLMConfigFragment` composes them with `.optional()`
+// so absent fields stay absent. Centralizing the validation rules here keeps
+// the two views consistent.
+// ---------------------------------------------------------------------------
+
+const ModelSchema = z.string().min(1);
+const MaxTokensSchema = z.number().int().positive();
+const TemperatureSchema = z.number().min(0).max(2).nullable();
+
+// ---------------------------------------------------------------------------
+// Thinking & ContextWindow
+//
+// These mirror the shapes already declared in `schemas/inference.ts` but are
+// redeclared here so the new `llm` namespace owns its own types. PRs 3 and
+// beyond will deprecate the legacy declarations once the resolver is the
+// single source of truth.
+//
+// Every leaf in the defaulted view carries a `.default(...)`, so
+// `Schema.parse({})` returns a fully-defaulted object. This is critical for
+// the loader's leaf-deletion recovery path: if any leaf in the user's config
+// is invalid, the loader strips that leaf and re-parses; without
+// schema-level defaults the parse would fail on missing required siblings,
+// and the loader would fall back to `cloneDefaultConfig()`, discarding the
+// user's other valid settings.
+//
+// Each defaulted schema has a sibling "fragment" schema with the same leaves
+// wrapped in `.optional()` instead of `.default(...)`. The fragment view is
+// used by `LLMConfigFragment` so partial overrides remain partial — Zod
+// would inject defaults for absent fields if we used `Schema.partial()`, and
+// the fragment contract is "any field may be absent and stays absent".
+// ---------------------------------------------------------------------------
+
+// Leaf primitives for thinking fields — defined once and reused by both the
+// defaulted (`ThinkingSchema`) and fragment (`ThinkingFragmentSchema`) views.
+const ThinkingEnabledSchema = z.boolean();
+const ThinkingStreamThinkingSchema = z.boolean();
+
+export const ThinkingSchema = z.object({
+  enabled: ThinkingEnabledSchema.default(true),
+  streamThinking: ThinkingStreamThinkingSchema.default(true),
+});
+export type Thinking = z.infer<typeof ThinkingSchema>;
+
+// Fragment view: every field optional, no defaults injected. Defining this
+// separately (rather than `ThinkingSchema.partial()`) avoids having Zod
+// inject defaults for absent fields when a partial override is parsed —
+// the fragment contract is "any field may be absent and stays absent".
+const ThinkingFragmentSchema = z.object({
+  enabled: ThinkingEnabledSchema.optional(),
+  streamThinking: ThinkingStreamThinkingSchema.optional(),
+});
+
+// Leaf primitives for context-overflow recovery.
+const OverflowEnabledSchema = z.boolean();
+const OverflowSafetyMarginRatioSchema = z.number().finite().gt(0).lt(1);
+const OverflowMaxAttemptsSchema = z.number().int().positive();
+const OverflowLatestTurnCompressionSchema = z.enum([
+  "truncate",
+  "summarize",
+  "drop",
+]);
+
+const ContextOverflowRecoverySchema = z.object({
+  enabled: OverflowEnabledSchema.default(true),
+  safetyMarginRatio: OverflowSafetyMarginRatioSchema.default(0.05),
+  maxAttempts: OverflowMaxAttemptsSchema.default(3),
+  interactiveLatestTurnCompression:
+    OverflowLatestTurnCompressionSchema.default("summarize"),
+  nonInteractiveLatestTurnCompression:
+    OverflowLatestTurnCompressionSchema.default("truncate"),
+});
+
+const ContextOverflowRecoveryFragmentSchema = z.object({
+  enabled: OverflowEnabledSchema.optional(),
+  safetyMarginRatio: OverflowSafetyMarginRatioSchema.optional(),
+  maxAttempts: OverflowMaxAttemptsSchema.optional(),
+  interactiveLatestTurnCompression:
+    OverflowLatestTurnCompressionSchema.optional(),
+  nonInteractiveLatestTurnCompression:
+    OverflowLatestTurnCompressionSchema.optional(),
+});
+
+// Leaf primitives for context-window fields.
+const ContextEnabledSchema = z.boolean();
+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({
+  enabled: ContextEnabledSchema.default(true),
+  maxInputTokens: ContextMaxInputTokensSchema.default(200000),
+  targetBudgetRatio: ContextTargetBudgetRatioSchema.default(0.3),
+  compactThreshold: ContextCompactThresholdSchema.default(0.8),
+  summaryBudgetRatio: ContextSummaryBudgetRatioSchema.default(0.05),
+  overflowRecovery: ContextOverflowRecoverySchema.default(
+    ContextOverflowRecoverySchema.parse({}),
+  ),
+});
+export type ContextWindow = z.infer<typeof ContextWindowSchema>;
+
+// Fragment view of `ContextWindowSchema` — all fields optional and no defaults
+// injected. Nested `overflowRecovery` likewise uses its fragment view, so a
+// partial override like `{ overflowRecovery: { maxAttempts: 5 } }` produces
+// exactly that and nothing else.
+const ContextWindowDeepPartialSchema = z.object({
+  enabled: ContextEnabledSchema.optional(),
+  maxInputTokens: ContextMaxInputTokensSchema.optional(),
+  targetBudgetRatio: ContextTargetBudgetRatioSchema.optional(),
+  compactThreshold: ContextCompactThresholdSchema.optional(),
+  summaryBudgetRatio: ContextSummaryBudgetRatioSchema.optional(),
+  overflowRecovery: ContextOverflowRecoveryFragmentSchema.optional(),
+});
+
+// ---------------------------------------------------------------------------
+// OpenRouter provider-routing preferences
+//
+// OpenRouter's `/v1/chat/completions` and `/v1/messages` endpoints both accept
+// a `provider: { only: [...] }` body field that restricts which upstream
+// providers (Anthropic, Google, etc.) may fulfill a request. Exposed here so
+// users can pin routing via config without touching the wire-format knobs
+// directly. Nested shape keeps room for sibling OpenRouter knobs (`order`,
+// `allow_fallbacks`, …) to be added later without another schema reshape.
+// ---------------------------------------------------------------------------
+
+const OpenRouterOnlyItemSchema = z.string().min(1);
+
+export const OpenRouterSchema = z.object({
+  only: z.array(OpenRouterOnlyItemSchema).default([]),
+});
+export type OpenRouter = z.infer<typeof OpenRouterSchema>;
+
+const OpenRouterDeepPartialSchema = z.object({
+  only: z.array(OpenRouterOnlyItemSchema).optional(),
+});
+
+// ---------------------------------------------------------------------------
+// Pricing overrides
+// ---------------------------------------------------------------------------
+
+export const PricingOverrideSchema = z.object({
+  provider: z.string(),
+  modelPattern: z.string(),
+  inputPer1M: z.number().nonnegative(),
+  outputPer1M: z.number().nonnegative(),
+});
+export type PricingOverride = z.infer<typeof PricingOverrideSchema>;
+
+// ---------------------------------------------------------------------------
+// Base config (all fields defaulted) and Fragment (all fields optional)
+// ---------------------------------------------------------------------------
+
+/**
+ * Fully specified LLM config. Used for `llm.default` — every knob has a
+ * schema-level default, so `LLMConfigBase.parse({})` returns a complete
+ * fallback object. This is essential for the loader's leaf-deletion recovery
+ * path; see the comment on `ThinkingSchema` above.
+ */
+export const LLMConfigBase = z.object({
+  provider: LLMProvider.default("anthropic"),
+  model: ModelSchema.default("claude-opus-4-7"),
+  maxTokens: MaxTokensSchema.default(64000),
+  effort: EffortEnum.default("max"),
+  speed: SpeedEnum.default("standard"),
+  temperature: TemperatureSchema.default(null),
+  thinking: ThinkingSchema.default(ThinkingSchema.parse({})),
+  contextWindow: ContextWindowSchema.default(ContextWindowSchema.parse({})),
+  openrouter: OpenRouterSchema.default(OpenRouterSchema.parse({})),
+});
+export type LLMConfigBase = z.infer<typeof LLMConfigBase>;
+
+/**
+ * Partial LLM config used for profiles and call-site overrides. Each top-level
+ * field is optional; nested `thinking` and `contextWindow` accept partial
+ * objects so callers can override individual leaves (e.g. `{ thinking:
+ * { enabled: false } }`).
+ */
+export const LLMConfigFragment = z.object({
+  provider: LLMProvider.optional(),
+  model: ModelSchema.optional(),
+  maxTokens: MaxTokensSchema.optional(),
+  effort: EffortEnum.optional(),
+  speed: SpeedEnum.optional(),
+  temperature: TemperatureSchema.optional(),
+  thinking: ThinkingFragmentSchema.optional(),
+  contextWindow: ContextWindowDeepPartialSchema.optional(),
+  openrouter: OpenRouterDeepPartialSchema.optional(),
+});
+export type LLMConfigFragment = z.infer<typeof LLMConfigFragment>;
+
+/**
+ * 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({
+  profile: z.string().min(1).optional(),
+});
+export type LLMCallSiteConfig = z.infer<typeof LLMCallSiteConfig>;
+
+// ---------------------------------------------------------------------------
+// Top-level LLM schema
+// ---------------------------------------------------------------------------
+
+export const LLMSchema = z
+  .object({
+    default: LLMConfigBase.default(LLMConfigBase.parse({})),
+    profiles: z.record(z.string().min(1), LLMConfigFragment).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
+    // every call site). Latency-optimized defaults for background call sites
+    // 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({}),
+    pricingOverrides: z.array(PricingOverrideSchema).default([]),
+  })
+  .superRefine((config, ctx) => {
+    const profileNames = new Set(Object.keys(config.profiles ?? {}));
+    for (const [siteId, siteConfig] of Object.entries(config.callSites ?? {})) {
+      if (siteConfig?.profile == null) continue;
+      if (!profileNames.has(siteConfig.profile)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["callSites", siteId, "profile"],
+          message: `Profile "${siteConfig.profile}" referenced by call site "${siteId}" is not defined in llm.profiles`,
+        });
+      }
+    }
+  });
+
+export type LLMConfig = z.infer<typeof LLMSchema>;

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

@@ -80,9 +80,21 @@ export const MemoryCleanupConfigSchema = z
       .nonnegative(
         "memory.cleanup.llmRequestLogRetentionMs must be non-negative",
       )
-      .default(1 * 24 * 60 * 60 * 1000)
+      // Upper bound must match gateway MAX_LLM_REQUEST_LOG_RETENTION_MS in
+      // gateway/src/http/routes/privacy-config.ts. If a manually edited
+      // config.json sets a value larger than this, the gateway GET would
+      // return it and the macOS picker would snap it to its largest known
+      // option, and the next PATCH would silently truncate the value —
+      // causing quiet data loss. Enforcing the same cap here prevents the
+      // daemon from accepting out-of-range values in the first place.
+      .max(
+        365 * 24 * 60 * 60 * 1000,
+        "memory.cleanup.llmRequestLogRetentionMs must be <= 365 days in ms",
+      )
+      .nullable()
+      .default(1 * 60 * 60 * 1000)
       .describe(
-        "Retention period for LLM request/response logs in milliseconds (0 disables pruning)",
+        "Retention period for LLM request/response logs in milliseconds (null keeps forever, 0 prunes immediately)",
       ),
   })
   .describe("Automatic memory cleanup and garbage collection settings");

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

@@ -43,17 +43,9 @@ export const MemorySummarizationConfigSchema = z
       .describe(
         "Whether to use an LLM for summarizing and consolidating memory items",
       ),
-    modelIntent: z
-      .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
-        error: "memory.summarization.modelIntent must be a valid model intent",
-      })
-      .default("quality-optimized")
-      .describe(
-        "Model selection strategy for summarization — trade off speed vs quality",
-      ),
   })
   .describe(
-    "Controls how memory items are summarized and consolidated over time",
+    "Controls how memory items are summarized and consolidated over time. Model selection lives under llm.callSites.conversationSummarization.",
   );
 
 export type MemoryExtractionConfig = z.infer<

package/src/config/schemas/notifications.ts

@@ -1,16 +1,9 @@
 import { z } from "zod";
 
 export const NotificationsConfigSchema = z
-  .object({
-    decisionModelIntent: z
-      .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
-        error: "notifications.decisionModelIntent must be a valid model intent",
-      })
-      .default("latency-optimized")
-      .describe(
-        "Model selection strategy for deciding whether to send a notification",
-      ),
-  })
-  .describe("Notification delivery configuration");
+  .object({})
+  .describe(
+    "Notification delivery configuration. Model selection lives under llm.callSites.notificationDecision and llm.callSites.preferenceExtraction.",
+  );
 
 export type NotificationsConfig = z.infer<typeof NotificationsConfigSchema>;

package/src/config/schemas/platform.ts

@@ -56,16 +56,10 @@ export const UiConfigSchema = z
       .describe(
         "IANA timezone identifier for displaying dates and times (e.g. 'America/New_York')",
       ),
-    greetingModelIntent: z
-      .enum(["latency-optimized", "quality-optimized"], {
-        error: "ui.greetingModelIntent must be 'latency-optimized' or 'quality-optimized'",
-      })
-      .default("latency-optimized")
-      .describe(
-        "Model intent for empty-state greeting generation (latency-optimized = fast/small model, quality-optimized = primary model)",
-      ),
   })
-  .describe("User interface display settings");
+  .describe(
+    "User interface display settings. Empty-state greeting model selection lives under llm.callSites.emptyStateGreeting.",
+  );
 
 export type DaemonConfig = z.infer<typeof DaemonConfigSchema>;
 export type UiConfig = z.infer<typeof UiConfigSchema>;

package/src/config/schemas/security.ts

@@ -87,6 +87,39 @@ export const PermissionsConfigSchema = z
       .describe(
         "Whether the assistant can execute commands on the host machine without prompting",
       ),
+    autoApproveUpTo: z
+      .union([
+        z.enum(["none", "low", "medium"], {
+          error:
+            "permissions.autoApproveUpTo must be one of: none, low, medium",
+        }),
+        z.object({
+          conversation: z
+            .enum(["none", "low", "medium"])
+            .default("low")
+            .describe(
+              "Threshold for interactive conversation sessions (default: low)",
+            ),
+          background: z
+            .enum(["none", "low", "medium"])
+            .default("medium")
+            .describe(
+              "Threshold for non-interactive guardian sessions (default: medium)",
+            ),
+          headless: z
+            .enum(["none", "low", "medium"])
+            .default("none")
+            .describe(
+              "Threshold for non-interactive non-guardian sessions (default: none)",
+            ),
+        }),
+      ])
+      .default({ conversation: "low", background: "medium", headless: "none" })
+      .describe(
+        "Auto-approve tools at or below this risk level without prompting. " +
+          "Accepts a scalar ('none', 'low', 'medium') applied to all contexts, " +
+          "or an object with per-context overrides: { conversation, background, headless }.",
+      ),
   })
   .describe("Permission enforcement mode for tool operations");
 

package/src/config/schemas/services.ts

@@ -1,5 +1,8 @@
 import { z } from "zod";
 
+import { SttServiceSchema } from "./stt.js";
+import { TtsServiceSchema } from "./tts.js";
+
 export const ServiceModeSchema = z.enum(["managed", "your-own"]);
 export type ServiceMode = z.infer<typeof ServiceModeSchema>;
 
@@ -25,10 +28,15 @@ export const BaseServiceSchema = z.object({
 });
 export type BaseService = z.infer<typeof BaseServiceSchema>;
 
-export const InferenceServiceSchema = BaseServiceSchema.extend({
-  provider: z.enum(VALID_INFERENCE_PROVIDERS).default("anthropic"),
-  model: z.string().default("claude-opus-4-6"),
-});
+/**
+ * Inference service entry. Carries only the routing `mode`
+ * (`managed` vs `your-own`) — the provider and model live under
+ * `llm.default.{provider, model}` (see `schemas/llm.ts`). PR 19 of the
+ * unify-llm-callsites plan removed the `provider` and `model` fields here;
+ * legacy configs that still carry them have those keys stripped by
+ * workspace migration `039-drop-legacy-llm-keys`.
+ */
+export const InferenceServiceSchema = BaseServiceSchema;
 export type InferenceService = z.infer<typeof InferenceServiceSchema>;
 
 export const ImageGenerationServiceSchema = BaseServiceSchema.extend({
@@ -66,6 +74,16 @@ export const GitHubOAuthServiceSchema = BaseServiceSchema.extend({
 });
 export type GitHubOAuthService = z.infer<typeof GitHubOAuthServiceSchema>;
 
+export const NotionOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+export type NotionOAuthService = z.infer<typeof NotionOAuthServiceSchema>;
+
+export const TwitterOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+export type TwitterOAuthService = z.infer<typeof TwitterOAuthServiceSchema>;
+
 export const ServicesSchema = z.object({
   inference: InferenceServiceSchema.default(InferenceServiceSchema.parse({})),
   "image-generation": ImageGenerationServiceSchema.default(
@@ -74,6 +92,12 @@ export const ServicesSchema = z.object({
   "web-search": WebSearchServiceSchema.default(
     WebSearchServiceSchema.parse({}),
   ),
+  stt: SttServiceSchema.default({
+    mode: "your-own" as const,
+    provider: "deepgram" as const,
+    providers: {},
+  }),
+  tts: TtsServiceSchema.default(TtsServiceSchema.parse({})),
   "google-oauth": GoogleOAuthServiceSchema.default(
     GoogleOAuthServiceSchema.parse({}),
   ),
@@ -86,5 +110,30 @@ export const ServicesSchema = z.object({
   "github-oauth": GitHubOAuthServiceSchema.default(
     GitHubOAuthServiceSchema.parse({}),
   ),
+  "notion-oauth": NotionOAuthServiceSchema.default(
+    NotionOAuthServiceSchema.parse({}),
+  ),
+  "twitter-oauth": TwitterOAuthServiceSchema.default(
+    TwitterOAuthServiceSchema.parse({}),
+  ),
 });
 export type Services = z.infer<typeof ServicesSchema>;
+
+/**
+ * Safely read the `mode` of a `services.*` entry.
+ *
+ * Most service entries (OAuth providers, inference, etc.) extend
+ * `BaseServiceSchema` and therefore carry a `mode: "managed" | "your-own"`
+ * field.
+ *
+ * Returns `undefined` when the requested service entry has no `mode` field,
+ * so callers can treat those entries as implicitly "your-own" without the
+ * compiler tripping on a union widened by non-BaseService members.
+ */
+export function getServiceMode(
+  services: Services,
+  key: keyof Services,
+): ServiceMode | undefined {
+  const entry = services[key] as { mode?: ServiceMode };
+  return entry.mode;
+}

package/src/config/schemas/stt.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+
+/**
+ * Valid STT provider identifiers. New providers append here and register
+ * an adapter.
+ */
+export const VALID_STT_PROVIDERS = [
+  "deepgram",
+  "google-gemini",
+  "openai-whisper",
+  "xai",
+] as const;
+
+/**
+ * Sparse provider config map under `services.stt.providers`.
+ *
+ * This is a forward-compatible record that accepts any provider ID as key
+ * with an object value. All provider entries — known (`openai-whisper`,
+ * `deepgram`, `google-gemini`) and unknown — are accepted with generic object
+ * validation. Adding a new provider ID does not require a migration to seed
+ * `services.stt.providers.<id>`.
+ *
+ * The map only holds entries the user has explicitly configured — it is
+ * NOT required to enumerate every known provider.
+ */
+export const SttProvidersSchema = z.record(
+  z.string(),
+  z.record(z.string(), z.unknown()).default({}),
+);
+export type SttProviders = z.infer<typeof SttProvidersSchema>;
+
+/**
+ * Canonical STT service configuration.
+ *
+ * `mode` is locked to `"your-own"` -- managed STT is not supported.
+ * Attempting to set `mode: "managed"` will fail schema validation.
+ */
+export const SttServiceSchema = z
+  .object({
+    mode: z
+      .literal("your-own", {
+        error:
+          'services.stt.mode must be "your-own" -- managed STT is not supported',
+      })
+      .default("your-own" as const)
+      .describe(
+        'STT service mode -- only "your-own" is supported (managed STT is not available)',
+      ),
+    provider: z
+      .enum(VALID_STT_PROVIDERS, {
+        error: `services.stt.provider must be one of: ${VALID_STT_PROVIDERS.join(", ")}`,
+      })
+      .describe("Active STT provider used for speech-to-text transcription"),
+    providers: SttProvidersSchema.default({}),
+  })
+  .describe(
+    "Speech-to-text service configuration -- provider selection and per-provider settings",
+  );
+
+export type SttService = z.infer<typeof SttServiceSchema>;