@vellumai/assistant 0.6.5 → 0.7.0

package/src/__tests__/runtime-events-sse.test.ts

@@ -29,7 +29,8 @@ mock.module("../config/loader.js", () => ({
 }));
 
 import { getOrCreateConversation } from "../memory/conversation-key-store.js";
-import { getDb, initializeDb } from "../memory/db.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { mintToken } from "../runtime/auth/token-service.js";
@@ -118,25 +119,21 @@ describe("SSE assistant-events endpoint", () => {
     const { conversationId } = getOrCreateConversation("sse-happy-path");
 
     const ac = new AbortController();
-    const req = new Request(
-      "http://localhost/v1/events?conversationKey=sse-happy-path",
-      { signal: ac.signal },
-    );
 
     const { handleSubscribeAssistantEvents } =
       await import("../runtime/routes/events-routes.js");
-    const response = handleSubscribeAssistantEvents(req, new URL(req.url));
-
-    expect(response.status).toBe(200);
-    expect(response.headers.get("content-type")).toContain("text/event-stream");
+    const stream = handleSubscribeAssistantEvents({
+      queryParams: { conversationKey: "sse-happy-path" },
+      abortSignal: ac.signal,
+    });
 
     // start() is called synchronously during ReadableStream construction, so the
     // hub subscription is already registered before we publish.
     const event = buildAssistantEvent("self", { type: "pong" }, conversationId);
     await assistantEventHub.publish(event);
 
-    // Read the first frame directly from the response body stream.
-    const reader = response.body!.getReader();
+    // Read the first frame directly from the stream.
+    const reader = stream.getReader();
 
     // The first chunk is the immediate heartbeat comment enqueued in start().
     const initial = await reader.read();
@@ -160,9 +157,6 @@ describe("SSE assistant-events endpoint", () => {
   test("streams all events when conversationKey is omitted", async () => {
     // Subscribe without a conversationKey — should receive events from any conversation.
     const ac = new AbortController();
-    const req = new Request("http://localhost/v1/events", {
-      signal: ac.signal,
-    });
 
     const { AssistantEventHub } =
       await import("../runtime/assistant-event-hub.js");
@@ -170,14 +164,12 @@ describe("SSE assistant-events endpoint", () => {
 
     const { handleSubscribeAssistantEvents } =
       await import("../runtime/routes/events-routes.js");
-    const response = handleSubscribeAssistantEvents(req, new URL(req.url), {
-      hub: testHub,
-      skipActorVerification: true,
-    });
-
-    expect(response.status).toBe(200);
+    const stream = handleSubscribeAssistantEvents(
+      { abortSignal: ac.signal },
+      { hub: testHub },
+    );
 
-    const reader = response.body!.getReader();
+    const reader = stream.getReader();
 
     // Consume the initial heartbeat.
     const heartbeat = await reader.read();

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

@@ -7,9 +7,47 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-import { getDb, initializeDb } from "../memory/db.js";
-import { scheduleRouteDefinitions } from "../runtime/routes/schedule-routes.js";
-import { createSchedule } from "../schedule/schedule-store.js";
+const getOrCreateCalls: Array<{
+  conversationId: string;
+  options?: Record<string, unknown>;
+}> = [];
+const processCalls: Array<unknown[]> = [];
+let fakeConversation: {
+  taskRunId?: string;
+  processMessage: (...args: unknown[]) => Promise<string>;
+};
+
+function resetConversationMock() {
+  getOrCreateCalls.length = 0;
+  processCalls.length = 0;
+  fakeConversation = {
+    taskRunId: "stale-task-run",
+    async processMessage(...args: unknown[]) {
+      processCalls.push(args);
+      return "message-id";
+    },
+  };
+}
+
+mock.module("../daemon/conversation-store.js", () => ({
+  getOrCreateConversation: async (
+    conversationId: string,
+    options?: Record<string, unknown>,
+  ) => {
+    getOrCreateCalls.push({ conversationId, options });
+    return fakeConversation;
+  },
+}));
+
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { ROUTES } from "../runtime/routes/schedule-routes.js";
+import type { RouteDefinition } from "../runtime/routes/types.js";
+import {
+  createSchedule,
+  createScheduleRun,
+  listSchedules,
+} from "../schedule/schedule-store.js";
 import { scheduleTask } from "../tasks/task-scheduler.js";
 import { createTask } from "../tasks/task-store.js";
 
@@ -25,27 +63,18 @@ function clearTables(): void {
   db.run("DELETE FROM conversations");
 }
 
-function getRunNowHandler(sendMessageDeps: {
-  getOrCreateConversation: (
-    conversationId: string,
-    options?: Record<string, unknown>,
-  ) => Promise<unknown>;
-}) {
-  const route = scheduleRouteDefinitions({
-    sendMessageDeps: sendMessageDeps as never,
-  }).find(
-    (candidate) =>
-      candidate.endpoint === "schedules/:id/run" && candidate.method === "POST",
+function findRoute(endpoint: string, method: string): RouteDefinition {
+  const route = ROUTES.find(
+    (r) => r.endpoint === endpoint && r.method === method,
   );
-  if (!route) {
-    throw new Error("Run-now schedule route not found");
-  }
-  return route.handler;
+  if (!route) throw new Error(`Route ${method} ${endpoint} not found`);
+  return route;
 }
 
 describe("schedule run-now trust propagation", () => {
   beforeEach(() => {
     clearTables();
+    resetConversationMock();
   });
 
   test("manual run-now executes plain schedules with guardian trust", async () => {
@@ -56,40 +85,12 @@ describe("schedule run-now trust propagation", () => {
       syntax: "cron",
     });
 
-    const getOrCreateCalls: Array<{
-      conversationId: string;
-      options?: Record<string, unknown>;
-    }> = [];
-    const processCalls: Array<unknown[]> = [];
-    const fakeConversation: {
-      taskRunId?: string;
-      processMessage: (...args: unknown[]) => Promise<string>;
-    } = {
-      taskRunId: "stale-task-run",
-      async processMessage(...args: unknown[]) {
-        processCalls.push(args);
-        return "message-id";
-      },
-    };
-
-    const handler = getRunNowHandler({
-      getOrCreateConversation: async (conversationId, options) => {
-        getOrCreateCalls.push({ conversationId, options });
-        return fakeConversation;
-      },
-    });
-
-    const response = await handler({
-      req: new Request(`http://localhost/v1/schedules/${schedule.id}/run`, {
-        method: "POST",
-      }),
-      url: new URL(`http://localhost/v1/schedules/${schedule.id}/run`),
-      server: {} as never,
-      authContext: {} as never,
-      params: { id: schedule.id },
-    });
+    const route = findRoute("schedules/:id/run", "POST");
+    const result = (await route.handler({
+      pathParams: { id: schedule.id },
+    })) as { schedules: unknown[] };
 
-    expect(response.status).toBe(200);
+    expect(result.schedules).toBeDefined();
     expect(getOrCreateCalls).toHaveLength(1);
     expect(getOrCreateCalls[0].options?.trustContext).toEqual({
       sourceChannel: "vellum",
@@ -112,16 +113,8 @@ describe("schedule run-now trust propagation", () => {
       cronExpression: "* * * * *",
     });
 
-    const getOrCreateCalls: Array<{
-      conversationId: string;
-      options?: Record<string, unknown>;
-    }> = [];
     const observedTaskRunIds: Array<string | undefined> = [];
-    const processCalls: Array<unknown[]> = [];
-    const fakeConversation: {
-      taskRunId?: string;
-      processMessage: (...args: unknown[]) => Promise<string>;
-    } = {
+    fakeConversation = {
       taskRunId: undefined,
       async processMessage(...args: unknown[]) {
         observedTaskRunIds.push(fakeConversation.taskRunId);
@@ -130,24 +123,12 @@ describe("schedule run-now trust propagation", () => {
       },
     };
 
-    const handler = getRunNowHandler({
-      getOrCreateConversation: async (conversationId, options) => {
-        getOrCreateCalls.push({ conversationId, options });
-        return fakeConversation;
-      },
-    });
-
-    const response = await handler({
-      req: new Request(`http://localhost/v1/schedules/${schedule.id}/run`, {
-        method: "POST",
-      }),
-      url: new URL(`http://localhost/v1/schedules/${schedule.id}/run`),
-      server: {} as never,
-      authContext: {} as never,
-      params: { id: schedule.id },
-    });
+    const route = findRoute("schedules/:id/run", "POST");
+    const result = (await route.handler({
+      pathParams: { id: schedule.id },
+    })) as { schedules: unknown[] };
 
-    expect(response.status).toBe(200);
+    expect(result.schedules).toBeDefined();
     expect(getOrCreateCalls).toHaveLength(1);
     expect(getOrCreateCalls[0].options?.trustContext).toEqual({
       sourceChannel: "vellum",
@@ -160,3 +141,249 @@ describe("schedule run-now trust propagation", () => {
     expect(fakeConversation.taskRunId).toBeUndefined();
   });
 });
+
+// ── GET /schedules — default defer exclusion ──────────────────────────────
+
+describe("GET /schedules — default defer exclusion", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  test("excludes deferred wakes by default", () => {
+    createSchedule({
+      name: "Agent schedule",
+      cronExpression: "* * * * *",
+      message: "hello",
+      syntax: "cron",
+    });
+    const deferred = createSchedule({
+      name: "Deferred wake",
+      cronExpression: "0 9 * * *",
+      message: "wake up",
+      syntax: "cron",
+      createdBy: "defer",
+    });
+
+    const route = findRoute("schedules", "GET");
+    const result = route.handler({}) as {
+      schedules: Array<{ id: string }>;
+    };
+    expect(result.schedules).toHaveLength(1);
+    expect(result.schedules.every((s) => s.id !== deferred.id)).toBe(true);
+  });
+
+  test("returns all schedules when include_all=true", () => {
+    createSchedule({
+      name: "Agent schedule",
+      cronExpression: "* * * * *",
+      message: "hello",
+      syntax: "cron",
+    });
+    createSchedule({
+      name: "Deferred wake",
+      cronExpression: "0 9 * * *",
+      message: "wake up",
+      syntax: "cron",
+      createdBy: "defer",
+    });
+
+    const route = findRoute("schedules", "GET");
+    const result = route.handler({
+      queryParams: { include_all: "true" },
+    }) as { schedules: Array<{ id: string }> };
+    expect(result.schedules).toHaveLength(2);
+  });
+
+  test("mutation responses also exclude deferred wakes", () => {
+    createSchedule({
+      name: "Agent schedule",
+      cronExpression: "* * * * *",
+      message: "hello",
+      syntax: "cron",
+    });
+    createSchedule({
+      name: "Deferred wake",
+      cronExpression: "0 9 * * *",
+      message: "wake up",
+      syntax: "cron",
+      createdBy: "defer",
+    });
+
+    const route = findRoute("schedules/:id/toggle", "POST");
+    const agent = listSchedules().find((j) => j.createdBy === "agent")!;
+    const result = route.handler({
+      pathParams: { id: agent.id },
+      body: { enabled: false },
+    }) as { schedules: Array<{ id: string }> };
+    expect(result.schedules).toHaveLength(1);
+    expect(result.schedules[0].id).toBe(agent.id);
+  });
+});
+
+// ── schedules/:id/runs limit handling ─────────────────────────────────────
+
+describe("schedule runs list — limit handling", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  test("returns with default limit when no param is provided", () => {
+    const job = createSchedule({
+      name: "runs default",
+      cronExpression: "* * * * *",
+      message: "hi",
+      syntax: "cron",
+    });
+    for (let i = 0; i < 3; i += 1) {
+      createScheduleRun(job.id, `conv-${i}`);
+    }
+    const route = findRoute("schedules/:id/runs", "GET");
+    const result = route.handler({ pathParams: { id: job.id } }) as {
+      runs: unknown[];
+    };
+    expect(Array.isArray(result.runs)).toBe(true);
+    expect(result.runs).toHaveLength(3);
+  });
+
+  test("non-numeric limit falls back to default", () => {
+    const job = createSchedule({
+      name: "runs nan",
+      cronExpression: "* * * * *",
+      message: "hi",
+      syntax: "cron",
+    });
+    createScheduleRun(job.id, "conv");
+    const route = findRoute("schedules/:id/runs", "GET");
+    const result = route.handler({
+      pathParams: { id: job.id },
+      queryParams: { limit: "abc" },
+    }) as { runs: unknown[] };
+    expect(Array.isArray(result.runs)).toBe(true);
+  });
+
+  test("negative limit is clamped to 1", () => {
+    const job = createSchedule({
+      name: "runs negative",
+      cronExpression: "* * * * *",
+      message: "hi",
+      syntax: "cron",
+    });
+    for (let i = 0; i < 5; i += 1) {
+      createScheduleRun(job.id, `conv-${i}`);
+    }
+    const route = findRoute("schedules/:id/runs", "GET");
+    const result = route.handler({
+      pathParams: { id: job.id },
+      queryParams: { limit: "-5" },
+    }) as { runs: unknown[] };
+    expect(result.runs).toHaveLength(1);
+  });
+
+  test("zero limit is clamped to 1", () => {
+    const job = createSchedule({
+      name: "runs zero",
+      cronExpression: "* * * * *",
+      message: "hi",
+      syntax: "cron",
+    });
+    for (let i = 0; i < 3; i += 1) {
+      createScheduleRun(job.id, `conv-${i}`);
+    }
+    const route = findRoute("schedules/:id/runs", "GET");
+    const result = route.handler({
+      pathParams: { id: job.id },
+      queryParams: { limit: "0" },
+    }) as { runs: unknown[] };
+    expect(result.runs).toHaveLength(1);
+  });
+
+  test("limit above 100 is capped at 100", () => {
+    const job = createSchedule({
+      name: "runs huge",
+      cronExpression: "* * * * *",
+      message: "hi",
+      syntax: "cron",
+    });
+    for (let i = 0; i < 5; i += 1) {
+      createScheduleRun(job.id, `conv-${i}`);
+    }
+    const route = findRoute("schedules/:id/runs", "GET");
+    const result = route.handler({
+      pathParams: { id: job.id },
+      queryParams: { limit: "9999" },
+    }) as { runs: unknown[] };
+    expect(result.runs).toHaveLength(5);
+  });
+
+  test("fractional limit is floored", () => {
+    const job = createSchedule({
+      name: "runs frac",
+      cronExpression: "* * * * *",
+      message: "hi",
+      syntax: "cron",
+    });
+    for (let i = 0; i < 5; i += 1) {
+      createScheduleRun(job.id, `conv-${i}`);
+    }
+    const route = findRoute("schedules/:id/runs", "GET");
+    const result = route.handler({
+      pathParams: { id: job.id },
+      queryParams: { limit: "2.7" },
+    }) as { runs: unknown[] };
+    expect(result.runs).toHaveLength(2);
+  });
+});
+
+// ── Wake mode support ─────────────────────────────────────────────────────
+
+describe("wake mode in schedule routes", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  test("PATCH accepts 'wake' as a valid mode", () => {
+    const schedule = createSchedule({
+      name: "Wake test",
+      cronExpression: "* * * * *",
+      message: "check deferred",
+      syntax: "cron",
+    });
+
+    const route = findRoute("schedules/:id", "PATCH");
+    const result = route.handler({
+      pathParams: { id: schedule.id },
+      body: { mode: "wake", wakeConversationId: "conv-xyz" },
+    }) as {
+      schedules: Array<{
+        id: string;
+        mode: string;
+        wakeConversationId: string | null;
+      }>;
+    };
+    const updated = result.schedules.find((s) => s.id === schedule.id);
+    expect(updated).toBeDefined();
+    expect(updated!.mode).toBe("wake");
+    expect(updated!.wakeConversationId).toBe("conv-xyz");
+  });
+
+  test("list schedules includes wakeConversationId", () => {
+    createSchedule({
+      name: "Wake schedule",
+      cronExpression: "0 9 * * *",
+      message: "morning wake",
+      syntax: "cron",
+      mode: "wake",
+      wakeConversationId: "conv-abc",
+    });
+
+    const route = findRoute("schedules", "GET");
+    const result = route.handler({}) as {
+      schedules: Array<{ name: string; wakeConversationId: string | null }>;
+    };
+    const wakeSchedule = result.schedules.find(
+      (s) => s.name === "Wake schedule",
+    );
+    expect(wakeSchedule).toBeDefined();
+    expect(wakeSchedule!.wakeConversationId).toBe("conv-abc");
+  });
+});

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

@@ -9,7 +9,8 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (value: string) => value,
 }));
 
-import { getDb, initializeDb } from "../memory/db.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
 import {
   cancelSchedule,
   claimDueSchedules,
@@ -972,6 +973,123 @@ describe("listSchedules filters", () => {
   });
 });
 
+// ── Wake mode ───────────────────────────────────────────────────────
+
+describe("createSchedule (wake mode)", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+  });
+
+  test("creates a wake schedule with wakeConversationId", () => {
+    const job = createSchedule({
+      name: "Wake conv",
+      message: "resume conversation",
+      nextRunAt: Date.now() + 60_000,
+      mode: "wake",
+      wakeConversationId: "conv-123",
+    });
+
+    expect(job.mode).toBe("wake");
+    expect(job.wakeConversationId).toBe("conv-123");
+    expect(job.status).toBe("active");
+
+    const retrieved = getSchedule(job.id);
+    expect(retrieved).not.toBeNull();
+    expect(retrieved!.wakeConversationId).toBe("conv-123");
+  });
+
+  test("throws when creating wake schedule without wakeConversationId", () => {
+    expect(() =>
+      createSchedule({
+        name: "Bad wake",
+        message: "no conv id",
+        nextRunAt: Date.now() + 60_000,
+        mode: "wake",
+      }),
+    ).toThrow("Wake schedules require wakeConversationId");
+  });
+});
+
+// ── listSchedules new filters ───────────────────────────────────────
+
+describe("listSchedules new filters", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+  });
+
+  test("mode filter returns only schedules with matching mode", () => {
+    createSchedule({
+      name: "Execute schedule",
+      message: "execute",
+      nextRunAt: Date.now() + 60_000,
+      mode: "execute",
+    });
+    createSchedule({
+      name: "Wake schedule",
+      message: "wake",
+      nextRunAt: Date.now() + 60_000,
+      mode: "wake",
+      wakeConversationId: "conv-abc",
+    });
+
+    const wakeOnly = listSchedules({ mode: "wake" });
+    expect(wakeOnly.length).toBe(1);
+    expect(wakeOnly[0].name).toBe("Wake schedule");
+    expect(wakeOnly[0].mode).toBe("wake");
+  });
+
+  test("createdBy filter returns only schedules with matching creator", () => {
+    createSchedule({
+      name: "Agent schedule",
+      message: "by agent",
+      nextRunAt: Date.now() + 60_000,
+      createdBy: "agent",
+    });
+    createSchedule({
+      name: "Defer schedule",
+      message: "by defer",
+      nextRunAt: Date.now() + 60_000,
+      createdBy: "defer",
+    });
+
+    const deferOnly = listSchedules({ createdBy: "defer" });
+    expect(deferOnly.length).toBe(1);
+    expect(deferOnly[0].name).toBe("Defer schedule");
+    expect(deferOnly[0].createdBy).toBe("defer");
+  });
+
+  test("conversationId filter returns only wakes targeting that conversation", () => {
+    createSchedule({
+      name: "Wake for conv-123",
+      message: "wake conv-123",
+      nextRunAt: Date.now() + 60_000,
+      mode: "wake",
+      wakeConversationId: "conv-123",
+    });
+    createSchedule({
+      name: "Wake for conv-456",
+      message: "wake conv-456",
+      nextRunAt: Date.now() + 60_000,
+      mode: "wake",
+      wakeConversationId: "conv-456",
+    });
+    createSchedule({
+      name: "Regular schedule",
+      message: "no wake",
+      nextRunAt: Date.now() + 60_000,
+    });
+
+    const conv123Only = listSchedules({ conversationId: "conv-123" });
+    expect(conv123Only.length).toBe(1);
+    expect(conv123Only[0].name).toBe("Wake for conv-123");
+    expect(conv123Only[0].wakeConversationId).toBe("conv-123");
+  });
+});
+
 // ── describeCronExpression ──────────────────────────────────────────
 
 describe("describeCronExpression", () => {

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

@@ -16,7 +16,8 @@ mock.module("../config/loader.js", () => ({
 
 import type { Database } from "bun:sqlite";
 
-import { getDb, initializeDb } from "../memory/db.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
 import { executeScheduleCreate } from "../tools/schedule/create.js";
 import { executeScheduleDelete } from "../tools/schedule/delete.js";
 import { executeScheduleList } from "../tools/schedule/list.js";