@vellumai/assistant 0.8.0 → 0.8.2

package/src/config/schemas/llm-request-logs.ts

@@ -0,0 +1,81 @@
+/**
+ * Configuration for LLM request log read source.
+ *
+ * Writes always land in the local SQLite `llm_request_logs` table; reads
+ * can be switched between local and ClickHouse via `readSource`.
+ *
+ * When `readSource === "clickhouse"` the URL and password are resolved
+ * from the credential store (`clickhouse:url`, `clickhouse:password`).
+ * The connection options below describe everything else (database/table/user).
+ *
+ * The shape is a discriminated union on `readSource` so the `clickhouse`
+ * block only exists on the ClickHouse branch — there's no stray defaults
+ * sitting around when the source is local.
+ *
+ * Note: the existing retention setting lives under
+ * `memory.cleanup.llmRequestLogRetentionMs` and is independent of this block.
+ * That covers when local rows get pruned; this block governs where reads
+ * are served from.
+ */
+import { z } from "zod";
+
+export const LlmRequestLogsClickHouseConfigSchema = z
+  .object({
+    database: z
+      .string({ error: "llmRequestLogs.clickhouse.database must be a string" })
+      .min(1, "llmRequestLogs.clickhouse.database cannot be empty")
+      .default("default")
+      .describe("ClickHouse database containing the llm_request_logs table"),
+    table: z
+      .string({ error: "llmRequestLogs.clickhouse.table must be a string" })
+      .min(1, "llmRequestLogs.clickhouse.table cannot be empty")
+      .default("llm_request_logs")
+      .describe("ClickHouse table name to read from"),
+    user: z
+      .string({ error: "llmRequestLogs.clickhouse.user must be a string" })
+      .min(1, "llmRequestLogs.clickhouse.user cannot be empty")
+      .default("default")
+      .describe("ClickHouse user (password is read from credential store)"),
+  })
+  .describe(
+    "ClickHouse connection settings used when `readSource` is `clickhouse`",
+  );
+
+const LocalLlmRequestLogsConfigSchema = z
+  .object({
+    readSource: z.literal("local"),
+  })
+  .describe("Read LLM request logs from local SQLite (default).");
+
+const ClickHouseLlmRequestLogsConfigSchema = z
+  .object({
+    readSource: z.literal("clickhouse"),
+    clickhouse: LlmRequestLogsClickHouseConfigSchema.default(
+      LlmRequestLogsClickHouseConfigSchema.parse({}),
+    ),
+  })
+  .describe(
+    "Read LLM request logs from the ClickHouse mirror. Requires the `clickhouse:url` and `clickhouse:password` credentials to be set.",
+  );
+
+// The default is baked into the export so the schema matches the sibling
+// pattern across `assistant/src/config/schemas/*` — `Schema.parse(undefined)`
+// returns documented defaults. The discriminated union has no inherent
+// default (no shared discriminator value), so we explicitly select the
+// `local` branch.
+//
+// Note: `LlmRequestLogsConfigSchema.parse({})` still throws — a discriminated
+// union cannot pick a branch without a discriminator. Use `parse(undefined)`
+// or omit the field entirely to get the default.
+export const LlmRequestLogsConfigSchema = z
+  .discriminatedUnion("readSource", [
+    LocalLlmRequestLogsConfigSchema,
+    ClickHouseLlmRequestLogsConfigSchema,
+  ])
+  .default({ readSource: "local" })
+  .describe("LLM request log read source configuration");
+
+export type LlmRequestLogsConfig = z.infer<typeof LlmRequestLogsConfigSchema>;
+export type LlmRequestLogsClickHouseConfig = z.infer<
+  typeof LlmRequestLogsClickHouseConfigSchema
+>;

package/src/config/schemas/llm.ts

@@ -20,6 +20,9 @@ const LLMProvider = z.enum([
   "ollama",
   "fireworks",
   "openrouter",
+  "zai",
+  "deepseek",
+  "minimax",
 ]);
 type LLMProvider = z.infer<typeof LLMProvider>;
 
@@ -47,11 +50,15 @@ export const LLMCallSiteEnum = z.enum([
   "memoryRetrieval",
   "memoryV2Migration",
   "memoryV2Sweep",
+  "memoryRouter",
+  "memoryV2Consolidation",
+  "memoryRetrospective",
   "recall",
   "narrativeRefinement",
   "patternScan",
   "conversationSummarization",
   "conversationStarters",
+  "replySuggestion",
   "conversationTitle",
   "commitMessage",
   "identityIntro",
@@ -68,7 +75,6 @@ export const LLMCallSiteEnum = z.enum([
   "meetConsentMonitor",
   "meetChatOpportunity",
   "inference",
-  "feedEventCopy",
   "trustRuleSuggestion",
   "proactiveArtifactDecision",
   "proactiveArtifactBuild",
@@ -281,6 +287,16 @@ const PricingOverrideSchema = z.object({
  */
 export const LLMConfigBase = z.object({
   provider: LLMProvider.default("anthropic"),
+  /**
+   * Name of a `provider_connections` row to use for this resolved config.
+   * Optional and additive: when set, the dispatcher resolves auth from the
+   * connection (mix-and-match managed/your-own per profile). When unset,
+   * the dispatcher falls back to the legacy `provider` lookup.
+   *
+   * Lives on the merged base type so it flows through `resolveCallSiteConfig`
+   * naturally — the underlying profile-level field is on `ProfileEntry`.
+   */
+  provider_connection: z.string().min(1).optional(),
   model: ModelSchema.default("claude-opus-4-7"),
   maxTokens: MaxTokensSchema.default(64000),
   effort: EffortEnum.default("max"),
@@ -313,6 +329,9 @@ const LLMConfigFragment = z.object({
 });
 type LLMConfigFragment = z.infer<typeof LLMConfigFragment>;
 
+export const ProfileStatusSchema = z.enum(["active", "disabled"]);
+export type ProfileStatus = z.infer<typeof ProfileStatusSchema>;
+
 /**
  * A named profile entry: an `LLMConfigFragment` augmented with
  * presentation/ownership metadata. These fields are intentionally kept off
@@ -321,8 +340,33 @@ type LLMConfigFragment = z.infer<typeof LLMConfigFragment>;
  */
 export const ProfileEntry = LLMConfigFragment.extend({
   source: ProfileSource.optional(),
-  label: z.string().min(1).optional(),
+  /**
+   * `.nullable()` is intentional: the PUT `/v1/config/llm/profiles/:name`
+   * route uses `null` as the "clear this override" sentinel for managed
+   * profiles (see `patchManagedProfileFields` in
+   * `runtime/routes/conversation-query-routes.ts`). Without `.nullable()`,
+   * Zod rejects `{ label: null }` at parse time before the route handler
+   * ever sees it, and the clear-back-to-seed path is unreachable from any
+   * client. `.min(1)` still applies to string values so empty strings
+   * remain rejected — `null` is the only non-string-non-undefined input
+   * accepted.
+   */
+  label: z.string().min(1).nullable().optional(),
   description: z.string().optional(),
+  /**
+   * Name of a `provider_connections` row to use for this profile.
+   * The dispatcher resolves auth from this connection; the legacy `provider`
+   * and `source` fields remain as read-only deprecated fallbacks for profiles
+   * not yet backfilled by the boot-time migration.
+   */
+  provider_connection: z.string().min(1).optional(),
+  /**
+   * Absent means active. `.nullable()` matches `label` so the PUT route's
+   * "send `null` to clear" sentinel works for status edits too — see
+   * `patchManagedProfileFields`, which has handled `status === null` since
+   * #30362 even though the schema didn't accept it until now.
+   */
+  status: ProfileStatusSchema.nullable().optional(),
 });
 export type ProfileEntry = z.infer<typeof ProfileEntry>;
 
@@ -355,6 +399,15 @@ export const LLMSchema = z
     // schema level, so `LLMSchema.parse({})` yields an empty map.
     callSites: z.partialRecord(LLMCallSiteEnum, LLMCallSiteConfig).default({}),
     activeProfile: z.string().min(1).optional(),
+    // TTL bounds for inference profile sessions. `defaultTtlSeconds` is read by
+    // the CLI to apply when `--ttl` is omitted; the daemon handler itself only
+    // reads `maxTtlSeconds` (to clamp caller-supplied values).
+    profileSession: z
+      .object({
+        defaultTtlSeconds: z.number().int().min(1).default(1800),
+        maxTtlSeconds: z.number().int().min(1).default(43200),
+      })
+      .default({ defaultTtlSeconds: 1800, maxTtlSeconds: 43200 }),
     pricingOverrides: z.array(PricingOverrideSchema).default([]),
   })
   .superRefine((config, ctx) => {

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

@@ -284,6 +284,21 @@ const MemoryInjectionConfigSchema = z
     "Controls how many memory items are injected at conversation start and per turn",
   );
 
+const ScratchpadInjectionConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({
+        error: "memory.retrieval.scratchpadInjection.enabled must be a boolean",
+      })
+      .default(true)
+      .describe(
+        "Whether NOW.md scratchpad content is injected into the conversation prompt. Injection occurs on the first turn and post-compaction; flipping this off takes effect on the next conversation or compaction.",
+      ),
+  })
+  .describe(
+    "Controls whether the user-maintained NOW.md scratchpad is injected into prompts",
+  );
+
 export const MemoryRetrievalConfigSchema = z
   .object({
     maxInjectTokens: z
@@ -312,6 +327,9 @@ export const MemoryRetrievalConfigSchema = z
     injection: MemoryInjectionConfigSchema.default(
       MemoryInjectionConfigSchema.parse({}),
     ),
+    scratchpadInjection: ScratchpadInjectionConfigSchema.default(
+      ScratchpadInjectionConfigSchema.parse({}),
+    ),
   })
   .describe(
     "Controls how memories are retrieved and injected into conversations",

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

@@ -0,0 +1,48 @@
+import { z } from "zod";
+
+export const MemoryRetrospectiveConfigSchema = z
+  .object({
+    timeThresholdMs: z
+      .number({
+        error: "memory.retrospective.timeThresholdMs must be a number",
+      })
+      .int("memory.retrospective.timeThresholdMs must be an integer")
+      .positive(
+        "memory.retrospective.timeThresholdMs must be a positive integer",
+      )
+      .default(30 * 60 * 1000)
+      .describe(
+        "Milliseconds since the last retrospective attempt before the interval trigger fires.",
+      ),
+
+    messageThreshold: z
+      .number({
+        error: "memory.retrospective.messageThreshold must be a number",
+      })
+      .int("memory.retrospective.messageThreshold must be an integer")
+      .positive(
+        "memory.retrospective.messageThreshold must be a positive integer",
+      )
+      .default(10)
+      .describe(
+        "New messages since the last successful retrospective run before the message-count trigger fires.",
+      ),
+
+    minCooldownMs: z
+      .number({ error: "memory.retrospective.minCooldownMs must be a number" })
+      .int("memory.retrospective.minCooldownMs must be an integer")
+      .nonnegative(
+        "memory.retrospective.minCooldownMs must be a non-negative integer",
+      )
+      .default(5 * 60 * 1000)
+      .describe(
+        "Minimum milliseconds between attempts (success or failure). Prevents tight retry loops across trigger types. Pre-compaction bypasses this gate.",
+      ),
+  })
+  .describe(
+    "Controls the memory-retrospective background pass triggered by the `memory-retrospective` feature flag. Model selection lives under llm.callSites.memoryRetrospective.",
+  );
+
+export type MemoryRetrospectiveConfig = z.infer<
+  typeof MemoryRetrospectiveConfigSchema
+>;

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

@@ -256,9 +256,40 @@ export const MemoryV2ConfigSchema = z
       .describe(
         "Cross-encoder rerank configuration. When enabled, picks the top-K candidates by pre-rerank A_o, runs the cross-encoder once per channel (user, assistant) on that unified set, and adds an alpha-weighted normalized boost to A_o for each scored slug.",
       ),
+    router: z
+      .object({
+        enabled: z
+          .boolean()
+          .default(false)
+          .describe(
+            "Whether to use the LLM router as the per-turn page-selection mechanism in place of spreading activation. Disabled by default — opt in once the router orchestration and dispatcher land.",
+          ),
+        max_page_ids: z
+          .number()
+          .int()
+          .min(1)
+          .max(100)
+          .default(25)
+          .describe(
+            "Upper bound on the number of concept-page ids the router may return per turn. Caps both prompt size and downstream injection budget.",
+          ),
+        router_prompt_path: z
+          .string({
+            error: "memory.v2.router.router_prompt_path must be a string",
+          })
+          .nullable()
+          .default(null)
+          .describe(
+            "Optional path to a file whose contents replace the bundled router prompt. Absolute paths are used as-is, a leading `~/` is expanded to the home directory, otherwise the path is resolved under the workspace root. The loaded contents may include `{{ASSISTANT_NAME}}`, `{{USER_NAME}}`, and `{{PAGE_INDEX}}`, which are substituted at runtime. If the file is missing, unreadable, or empty, the bundled prompt is used and a warning is logged.",
+          ),
+      })
+      .default({ enabled: false, max_page_ids: 25, router_prompt_path: null })
+      .describe(
+        "LLM router configuration. When enabled, a single Sonnet router call replaces spreading activation for per-turn page selection.",
+      ),
   })
   .describe(
-    "Memory v2 — concept-page activation model with hourly LLM-driven consolidation",
+    "Memory v2 — concept-page activation model with periodic LLM-driven consolidation",
   )
   .superRefine((config, ctx) => {
     const activationSum =

package/src/config/schemas/memory.ts

@@ -10,6 +10,7 @@ import {
   MemorySummarizationConfigSchema,
 } from "./memory-processing.js";
 import { MemoryRetrievalConfigSchema } from "./memory-retrieval.js";
+import { MemoryRetrospectiveConfigSchema } from "./memory-retrospective.js";
 import {
   MemoryEmbeddingsConfigSchema,
   MemorySegmentationConfigSchema,
@@ -47,6 +48,9 @@ export const MemoryConfigSchema = z
       MemorySummarizationConfigSchema.parse({}),
     ),
     v2: MemoryV2ConfigSchema.default(MemoryV2ConfigSchema.parse({})),
+    retrospective: MemoryRetrospectiveConfigSchema.default(
+      MemoryRetrospectiveConfigSchema.parse({}),
+    ),
   })
   .describe(
     "Long-term memory system — stores, retrieves, and manages persistent knowledge across conversations",

package/src/config/schemas/services.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 
+import { SEARCH_PROVIDER_IDS } from "../../providers/search-provider-catalog.js";
 import { SttServiceSchema } from "./stt.js";
 import { TtsServiceSchema } from "./tts.js";
 
@@ -17,25 +18,27 @@ export const VALID_INFERENCE_PROVIDERS = [
 
 const VALID_IMAGE_GEN_PROVIDERS = ["gemini", "openai"] as const;
 
-const VALID_WEB_SEARCH_PROVIDERS = [
-  "perplexity",
-  "brave",
-  "inference-provider-native",
-] as const;
+/**
+ * Derived from `SEARCH_PROVIDER_CATALOG`. Adding a new web-search provider
+ * to the catalog automatically extends the config-schema enum — no edit
+ * here required.
+ */
+const VALID_WEB_SEARCH_PROVIDERS = SEARCH_PROVIDER_IDS;
 
 const BaseServiceSchema = z.object({
   mode: ServiceModeSchema.default("your-own"),
 });
 
 /**
- * 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`.
+ * Inference service entry. Carries no fields — routing is now governed
+ * entirely by `provider_connections` rows and the `provider_connection`
+ * reference on each `llm.profile`. The namespace is kept so callers
+ * that walk `config.services.inference` do not need updating.
+ *
+ * Legacy `provider`, `model`, and `mode` fields are stripped by workspace
+ * migrations `039-drop-legacy-llm-keys` and `076-drop-services-inference-mode`.
  */
-const InferenceServiceSchema = BaseServiceSchema;
+const InferenceServiceSchema = z.object({});
 
 const ImageGenerationServiceSchema = BaseServiceSchema.extend({
   provider: z.enum(VALID_IMAGE_GEN_PROVIDERS).default("gemini"),

package/src/config/schemas/tools.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+
+export const ToolsConfigSchema = z
+  .object({
+    exclude: z
+      .array(z.string(), { error: "tools.exclude must be an array of strings" })
+      .default([])
+      .describe(
+        "Tool names to suppress. Excluded tools are not sent to the LLM. Names match `ToolDefinition.name` exactly (e.g. `bash`, `mcp__server__tool`).",
+      ),
+  })
+  .describe("Tool visibility configuration");
+
+export type ToolsConfig = z.infer<typeof ToolsConfigSchema>;