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

package/src/__tests__/media-generate-image.test.ts

@@ -5,6 +5,7 @@ import { dirname, join } from "path";
 
 import { __resetRegistryForTesting, getTool } from "../tools/registry.js";
 import type { ToolContext } from "../tools/types.js";
+import { setConfig } from "./helpers/set-config.js";
 
 // ---------------------------------------------------------------------------
 // Mock dependencies for the tool wrapper
@@ -12,8 +13,6 @@ import type { ToolContext } from "../tools/types.js";
 
 let mockGeminiKey: string | undefined = "test-gemini-key";
 let mockOpenAIKey: string | undefined = "test-openai-key";
-let mockImageGenMode: "your-own" | "managed" = "your-own";
-let mockImageGenProvider: "gemini" | "openai" = "gemini";
 let mockGenerateResult = {
   images: [{ mimeType: "image/png", dataBase64: "generated-data" }],
   text: "A beautiful image",
@@ -23,24 +22,19 @@ let mockGenerateError: Error | null = null;
 let lastGenerateProvider: unknown = null;
 let lastGenerateCredentials: unknown = null;
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    services: {
-      inference: {
-        mode: "your-own",
-        provider: "anthropic",
-        model: "claude-opus-4-6",
-      },
-      "image-generation": {
-        mode: mockImageGenMode,
-        provider: mockImageGenProvider,
-        model: "gemini-3.1-flash-image-preview",
-      },
-      "web-search": { mode: "your-own", provider: "inference-provider-native" },
-    },
-  }),
-}));
+/**
+ * Seed the image-generation service entry in the real workspace config.
+ * Omitted fields fall back to the schema defaults (`mode: "your-own"`,
+ * `provider: "gemini"`, model `gemini-3.1-flash-image-preview`).
+ */
+function seedImageGenService(
+  overrides: {
+    mode?: "your-own" | "managed";
+    provider?: "gemini" | "openai";
+  } = {},
+): void {
+  setConfig("services", { "image-generation": overrides });
+}
 
 mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: async (account: string) => {
@@ -119,8 +113,7 @@ const CONFIG_DIR = join(
 beforeEach(() => {
   mockGeminiKey = "test-gemini-key";
   mockOpenAIKey = "test-openai-key";
-  mockImageGenMode = "your-own";
-  mockImageGenProvider = "gemini";
+  seedImageGenService();
   mockGenerateResult = {
     images: [{ mimeType: "image/png", dataBase64: "generated-data" }],
     text: "A beautiful image",
@@ -159,7 +152,7 @@ describe("image-studio skill script wrapper", () => {
   });
 
   test("managed mode uses managed proxy credentials", async () => {
-    mockImageGenMode = "managed";
+    seedImageGenService({ mode: "managed" });
     mockManagedBaseUrl = "https://platform.example.com/v1/runtime-proxy/gemini";
     mockManagedProxyContext = {
       enabled: true,
@@ -180,7 +173,7 @@ describe("image-studio skill script wrapper", () => {
   });
 
   test("managed mode returns error when managed proxy is unavailable", async () => {
-    mockImageGenMode = "managed";
+    seedImageGenService({ mode: "managed" });
     mockGeminiKey = "direct-key"; // should be ignored in managed mode
     mockManagedBaseUrl = undefined;
 
@@ -191,7 +184,7 @@ describe("image-studio skill script wrapper", () => {
   });
 
   test("your-own mode uses direct API key", async () => {
-    mockImageGenMode = "your-own";
+    seedImageGenService({ mode: "your-own" });
     mockGeminiKey = "direct-key";
     mockManagedBaseUrl = "https://platform.example.com/v1/runtime-proxy/gemini";
     mockManagedProxyContext = {
@@ -210,7 +203,7 @@ describe("image-studio skill script wrapper", () => {
   });
 
   test("openai provider dispatches to OpenAI with its key", async () => {
-    mockImageGenProvider = "openai";
+    seedImageGenService({ provider: "openai" });
     mockOpenAIKey = "openai-direct-key";
 
     const result = await run({ prompt: "a robot" }, fakeContext);
@@ -224,7 +217,7 @@ describe("image-studio skill script wrapper", () => {
   });
 
   test("openai provider returns OpenAI-specific error hint when no key", async () => {
-    mockImageGenProvider = "openai";
+    seedImageGenService({ provider: "openai" });
     mockOpenAIKey = undefined;
 
     const result = await run({ prompt: "a robot" }, fakeContext);
@@ -238,7 +231,7 @@ describe("image-studio skill script wrapper", () => {
     // Config says the user's default provider is gemini, but the LLM
     // explicitly requests a gpt-* model. The tool must dispatch to OpenAI
     // and resolve OpenAI credentials, not fall back to Gemini's default.
-    mockImageGenProvider = "gemini";
+    seedImageGenService({ provider: "gemini" });
     mockOpenAIKey = "openai-direct-key";
 
     const result = await run(
@@ -256,7 +249,7 @@ describe("image-studio skill script wrapper", () => {
 
   test("explicit model override routes to owning provider (openai config → gemini call)", async () => {
     // The inverse: config says openai but the LLM asks for a gemini-* model.
-    mockImageGenProvider = "openai";
+    seedImageGenService({ provider: "openai" });
     mockGeminiKey = "gemini-direct-key";
 
     const result = await run(
@@ -276,7 +269,7 @@ describe("image-studio skill script wrapper", () => {
     // Config: gemini (with a gemini key). LLM asks for gpt-image-2 but the
     // OpenAI key is missing. The error hint must reference OpenAI, not
     // Gemini, because the dispatch target is OpenAI.
-    mockImageGenProvider = "gemini";
+    seedImageGenService({ provider: "gemini" });
     mockGeminiKey = "test-gemini-key";
     mockOpenAIKey = undefined;
 
@@ -344,7 +337,7 @@ describe("image-studio skill script wrapper", () => {
   });
 
   test("openai generation error uses OpenAI-specific mapping", async () => {
-    mockImageGenProvider = "openai";
+    seedImageGenService({ provider: "openai" });
     mockGenerateError = new Error("openai failure");
 
     const result = await run({ prompt: "a cat" }, fakeContext);
@@ -373,7 +366,7 @@ describe("image-studio skill script wrapper", () => {
   });
 
   test("managed mode credential error includes guidance not to change service config", async () => {
-    mockImageGenMode = "managed";
+    seedImageGenService({ mode: "managed" });
     mockManagedBaseUrl = undefined;
 
     const result = await run({ prompt: "a cat" }, fakeContext);

package/src/__tests__/media-stream-output.test.ts

@@ -4,15 +4,6 @@ import { afterEach, describe, expect, jest, mock, test } from "bun:test";
 // Module mocks
 // ---------------------------------------------------------------------------
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () => ({
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    debug: () => {},
-  }),
-}));
-
 // Mock TTS provider for synthesis tests
 const mockSynthesize = jest.fn();
 const mockProvider = {

package/src/__tests__/media-stream-server-integration.test.ts

@@ -21,16 +21,6 @@ mock.module("../providers/speech-to-text/resolve.js", () => ({
   resolveStreamingTranscriber: jest.fn(async () => null),
 }));
 
-// Mock the logger to suppress output during tests
-mock.module("../util/logger.js", () => ({
-  getLogger: () => ({
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    debug: () => {},
-  }),
-}));
-
 // Mock the call store — lightweight in-memory stubs
 const mockSessions = new Map<string, Record<string, unknown>>();
 const mockEvents: Array<{
@@ -392,11 +382,11 @@ mock.module("../runtime/access-request-helper.js", () => ({
   notifyGuardianOfAccessRequest: mockNotifyGuardianOfAccessRequest,
 }));
 
-// Canonical guardian-request store polled by the guardian wait controller.
-let mockCanonicalRequest: { status: string } | null = null;
-const mockGetCanonicalGuardianRequest = jest.fn(() => mockCanonicalRequest);
-mock.module("../contacts/canonical-guardian-store.js", () => ({
-  getCanonicalGuardianRequest: mockGetCanonicalGuardianRequest,
+// Gateway guardian-request client polled by the guardian wait controller.
+let mockGuardianRequest: { status: string } | null = null;
+const mockGetGuardianRequest = jest.fn(async () => mockGuardianRequest);
+mock.module("../channels/gateway-guardian-requests.js", () => ({
+  getGuardianRequestOrNull: mockGetGuardianRequest,
 }));
 
 // Wait-state helpers: no heartbeats in tests; capture callback handoffs.
@@ -445,7 +435,9 @@ function createMockWs() {
   return {
     ws: {
       send(data: string) {
-        if (closed) {throw new Error("WebSocket is closed");}
+        if (closed) {
+          throw new Error("WebSocket is closed");
+        }
         sent.push(data);
       },
       close(code?: number, reason?: string) {
@@ -594,8 +586,8 @@ beforeEach(() => {
   };
   mockNotifyGuardianOfAccessRequest.mockClear();
   mockNotifyResult = { notified: true, created: true, requestId: "req-1" };
-  mockGetCanonicalGuardianRequest.mockClear();
-  mockCanonicalRequest = null;
+  mockGetGuardianRequest.mockClear();
+  mockGuardianRequest = null;
   mockEmitCallbackHandoff.mockClear();
   mockTtsPlaybackDelayMs = 5;
   mockAccessRequestPollIntervalMs = 5;
@@ -2360,7 +2352,7 @@ describe("setup flows over the media-stream transport", () => {
       );
       expect(session.getSetupFlow()?.getState()).toBe("capturing_name");
 
-      mockCanonicalRequest = { status: "pending" };
+      mockGuardianRequest = { status: "pending" };
       deliverTranscript(session, "Casey Example");
       await sleep();
 
@@ -2386,7 +2378,7 @@ describe("setup flows over the media-stream transport", () => {
       expect(registerCallController).not.toHaveBeenCalled();
 
       // The guardian approves; the wait poll picks it up.
-      mockCanonicalRequest = { status: "approved" };
+      mockGuardianRequest = { status: "approved" };
       await sleep(40);
 
       expect(speakSystemPrompt).toHaveBeenCalledWith(
@@ -2411,11 +2403,11 @@ describe("setup flows over the media-stream transport", () => {
       });
       await session.whenSetupSettled();
 
-      mockCanonicalRequest = { status: "pending" };
+      mockGuardianRequest = { status: "pending" };
       deliverTranscript(session, "Casey Example");
       await sleep();
 
-      mockCanonicalRequest = { status: "denied" };
+      mockGuardianRequest = { status: "denied" };
       await sleep(40);
 
       expect(speakSystemPrompt).toHaveBeenCalledWith(
@@ -2445,7 +2437,7 @@ describe("setup flows over the media-stream transport", () => {
       });
       await session.whenSetupSettled();
 
-      mockCanonicalRequest = { status: "pending" };
+      mockGuardianRequest = { status: "pending" };
       deliverTranscript(session, "Casey Example");
       await sleep();
 
@@ -2475,7 +2467,7 @@ describe("setup flows over the media-stream transport", () => {
       });
       await session.whenSetupSettled();
 
-      mockCanonicalRequest = { status: "pending" };
+      mockGuardianRequest = { status: "pending" };
       deliverTranscript(session, "Casey Example");
       await sleep();
       expect(session.getSetupFlow()?.getState()).toBe(
@@ -2495,7 +2487,7 @@ describe("setup flows over the media-stream transport", () => {
       expect(session.getSetupFlow()).toBeNull();
 
       // A late approval must not resurrect the torn-down call.
-      mockCanonicalRequest = { status: "approved" };
+      mockGuardianRequest = { status: "approved" };
       await sleep(40);
       expect(registerCallController).not.toHaveBeenCalled();
       expect(finalizeCall).toHaveBeenCalledTimes(1);
@@ -2612,12 +2604,12 @@ describe("setup flows over the media-stream transport", () => {
       });
       await session.whenSetupSettled();
 
-      mockCanonicalRequest = { status: "pending" };
+      mockGuardianRequest = { status: "pending" };
       deliverTranscript(session, "Casey Example");
       await sleep();
 
       const releaseSpeech = gateNextSpeech();
-      mockCanonicalRequest = { status: "denied" };
+      mockGuardianRequest = { status: "denied" };
       await sleep(40);
 
       expect(updateCallSession).toHaveBeenCalledWith(

package/src/__tests__/media-stream-stt-session.test.ts

@@ -26,30 +26,6 @@ mock.module("../providers/speech-to-text/resolve.js", () => ({
   resolveStreamingTranscriber: jest.fn(),
 }));
 
-// Mock the config loader so the session's telephony-streaming flag read
-// never touches the real filesystem config.
-const configState = { telephonyStreaming: true, utteranceEndMs: 1000 };
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    calls: {
-      voice: {
-        telephonyStreaming: configState.telephonyStreaming,
-        utteranceEndMs: configState.utteranceEndMs,
-      },
-    },
-  }),
-}));
-
-// Mock the logger to suppress output during tests
-mock.module("../util/logger.js", () => ({
-  getLogger: () => ({
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    debug: () => {},
-  }),
-}));
-
 // Now import the mocked modules and the module under test.
 import { MediaStreamSttSession } from "../calls/media-stream-stt-session.js";
 import {
@@ -57,6 +33,18 @@ import {
   resolveStreamingTranscriber,
   resolveTelephonySttCapability,
 } from "../providers/speech-to-text/resolve.js";
+import { setConfig } from "./helpers/set-config.js";
+
+/**
+ * Seed the session's `calls.voice` settings in the real workspace config.
+ * `utteranceEndMs` defaults to the schema default (1000).
+ */
+function seedCallsVoice(
+  telephonyStreaming: boolean,
+  utteranceEndMs = 1000,
+): void {
+  setConfig("calls", { voice: { telephonyStreaming, utteranceEndMs } });
+}
 
 // ---------------------------------------------------------------------------
 // Fixture factories
@@ -202,8 +190,7 @@ describe("MediaStreamSttSession", () => {
     // Most tests exercise the batch path — flip the kill-switch off so the
     // session selects batch mode deterministically. Streaming-mode tests
     // set it back to true.
-    configState.telephonyStreaming = false;
-    configState.utteranceEndMs = 1000;
+    seedCallsVoice(false);
 
     // Default: provider is supported and transcriber is available
     (resolveTelephonySttCapability as jest.Mock).mockResolvedValue({
@@ -677,7 +664,7 @@ describe("MediaStreamSttSession", () => {
   // ── Telephony streaming flag ─────────────────────────────────────
 
   test("flag off: never resolves a streaming transcriber", async () => {
-    configState.telephonyStreaming = false;
+    seedCallsVoice(false);
     const session = new MediaStreamSttSession({}, {});
 
     session.handleMessage(makeStartMessage());
@@ -691,7 +678,7 @@ describe("MediaStreamSttSession", () => {
 
   describe("streaming mode", () => {
     beforeEach(() => {
-      configState.telephonyStreaming = true;
+      seedCallsVoice(true);
     });
 
     /** Start a session with an already-started streaming transcriber. */
@@ -726,7 +713,7 @@ describe("MediaStreamSttSession", () => {
     });
 
     test("forwards the configured calls.voice.utteranceEndMs to the resolver", async () => {
-      configState.utteranceEndMs = 2500;
+      seedCallsVoice(true, 2500);
       const { session } = await startStreamingSession();
 
       expect(resolveStreamingTranscriber).toHaveBeenCalledWith({

package/src/__tests__/memory-jobs-worker-backoff.test.ts

@@ -9,23 +9,6 @@ import { describe, expect, mock, test } from "bun:test";
 
 // ── Mocks (must precede imports of tested module) ──────────────────
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-// Mock config — memory disabled so runMemoryJobsOnce returns 0 immediately
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    memory: { enabled: false },
-  }),
-  loadConfig: () => ({
-    memory: { enabled: false },
-  }),
-}));
-
 // Mock jobs-store (accesses DB)
 mock.module("../persistence/jobs-store.js", () => ({
   resetRunningJobsToPending: () => 0,
@@ -48,8 +31,12 @@ mock.module("../persistence/checkpoints.js", () => ({
 import {
   POLL_INTERVAL_MAX_MS,
   POLL_INTERVAL_MIN_MS,
-  startMemoryJobsWorker,
+  startMemoryJobsWorkerLoop,
 } from "../plugins/defaults/memory/jobs-worker.js";
+import { setConfig } from "./helpers/set-config.js";
+
+// Memory disabled so each idle tick stays on the mocked-store fast path.
+setConfig("memory", { enabled: false });
 
 describe("memory jobs worker adaptive poll interval", () => {
   test("exports expected poll interval constants", () => {
@@ -97,7 +84,7 @@ describe("memory jobs worker adaptive poll interval", () => {
     globalThis.clearTimeout = (() => {}) as typeof clearTimeout;
 
     try {
-      const worker = startMemoryJobsWorker();
+      const worker = startMemoryJobsWorkerLoop();
 
       // Wait for the initial tick() promise to settle
       await new Promise((resolve) => originalSetTimeout(resolve, 20));

package/src/__tests__/memory-jobs-worker-cleanup-cadence.test.ts

@@ -19,13 +19,6 @@ import type { AssistantConfig } from "../config/types.js";
 
 // ── Mocks (must precede imports of tested module) ──────────────────
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 let convCalls: Array<number | undefined> = [];
 let llmCalls: Array<number | undefined> = [];
 let toolCalls: Array<number | undefined> = [];
@@ -64,11 +57,6 @@ mock.module("../persistence/checkpoints.js", () => ({
   },
 }));
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({ memory: { enabled: false } }),
-  loadConfig: () => ({ memory: { enabled: false } }),
-}));
-
 import { resetCleanupScheduleThrottle } from "../persistence/cleanup-schedule-state.js";
 import {
   maybeEnqueueScheduledCleanupJobs,
@@ -196,6 +184,39 @@ describe("maybeEnqueueScheduledCleanupJobs retention-derived cadence", () => {
     expect(llmCalls).toEqual([]);
   });
 
+  test("zero LLM-log retention disables pruning and never busy-loops", () => {
+    // A retention of 0 makes the cadence interval 0, so `isDue` would be true
+    // on every tick. Guard against the resulting runaway enqueue loop: 0 must
+    // enqueue nothing, on the first tick and on every subsequent one.
+    const config = makeConfig({ llmRequestLogRetentionMs: 0 });
+
+    expect(maybeEnqueueScheduledCleanupJobs(config, BASE)).toBe(false);
+    expect(maybeEnqueueScheduledCleanupJobs(config, BASE + 1)).toBe(false);
+    expect(maybeEnqueueScheduledCleanupJobs(config, BASE + 60_000)).toBe(false);
+    expect(llmCalls).toEqual([]);
+  });
+
+  test("zero conversation retention disables pruning and never busy-loops", () => {
+    // Same 0-window cadence trap as LLM logs: interval 0 → `isDue` always
+    // true. The `> 0` guard must hold across ticks so nothing is enqueued.
+    const config = makeConfig({ conversationRetentionDays: 0 });
+
+    expect(maybeEnqueueScheduledCleanupJobs(config, BASE)).toBe(false);
+    expect(maybeEnqueueScheduledCleanupJobs(config, BASE + 1)).toBe(false);
+    expect(maybeEnqueueScheduledCleanupJobs(config, BASE + 60_000)).toBe(false);
+    expect(convCalls).toEqual([]);
+  });
+
+  test("zero audit-log retention disables pruning and never busy-loops", () => {
+    // Same 0-window cadence trap for tool_invocations (auditLog.retentionDays).
+    const config = makeConfig({ auditLogRetentionDays: 0 });
+
+    expect(maybeEnqueueScheduledCleanupJobs(config, BASE)).toBe(false);
+    expect(maybeEnqueueScheduledCleanupJobs(config, BASE + 1)).toBe(false);
+    expect(maybeEnqueueScheduledCleanupJobs(config, BASE + 60_000)).toBe(false);
+    expect(toolCalls).toEqual([]);
+  });
+
   test("resetCleanupScheduleThrottle makes every job due on the next tick", () => {
     const config = makeConfig({
       conversationRetentionDays: 30,

package/src/__tests__/memory-jobs-worker-lanes.test.ts

@@ -15,17 +15,9 @@ import { beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { eq } from "drizzle-orm";
 
-import { DEFAULT_CONFIG } from "../config/defaults.js";
-import type { AssistantConfig } from "../config/types.js";
+import { setConfig } from "./helpers/set-config.js";
 
-// ── Mocks (must precede imports of tested module) ──────────────────
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
+// ── Config seed (before the tested module reads config) ────────────
 
 // Per-lane caps: 1 slow slot (so only 1 of the 5 enqueued slow jobs runs in
 // this tick) and a generous fast cap so every fast job both gets claimed
@@ -33,26 +25,15 @@ mock.module("../util/logger.js", () => ({
 // claimed jobs without lane awareness and ran them through a single
 // workerConcurrency-sized pool — would pin its slots on the first claimed
 // slow jobs and force the fast jobs to queue behind a 200ms LLM call.
-const TEST_CONFIG: AssistantConfig = {
-  ...DEFAULT_CONFIG,
-  memory: {
-    ...DEFAULT_CONFIG.memory,
-    enabled: true,
-    jobs: {
-      ...DEFAULT_CONFIG.memory.jobs,
-      slowLlmConcurrency: 1,
-      fastConcurrency: 5,
-      embedConcurrency: 1,
-      workerConcurrency: 2,
-    },
+// Everything else (including `memory.enabled: true`) is the schema default.
+setConfig("memory", {
+  jobs: {
+    slowLlmConcurrency: 1,
+    fastConcurrency: 5,
+    embedConcurrency: 1,
+    workerConcurrency: 2,
   },
-};
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => TEST_CONFIG,
-  loadConfig: () => TEST_CONFIG,
-  invalidateConfigCache: () => {},
-}));
+});
 
 // ── Track timestamps so we can assert ordering ─────────────────────
 

package/src/__tests__/memory-recall-log-store.test.ts

@@ -1,22 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    model: "test",
-    provider: "test",
-    memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0 },
-    secretDetection: { enabled: false },
-  }),
-}));
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";

package/src/__tests__/memory-retrieval-hook.test.ts

@@ -55,9 +55,6 @@ mock.module("../daemon/conversation-registry.js", () => ({
 mock.module("../daemon/trust-context.js", () => ({
   resolveTrustClass: () => currentTrustClass,
 }));
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({}) as AssistantConfig,
-}));
 
 // The hook publishes `memory_recalled` (and forwards the sink into
 // `prepareMemory` for `memory_status`) through the shared `broadcastMessage`