@vellumai/assistant 0.8.1 → 0.8.2

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

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test";
+
+import { LlmRequestLogsConfigSchema } from "../llm-request-logs.js";
+
+describe("LlmRequestLogsConfigSchema", () => {
+  test("parses undefined to the local default", () => {
+    expect(LlmRequestLogsConfigSchema.parse(undefined)).toEqual({
+      readSource: "local",
+    });
+  });
+
+  test("parses an explicit local readSource", () => {
+    expect(
+      LlmRequestLogsConfigSchema.parse({ readSource: "local" }),
+    ).toEqual({ readSource: "local" });
+  });
+
+  test("parses an explicit clickhouse readSource with defaulted connection fields", () => {
+    expect(
+      LlmRequestLogsConfigSchema.parse({ readSource: "clickhouse" }),
+    ).toEqual({
+      readSource: "clickhouse",
+      clickhouse: {
+        database: "default",
+        table: "llm_request_logs",
+        user: "default",
+      },
+    });
+  });
+
+  test("rejects an unknown readSource", () => {
+    expect(() =>
+      LlmRequestLogsConfigSchema.parse({ readSource: "postgres" }),
+    ).toThrow();
+  });
+});

package/src/config/schemas/channels.ts

@@ -10,6 +10,10 @@ export const TwilioConfigSchema = z
       .string({ error: "twilio.phoneNumber must be a string" })
       .default("")
       .describe("Twilio phone number used for outbound calls and SMS"),
+    setupStarted: z
+      .boolean({ error: "twilio.setupStarted must be a boolean" })
+      .default(false)
+      .describe("Whether Twilio setup has ever been started"),
   })
   .describe("Twilio account configuration");
 
@@ -111,6 +115,10 @@ export const SlackConfigSchema = z
       .string({ error: "slack.teamName must be a string" })
       .default("")
       .describe("Slack workspace team name"),
+    teamUrl: z
+      .string({ error: "slack.teamUrl must be a string" })
+      .default("")
+      .describe("Slack workspace URL"),
     botUserId: z
       .string({ error: "slack.botUserId must be a string" })
       .default("")

package/src/config/schemas/compaction.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+
+export const CompactionConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "compaction.enabled must be a boolean" })
+      .default(true)
+      .describe("Whether assistant-driven context compaction is enabled"),
+    autoThreshold: z
+      .number({ error: "compaction.autoThreshold must be a number" })
+      .finite("compaction.autoThreshold must be finite")
+      .gt(0, "compaction.autoThreshold must be greater than 0")
+      .lte(1, "compaction.autoThreshold must be less than or equal to 1")
+      .default(0.7)
+      .describe(
+        "Fraction of the context window at which automatic compaction fires",
+      ),
+    prompt: z
+      .string({ error: "compaction.prompt must be a string" })
+      .nullable()
+      .optional()
+      .describe(
+        "Custom compaction instruction. When set, replaces the generic default verbatim. The `{image_manifest}` placeholder is still interpolated.",
+      ),
+  })
+  .describe("Assistant-driven context compaction");
+
+export type CompactionConfig = z.infer<typeof CompactionConfigSchema>;

package/src/config/schemas/heartbeat.ts

@@ -47,6 +47,15 @@ export const HeartbeatConfigSchema = z
       .describe(
         "Hour of the day (0-23) when heartbeat checks stop, or null to disable active hours restriction",
       ),
+    maxConsecutiveRuns: z
+      .number({ error: "heartbeat.maxConsecutiveRuns must be a number" })
+      .int("heartbeat.maxConsecutiveRuns must be an integer")
+      .positive("heartbeat.maxConsecutiveRuns must be a positive integer")
+      .nullable()
+      .default(3)
+      .describe(
+        "Maximum heartbeats that can run consecutively without a guardian message. Counter resets when the guardian sends a message. Set to null for unlimited.",
+      ),
   })
   .describe("Periodic heartbeat configuration for health monitoring")
   .superRefine((config, ctx) => {

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

@@ -8,6 +8,10 @@
  * 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
@@ -37,18 +41,38 @@ export const LlmRequestLogsClickHouseConfigSchema = z
     "ClickHouse connection settings used when `readSource` is `clickhouse`",
   );
 
-export const LlmRequestLogsConfigSchema = z
+const LocalLlmRequestLogsConfigSchema = z
+  .object({
+    readSource: z.literal("local"),
+  })
+  .describe("Read LLM request logs from local SQLite (default).");
+
+const ClickHouseLlmRequestLogsConfigSchema = z
   .object({
-    readSource: z
-      .enum(["local", "clickhouse"])
-      .default("local")
-      .describe(
-        "Where to read LLM request logs from for Inspector queries. `local` reads the SQLite source-of-truth (default, lowest latency). `clickhouse` reads the mirror, which retains data longer than local but only sees writes that the mirror job has flushed.",
-      ),
+    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>;

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>;
 

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/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>;

package/src/config/skills.ts

@@ -203,10 +203,6 @@ export function getBundledSkillsDir(): string {
   return join(dir, "bundled-skills");
 }
 
-function getSkillsIndexPath(skillsDir: string): string {
-  return join(skillsDir, "SKILLS.md");
-}
-
 // ─── Frontmatter parsing ─────────────────────────────────────────────────────
 
 interface ParsedFrontmatter {
@@ -618,94 +614,6 @@ function loadBundledSkills(): SkillSummary[] {
   return skills;
 }
 
-// ─── Index parsing ───────────────────────────────────────────────────────────
-
-function parseIndexEntry(line: string): string | null {
-  const bulletMatch = line.trim().match(/^[-*]\s+(.+)$/);
-  if (!bulletMatch) return null;
-
-  let entry = bulletMatch[1].trim();
-  const markdownLinkMatch = entry.match(/^\[[^\]]+\]\(([^)]+)\)$/);
-  if (markdownLinkMatch) {
-    entry = markdownLinkMatch[1].trim();
-  }
-
-  if (entry.startsWith("`") && entry.endsWith("`")) {
-    entry = entry.slice(1, -1).trim();
-  }
-
-  return entry.length > 0 ? entry : null;
-}
-
-function resolveIndexEntryToDirectory(
-  skillsDir: string,
-  entry: string,
-): string | null {
-  if (isAbsolute(entry)) {
-    log.warn(
-      { entry },
-      "Skipping SKILLS.md entry because absolute paths are not allowed",
-    );
-    return null;
-  }
-
-  const resolvedEntryPath = resolve(skillsDir, entry);
-  const resolvedDirectory =
-    basename(resolvedEntryPath).toLowerCase() === "skill.md"
-      ? dirname(resolvedEntryPath)
-      : resolvedEntryPath;
-
-  const relativePath = getRelativeToSkillsRoot(skillsDir, resolvedDirectory);
-  if (relativePath.length === 0) {
-    log.warn(
-      { entry },
-      "Skipping SKILLS.md entry that resolves to the skills root",
-    );
-    return null;
-  }
-  if (isOutsideSkillsRoot(skillsDir, resolvedDirectory)) {
-    log.warn(
-      { entry, resolvedDirectory: getCanonicalPath(resolvedDirectory) },
-      "Skipping SKILLS.md entry that resolves outside ~/.vellum/workspace/skills",
-    );
-    return null;
-  }
-
-  return resolvedDirectory;
-}
-
-function getIndexedSkillDirectories(skillsDir: string): string[] | null {
-  const indexPath = getSkillsIndexPath(skillsDir);
-  if (!existsSync(indexPath)) return null;
-
-  let rawIndex = "";
-  try {
-    rawIndex = readFileSync(indexPath, "utf-8");
-  } catch (err) {
-    log.warn(
-      { err, indexPath },
-      "Failed to read SKILLS.md; treating as empty catalog",
-    );
-    return [];
-  }
-
-  const directories: string[] = [];
-  const seen = new Set<string>();
-
-  for (const line of rawIndex.split(/\r?\n/)) {
-    const parsedEntry = parseIndexEntry(line);
-    if (!parsedEntry) continue;
-
-    const directory = resolveIndexEntryToDirectory(skillsDir, parsedEntry);
-    if (!directory || seen.has(directory)) continue;
-
-    seen.add(directory);
-    directories.push(directory);
-  }
-
-  return directories;
-}
-
 function discoverSkillDirectories(skillsDir: string): string[] {
   if (!existsSync(skillsDir)) return [];
 
@@ -713,7 +621,7 @@ function discoverSkillDirectories(skillsDir: string): string[] {
   try {
     const entries = readdirSync(skillsDir, { withFileTypes: true });
     for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
+      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
       const directoryPath = join(skillsDir, entry.name);
       if (existsSync(join(directoryPath, "SKILL.md"))) {
         dirs.push(directoryPath);
@@ -867,8 +775,7 @@ export function loadSkillCatalog(
 
   // Load managed (user) skills, which take precedence over bundled skills with the same ID
   const skillsDir = getSkillsDir();
-  const indexedDirectories = getIndexedSkillDirectories(skillsDir);
-  const directories = indexedDirectories ?? discoverSkillDirectories(skillsDir);
+  const directories = discoverSkillDirectories(skillsDir);
 
   for (const directory of directories) {
     const skill = readSkillFromDirectory(directory, skillsDir, "managed");
@@ -1164,7 +1071,7 @@ export function resolveSkillSelector(
   const catalog = loadSkillCatalog(workspaceSkillsDir);
   if (catalog.length === 0) {
     return {
-      error: `No skills are available. Configure ${getWorkspaceDirDisplay()}/skills/SKILLS.md or add skill directories.`,
+      error: `No skills are available. Add skill directories under ${getWorkspaceDirDisplay()}/skills/.`,
       errorCode: "empty_catalog",
     };
   }