@vellumai/assistant 0.10.3-dev.202606301109.f6f8c0c → 0.10.3-dev.202606301343.ebf8f0b

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.3-dev.202606301109.f6f8c0c",
+  "version": "0.10.3-dev.202606301343.ebf8f0b",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/credential-security-invariants.test.ts

@@ -221,13 +221,11 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "runtime/routes/credential-routes.ts", // CLI credential management routes (CLI-migrated to IPC)
       "runtime/routes/sanity-routes.ts", // Sanity connect/discover routes (reads stored api_token from credential store)
       "runtime/routes/platform-routes.ts", // CLI platform connect/disconnect/status routes (CLI-migrated to IPC)
-      "ipc/skill-routes/providers.ts", // host.providers.secureKeys.getProviderKey IPC route (out-of-process SkillHost companion)
       "inbound/platform-callback-registration.ts", // managed credential lookup for platform base URL, assistant ID, and API key
       "tts/providers/elevenlabs-provider.ts", // ElevenLabs TTS API key lookup
       "tts/providers/deepgram-provider.ts", // Deepgram TTS API key lookup
       "tts/providers/xai-provider.ts", // xAI TTS API key lookup
       "credential-health/credential-health-service.ts", // credential health check reads access tokens for liveness pings
-      "ipc/skill-routes/providers.ts", // skill IPC route exposes provider key lookup to hosted skills
       "runtime/routes/avatar-routes.ts", // avatar generate route reads platform_base_url from credential store
       "cli/commands/keys.ts", // CLI provider key management
       "cli/commands/oauth/connect.ts", // CLI OAuth connect stored-secret verification

package/src/__tests__/schedule-retry.test.ts

@@ -43,6 +43,27 @@ mock.module("../runtime/background-job-runner.js", () => ({
   },
 }));
 
+// The scheduler's conversation-reuse path dispatches through `processMessage`;
+// route it to the same per-test delegate the runner mock uses.
+let processMessageImpl: (
+  conversationId: string,
+  message: string,
+) => Promise<unknown> = async () => {};
+mock.module("../daemon/process-message.js", () => ({
+  processMessage: (conversationId: string, message: string) =>
+    processMessageImpl(conversationId, message),
+}));
+
+// Notify-mode firings dispatch through `emitNotificationSignal`; a per-test
+// delegate lets a scenario make the notification throw to drive failure paths.
+let emitNotificationSignalImpl: (
+  payload: unknown,
+) => Promise<unknown> = async () => {};
+mock.module("../notifications/emit-signal.js", () => ({
+  emitNotificationSignal: (payload: unknown) =>
+    emitNotificationSignalImpl(payload),
+}));
+
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { applyRetryDecision, decideRetry } from "../schedule/retry-policy.js";
@@ -62,24 +83,23 @@ import { startScheduler as startSchedulerReal } from "../schedule/scheduler.js";
 import type { ScheduleMessageProcessor } from "../schedule/scheduler-types.js";
 
 /**
- * Wrap `startScheduler` so the same `processMessage` the scheduler holds for
- * its conversation-reuse path is also handed to the mocked
- * `runBackgroundJob` for the fresh-bootstrap path. The two paths in scheduler
- * production code dispatch through different mechanisms; tests exercise both
- * deterministically through this single callback.
+ * Wrap `startScheduler` so a single per-test `processMessage` callback drives
+ * both scheduler dispatch paths: the conversation-reuse path (which calls the
+ * mocked `daemon/process-message`) and the fresh-bootstrap path (which calls
+ * the mocked `runBackgroundJob`). Tests exercise both deterministically through
+ * this one callback.
  */
 function startScheduler(
   processMessage: ScheduleMessageProcessor,
-  notifyScheduleOneShot: Parameters<typeof startSchedulerReal>[1],
-  options?: Parameters<typeof startSchedulerReal>[2],
+  _notifyScheduleOneShot?: unknown,
+  _options?: unknown,
 ): SchedulerHandle {
-  injectedProcessMessageForRunner = async (
-    conversationId: string,
-    message: string,
-  ) => {
+  const dispatch = async (conversationId: string, message: string) => {
     await processMessage(conversationId, message, { trustClass: "guardian" });
   };
-  return startSchedulerReal(processMessage, notifyScheduleOneShot, options);
+  processMessageImpl = dispatch;
+  injectedProcessMessageForRunner = dispatch;
+  return startSchedulerReal();
 }
 
 await initializeDb();
@@ -102,6 +122,7 @@ function forceScheduleDue(scheduleId: string): void {
 
 describe("schedule retry store", () => {
   beforeEach(() => {
+    emitNotificationSignalImpl = async () => {};
     const db = getDb();
     db.run("DELETE FROM cron_runs");
     db.run("DELETE FROM cron_jobs");
@@ -203,6 +224,7 @@ describe("scheduler retry integration", () => {
   let scheduler: SchedulerHandle;
 
   beforeEach(() => {
+    emitNotificationSignalImpl = async () => {};
     const db = getDb();
     db.run("DELETE FROM cron_runs");
     db.run("DELETE FROM cron_jobs");
@@ -389,11 +411,11 @@ describe("scheduler retry integration", () => {
       maxRetries: 2,
     });
 
-    const notifyScheduleOneShot = async () => {
+    emitNotificationSignalImpl = async () => {
       throw new Error("notify failed");
     };
 
-    scheduler = startScheduler(async () => {}, notifyScheduleOneShot);
+    scheduler = startScheduler(async () => {});
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -439,6 +461,7 @@ describe("scheduler retry integration", () => {
 
 describe("crash recovery", () => {
   beforeEach(() => {
+    emitNotificationSignalImpl = async () => {};
     const db = getDb();
     db.run("DELETE FROM cron_runs");
     db.run("DELETE FROM cron_jobs");
@@ -574,6 +597,7 @@ describe("scheduler-recovery equivalence", () => {
   let scheduler: SchedulerHandle;
 
   beforeEach(() => {
+    emitNotificationSignalImpl = async () => {};
     const db = getDb();
     db.run("DELETE FROM cron_runs");
     db.run("DELETE FROM cron_jobs");

package/src/__tests__/scheduler-disk-pressure.test.ts

@@ -89,6 +89,18 @@ mock.module("../daemon/disk-pressure-background-gate.js", () => ({
   shouldLogDiskPressureBackgroundSkip: () => true,
 }));
 
+const mockProcessMessage = mock((..._args: unknown[]) => Promise.resolve());
+mock.module("../daemon/process-message.js", () => ({
+  processMessage: mockProcessMessage,
+}));
+
+const mockEmitNotificationSignal = mock((..._args: unknown[]) =>
+  Promise.resolve(),
+);
+mock.module("../notifications/emit-signal.js", () => ({
+  emitNotificationSignal: mockEmitNotificationSignal,
+}));
+
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { createSchedule } from "../schedule/schedule-store.js";
@@ -104,6 +116,8 @@ function rawDb(): import("bun:sqlite").Database {
 describe("scheduler disk pressure gate", () => {
   beforeEach(() => {
     locked = true;
+    mockProcessMessage.mockClear();
+    mockEmitNotificationSignal.mockClear();
     const db = getDb();
     db.run("DELETE FROM cron_runs");
     db.run("DELETE FROM cron_jobs");
@@ -122,14 +136,11 @@ describe("scheduler disk pressure gate", () => {
       nextRunAt: dueAt,
     });
 
-    const processMessage = mock(() => Promise.resolve());
-    const notify = mock(() => Promise.resolve());
-
-    const processed = await runScheduleOnce(processMessage, notify);
+    const processed = await runScheduleOnce();
 
     expect(processed).toBe(0);
-    expect(processMessage).not.toHaveBeenCalled();
-    expect(notify).not.toHaveBeenCalled();
+    expect(mockProcessMessage).not.toHaveBeenCalled();
+    expect(mockEmitNotificationSignal).not.toHaveBeenCalled();
 
     const row = rawDb()
       .query("SELECT status, next_run_at FROM cron_jobs WHERE id = ?")

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

@@ -50,6 +50,25 @@ mock.module("../runtime/background-job-runner.js", () => ({
   },
 }));
 
+// The scheduler dispatches reuse/task-path messages through `processMessage`;
+// route them to a per-test delegate so tests can capture those calls.
+let processMessageImpl: (
+  conversationId: string,
+  message: string,
+) => Promise<void> = async () => {};
+mock.module("../daemon/process-message.js", () => ({
+  processMessage: (conversationId: string, message: string) =>
+    processMessageImpl(conversationId, message),
+}));
+
+// Notify-mode firings go through `emitNotificationSignal`; capture them.
+const notifySignalCalls: Array<Record<string, unknown>> = [];
+mock.module("../notifications/emit-signal.js", () => ({
+  emitNotificationSignal: async (payload: Record<string, unknown>) => {
+    notifySignalCalls.push(payload);
+  },
+}));
+
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import {
@@ -138,6 +157,8 @@ describe("scheduler RRULE execution", () => {
     db.run("DELETE FROM conversations");
     onRunBackgroundJobPrompt = null;
     runBackgroundJobShouldFail = false;
+    processMessageImpl = async () => {};
+    notifySignalCalls.length = 0;
   });
 
   test("RRULE schedule fires and creates cron_runs entry", async () => {
@@ -163,10 +184,7 @@ describe("scheduler RRULE execution", () => {
       processedMessages.push({ conversationId, message: prompt });
     };
 
-    const scheduler = startScheduler(
-      async () => {},
-      () => {},
-    );
+    const scheduler = startScheduler();
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -201,12 +219,12 @@ describe("scheduler RRULE execution", () => {
     const directCalls: { conversationId: string; message: string }[] = [];
     let onMessage: (() => void) | undefined;
     const messageReceived = new Promise<void>((r) => (onMessage = r));
-    const processMessage = async (conversationId: string, message: string) => {
+    processMessageImpl = async (conversationId, message) => {
       directCalls.push({ conversationId, message });
       onMessage?.();
     };
 
-    const scheduler = startScheduler(processMessage, () => {});
+    const scheduler = startScheduler();
     // The run_task path involves a dynamic import which can take >50ms in CI,
     // exceeding the patched setTimeout delay. Await the actual callback instead
     // of relying on a fixed timeout.
@@ -271,10 +289,7 @@ describe("scheduler RRULE execution", () => {
     };
 
     // First tick: the expired schedule should fire its final due run
-    const scheduler1 = startScheduler(
-      async () => {},
-      () => {},
-    );
+    const scheduler1 = startScheduler();
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler1.stop();
 
@@ -294,10 +309,7 @@ describe("scheduler RRULE execution", () => {
 
     // Second tick: the disabled schedule must NOT fire again
     processedMessages.length = 0;
-    const scheduler2 = startScheduler(
-      async () => {},
-      () => {},
-    );
+    const scheduler2 = startScheduler();
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler2.stop();
 
@@ -327,10 +339,7 @@ describe("scheduler RRULE execution", () => {
       processedMessages.push({ conversationId, message: prompt });
     };
 
-    const scheduler = startScheduler(
-      async () => {},
-      () => {},
-    );
+    const scheduler = startScheduler();
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -385,10 +394,7 @@ describe("scheduler RRULE execution", () => {
     // Force the schedule to be due
     forceScheduleDue(schedule.id);
 
-    const scheduler = startScheduler(
-      async () => {},
-      () => {},
-    );
+    const scheduler = startScheduler();
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -437,10 +443,7 @@ describe("scheduler RRULE execution", () => {
       processedMessages.push(prompt);
     };
 
-    const scheduler = startScheduler(
-      async () => {},
-      () => {},
-    );
+    const scheduler = startScheduler();
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -516,10 +519,7 @@ describe("scheduler RRULE execution", () => {
         processedMessages.push(prompt);
       };
 
-      const scheduler = startScheduler(
-        async () => {},
-        () => {},
-      );
+      const scheduler = startScheduler();
       await new Promise((resolve) => setTimeout(resolve, 500));
       scheduler.stop();
 
@@ -557,8 +557,7 @@ describe("scheduler RRULE execution", () => {
     forceScheduleDue(schedule.id);
     const forcedDueAt = getSchedule(schedule.id)!.nextRunAt;
 
-    const processMessage = async () => {};
-    const scheduler = startScheduler(processMessage, () => {});
+    const scheduler = startScheduler();
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -589,10 +588,7 @@ describe("scheduler RRULE execution", () => {
       processedMessages.push({ conversationId, message: prompt });
     };
 
-    const scheduler = startScheduler(
-      async () => {},
-      () => {},
-    );
+    const scheduler = startScheduler();
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -623,32 +619,19 @@ describe("scheduler RRULE execution", () => {
 
     expect(getSchedule(schedule.id)!.status).toBe("active");
 
-    const notifyCalls: Array<{
-      id: string;
-      label: string;
-      message: string;
-      routingIntent: string;
-      routingHints: Record<string, unknown>;
-    }> = [];
-    const notifyScheduleOneShot = (payload: {
-      id: string;
-      label: string;
-      message: string;
-      routingIntent: string;
-      routingHints: Record<string, unknown>;
-    }) => {
-      notifyCalls.push(payload);
-    };
-
-    const scheduler = startScheduler(async () => {}, notifyScheduleOneShot);
+    const scheduler = startScheduler();
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
-    expect(notifyCalls).toHaveLength(1);
-    expect(notifyCalls[0]).toEqual({
-      id: schedule.id,
-      label: "One-shot notify",
-      message: "Notify about this",
+    expect(notifySignalCalls).toHaveLength(1);
+    expect(notifySignalCalls[0]).toMatchObject({
+      sourceEventName: "schedule.notify",
+      sourceContextId: schedule.id,
+      contextPayload: {
+        scheduleId: schedule.id,
+        label: "One-shot notify",
+        message: "Notify about this",
+      },
       routingIntent: "multi_channel",
       routingHints: { channel: "slack" },
     });
@@ -671,10 +654,7 @@ describe("scheduler RRULE execution", () => {
 
     runBackgroundJobShouldFail = true;
 
-    const scheduler = startScheduler(
-      async () => {},
-      () => {},
-    );
+    const scheduler = startScheduler();
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
@@ -699,32 +679,19 @@ describe("scheduler RRULE execution", () => {
 
     forceScheduleDue(schedule.id);
 
-    const notifyCalls: Array<{
-      id: string;
-      label: string;
-      message: string;
-      routingIntent: string;
-      routingHints: Record<string, unknown>;
-    }> = [];
-    const notifyScheduleOneShot = (payload: {
-      id: string;
-      label: string;
-      message: string;
-      routingIntent: string;
-      routingHints: Record<string, unknown>;
-    }) => {
-      notifyCalls.push(payload);
-    };
-
-    const scheduler = startScheduler(async () => {}, notifyScheduleOneShot);
+    const scheduler = startScheduler();
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
-    expect(notifyCalls).toHaveLength(1);
-    expect(notifyCalls[0]).toEqual({
-      id: schedule.id,
-      label: "Recurring notify",
-      message: "Recurring notification",
+    expect(notifySignalCalls).toHaveLength(1);
+    expect(notifySignalCalls[0]).toMatchObject({
+      sourceEventName: "schedule.notify",
+      sourceContextId: schedule.id,
+      contextPayload: {
+        scheduleId: schedule.id,
+        label: "Recurring notify",
+        message: "Recurring notification",
+      },
       routingIntent: "single_channel",
       routingHints: { preferred: "email" },
     });
@@ -752,30 +719,13 @@ describe("scheduler RRULE execution", () => {
       },
     });
 
-    const notifyCalls: Array<{
-      id: string;
-      label: string;
-      message: string;
-      routingIntent: string;
-      routingHints: Record<string, unknown>;
-    }> = [];
-    const notifyScheduleOneShot = (payload: {
-      id: string;
-      label: string;
-      message: string;
-      routingIntent: string;
-      routingHints: Record<string, unknown>;
-    }) => {
-      notifyCalls.push(payload);
-    };
-
-    const scheduler = startScheduler(async () => {}, notifyScheduleOneShot);
+    const scheduler = startScheduler();
     await new Promise((resolve) => setTimeout(resolve, 500));
     scheduler.stop();
 
-    expect(notifyCalls).toHaveLength(1);
-    expect(notifyCalls[0].routingIntent).toBe("all_channels");
-    expect(notifyCalls[0].routingHints).toEqual({
+    expect(notifySignalCalls).toHaveLength(1);
+    expect(notifySignalCalls[0].routingIntent).toBe("all_channels");
+    expect(notifySignalCalls[0].routingHints).toEqual({
       requestedByUser: true,
       channelMentions: ["telegram", "slack"],
       priority: "high",