@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/__tests__/shell-observability.test.ts

@@ -45,27 +45,6 @@ mock.module("../util/logger.js", () => ({
   }),
 }));
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    // 1s timeout so the timeout-path test doesn't take forever.
-    timeouts: { shellDefaultTimeoutSec: 120, shellMaxTimeoutSec: 600 },
-    sandbox: {
-      enabled: false,
-      backend: "native",
-      docker: {
-        image: "vellum-sandbox:latest",
-        shell: "bash",
-        cpus: 1,
-        memoryMb: 512,
-        pidsLimit: 256,
-        network: "none",
-      },
-    },
-  }),
-  loadConfig: () => ({}),
-}));
-
 mock.module("../tools/network/script-proxy/index.js", () => ({
   getOrStartSession: mock(() =>
     Promise.resolve({ session: { id: "mock-session" } }),

package/src/__tests__/shell-tool-proxy-mode.test.ts

@@ -24,40 +24,6 @@ mock.module("node:child_process", () => ({
   spawn: spawnSpy,
 }));
 
-const mockConfig = {
-  provider: "anthropic",
-  model: "test",
-  maxTokens: 4096,
-  dataDir: "/tmp",
-  timeouts: {
-    shellDefaultTimeoutSec: 120,
-    shellMaxTimeoutSec: 600,
-    permissionTimeoutSec: 300,
-  },
-  rateLimit: { maxRequestsPerMinute: 0 },
-  secretDetection: {
-    enabled: true,
-  },
-  auditLog: { retentionDays: 0 },
-};
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => mockConfig,
-  loadConfig: () => mockConfig,
-  invalidateConfigCache: () => {},
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-}));
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 mock.module("../security/secret-scanner.js", () => ({
   redactSecrets: (s: string) => s,
 }));

package/src/__tests__/skill-load-feature-flag.test.ts

@@ -10,8 +10,6 @@ import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
 
-let currentConfig: Record<string, unknown> = {};
-
 const DECLARED_SKILL_ID = "a2a-channel";
 const DECLARED_FLAG_KEY = "a2a-channel";
 
@@ -30,30 +28,6 @@ mock.module("../util/logger.js", () => ({
   pruneOldLogFiles: () => 0,
 }));
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => currentConfig,
-  getConfigReadOnly: () => currentConfig,
-  loadConfig: () => currentConfig,
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-  deepMergeOverwrite: (a: unknown) => a,
-  mergeDefaultWorkspaceConfig: () => {},
-  API_KEY_PROVIDERS: [
-    "anthropic",
-    "openai",
-    "gemini",
-    "ollama",
-    "fireworks",
-    "openrouter",
-    "brave",
-    "perplexity",
-    "tavily",
-  ],
-}));
-
 const { skillLoadTool } = await import("../tools/skills/load.js");
 
 function writeSkill(
@@ -86,7 +60,6 @@ async function executeSkillLoad(
 describe("skill_load feature flag enforcement", () => {
   beforeEach(() => {
     mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
-    currentConfig = {};
     setOverridesForTesting({});
   });
 

package/src/__tests__/skill-load-inline-command.test.ts

@@ -72,29 +72,6 @@ mock.module("../skills/catalog-install.js", () => ({
   resolveCatalog: (_skillId?: string) => Promise.resolve([]),
 }));
 
-interface TestConfig {
-  permissions: { autoApproveUpTo?: "none" | "low" | "medium" | "high" };
-  skills: { load: { extraDirs: string[] } };
-  sandbox: { enabled: boolean };
-  [key: string]: unknown;
-}
-
-const testConfig: TestConfig = {
-  permissions: {},
-  skills: { load: { extraDirs: [] } },
-  sandbox: { enabled: true },
-};
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => testConfig,
-  loadConfig: () => testConfig,
-  invalidateConfigCache: () => {},
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-}));
-
 // ── Imports (after mocks) ─────────────────────────────────────────────────
 
 const { skillLoadTool } = await import("../tools/skills/load.js");
@@ -155,8 +132,6 @@ describe("skill_load inline command expansion", () => {
         _options?: unknown,
       ) => mockRunInlineCommand(command, workingDir),
     }));
-
-    testConfig.skills = { load: { extraDirs: [] } };
   });
 
   // ── Basic expansion ──────────────────────────────────────────────────

package/src/__tests__/skill-load-inline-includes.test.ts

@@ -76,29 +76,6 @@ mock.module("../skills/catalog-install.js", () => ({
   resolveCatalog: (_skillId?: string) => Promise.resolve([]),
 }));
 
-interface TestConfig {
-  permissions: { autoApproveUpTo?: "none" | "low" | "medium" | "high" };
-  skills: { load: { extraDirs: string[] } };
-  sandbox: { enabled: boolean };
-  [key: string]: unknown;
-}
-
-const testConfig: TestConfig = {
-  permissions: {},
-  skills: { load: { extraDirs: [] } },
-  sandbox: { enabled: true },
-};
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => testConfig,
-  loadConfig: () => testConfig,
-  invalidateConfigCache: () => {},
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-}));
-
 // ── Imports (after mocks) ─────────────────────────────────────────────────
 
 const { skillLoadTool } = await import("../tools/skills/load.js");
@@ -167,8 +144,6 @@ describe("skill_load inline command expansion for included skills", () => {
         _options?: unknown,
       ) => mockRunInlineCommand(command, workingDir),
     }));
-
-    testConfig.skills = { load: { extraDirs: [] } };
   });
 
   // ── Single inline-command child ──────────────────────────────────────

package/src/__tests__/skill-load-plugin-scope.test.ts

@@ -25,30 +25,6 @@ mock.module("../util/logger.js", () => ({
   pruneOldLogFiles: () => 0,
 }));
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({}),
-  getConfigReadOnly: () => ({}),
-  loadConfig: () => ({}),
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-  deepMergeOverwrite: (a: unknown) => a,
-  mergeDefaultWorkspaceConfig: () => {},
-  API_KEY_PROVIDERS: [
-    "anthropic",
-    "openai",
-    "gemini",
-    "ollama",
-    "fireworks",
-    "openrouter",
-    "brave",
-    "perplexity",
-    "tavily",
-  ],
-}));
-
 // A real directory so the in-scope load's filesystem reads (reference listing,
 // version hash, tool manifest) succeed.
 const skillDir = mkdtempSync(join(tmpdir(), "skill-plugin-scope-"));

package/src/__tests__/skill-projection-feature-flag.test.ts

@@ -2,7 +2,9 @@
  * Tests that projectSkillTools drops flag-OFF active skills from projected
  * tools, even when conversation history contains old markers for those skills.
  */
-import * as realFs from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { SkillSummary, SkillToolManifest } from "../config/skills.js";
@@ -14,13 +16,13 @@ import type { Tool } from "../tools/types.js";
 // Mock state
 // ---------------------------------------------------------------------------
 
+let tmpRoot: string;
 let mockCatalog: SkillSummary[] = [];
 let mockManifests: Record<string, SkillToolManifest | null> = {};
 let mockRegisteredTools: Map<string, Tool[]> = new Map();
 let mockUnregisteredSkillIds: string[] = [];
 let mockSkillRefCount: Map<string, number> = new Map();
 
-let currentConfig: Record<string, unknown> = {};
 const DECLARED_SKILL_ID = "contacts";
 const DECLARED_FLAG_KEY = "contacts";
 
@@ -34,12 +36,6 @@ mock.module("../config/skills.js", () => ({
   filterSkillsByEnabledPlugins: (skills: unknown) => skills,
 }));
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => currentConfig,
-  loadConfig: () => currentConfig,
-  invalidateConfigCache: () => {},
-}));
-
 mock.module("../config/skill-state.js", () => ({
   skillFlagKey: (skill: { featureFlag?: string }) =>
     skill.featureFlag || undefined,
@@ -222,18 +218,6 @@ mock.module("../tools/registry.js", () => ({
   },
 }));
 
-mock.module("node:fs", () => ({
-  ...realFs,
-  existsSync: (p: string) => {
-    if (typeof p === "string" && p.endsWith("TOOLS.json")) {
-      const parts = p.split("/");
-      const skillId = parts[parts.length - 2];
-      return skillId in mockManifests;
-    }
-    return realFs.existsSync(p);
-  },
-}));
-
 mock.module("../skills/version-hash.js", () => ({
   computeSkillVersionHash: (skillDir: string) => {
     const parts = skillDir.split("/");
@@ -242,15 +226,6 @@ mock.module("../skills/version-hash.js", () => ({
   },
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () => ({
-    info: () => {},
-    warn: () => {},
-    debug: () => {},
-    error: () => {},
-  }),
-}));
-
 // Mock the skill_loaded telemetry dependencies of conversation-skill-tools so
 // their heavy transitive imports (catalog-install → CLI program, sqlite) stay
 // out of this import-light test.
@@ -279,13 +254,19 @@ const { setOverridesForTesting } =
 // ---------------------------------------------------------------------------
 
 function makeSkill(id: string, featureFlag?: string): SkillSummary {
+  // A real on-disk skill dir with a TOOLS.json so the production manifest
+  // existence check (`existsSync(<dir>/TOOLS.json)`) passes for real; the
+  // manifest's contents are supplied by the mocked `parseToolManifestFile`.
+  const directoryPath = join(tmpRoot, id);
+  mkdirSync(directoryPath, { recursive: true });
+  writeFileSync(join(directoryPath, "TOOLS.json"), "{}");
   return {
     id,
     name: id,
     displayName: id,
     description: `Skill ${id}`,
-    directoryPath: `/skills/${id}`,
-    skillFilePath: `/skills/${id}/SKILL.md`,
+    directoryPath,
+    skillFilePath: join(directoryPath, "SKILL.md"),
 
     source: "managed",
     featureFlag,
@@ -340,18 +321,19 @@ function buildHistoryWithMarker(skillId: string): Message[] {
 
 describe("projectSkillTools feature flag enforcement", () => {
   beforeEach(() => {
+    tmpRoot = mkdtempSync(join(tmpdir(), "skill-projection-flag-"));
     mockCatalog = [];
     mockManifests = {};
     mockRegisteredTools = new Map();
     mockUnregisteredSkillIds = [];
     mockSkillRefCount = new Map();
-    currentConfig = {};
     setOverridesForTesting({});
     resetSkillToolProjection();
   });
 
   afterEach(() => {
     setOverridesForTesting({});
+    rmSync(tmpRoot, { recursive: true, force: true });
   });
 
   test("no skill tools projected for flag OFF skill even with old markers", () => {
@@ -408,7 +390,6 @@ describe("projectSkillTools feature flag enforcement", () => {
     const prevActive = new Map<string, string>();
 
     // No overrides — skill has no featureFlag so it's never gated
-    currentConfig = {};
 
     const result = projectSkillTools(history, {
       previouslyActiveSkillIds: prevActive,

package/src/__tests__/skill-projection.benchmark.test.ts

@@ -9,7 +9,7 @@
  * - Cold projection (1000 msgs / 5 skills): < 100ms
  * - Incremental scan (10 new msgs):         < 20ms
  */
-import { describe, expect, mock, test } from "bun:test";
+import { beforeAll, describe, expect, mock, test } from "bun:test";
 
 import type { Message } from "../providers/types.js";
 
@@ -17,25 +17,8 @@ import type { Message } from "../providers/types.js";
 // Mocks — must be registered before importing the module under test
 // ---------------------------------------------------------------------------
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
-// Mock config loader and feature flags to avoid filesystem reads on CI.
+// Mock feature flags to avoid filesystem reads on CI.
 // The benchmark fixture treats every feature flag as enabled.
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({}),
-  loadConfig: () => ({}),
-  applyNestedDefaults: (c: unknown) => c,
-  invalidateConfigCache: () => {},
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-  API_KEY_PROVIDERS: [],
-}));
-
 mock.module("../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: () => true,
   loadDefaultsRegistry: () => ({}),
@@ -59,6 +42,8 @@ mock.module("../config/skills.js", () => ({
   resolveSkillSelector: () => ({ found: false }),
   loadSkillBySelector: () => ({ found: false }),
   readCachedSkillIcon: () => undefined,
+  // Pass-through: the benchmark doesn't exercise per-chat plugin scoping.
+  filterSkillsByEnabledPlugins: (skills: unknown) => skills,
 }));
 
 // Mock skill-state.js to break the transitive import chain — the benchmark
@@ -285,6 +270,16 @@ function timeMs(fn: () => void): number {
 // ---------------------------------------------------------------------------
 
 describe("Skill projection benchmark", () => {
+  beforeAll(() => {
+    // Prime the real config loader and JIT the projection path once so the
+    // first measured "cold" run reflects projection latency, not the one-time
+    // loader/module warmup cost that a trivial config mock used to hide.
+    const warmIds = ["warmup-skill"];
+    catalogSkillIds = warmIds;
+    projectSkillTools(buildHistory(20, warmIds));
+    catalogSkillIds = [];
+  });
+
   test("cold projection: 100 messages / 3 skills < 50ms", () => {
     const skillIds = ["skill-alpha", "skill-beta", "skill-gamma"];
     catalogSkillIds = skillIds;

package/src/__tests__/skill-script-runner-sandbox.test.ts

@@ -1,45 +1,7 @@
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterAll, beforeAll, describe, expect, mock, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Mocks — must be declared before the module under test is imported
-// ---------------------------------------------------------------------------
-
-const mockConfig = {
-  provider: "anthropic",
-  model: "test",
-  maxTokens: 4096,
-  dataDir: "/tmp",
-  timeouts: {
-    shellDefaultTimeoutSec: 120,
-    shellMaxTimeoutSec: 600,
-    permissionTimeoutSec: 300,
-  },
-  rateLimit: { maxRequestsPerMinute: 0 },
-  secretDetection: {
-    enabled: true,
-  },
-  auditLog: { retentionDays: 0 },
-};
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => mockConfig,
-  loadConfig: () => mockConfig,
-  invalidateConfigCache: () => {},
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-}));
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 
 import { runSkillToolScript } from "../tools/skills/skill-script-runner.js";
 import type { ToolContext } from "../tools/types.js";

package/src/__tests__/skills-file-content-endpoint.test.ts

@@ -95,13 +95,6 @@ mock.module("../config/skills.js", () => ({
   loadSkillCatalog: () => mockResolvedSkills.map((r) => r.summary),
 }));
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({}),
-  invalidateConfigCache: () => {},
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-}));
-
 mock.module("../config/skill-state.js", () => ({
   resolveSkillStates: () => mockResolvedSkills,
   skillFlagKey: () => null,

package/src/__tests__/skills-files-catalog-fallback.test.ts

@@ -85,20 +85,6 @@ function makeNoopProvider(name: string): SkillFileProvider {
 // Module mocks — must be declared before importing the module under test
 // ---------------------------------------------------------------------------
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({}),
-  invalidateConfigCache: () => {},
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-}));
-
 mock.module("../config/skills.js", () => ({
   loadSkillCatalog: () => [],
 }));

package/src/__tests__/slack-channel-config.test.ts

@@ -17,57 +17,6 @@ const originalVellumDev = process.env.VELLUM_DEV;
 
 process.env.VELLUM_DEV = "1";
 
-// In-memory config store for tests
-let configStore: Record<string, unknown> = {};
-
-function setNestedValue(
-  obj: Record<string, unknown>,
-  path: string,
-  value: unknown,
-): void {
-  const keys = path.split(".");
-  let current = obj;
-  for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i];
-    if (current[key] == null || typeof current[key] !== "object") {
-      current[key] = {};
-    }
-    current = current[key] as Record<string, unknown>;
-  }
-  current[keys[keys.length - 1]] = value;
-}
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    slack: {
-      deliverAuthBypass: false,
-      teamId:
-        ((configStore.slack as Record<string, unknown>)?.teamId as string) ??
-        "",
-      teamName:
-        ((configStore.slack as Record<string, unknown>)?.teamName as string) ??
-        "",
-      teamUrl:
-        ((configStore.slack as Record<string, unknown>)?.teamUrl as string) ??
-        "",
-      botUserId:
-        ((configStore.slack as Record<string, unknown>)?.botUserId as string) ??
-        "",
-      botUsername:
-        ((configStore.slack as Record<string, unknown>)
-          ?.botUsername as string) ?? "",
-    },
-  }),
-  loadConfig: () => ({}),
-  loadRawConfig: () => structuredClone(configStore),
-  saveRawConfig: (raw: Record<string, unknown>) => {
-    configStore = structuredClone(raw);
-  },
-  invalidateConfigCache: () => {},
-  setNestedValue,
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () => ({
     info: () => {},
@@ -147,6 +96,7 @@ mock.module("../oauth/manual-token-connection.js", () => ({
 // Mock fetch for Slack API validation
 const originalFetch = globalThis.fetch;
 
+import { loadRawConfig } from "../config/loader.js";
 import {
   clearSlackChannelConfig,
   clearSlackUserToken,
@@ -167,6 +117,7 @@ import {
   upsertCredentialMetadata,
 } from "../tools/credentials/metadata-store.js";
 import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
+import { setConfig } from "./helpers/set-config.js";
 
 afterAll(() => {
   globalThis.fetch = originalFetch;
@@ -183,7 +134,7 @@ afterAll(() => {
 describe("Slack channel config handler", () => {
   beforeEach(() => {
     oauthConnectionStore = {};
-    configStore = {};
+    setConfig("slack", {});
     globalThis.fetch = originalFetch;
     rmSync(secureStorePath, { force: true });
     rmSync(metadataPath, { force: true });
@@ -276,15 +227,13 @@ describe("Slack channel config handler", () => {
         "xapp-test",
       ),
     ]);
-    configStore = {
-      slack: {
-        teamId: "T123",
-        teamName: "TestTeam",
-        teamUrl: "https://example.slack.com/",
-        botUserId: "U_BOT",
-        botUsername: "testbot",
-      },
-    };
+    setConfig("slack", {
+      teamId: "T123",
+      teamName: "TestTeam",
+      teamUrl: "https://example.slack.com/",
+      botUserId: "U_BOT",
+      botUsername: "testbot",
+    });
 
     const result = await getSlackChannelConfig();
     expect(result.teamId).toBe("T123");
@@ -338,7 +287,7 @@ describe("Slack channel config handler", () => {
     expect(result.teamUrl).toBe("https://myteam.slack.com/");
 
     // Assert metadata was written to config (not credential metadata)
-    const slack = configStore.slack as Record<string, unknown>;
+    const slack = loadRawConfig().slack as Record<string, unknown>;
     expect(slack.teamId).toBe("T_TEAM");
     expect(slack.teamName).toBe("MyTeam");
     expect(slack.teamUrl).toBe("https://myteam.slack.com/");
@@ -378,14 +327,12 @@ describe("Slack channel config handler", () => {
     ]);
     upsertCredentialMetadata("slack_channel", "bot_token", {});
     upsertCredentialMetadata("slack_channel", "app_token", {});
-    configStore = {
-      slack: {
-        teamId: "T123",
-        teamName: "TestTeam",
-        botUserId: "U_BOT",
-        botUsername: "testbot",
-      },
-    };
+    setConfig("slack", {
+      teamId: "T123",
+      teamName: "TestTeam",
+      botUserId: "U_BOT",
+      botUsername: "testbot",
+    });
 
     const result = await clearSlackChannelConfig();
     expect(result.success).toBe(true);
@@ -402,7 +349,7 @@ describe("Slack channel config handler", () => {
     expect(listCredentialMetadata()).toHaveLength(0);
 
     // Assert config values were cleared
-    const slack = configStore.slack as Record<string, unknown>;
+    const slack = loadRawConfig().slack as Record<string, unknown>;
     expect(slack.teamId).toBe("");
     expect(slack.teamName).toBe("");
     expect(slack.teamUrl).toBe("");
@@ -748,14 +695,12 @@ describe("Slack channel config handler", () => {
   test("POST rejects user token from a different workspace than the bot token", async () => {
     // Pre-seed config with bot-token-derived team id (T_TEAM) to simulate that
     // a bot token has already been configured.
-    configStore = {
-      slack: {
-        teamId: "T_TEAM",
-        teamName: "TestTeam",
-        botUserId: "U_BOT",
-        botUsername: "testbot",
-      },
-    };
+    setConfig("slack", {
+      teamId: "T_TEAM",
+      teamName: "TestTeam",
+      botUserId: "U_BOT",
+      botUsername: "testbot",
+    });
 
     globalThis.fetch = (async () => {
       // User token's auth.test returns a different team_id.