@vellumai/assistant 0.7.3 → 0.8.1

package/src/__tests__/scheduler-recurrence.test.ts

@@ -16,6 +16,40 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (value: string) => value,
 }));
 
+// Mock the shared `runBackgroundJob` runner so the scheduler's fresh-bootstrap
+// talk-mode path stays observable in unit tests. Each invocation creates a new
+// conversation row (so downstream lookups reflect reality) and pushes the
+// prompt onto the per-test message log via the supplied `onPrompt` hook.
+let onRunBackgroundJobPrompt:
+  | ((info: { conversationId: string; prompt: string }) => void)
+  | null = null;
+let runBackgroundJobShouldFail = false;
+mock.module("../runtime/background-job-runner.js", () => ({
+  runBackgroundJob: async (opts: { prompt: string; groupId?: string }) => {
+    const { createConversation } =
+      await import("../memory/conversation-crud.js");
+    const conv = createConversation({
+      title: "(test stub)",
+      conversationType: "background",
+      source: "schedule",
+      ...(opts.groupId ? { groupId: opts.groupId } : {}),
+    });
+    onRunBackgroundJobPrompt?.({
+      conversationId: conv.id,
+      prompt: opts.prompt,
+    });
+    if (runBackgroundJobShouldFail) {
+      return {
+        conversationId: conv.id,
+        ok: false,
+        error: new Error("Simulated failure"),
+        errorKind: "exception" as const,
+      };
+    }
+    return { conversationId: conv.id, ok: true };
+  },
+}));
+
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import {
@@ -102,6 +136,8 @@ describe("scheduler RRULE execution", () => {
     db.run("DELETE FROM tasks");
     db.run("DELETE FROM messages");
     db.run("DELETE FROM conversations");
+    onRunBackgroundJobPrompt = null;
+    runBackgroundJobShouldFail = false;
   });
 
   test("RRULE schedule fires and creates cron_runs entry", async () => {
@@ -123,15 +159,18 @@ describe("scheduler RRULE execution", () => {
     forceScheduleDue(schedule.id);
 
     const processedMessages: { conversationId: string; message: string }[] = [];
-    const processMessage = async (conversationId: string, message: string) => {
-      processedMessages.push({ conversationId, message });
+    onRunBackgroundJobPrompt = ({ conversationId, prompt }) => {
+      processedMessages.push({ conversationId, message: prompt });
     };
 
-    const scheduler = startScheduler(processMessage, () => {});
+    const scheduler = startScheduler(
+      async () => {},
+      () => {},
+    );
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
-    // processMessage should have been called with the RRULE message
+    // The runner should have been invoked with the RRULE message
     expect(
       processedMessages.some((m) => m.message === "Hello from RRULE"),
     ).toBe(true);
@@ -227,12 +266,15 @@ describe("scheduler RRULE execution", () => {
     );
 
     const processedMessages: string[] = [];
-    const processMessage = async (_conversationId: string, message: string) => {
-      processedMessages.push(message);
+    onRunBackgroundJobPrompt = ({ prompt }) => {
+      processedMessages.push(prompt);
     };
 
     // First tick: the expired schedule should fire its final due run
-    const scheduler1 = startScheduler(processMessage, () => {});
+    const scheduler1 = startScheduler(
+      async () => {},
+      () => {},
+    );
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler1.stop();
 
@@ -252,7 +294,10 @@ describe("scheduler RRULE execution", () => {
 
     // Second tick: the disabled schedule must NOT fire again
     processedMessages.length = 0;
-    const scheduler2 = startScheduler(processMessage, () => {});
+    const scheduler2 = startScheduler(
+      async () => {},
+      () => {},
+    );
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler2.stop();
 
@@ -278,15 +323,18 @@ describe("scheduler RRULE execution", () => {
     forceScheduleDue(schedule.id);
 
     const processedMessages: { conversationId: string; message: string }[] = [];
-    const processMessage = async (conversationId: string, message: string) => {
-      processedMessages.push({ conversationId, message });
+    onRunBackgroundJobPrompt = ({ conversationId, prompt }) => {
+      processedMessages.push({ conversationId, message: prompt });
     };
 
-    const scheduler = startScheduler(processMessage, () => {});
+    const scheduler = startScheduler(
+      async () => {},
+      () => {},
+    );
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
-    // processMessage should have been called with the cron message
+    // The runner should have been invoked with the cron message
     expect(processedMessages.some((m) => m.message === "Cron message")).toBe(
       true,
     );
@@ -337,12 +385,10 @@ describe("scheduler RRULE execution", () => {
     // Force the schedule to be due
     forceScheduleDue(schedule.id);
 
-    const processedMessages: string[] = [];
-    const processMessage = async (_conversationId: string, message: string) => {
-      processedMessages.push(message);
-    };
-
-    const scheduler = startScheduler(processMessage, () => {});
+    const scheduler = startScheduler(
+      async () => {},
+      () => {},
+    );
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -387,11 +433,14 @@ describe("scheduler RRULE execution", () => {
     forceScheduleDue(schedule.id);
 
     const processedMessages: string[] = [];
-    const processMessage = async (_conversationId: string, message: string) => {
-      processedMessages.push(message);
+    onRunBackgroundJobPrompt = ({ prompt }) => {
+      processedMessages.push(prompt);
     };
 
-    const scheduler = startScheduler(processMessage, () => {});
+    const scheduler = startScheduler(
+      async () => {},
+      () => {},
+    );
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -463,14 +512,14 @@ describe("scheduler RRULE execution", () => {
       forceScheduleDue(schedule.id);
 
       const processedMessages: string[] = [];
-      const processMessage = async (
-        _conversationId: string,
-        message: string,
-      ) => {
-        processedMessages.push(message);
+      onRunBackgroundJobPrompt = ({ prompt }) => {
+        processedMessages.push(prompt);
       };
 
-      const scheduler = startScheduler(processMessage, () => {});
+      const scheduler = startScheduler(
+        async () => {},
+        () => {},
+      );
       await new Promise((resolve) => setTimeout(resolve, 500));
       scheduler.stop();
 
@@ -536,11 +585,14 @@ describe("scheduler RRULE execution", () => {
     expect(getSchedule(schedule.id)!.status).toBe("active");
 
     const processedMessages: { conversationId: string; message: string }[] = [];
-    const processMessage = async (conversationId: string, message: string) => {
-      processedMessages.push({ conversationId, message });
+    onRunBackgroundJobPrompt = ({ conversationId, prompt }) => {
+      processedMessages.push({ conversationId, message: prompt });
     };
 
-    const scheduler = startScheduler(processMessage, () => {});
+    const scheduler = startScheduler(
+      async () => {},
+      () => {},
+    );
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -617,11 +669,12 @@ describe("scheduler RRULE execution", () => {
 
     expect(getSchedule(schedule.id)!.status).toBe("active");
 
-    const processMessage = async () => {
-      throw new Error("Simulated failure");
-    };
+    runBackgroundJobShouldFail = true;
 
-    const scheduler = startScheduler(processMessage, () => {});
+    const scheduler = startScheduler(
+      async () => {},
+      () => {},
+    );
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 

package/src/__tests__/scheduler-reuse-conversation.test.ts

@@ -16,6 +16,63 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (value: string) => value,
 }));
 
+// Mock the shared `runBackgroundJob` runner so the scheduler's fresh-bootstrap
+// talk-mode path stays observable in unit tests. Each invocation creates a new
+// conversation row (so `getLastScheduleConversationId` lookups reflect reality)
+// and pushes onto a shared log mirrored by the per-test `processMessage`
+// callback used for the reuse path — that way assertions don't have to know
+// which path a given run took.
+const processedMessages: { conversationId: string; message: string }[] = [];
+const runBackgroundJobOptions: Array<{
+  conversationType?: string;
+  scheduleJobId?: string;
+  groupId?: string;
+  suppressFailureNotifications?: boolean;
+  onConversationCreated?: (id: string) => void;
+}> = [];
+let runBackgroundJobShouldFail = false;
+mock.module("../runtime/background-job-runner.js", () => ({
+  runBackgroundJob: async (opts: {
+    prompt: string;
+    groupId?: string;
+    conversationType?: "background" | "scheduled";
+    scheduleJobId?: string;
+    suppressFailureNotifications?: boolean;
+    onConversationCreated?: (id: string) => void;
+  }) => {
+    const { createConversation } =
+      await import("../memory/conversation-crud.js");
+    const conv = createConversation({
+      title: "(test stub)",
+      conversationType: opts.conversationType ?? "background",
+      source: "schedule",
+      ...(opts.groupId ? { groupId: opts.groupId } : {}),
+      ...(opts.scheduleJobId ? { scheduleJobId: opts.scheduleJobId } : {}),
+    });
+    runBackgroundJobOptions.push({
+      conversationType: opts.conversationType,
+      scheduleJobId: opts.scheduleJobId,
+      groupId: opts.groupId,
+      suppressFailureNotifications: opts.suppressFailureNotifications,
+      onConversationCreated: opts.onConversationCreated,
+    });
+    // Mirror the real runner's contract: fire the SSE callback synchronously
+    // BEFORE the job's processMessage finishes, with the bootstrap-returned
+    // conversation id.
+    opts.onConversationCreated?.(conv.id);
+    processedMessages.push({ conversationId: conv.id, message: opts.prompt });
+    if (runBackgroundJobShouldFail) {
+      return {
+        conversationId: conv.id,
+        ok: false,
+        error: new Error("Simulated failure"),
+        errorKind: "exception" as const,
+      };
+    }
+    return { conversationId: conv.id, ok: true };
+  },
+}));
+
 import { deleteConversation } from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
@@ -77,6 +134,9 @@ describe("scheduler conversation reuse", () => {
     db.run("DELETE FROM tasks");
     db.run("DELETE FROM messages");
     db.run("DELETE FROM conversations");
+    processedMessages.length = 0;
+    runBackgroundJobOptions.length = 0;
+    runBackgroundJobShouldFail = false;
   });
 
   test("recurring schedule with reuseConversation=true reuses conversation across runs", async () => {
@@ -99,7 +159,6 @@ describe("scheduler conversation reuse", () => {
     // WHEN the schedule fires for the first time
     forceScheduleDue(schedule.id);
 
-    const processedMessages: { conversationId: string; message: string }[] = [];
     const processMessage = async (conversationId: string, message: string) => {
       processedMessages.push({ conversationId, message });
     };
@@ -156,7 +215,6 @@ describe("scheduler conversation reuse", () => {
     // WHEN the schedule fires for the first time
     forceScheduleDue(schedule.id);
 
-    const processedMessages: { conversationId: string; message: string }[] = [];
     const processMessage = async (conversationId: string, message: string) => {
       processedMessages.push({ conversationId, message });
     };
@@ -200,7 +258,6 @@ describe("scheduler conversation reuse", () => {
 
     forceScheduleDue(schedule.id);
 
-    const processedMessages: { conversationId: string; message: string }[] = [];
     const processMessage = async (conversationId: string, message: string) => {
       processedMessages.push({ conversationId, message });
     };
@@ -245,7 +302,6 @@ describe("scheduler conversation reuse", () => {
     });
 
     // WHEN the schedule fires
-    const processedMessages: { conversationId: string; message: string }[] = [];
     const processMessage = async (conversationId: string, message: string) => {
       processedMessages.push({ conversationId, message });
     };
@@ -285,7 +341,6 @@ describe("scheduler conversation reuse", () => {
     forceScheduleDue(schedule.id);
 
     let shouldFail = false;
-    const processedMessages: { conversationId: string; message: string }[] = [];
     const processMessage = async (conversationId: string, message: string) => {
       processedMessages.push({ conversationId, message });
       if (shouldFail) throw new Error("Simulated failure");
@@ -327,3 +382,104 @@ describe("scheduler conversation reuse", () => {
     expect(processedMessages[0].conversationId).toBe(successConversationId);
   });
 });
+
+describe("scheduler talk-mode runner option propagation", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+    db.run("DELETE FROM messages");
+    db.run("DELETE FROM conversations");
+    processedMessages.length = 0;
+    runBackgroundJobOptions.length = 0;
+    runBackgroundJobShouldFail = false;
+  });
+
+  test("talk-mode propagates conversationType=scheduled, scheduleJobId, and quiet=>suppressFailureNotifications", async () => {
+    const rruleExpr = buildEveryMinuteRrule();
+    const schedule = createSchedule({
+      name: "Quiet Talk Mode",
+      cronExpression: rruleExpr,
+      message: "Background work",
+      syntax: "rrule",
+      expression: rruleExpr,
+      quiet: true,
+    });
+    forceScheduleDue(schedule.id);
+
+    const processMessage = async () => {};
+    const scheduler = startScheduler(processMessage, () => {});
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler.stop();
+
+    expect(runBackgroundJobOptions).toHaveLength(1);
+    const opts = runBackgroundJobOptions[0]!;
+    expect(opts.conversationType).toBe("scheduled");
+    expect(opts.scheduleJobId).toBe(schedule.id);
+    expect(opts.groupId).toBe("system:scheduled");
+    expect(opts.suppressFailureNotifications).toBe(true);
+  });
+
+  test("talk-mode without quiet leaves suppressFailureNotifications=false", async () => {
+    const rruleExpr = buildEveryMinuteRrule();
+    const schedule = createSchedule({
+      name: "Loud Talk Mode",
+      cronExpression: rruleExpr,
+      message: "Background work",
+      syntax: "rrule",
+      expression: rruleExpr,
+      // quiet defaults to false
+    });
+    forceScheduleDue(schedule.id);
+
+    const processMessage = async () => {};
+    const scheduler = startScheduler(processMessage, () => {});
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler.stop();
+
+    expect(runBackgroundJobOptions).toHaveLength(1);
+    expect(runBackgroundJobOptions[0]!.suppressFailureNotifications).toBe(
+      false,
+    );
+  });
+
+  test("talk-mode fires onScheduleConversationCreated synchronously via runner callback (BEFORE the runner returns)", async () => {
+    const rruleExpr = buildEveryMinuteRrule();
+    const schedule = createSchedule({
+      name: "SSE timing",
+      cronExpression: rruleExpr,
+      message: "x",
+      syntax: "rrule",
+      expression: rruleExpr,
+    });
+    forceScheduleDue(schedule.id);
+
+    const sseCalls: Array<{
+      conversationId: string;
+      scheduleJobId: string;
+      title: string;
+    }> = [];
+    const processMessage = async () => {};
+    const scheduler = startScheduler(
+      processMessage,
+      () => {},
+      undefined,
+      (info) => sseCalls.push(info),
+    );
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler.stop();
+
+    expect(sseCalls).toHaveLength(1);
+    expect(sseCalls[0]).toMatchObject({
+      scheduleJobId: schedule.id,
+      title: "SSE timing",
+    });
+    // The mock runner fires the callback synchronously after creating the
+    // conversation row, so the conversationId must be the same id the runner
+    // ultimately reports.
+    expect(processedMessages).toHaveLength(1);
+    expect(sseCalls[0].conversationId).toBe(
+      processedMessages[0].conversationId,
+    );
+  });
+});

package/src/__tests__/scheduler-wake.test.ts

@@ -27,11 +27,6 @@ mock.module("../runtime/agent-wake.js", () => ({
   wakeAgentForOpportunity: mockWakeAgentForOpportunity,
 }));
 
-const mockEmitFeedEvent = mock(() => Promise.resolve());
-mock.module("../home/emit-feed-event.js", () => ({
-  emitFeedEvent: mockEmitFeedEvent,
-}));
-
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { createSchedule } from "../schedule/schedule-store.js";
@@ -82,7 +77,6 @@ describe("scheduler wake mode", () => {
     db.run("DELETE FROM messages");
     db.run("DELETE FROM conversations");
     mockWakeAgentForOpportunity.mockClear();
-    mockEmitFeedEvent.mockClear();
   });
 
   test("wake schedule calls wakeAgentForOpportunity with correct args", async () => {
@@ -208,63 +202,6 @@ describe("scheduler wake mode", () => {
     expect(row?.status).toBe("active");
   });
 
-  test("quiet: true suppresses feed event", async () => {
-    // GIVEN a one-shot wake schedule with quiet: true
-    const schedule = createSchedule({
-      name: "Wake Quiet",
-      message: "Quiet wake",
-      mode: "wake",
-      wakeConversationId: "conv-quiet",
-      quiet: true,
-      nextRunAt: Date.now() - 1000,
-    });
-    forceScheduleDue(schedule.id);
-
-    // WHEN the scheduler fires
-    const scheduler = startScheduler(
-      mock(() => Promise.resolve()),
-      () => {},
-    );
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
-
-    // THEN wakeAgentForOpportunity is called
-    expect(mockWakeAgentForOpportunity).toHaveBeenCalledTimes(1);
-
-    // AND no feed event is emitted
-    expect(mockEmitFeedEvent).not.toHaveBeenCalled();
-  });
-
-  test("quiet: false emits feed event on success", async () => {
-    // GIVEN a one-shot wake schedule with quiet: false (default)
-    const schedule = createSchedule({
-      name: "Wake Loud",
-      message: "Loud wake",
-      mode: "wake",
-      wakeConversationId: "conv-loud",
-      nextRunAt: Date.now() - 1000,
-    });
-    forceScheduleDue(schedule.id);
-
-    // WHEN the scheduler fires
-    const scheduler = startScheduler(
-      mock(() => Promise.resolve()),
-      () => {},
-    );
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    scheduler.stop();
-
-    // THEN a feed event IS emitted
-    expect(mockEmitFeedEvent).toHaveBeenCalledTimes(1);
-    expect(mockEmitFeedEvent).toHaveBeenCalledWith(
-      expect.objectContaining({
-        source: "assistant",
-        title: "Wake Loud",
-        summary: "Deferred wake fired.",
-      }),
-    );
-  });
-
   test("retries wake when wakeAgentForOpportunity returns timeout", async () => {
     // GIVEN wakeAgentForOpportunity returns timeout on first call, then succeeds
     mockWakeAgentForOpportunity

package/src/__tests__/secret-allowlist.test.ts

@@ -135,6 +135,7 @@ describe("secret-allowlist", () => {
 
   // -----------------------------------------------------------------------
   // Integration with scanText
+  // AKIAIOSFODNN7* keys below are fake — based on the AWS docs example prefix, not real credentials.
   // -----------------------------------------------------------------------
   test("[experimental] allowlisted values are suppressed by scanText", () => {
     const awsKey = "AKIAIOSFODNN7REALKEY";

package/src/__tests__/secret-prompt-log-hygiene.test.ts

@@ -39,15 +39,17 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
 }));
 
 // Stub pendingInteractions — SecretPrompter registers/resolves there now
+// Use a real Map so SecretPrompter can store and retrieve promptResolve/promptReject callbacks.
+const _piStore = new Map<string, object>();
 mock.module("../runtime/pending-interactions.js", () => ({
-  register: () => {},
-  resolve: () => undefined,
-  get: () => undefined,
-  getAll: () => [],
+  register: (id: string, entry: object) => _piStore.set(id, entry),
+  resolve: (id: string) => { const e = _piStore.get(id); _piStore.delete(id); return e; },
+  get: (id: string) => _piStore.get(id),
+  getAll: () => [..._piStore.values()],
   getByConversation: () => [],
   getByKind: () => [],
   removeByConversation: () => {},
-  clear: () => {},
+  clear: () => _piStore.clear(),
 }));
 
 // Use a tiny timeout so the setTimeout branch fires quickly in tests

package/src/__tests__/secret-prompter-channel-fallback.test.ts

@@ -38,15 +38,17 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: (msg: ServerMessage) => broadcastMessages.push(msg),
 }));
 
+// Use a real Map so SecretPrompter can store and retrieve promptResolve/promptReject callbacks.
+const _piStore = new Map<string, object>();
 mock.module("../runtime/pending-interactions.js", () => ({
-  register: () => {},
-  resolve: () => undefined,
-  get: () => undefined,
-  getAll: () => [],
+  register: (id: string, entry: object) => _piStore.set(id, entry),
+  resolve: (id: string) => { const e = _piStore.get(id); _piStore.delete(id); return e; },
+  get: (id: string) => _piStore.get(id),
+  getAll: () => [..._piStore.values()],
   getByConversation: () => [],
   getByKind: () => [],
   removeByConversation: () => {},
-  clear: () => {},
+  clear: () => _piStore.clear(),
 }));
 
 const { SecretPrompter } = await import("../permissions/secret-prompter.js");

package/src/__tests__/secret-response-routing.test.ts

@@ -11,15 +11,17 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: (msg: ServerMessage) => broadcastedMessages.push(msg),
 }));
 
+// Use a real Map so SecretPrompter can store and retrieve promptResolve/promptReject callbacks.
+const _piStore = new Map<string, object>();
 mock.module("../runtime/pending-interactions.js", () => ({
-  register: () => {},
-  resolve: () => undefined,
-  get: () => undefined,
-  getAll: () => [],
+  register: (id: string, entry: object) => _piStore.set(id, entry),
+  resolve: (id: string) => { const e = _piStore.get(id); _piStore.delete(id); return e; },
+  get: (id: string) => _piStore.get(id),
+  getAll: () => [..._piStore.values()],
   getByConversation: () => [],
   getByKind: () => [],
   removeByConversation: () => {},
-  clear: () => {},
+  clear: () => _piStore.clear(),
 }));
 
 const { SecretPrompter } = await import("../permissions/secret-prompter.js");

package/src/__tests__/secret-routes-managed-proxy.test.ts

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { LLMSchema } from "../config/schemas/llm.js";
 import { credentialKey } from "../security/credential-key.js";
 
 let lastGeminiConstructorOpts: Record<string, unknown> | null = null;
@@ -15,11 +16,11 @@ const MANAGED_PROVIDERS = ["anthropic", "openai", "gemini"] as const;
 
 let platformBaseUrlOverride: string | undefined;
 
+const baseLlm = LLMSchema.parse({});
+
 const mockConfig = {
   services: {
-    inference: {
-      mode: "your-own" as const,
-    },
+    inference: {},
     "image-generation": {
       mode: "your-own" as const,
       provider: "gemini",
@@ -30,7 +31,14 @@ const mockConfig = {
       provider: "inference-provider-native",
     },
   },
-  llm: { default: { provider: "anthropic", model: "test-model" } },
+  llm: {
+    ...baseLlm,
+    default: {
+      ...baseLlm.default,
+      provider: "anthropic" as const,
+      model: "test-model",
+    },
+  },
 };
 
 mock.module("@google/genai", () => ({