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

package/src/__tests__/managed-skill-lifecycle.test.ts

@@ -2,59 +2,15 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { setConfig } from "./helpers/set-config.js";
+
 let TEST_DIR = "";
 const seedUpsertSlugs: string[] = [];
 
-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 },
-  services: {
-    inference: {
-      mode: "your-own",
-      provider: "anthropic",
-      model: "claude-opus-4-6",
-    },
-    "image-generation": {
-      mode: "your-own",
-      provider: "gemini",
-      model: "gemini-3.1-flash-image-preview",
-    },
-    "web-search": { mode: "your-own", provider: "inference-provider-native" },
-  },
-  skills: {
-    entries: {},
-    allowBundled: [],
-  },
-};
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => mockConfig,
-  loadConfig: () => mockConfig,
-  invalidateConfigCache: () => {},
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-}));
+// Keep bundled skills out of the catalog so the lifecycle assertions only
+// see the managed skills these tests create (default `allowBundled: null`
+// would load every bundled skill).
+setConfig("skills", { allowBundled: [] });
 
 mock.module("../skills/catalog-cache.js", () => ({
   getCatalog: async () => [],

package/src/__tests__/managed-speech-defaults.test.ts

@@ -0,0 +1,138 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import * as actualTtsCapability from "../calls/telephony-tts-capability.js";
+import * as actualManagedSpeech from "../platform/managed-speech.js";
+import * as actualResolve from "../providers/speech-to-text/resolve.js";
+
+let mockManagedSpeechAvailable = false;
+let mockSttKeyResolves = false;
+let mockTtsSecretResolves = false;
+
+mock.module("../platform/managed-speech.js", () => ({
+  ...actualManagedSpeech,
+  managedSpeechAvailable: async () => mockManagedSpeechAvailable,
+}));
+
+mock.module("../providers/speech-to-text/resolve.js", () => ({
+  ...actualResolve,
+  sttProviderKeyResolves: async () => mockSttKeyResolves,
+}));
+
+mock.module("../calls/telephony-tts-capability.js", () => ({
+  ...actualTtsCapability,
+  ttsSecretResolves: async () => mockTtsSecretResolves,
+}));
+
+import { getConfig, invalidateConfigCache } from "../config/loader.js";
+import { maybeDefaultSpeechToManaged } from "../config/managed-speech-defaults.js";
+
+const WORKSPACE_DIR = process.env.VELLUM_WORKSPACE_DIR!;
+const CONFIG_PATH = join(WORKSPACE_DIR, "config.json");
+
+function ensureTestDir(): void {
+  if (!existsSync(WORKSPACE_DIR)) {
+    mkdirSync(WORKSPACE_DIR, { recursive: true });
+  }
+}
+
+function writeConfig(obj: unknown): void {
+  writeFileSync(CONFIG_PATH, JSON.stringify(obj));
+  invalidateConfigCache();
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+}
+
+beforeEach(() => {
+  ensureTestDir();
+  writeConfig({});
+  mockManagedSpeechAvailable = false;
+  mockSttKeyResolves = false;
+  mockTtsSecretResolves = false;
+});
+
+describe("maybeDefaultSpeechToManaged", () => {
+  test("no-ops when managed speech is unavailable", async () => {
+    await maybeDefaultSpeechToManaged();
+
+    const config = readConfig();
+    expect(config.services).toBeUndefined();
+  });
+
+  test("defaults both services to managed when no BYOK credentials resolve", async () => {
+    mockManagedSpeechAvailable = true;
+
+    await maybeDefaultSpeechToManaged();
+
+    const config = readConfig();
+    expect((config.services as any)?.stt?.mode).toBe("managed");
+    expect((config.services as any)?.tts?.mode).toBe("managed");
+    // Sparse configs must stay schema-valid: SttServiceSchema requires
+    // `provider` whenever the stt object exists.
+    expect((config.services as any)?.stt?.provider).toBeDefined();
+    expect(getConfig().services.stt.mode).toBe("managed");
+  });
+
+  test("leaves a service alone when its BYOK credential resolves", async () => {
+    mockManagedSpeechAvailable = true;
+    mockSttKeyResolves = true;
+
+    await maybeDefaultSpeechToManaged();
+
+    const config = readConfig();
+    expect((config.services as any)?.stt?.mode).toBeUndefined();
+    expect((config.services as any)?.tts?.mode).toBe("managed");
+  });
+
+  test("no-ops when both BYOK credentials resolve", async () => {
+    mockManagedSpeechAvailable = true;
+    mockSttKeyResolves = true;
+    mockTtsSecretResolves = true;
+
+    await maybeDefaultSpeechToManaged();
+
+    const config = readConfig();
+    expect(config.services).toBeUndefined();
+  });
+
+  test("no-ops when services are already managed", async () => {
+    mockManagedSpeechAvailable = true;
+    writeConfig({
+      services: {
+        stt: { mode: "managed", provider: "deepgram" },
+        tts: { mode: "managed" },
+      },
+    });
+
+    await maybeDefaultSpeechToManaged();
+
+    const config = readConfig();
+    expect(config).toEqual({
+      services: {
+        stt: { mode: "managed", provider: "deepgram" },
+        tts: { mode: "managed" },
+      },
+    });
+  });
+
+  test("never downgrades an explicit your-own mode with resolving credentials", async () => {
+    mockManagedSpeechAvailable = true;
+    mockSttKeyResolves = true;
+    mockTtsSecretResolves = true;
+    writeConfig({
+      services: {
+        stt: { mode: "your-own", provider: "deepgram" },
+        tts: { mode: "your-own", provider: "elevenlabs" },
+      },
+    });
+
+    await maybeDefaultSpeechToManaged();
+
+    const config = readConfig();
+    expect((config.services as any).stt.mode).toBe("your-own");
+    expect((config.services as any).tts.mode).toBe("your-own");
+  });
+});

package/src/__tests__/managed-store.test.ts

@@ -8,27 +8,12 @@ import {
   writeFileSync,
 } from "node:fs";
 import { join } from "node:path";
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  spyOn,
-  test,
-} from "bun:test";
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
 
 import { parse as parseYaml } from "yaml";
 
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 import { loadSkillCatalog } from "../config/skills.js";
 import {
   buildSkillMarkdown,

package/src/__tests__/mcp-auth-routes.test.ts

@@ -24,32 +24,19 @@ mock.module("../mcp/mcp-auth-state.js", () => ({
   getMcpAuthState: mockGetMcpAuthState,
 }));
 
-const mockConfig = {
-  mcp: {
-    servers: {
-      "my-server": {
-        transport: { type: "sse", url: "https://mcp.example.com" },
-        enabled: true,
-        defaultRiskLevel: "high",
-      },
+import { setConfig } from "./helpers/set-config.js";
+
+// Seed the MCP server the routes look up via `loadRawConfig()` into the
+// workspace config for real.
+setConfig("mcp", {
+  servers: {
+    "my-server": {
+      transport: { type: "sse", url: "https://mcp.example.com" },
+      enabled: true,
+      defaultRiskLevel: "high",
     },
   },
-};
-mock.module("../config/loader.js", () => ({
-  loadRawConfig: () => mockConfig,
-  saveRawConfig: () => {},
-  // route-policy → config/env transitively imports `getConfig`; stub it
-  // here so the mock surface matches what consumers expect.
-  getConfig: () => mockConfig,
-  getConfigReadOnly: () => mockConfig,
-}));
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
+});
 
 // ── Import SUT after mocks ─────────────────────────────────────────────────────
 
@@ -59,7 +46,9 @@ const { ROUTES } = await import("../runtime/routes/mcp-auth-routes.js");
 
 function findRoute(operationId: string) {
   const route = ROUTES.find((r) => r.operationId === operationId);
-  if (!route) throw new Error(`Route ${operationId} not found`);
+  if (!route) {
+    throw new Error(`Route ${operationId} not found`);
+  }
   return route;
 }
 
@@ -70,7 +59,7 @@ describe("mcp-auth-routes", () => {
     mockOrchestrateConnect.mockClear();
     mockGetMcpAuthState.mockClear();
     mockGetMcpAuthState.mockImplementation(() => null);
-    mockReloadMcpServers.mockClear();  // ← add this line
+    mockReloadMcpServers.mockClear(); // ← add this line
   });
 
   describe("POST internal/mcp/auth/start", () => {

package/src/__tests__/mcp-config-secret-boundary.test.ts

@@ -1,3 +1,5 @@
+import { readFileSync, utimesSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { makeMockLogger } from "./helpers/mock-logger.js";
@@ -12,86 +14,41 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (value: string, maxLen = 500) => value.slice(0, maxLen),
 }));
 
+// The config routes under test read and write the workspace config.json via
+// the real loader (`loadRawConfig`/`saveRawConfig`). Tests seed the raw file
+// directly (the fixtures are raw-file shapes, including deliberately
+// malformed trees, so the whole file is replaced rather than composed via
+// `setConfig`) and detect commits by comparing the on-disk text against the
+// seeded snapshot — `saveRawConfig` pretty-prints, so any commit changes the
+// text.
 let rawConfig: Record<string, unknown> = {};
-let savedRawConfig: Record<string, unknown> | null = null;
-
-function deepMerge(
-  target: Record<string, unknown>,
-  patch: Record<string, unknown>,
-): void {
-  for (const [key, value] of Object.entries(patch)) {
-    if (
-      value !== null &&
-      typeof value === "object" &&
-      !Array.isArray(value) &&
-      target[key] !== null &&
-      typeof target[key] === "object" &&
-      !Array.isArray(target[key])
-    ) {
-      deepMerge(
-        target[key] as Record<string, unknown>,
-        value as Record<string, unknown>,
-      );
-    } else {
-      target[key] = value;
-    }
-  }
+let seededRawText = "";
+let mtimeSeq = 0;
+
+function configJsonPath(): string {
+  return join(process.env.VELLUM_WORKSPACE_DIR!, "config.json");
 }
 
-function setNestedValue(
-  obj: Record<string, unknown>,
-  path: string,
-  value: unknown,
-): void {
-  const keys = path.split(".");
-  let current = obj;
-  for (const key of keys.slice(0, -1)) {
-    if (
-      current[key] === null ||
-      typeof current[key] !== "object" ||
-      Array.isArray(current[key])
-    ) {
-      current[key] = {};
-    }
-    current = current[key] as Record<string, unknown>;
-  }
-  current[keys[keys.length - 1]!] = value;
+/** Write `raw` to the workspace config.json as the seeded pre-test state. */
+function seedRawConfig(raw: Record<string, unknown>): void {
+  rawConfig = raw;
+  seededRawText = JSON.stringify(raw);
+  writeFileSync(configJsonPath(), seededRawText);
+  // Distinct mtime per write so the loader's file-signature cache can never
+  // read two consecutive seeds as identical.
+  mtimeSeq += 1;
+  const stamp = new Date(Date.now() + mtimeSeq);
+  utimesSync(configJsonPath(), stamp, stamp);
 }
 
-mock.module("../config/loader.js", () => ({
-  API_KEY_PROVIDERS: [],
-  applyNestedDefaults: (config: unknown) => config,
-  loadRawConfig: () => structuredClone(savedRawConfig ?? rawConfig),
-  saveRawConfig: (raw: Record<string, unknown>) => {
-    savedRawConfig = structuredClone(raw);
-  },
-  deepMergeOverwrite: deepMerge,
-  fillContextDefaultsForMissingKeys: () => {},
-  loadConfig: () => structuredClone(savedRawConfig ?? rawConfig),
-  getConfig: () => structuredClone(savedRawConfig ?? rawConfig),
-  getConfigReadOnly: () => structuredClone(savedRawConfig ?? rawConfig),
-  getDeploymentContextDefaults: () => ({}),
-  getNestedValue: (obj: Record<string, unknown>, path: string) =>
-    path.split(".").reduce<unknown>((current, key) => {
-      if (
-        current === null ||
-        typeof current !== "object" ||
-        Array.isArray(current)
-      ) {
-        return undefined;
-      }
-      return (current as Record<string, unknown>)[key];
-    }, obj),
-  invalidateConfigCache: () => {},
-  mergeDefaultWorkspaceConfig: () => ({
-    merged: false,
-    config: structuredClone(savedRawConfig ?? rawConfig),
-  }),
-  setNestedValue,
-  withSuppressedConfigDiskWrites: async (fn: () => unknown) => fn(),
-  withSuppressedConfigDiskWritesSync: (fn: () => unknown) => fn(),
-  _writeQuarantineNotice: () => {},
-}));
+/** The raw config a route commit persisted, or null when nothing was saved. */
+function committedRaw(): Record<string, unknown> | null {
+  const text = readFileSync(configJsonPath(), "utf8");
+  if (text === seededRawText) {
+    return null;
+  }
+  return JSON.parse(text) as Record<string, unknown>;
+}
 
 mock.module("../daemon/config-watcher.js", () => ({
   getConfigWatcher: () => ({
@@ -150,7 +107,9 @@ const { BadRequestError } = await import("../runtime/routes/errors.js");
 
 function findRoute(operationId: string) {
   const route = ROUTES.find((r) => r.operationId === operationId);
-  if (!route) throw new Error(`Route not found: ${operationId}`);
+  if (!route) {
+    throw new Error(`Route not found: ${operationId}`);
+  }
   return route;
 }
 
@@ -172,12 +131,11 @@ function withoutWireProfiles(
 
 describe("MCP config secret boundary", () => {
   beforeEach(() => {
-    rawConfig = {};
-    savedRawConfig = null;
+    seedRawConfig({});
   });
 
   test("config_get omits legacy MCP transport headers from settings-read responses", () => {
-    rawConfig = {
+    seedRawConfig({
       mcp: {
         servers: {
           remote: {
@@ -192,7 +150,7 @@ describe("MCP config secret boundary", () => {
           },
         },
       },
-    };
+    });
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
@@ -208,7 +166,7 @@ describe("MCP config secret boundary", () => {
   });
 
   test("config_get omits headers inside malformed MCP server trees", () => {
-    rawConfig = {
+    seedRawConfig({
       mcp: {
         servers: [
           {
@@ -218,7 +176,7 @@ describe("MCP config secret boundary", () => {
           },
         ],
       },
-    };
+    });
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
@@ -235,7 +193,7 @@ describe("MCP config secret boundary", () => {
   });
 
   test("config_get preserves an MCP server named headers", () => {
-    rawConfig = {
+    seedRawConfig({
       mcp: {
         servers: {
           headers: {
@@ -246,7 +204,7 @@ describe("MCP config secret boundary", () => {
           },
         },
       },
-    };
+    });
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
@@ -254,7 +212,7 @@ describe("MCP config secret boundary", () => {
   });
 
   test("config_get preserves non-credential headers env vars", () => {
-    rawConfig = {
+    seedRawConfig({
       mcp: {
         servers: {
           local: {
@@ -268,7 +226,7 @@ describe("MCP config secret boundary", () => {
           },
         },
       },
-    };
+    });
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
@@ -293,7 +251,7 @@ describe("MCP config secret boundary", () => {
         },
       }),
     ).rejects.toThrow(BadRequestError);
-    expect(savedRawConfig).toBeNull();
+    expect(committedRaw()).toBeNull();
   });
 
   test("config_patch allows an MCP server named headers when its value has no header credentials", async () => {
@@ -377,11 +335,11 @@ describe("MCP config secret boundary", () => {
         },
       }),
     ).rejects.toThrow(BadRequestError);
-    expect(savedRawConfig).toBeNull();
+    expect(committedRaw()).toBeNull();
   });
 
   test("config_set rejects direct MCP transport header paths", async () => {
-    rawConfig = {
+    seedRawConfig({
       mcp: {
         servers: {
           remote: {
@@ -392,7 +350,7 @@ describe("MCP config secret boundary", () => {
           },
         },
       },
-    };
+    });
 
     await expect(
       configSetRoute.handler({
@@ -402,6 +360,6 @@ describe("MCP config secret boundary", () => {
         },
       }),
     ).rejects.toThrow(BadRequestError);
-    expect(savedRawConfig).toBeNull();
+    expect(committedRaw()).toBeNull();
   });
 });

package/src/__tests__/mcp-health-check.test.ts

@@ -18,29 +18,23 @@ mock.module("../mcp/client.js", () => ({
   },
 }));
 
-const mockConfig = {
-  mcp: {
-    servers: {
-      test: {
-        transport: {
-          type: "streamable-http",
-          url: "https://example.com/mcp",
-        },
-        enabled: true,
-        defaultRiskLevel: "high",
-        maxTools: 20,
+import { setConfig } from "./helpers/set-config.js";
+
+// Seed the MCP server the list route reads via `loadRawConfig()` into the
+// workspace config for real.
+setConfig("mcp", {
+  servers: {
+    test: {
+      transport: {
+        type: "streamable-http",
+        url: "https://example.com/mcp",
       },
+      enabled: true,
+      defaultRiskLevel: "high",
+      maxTools: 20,
     },
   },
-};
-mock.module("../config/loader.js", () => ({
-  loadRawConfig: () => mockConfig,
-  saveRawConfig: () => {},
-  // route-policy → config/env transitively imports `getConfig`; stub it
-  // here so the mock surface matches what consumers expect.
-  getConfig: () => mockConfig,
-  getConfigReadOnly: () => mockConfig,
-}));
+});
 
 mock.module("../daemon/mcp-reload-service.js", () => ({
   reloadMcpServers: async () => {},