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

package/src/__tests__/telegram-bot-username-resolution.test.ts

@@ -8,46 +8,35 @@
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { loadRawConfig } from "../config/loader.js";
+import { setConfig } from "./helpers/set-config.js";
+
 // ---------------------------------------------------------------------------
 // Mutable mock state — tests toggle these before each call
 // ---------------------------------------------------------------------------
 
 let mockBotUsername: string | undefined;
 let mockSecureKey: string | undefined;
-let mockConfigWriteCalls: Array<{
-  path: string;
-  value: unknown;
-}> = [];
 
 mock.module("../telegram/bot-username.js", () => ({
   getTelegramBotUsername: () => mockBotUsername,
   getTelegramBotId: () => (mockBotUsername ? "123456" : undefined),
 }));
 
-mock.module("../config/loader.js", () => ({
-  loadRawConfig: () => ({}),
-  setNestedValue: (
-    _obj: Record<string, unknown>,
-    path: string,
-    value: unknown,
-  ) => {
-    mockConfigWriteCalls.push({ path, value });
-  },
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
-}));
-
 mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: async (_keyId: string) => mockSecureKey,
 }));
 
-// Suppress logger output during tests
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
+// ---------------------------------------------------------------------------
+// Real-config assertion helper — the function under test persists the
+// resolved username via the real loader (`loadRawConfig` → `setNestedValue`
+// → `saveRawConfig`), so tests assert against the workspace config file.
+// ---------------------------------------------------------------------------
+
+function readResolvedBotUsername(): unknown {
+  const raw = loadRawConfig() as { telegram?: { botUsername?: unknown } };
+  return raw.telegram?.botUsername;
+}
 
 // ---------------------------------------------------------------------------
 // Global fetch mock — swapped per test
@@ -64,7 +53,9 @@ let fetchCallCount = 0;
 beforeEach(() => {
   mockBotUsername = undefined;
   mockSecureKey = undefined;
-  mockConfigWriteCalls = [];
+  // Clear any username a prior test persisted; all tests share one workspace
+  // config.json, and the file is the write target under test.
+  setConfig("telegram", {});
   mockFetchThrows = undefined;
   mockFetchResponse = {
     ok: true,
@@ -99,7 +90,7 @@ describe("ensureTelegramBotUsernameResolved", () => {
     await ensureTelegramBotUsernameResolved();
 
     expect(fetchCallCount).toBe(0);
-    expect(mockConfigWriteCalls).toHaveLength(0);
+    expect(readResolvedBotUsername()).toBeUndefined();
   });
 
   test("(b) fetches getMe and writes username to config on success", async () => {
@@ -114,12 +105,7 @@ describe("ensureTelegramBotUsernameResolved", () => {
     await ensureTelegramBotUsernameResolved();
 
     expect(fetchCallCount).toBe(1);
-    expect(mockConfigWriteCalls).toEqual([
-      {
-        path: "telegram.botUsername",
-        value: "MyNewBot",
-      },
-    ]);
+    expect(readResolvedBotUsername()).toBe("MyNewBot");
   });
 
   test("(c) handles non-200 response gracefully without writing to config", async () => {
@@ -134,7 +120,7 @@ describe("ensureTelegramBotUsernameResolved", () => {
     await ensureTelegramBotUsernameResolved();
 
     expect(fetchCallCount).toBe(1);
-    expect(mockConfigWriteCalls).toHaveLength(0);
+    expect(readResolvedBotUsername()).toBeUndefined();
   });
 
   test("(d) handles missing username in response gracefully", async () => {
@@ -149,7 +135,7 @@ describe("ensureTelegramBotUsernameResolved", () => {
     await ensureTelegramBotUsernameResolved();
 
     expect(fetchCallCount).toBe(1);
-    expect(mockConfigWriteCalls).toHaveLength(0);
+    expect(readResolvedBotUsername()).toBeUndefined();
   });
 
   test("(e) handles network errors (fetch throws) gracefully", async () => {
@@ -160,7 +146,7 @@ describe("ensureTelegramBotUsernameResolved", () => {
     await ensureTelegramBotUsernameResolved();
 
     expect(fetchCallCount).toBe(1);
-    expect(mockConfigWriteCalls).toHaveLength(0);
+    expect(readResolvedBotUsername()).toBeUndefined();
   });
 
   test("(f) no-ops when no bot token is configured", async () => {
@@ -170,7 +156,7 @@ describe("ensureTelegramBotUsernameResolved", () => {
     await ensureTelegramBotUsernameResolved();
 
     expect(fetchCallCount).toBe(0);
-    expect(mockConfigWriteCalls).toHaveLength(0);
+    expect(readResolvedBotUsername()).toBeUndefined();
   });
 
   test("writes to config when bot username not in config", async () => {
@@ -185,12 +171,7 @@ describe("ensureTelegramBotUsernameResolved", () => {
     await ensureTelegramBotUsernameResolved();
 
     expect(fetchCallCount).toBe(1);
-    expect(mockConfigWriteCalls).toEqual([
-      {
-        path: "telegram.botUsername",
-        value: "FreshBot",
-      },
-    ]);
+    expect(readResolvedBotUsername()).toBe("FreshBot");
   });
 
   test("writes to config when bot username resolved from API", async () => {
@@ -205,11 +186,6 @@ describe("ensureTelegramBotUsernameResolved", () => {
     await ensureTelegramBotUsernameResolved();
 
     expect(fetchCallCount).toBe(1);
-    expect(mockConfigWriteCalls).toEqual([
-      {
-        path: "telegram.botUsername",
-        value: "AnotherBot",
-      },
-    ]);
+    expect(readResolvedBotUsername()).toBe("AnotherBot");
   });
 });

package/src/__tests__/telegram-config.test.ts

@@ -9,14 +9,6 @@ let oauthConnectionStore: Record<
 > = {};
 const syncCalls: Array<{ provider: string; accountInfo?: string }> = [];
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({ telegram: {}, ui: {} }),
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
-  setNestedValue: () => {},
-}));
-
 mock.module("../inbound/platform-callback-registration.js", () => ({
   registerCallbackRoute: async () => {},
 }));

package/src/__tests__/telemetry-routes.test.ts

@@ -0,0 +1,100 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { ACTOR_PRINCIPALS } from "../runtime/auth/route-policy.js";
+import { RouteError } from "../runtime/routes/errors.js";
+import { ROUTES } from "../runtime/routes/telemetry-routes.js";
+import type { RouteHandlerArgs } from "../runtime/routes/types.js";
+import {
+  pendingOutboxPayloads,
+  resetOutboxTable,
+  setShareAnalytics,
+  setShareDiagnostics,
+} from "../telemetry/__tests__/outbox-test-harness.js";
+import type { OnboardingResearchTelemetryEvent } from "../telemetry/types.js";
+
+function pendingPayloads(): OnboardingResearchTelemetryEvent[] {
+  return pendingOutboxPayloads<OnboardingResearchTelemetryEvent>(
+    "onboarding_research",
+  );
+}
+
+const route = ROUTES.find(
+  (r) => r.operationId === "telemetry_onboarding_research",
+);
+
+function call(body: unknown) {
+  if (!route) {
+    throw new Error("route not found");
+  }
+  return route.handler({ body } as RouteHandlerArgs);
+}
+
+const VALID_BODY = {
+  conversation_id: "conv-xyz",
+  status: "done",
+  claims: [{ claim: "Senior engineer", confidence: "confident", sources: [] }],
+  suggestions: [
+    { suggestion: "I'll find 3 papers", prompt: "Find me 3 papers" },
+  ],
+  plugins: ["marketing-expert"],
+  installed_plugins: ["marketing-expert", "web-research"],
+};
+
+describe("telemetry-routes: onboarding-research", () => {
+  beforeEach(() => {
+    setShareAnalytics(true);
+    setShareDiagnostics(true);
+    resetOutboxTable();
+  });
+
+  test("route policy matches the other client-facing telemetry routes", () => {
+    expect(route).toBeDefined();
+    expect(route?.endpoint).toBe("telemetry/onboarding-research");
+    expect(route?.method).toBe("POST");
+    expect(route?.policy?.allowedPrincipalTypes).toEqual(ACTOR_PRINCIPALS);
+    expect(route?.policy?.requiredScopes).toEqual(["settings.write"]);
+  });
+
+  test("valid body is persisted to the outbox as a wire onboarding_research event", () => {
+    const result = call(VALID_BODY);
+    expect(result).toEqual({ id: expect.any(String) });
+
+    const payloads = pendingPayloads();
+    expect(payloads.length).toBe(1);
+    expect(payloads[0]).toMatchObject({
+      type: "onboarding_research",
+      conversation_id: "conv-xyz",
+      status: "done",
+      claim_count: 1,
+      claims_confident: 1,
+      suggestion_count: 1,
+      plugins: ["marketing-expert"],
+      installed_plugins: ["marketing-expert", "web-research"],
+    });
+  });
+
+  test("returns skipped and persists nothing under the analytics opt-out", () => {
+    setShareAnalytics(false);
+    expect(call(VALID_BODY)).toEqual({ skipped: true });
+    expect(pendingPayloads().length).toBe(0);
+  });
+
+  test("persists regardless of the diagnostics opt-out (rides analytics only)", () => {
+    // No longer diagnostics-gated: with analytics consent, the event persists
+    // even when diagnostics is opted out (and the accepted version is stale).
+    // The platform re-checks the owner's consent server-side at ingest.
+    setShareDiagnostics(false, "2000-01-01");
+    expect(call(VALID_BODY)).toEqual({ id: expect.any(String) });
+    expect(pendingPayloads().length).toBe(1);
+  });
+
+  test("rejects a malformed body without persisting", () => {
+    expect(() => call({ ...VALID_BODY, status: "not-a-status" })).toThrow(
+      RouteError,
+    );
+    expect(() => call({ ...VALID_BODY, claims: [{ claim: "x" }] })).toThrow(
+      RouteError,
+    );
+    expect(pendingPayloads().length).toBe(0);
+  });
+});

package/src/__tests__/telephony-credential-preflight.test.ts

@@ -34,7 +34,6 @@ const realTtsCapabilityModule = {
 const realCallTtsResolverModule = {
   ...(await import("../calls/resolve-call-tts-provider.js")),
 };
-const realConfigLoaderModule = { ...(await import("../config/loader.js")) };
 
 // -- Mutable capability results -----------------------------------------------
 
@@ -47,10 +46,6 @@ let ttsCapability: TelephonyTtsCapability;
 let fallbackProviderId: TtsProviderId | null;
 let fallbackScanCalls: Array<TtsProviderId | undefined> = [];
 
-const testConfig = {
-  services: { stt: { provider: "acme-stt" } },
-} as unknown as ReturnType<typeof realConfigLoaderModule.getConfig>;
-
 mock.module("../providers/speech-to-text/resolve.js", () => ({
   ...realSttResolveModule,
   resolveTelephonySttCapability: async () =>
@@ -82,16 +77,17 @@ mock.module("../calls/resolve-call-tts-provider.js", () => ({
   },
 }));
 
-mock.module("../config/loader.js", () => ({
-  ...realConfigLoaderModule,
-  getConfig: () =>
-    preflightMocksActive ? testConfig : realConfigLoaderModule.getConfig(),
-}));
-
 import { resolveTelephonyCredentialReadiness } from "../calls/telephony-credential-preflight.js";
+import { getConfig } from "../config/loader.js";
 
 beforeAll(() => {
   preflightMocksActive = true;
+  // The catalog-miss test needs `services.stt.provider` set to a name absent
+  // from the STT provider catalog. That field is a schema enum, so the value
+  // cannot be seeded through config.json; mutate the loader's cached config
+  // object directly. No test in this file writes the config file, so the
+  // mutation persists for the whole suite.
+  (getConfig().services.stt as { provider: string }).provider = "acme-stt";
 });
 
 afterAll(() => {

package/src/__tests__/telephony-tts-guard.test.ts

@@ -47,7 +47,6 @@ let guardMocksActive = false;
 const realProviderCatalogModule = {
   ...(await import("../tts/provider-catalog.js")),
 };
-const realConfigLoaderModule = { ...(await import("../config/loader.js")) };
 const realSecureKeysModule = {
   ...(await import("../security/secure-keys.js")),
 };
@@ -100,6 +99,7 @@ const fakeCatalog: FakeCatalogEntry[] = [
   makeEntry("fish-audio", "synthesized-play", "pcm", true),
   makeEntry("deepgram", "synthesized-play", "pcm", false),
   makeEntry("compressed-only", "synthesized-play", "none", false),
+  makeEntry("vellum", "synthesized-play", "pcm", false),
 ];
 
 // The catalog is also the adapter-resolution point (`getTtsProvider`), so the
@@ -140,30 +140,20 @@ mock.module("../tts/provider-catalog.js", () => ({
 
 // -- Mutable config ------------------------------------------------------------
 
-const testConfig = {
+// Alias the loader's live cached config so each test's mutations write straight
+// through to what `getConfig()` returns. Some assigned provider ids
+// ("compressed-only") are fictional catalog entries the schema enum cannot
+// express, so mutating the cached object is the only way to drive them. No test
+// in this file writes the config file, so the mutations persist for the suite.
+const testConfig = getConfig() as unknown as {
   services: {
     tts: {
-      provider: "elevenlabs",
-      providers: {
-        elevenlabs: {},
-        "fish-audio": { referenceId: "", format: "mp3" },
-        deepgram: { format: "mp3" },
-        "compressed-only": { format: "mp3" },
-      } as Record<string, { referenceId?: string; format?: string }>,
-    },
-  },
+      provider: string;
+      providers: Record<string, { referenceId?: string; format?: string }>;
+    };
+  };
 };
 
-mock.module("../config/loader.js", () => ({
-  ...realConfigLoaderModule,
-  loadConfig: () =>
-    guardMocksActive ? testConfig : realConfigLoaderModule.loadConfig(),
-  getConfig: () =>
-    guardMocksActive ? testConfig : realConfigLoaderModule.getConfig(),
-  getConfigReadOnly: () =>
-    guardMocksActive ? testConfig : realConfigLoaderModule.getConfigReadOnly(),
-}));
-
 // -- Mutable credential store --------------------------------------------------
 
 let storedKeys: Record<string, string | undefined> = {};
@@ -202,6 +192,12 @@ mock.module("../calls/audio-store.js", () => ({
   },
 }));
 
+let mockManagedSpeechAvailable = true;
+
+mock.module("../platform/managed-speech.js", () => ({
+  managedSpeechAvailable: async () => mockManagedSpeechAvailable,
+}));
+
 mock.module("../inbound/public-ingress-urls.js", () => ({
   ...realPublicIngressUrlsModule,
   getPublicBaseUrl: (
@@ -222,6 +218,7 @@ import {
   evaluateTelephonyTtsPlayability,
   resolveTelephonyTtsCapability,
 } from "../calls/telephony-tts-capability.js";
+import { getConfig } from "../config/loader.js";
 import type { TtsProvider } from "../tts/types.js";
 
 // ---------------------------------------------------------------------------
@@ -761,3 +758,23 @@ describe("speakSystemPrompt aborted synthesis", () => {
     ]);
   });
 });
+
+describe("vellum managed playability", () => {
+  test("playable only when the platform identity is fully provisioned", async () => {
+    // The stored secret resolves, but availability decides.
+    storedKeys["vellum"] = "stored";
+    mockManagedSpeechAvailable = true;
+    const playable = await evaluateTelephonyTtsPlayability("vellum");
+    expect(playable.status).toBe("playable");
+  });
+
+  test("half-connected platform (secret without identity) is not playable", async () => {
+    storedKeys["vellum"] = "stored";
+    mockManagedSpeechAvailable = false;
+    const playable = await evaluateTelephonyTtsPlayability("vellum");
+    expect(playable).toMatchObject({
+      status: "not-playable",
+      reason: "missing-platform-connection",
+    });
+  });
+});

package/src/__tests__/terminal-tools.test.ts

@@ -12,27 +12,6 @@ mock.module("../util/logger.js", () => ({
 
 const testTmpDir = process.env.VELLUM_WORKSPACE_DIR!;
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-
-    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: () => ({}),
-}));
-
 const proxyGetOrStartSession = mock(() =>
   Promise.resolve({
     session: { id: "mock-session" },

package/src/__tests__/thread-backfill.test.ts

@@ -28,13 +28,6 @@ import {
 // into other test files (e.g. backfill.test.ts) that import the same module.
 // ---------------------------------------------------------------------------
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 mock.module("../config/env.js", () => ({
   isHttpAuthDisabled: () => true,
   getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",

package/src/__tests__/title-generate-hook.test.ts

@@ -69,13 +69,6 @@ mock.module("../persistence/conversation-crud.js", () => ({
   getConversation: mockGetConversation,
 }));
 
-// The `stop` hook reads `conversations.skipAutoRetitling`; stub the loader so
-// the opt-out is controllable per test.
-let skipAutoRetitling = false;
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({ conversations: { skipAutoRetitling } }),
-}));
-
 import { HOOKS } from "../plugin-api/constants.js";
 import type {
   PluginLogger,
@@ -91,6 +84,14 @@ import {
   resetPluginRegistryForTests,
 } from "../plugins/registry.js";
 import type { Message } from "../providers/types.js";
+import { setConfig } from "./helpers/set-config.js";
+
+// The `stop` hook reads `conversations.skipAutoRetitling`; seed it for real so
+// the opt-out is controllable per test.
+/** Seed the retitling opt-out into the workspace config. */
+function setSkipAutoRetitling(skipAutoRetitling: boolean): void {
+  setConfig("conversations", { skipAutoRetitling });
+}
 
 const noopLogger: PluginLogger = {
   info: () => {},
@@ -254,7 +255,7 @@ describe("title-generate stop hook", () => {
           conversationType: string;
         },
     );
-    skipAutoRetitling = false;
+    setSkipAutoRetitling(false);
   });
 
   test("regenerates the title on the third user turn", async () => {
@@ -311,7 +312,7 @@ describe("title-generate stop hook", () => {
   });
 
   test("fallback title retry is not blocked by the retitling opt-out", async () => {
-    skipAutoRetitling = true;
+    setSkipAutoRetitling(true);
     mockGetConversation.mockReturnValueOnce({
       title: "Generating title...",
       isAutoTitle: 1,
@@ -409,7 +410,7 @@ describe("title-generate stop hook", () => {
 
   test("respects the skipAutoRetitling opt-out", async () => {
     // GIVEN the user opted out of second-pass retitling
-    skipAutoRetitling = true;
+    setSkipAutoRetitling(true);
     const ctx = makeStopCtx({ messages: historyWithUserTurns(3) });
 
     // WHEN the stop hook runs on the third user turn and any work flushes

package/src/__tests__/token-manager.test.ts

@@ -16,18 +16,9 @@ import {
 // ---------------------------------------------------------------------------
 // Mock logger
 // ---------------------------------------------------------------------------
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // ---------------------------------------------------------------------------
 // Use encrypted backend with a temp store path
 // ---------------------------------------------------------------------------
-
 import { _resetBackend, setSecureKeyAsync } from "../security/secure-keys.js";
 import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
 

package/src/__tests__/tool-approval-handler.test.ts

@@ -2,14 +2,6 @@ import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 const testDir = process.env.VELLUM_WORKSPACE_DIR!;
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
-
 // Mock verification control-plane policy -- not targeting control-plane by default
 mock.module("../tools/verification-control-plane-policy.js", () => ({
   enforceVerificationControlPlanePolicy: () => ({ denied: false }),

package/src/__tests__/tool-execution-abort-cleanup.test.ts

@@ -16,39 +16,11 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ── Shared mock setup ────────────────────────────────────────────────────────
-// Config mock must be declared before importing tool modules so that the
-// mock.module calls are hoisted above the dynamic imports.
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-
-    provider: "anthropic",
-    model: "test",
-    maxTokens: 4096,
-    dataDir: "/tmp",
-    timeouts: {
-      shellDefaultTimeoutSec: 120,
-      shellMaxTimeoutSec: 600,
-      permissionTimeoutSec: 300,
-    },
-    rateLimit: { maxRequestsPerMinute: 0 },
-    secretDetection: {
-      enabled: false,
-    },
-  }),
-  loadConfig: () => ({}),
-  invalidateConfigCache: () => {},
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-}));
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
+// The real config loader serves these tests: it reads from the per-test temp
+// workspace and returns schema defaults (the timeout values the shell tool
+// needs are the documented defaults). Mocking `config/loader` here would force
+// the mock to mirror the loader's full export surface — modules under test
+// import it by name, and a partial mock fails to link.
 
 // shell.ts uses the script proxy — stub it to avoid network side-effects.
 mock.module("../tools/network/script-proxy/index.js", () => ({

package/src/__tests__/tool-execution-pipeline.benchmark.test.ts

@@ -18,33 +18,12 @@
 
 import { beforeAll, describe, expect, mock, test } from "bun:test";
 
+import * as realPlatform from "../util/platform.js";
+
 // Local registry for ToolExecutor tests — the mock delegates to this map
 // so that registerTool/getTool/getAllTools work for our benchmark tools.
 const localRegistry = new Map<string, import("../tools/types.js").Tool>();
 
-// Mocks must precede imports of modules under test.
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-
-    provider: "mock-provider",
-    timeouts: { permissionTimeoutSec: 5, toolExecutionTimeoutSec: 120 },
-    permissions: {},
-    skills: { load: { extraDirs: [] } },
-    secretDetection: { enabled: true },
-    sandbox: { enabled: false },
-    contextWindow: {},
-    memory: {},
-  }),
-}));
-
 mock.module("../config/skills.js", () => ({
   resolveSkillSelector: () => ({ skill: null }),
   loadSkillCatalog: () => [],
@@ -68,6 +47,7 @@ mock.module("../config/env-registry.js", () => ({
 }));
 
 mock.module("../util/platform.js", () => ({
+  ...realPlatform,
   getWorkspaceDir: () => "/tmp",
   getProtectedDir: () => "/tmp/protected",
   getWorkspaceHooksDir: () => "/tmp/hooks",