@vellumai/assistant 0.8.6 → 0.8.7

package/src/__tests__/retry-thinking-tool-choice.test.ts

@@ -30,7 +30,6 @@ import type {
   Provider,
   ProviderResponse,
   SendMessageOptions,
-  ToolDefinition,
 } from "../providers/types.js";
 
 function setLlmConfig(raw: unknown): void {
@@ -50,8 +49,6 @@ function makePipeline(providerName: string): {
     name: providerName,
     async sendMessage(
       _messages: Message[],
-      _tools?: ToolDefinition[],
-      _systemPrompt?: string,
       options?: SendMessageOptions,
     ): Promise<ProviderResponse> {
       captured = options?.config as Record<string, unknown> | undefined;
@@ -84,7 +81,7 @@ describe("retry normalization: thinking + forced tool_choice", () => {
       },
     });
     const { provider, lastConfig } = makePipeline("anthropic");
-    await provider.sendMessage([userMessage], undefined, undefined, {
+    await provider.sendMessage([userMessage], {
       config: {
         callSite: "memoryExtraction",
         tool_choice: { type: "tool", name: "extract_graph_diff" },
@@ -108,7 +105,7 @@ describe("retry normalization: thinking + forced tool_choice", () => {
       },
     });
     const { provider, lastConfig } = makePipeline("anthropic");
-    await provider.sendMessage([userMessage], undefined, undefined, {
+    await provider.sendMessage([userMessage], {
       config: {
         callSite: "memoryExtraction",
         tool_choice: { type: "any" },
@@ -126,7 +123,7 @@ describe("retry normalization: thinking + forced tool_choice", () => {
       },
     });
     const { provider, lastConfig } = makePipeline("anthropic");
-    await provider.sendMessage([userMessage], undefined, undefined, {
+    await provider.sendMessage([userMessage], {
       config: {
         callSite: "memoryExtraction",
         tool_choice: { type: "auto" },
@@ -144,7 +141,7 @@ describe("retry normalization: thinking + forced tool_choice", () => {
       },
     });
     const { provider, lastConfig } = makePipeline("anthropic");
-    await provider.sendMessage([userMessage], undefined, undefined, {
+    await provider.sendMessage([userMessage], {
       config: { callSite: "memoryExtraction" },
     });
     expect(lastConfig()?.thinking).toEqual({ type: "adaptive" });
@@ -155,7 +152,7 @@ describe("retry normalization: thinking + forced tool_choice", () => {
     // alongside forced tool_choice. This should pass through unchanged since
     // disabled thinking is compatible with forced tool_choice.
     const { provider, lastConfig } = makePipeline("anthropic");
-    await provider.sendMessage([userMessage], undefined, undefined, {
+    await provider.sendMessage([userMessage], {
       config: {
         thinking: { type: "disabled" },
         tool_choice: { type: "tool", name: "select_memories" },
@@ -170,7 +167,7 @@ describe("retry normalization: thinking + forced tool_choice", () => {
     // convert it to Anthropic's wire shape `{ type: "disabled" }`, otherwise
     // Anthropic rejects the request with a 400 on malformed `thinking`.
     const { provider, lastConfig } = makePipeline("anthropic");
-    await provider.sendMessage([userMessage], undefined, undefined, {
+    await provider.sendMessage([userMessage], {
       config: {
         thinking: { enabled: false },
         tool_choice: { type: "tool", name: "select_memories" },
@@ -188,7 +185,7 @@ describe("retry normalization: thinking + forced tool_choice", () => {
       },
     });
     const { provider, lastConfig } = makePipeline("anthropic");
-    await provider.sendMessage([userMessage], undefined, undefined, {
+    await provider.sendMessage([userMessage], {
       config: {
         callSite: "memoryExtraction",
         tool_choice: { type: "tool", name: "extract_graph_diff" },
@@ -206,7 +203,7 @@ describe("retry normalization: thinking + forced tool_choice", () => {
       },
     });
     const { provider, lastConfig } = makePipeline("openrouter");
-    await provider.sendMessage([userMessage], undefined, undefined, {
+    await provider.sendMessage([userMessage], {
       config: {
         callSite: "memoryExtraction",
         tool_choice: { type: "tool", name: "extract_graph_diff" },
@@ -224,7 +221,7 @@ describe("retry normalization: thinking + forced tool_choice", () => {
       },
     });
     const { provider, lastConfig } = makePipeline("openrouter");
-    await provider.sendMessage([userMessage], undefined, undefined, {
+    await provider.sendMessage([userMessage], {
       config: {
         callSite: "memoryExtraction",
         tool_choice: { type: "tool", name: "extract_graph_diff" },
@@ -240,7 +237,7 @@ describe("retry normalization: thinking + forced tool_choice", () => {
     // earlier provider check — this test ensures the tool_choice check
     // doesn't interfere with that path.
     const { provider, lastConfig } = makePipeline("openai");
-    await provider.sendMessage([userMessage], undefined, undefined, {
+    await provider.sendMessage([userMessage], {
       config: {
         thinking: { type: "adaptive" },
         tool_choice: { type: "tool", name: "some_tool" },

package/src/__tests__/retry-verbosity-normalization.test.ts

@@ -25,7 +25,6 @@ import type {
   Provider,
   ProviderResponse,
   SendMessageOptions,
-  ToolDefinition,
 } from "../providers/types.js";
 
 function setLlmConfig(raw: unknown): void {
@@ -45,8 +44,6 @@ function makePipeline(providerName: string): {
     name: providerName,
     async sendMessage(
       _messages: Message[],
-      _tools?: ToolDefinition[],
-      _systemPrompt?: string,
       options?: SendMessageOptions,
     ): Promise<ProviderResponse> {
       captured = options?.config as Record<string, unknown> | undefined;
@@ -79,7 +76,7 @@ describe("retry normalization for verbosity", () => {
       },
     });
     const { provider, lastConfig } = makePipeline("openai");
-    await provider.sendMessage([userMessage], undefined, undefined, {
+    await provider.sendMessage([userMessage], {
       config: { callSite: "mainAgent" },
     });
     expect(lastConfig()?.verbosity).toBe("high");
@@ -87,7 +84,7 @@ describe("retry normalization for verbosity", () => {
 
   test("strips verbosity from config for anthropic provider", async () => {
     const { provider, lastConfig } = makePipeline("anthropic");
-    await provider.sendMessage([userMessage], undefined, undefined, {
+    await provider.sendMessage([userMessage], {
       config: { verbosity: "low" },
     });
     expect(lastConfig()?.verbosity).toBe(undefined);
@@ -95,7 +92,7 @@ describe("retry normalization for verbosity", () => {
 
   test("strips verbosity from config for openrouter provider", async () => {
     const { provider, lastConfig } = makePipeline("openrouter");
-    await provider.sendMessage([userMessage], undefined, undefined, {
+    await provider.sendMessage([userMessage], {
       config: { verbosity: "low" },
     });
     expect(lastConfig()?.verbosity).toBe(undefined);
@@ -113,7 +110,7 @@ describe("retry normalization for verbosity", () => {
       },
     });
     const { provider, lastConfig } = makePipeline("openai");
-    await provider.sendMessage([userMessage], undefined, undefined, {
+    await provider.sendMessage([userMessage], {
       config: { callSite: "mainAgent" },
     });
     expect(lastConfig()?.verbosity).toBe("high");
@@ -131,7 +128,7 @@ describe("retry normalization for verbosity", () => {
       },
     });
     const { provider, lastConfig } = makePipeline("openai");
-    await provider.sendMessage([userMessage], undefined, undefined, {
+    await provider.sendMessage([userMessage], {
       config: { callSite: "mainAgent", verbosity: "high" },
     });
     expect(lastConfig()?.verbosity).toBe("high");

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

@@ -0,0 +1,353 @@
+/**
+ * HTTP-layer tests for the B7.2 reconnect handler on GET /v1/events.
+ *
+ * Covers:
+ *   - replay of buffered events when `lastSeenSeq` is in-window
+ *   - cursor older than the ring -> connection goes live without any
+ *     extra wire signal (client is expected to detect the seq jump
+ *     and refetch via the messages API)
+ *   - omitted `lastSeenSeq` falls through to legacy live-only behavior
+ *   - dedup against live events that race in mid-replay
+ *   - malformed `lastSeenSeq` query param rejected with 400
+ */
+import { afterEach, 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 { getOrCreateConversation } from "../memory/conversation-key-store.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { buildAssistantEvent } from "../runtime/assistant-event.js";
+import {
+  _resetConversationStreamsForTesting,
+  stampAndBuffer,
+} from "../runtime/conversation-stream-state.js";
+
+initializeDb();
+
+const decoder = new TextDecoder();
+
+async function readFrame(
+  reader: ReadableStreamDefaultReader<Uint8Array>,
+): Promise<string> {
+  const { value, done } = await reader.read();
+  expect(done).toBe(false);
+  return decoder.decode(value);
+}
+
+describe("SSE reconnect replay (B7.2)", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM conversation_keys");
+    db.run("DELETE FROM conversations");
+    _resetConversationStreamsForTesting();
+  });
+
+  afterEach(() => {
+    _resetConversationStreamsForTesting();
+  });
+
+  test("replays buffered events with seq > lastSeenSeq before the first heartbeat", async () => {
+    const { conversationId } = getOrCreateConversation("reconnect-replay");
+
+    // Stamp three events into the ring as if they had already been
+    // broadcast prior to the client's reconnect. Seqs start at 1, so
+    // these get seqs 1, 2, 3.
+    const events = [
+      buildAssistantEvent({ type: "pong" }, conversationId),
+      buildAssistantEvent({ type: "pong" }, conversationId),
+      buildAssistantEvent({ type: "pong" }, conversationId),
+    ];
+    for (const event of events) stampAndBuffer(event);
+
+    const ac = new AbortController();
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    const stream = handleSubscribeAssistantEvents({
+      queryParams: {
+        conversationKey: "reconnect-replay",
+        lastSeenSeq: "1",
+      },
+      abortSignal: ac.signal,
+    });
+
+    const reader = stream.getReader();
+
+    // Frames 1-2 are the two events with seq > 1 (i.e. seqs 2 and 3),
+    // emitted before the initial heartbeat.
+    const frame1 = await readFrame(reader);
+    expect(frame1).toContain("event: assistant_event");
+    expect(frame1).toContain('"seq":2');
+    expect(frame1).toContain('"clientSeq":1');
+
+    const frame2 = await readFrame(reader);
+    expect(frame2).toContain('"seq":3');
+    expect(frame2).toContain('"clientSeq":2');
+
+    // Then the heartbeat.
+    const heartbeat = await readFrame(reader);
+    expect(heartbeat).toBe(": heartbeat\n\n");
+
+    ac.abort();
+  });
+
+  test("connects live without replay when lastSeenSeq is older than the ring's oldest entry", async () => {
+    // When the client's cursor is older than the ring can serve, the
+    // route deliberately does NOT signal anything special over the
+    // wire -- the connection just goes live. The client is expected to
+    // detect the gap from the seq jump on its first live event and
+    // refetch via the existing messages API.
+    const { conversationId } = getOrCreateConversation(
+      "reconnect-out-of-window",
+    );
+
+    // Push 202 events through stampAndBuffer so the ring's natural
+    // count-based eviction (cap 200) drops seqs 1 and 2. A cursor of
+    // 0 then falls outside what getReplayWindow can serve.
+    for (let i = 0; i < 202; i++) {
+      stampAndBuffer(buildAssistantEvent({ type: "pong" }, conversationId));
+    }
+    const { _peekStreamForTesting } =
+      await import("../runtime/conversation-stream-state.js");
+    const peek = _peekStreamForTesting(conversationId);
+    expect(peek?.oldestSeq).toBe(3);
+    expect(peek?.newestSeq).toBe(202);
+
+    const ac = new AbortController();
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    const stream = handleSubscribeAssistantEvents({
+      queryParams: {
+        conversationKey: "reconnect-out-of-window",
+        lastSeenSeq: "0",
+      },
+      abortSignal: ac.signal,
+    });
+
+    const reader = stream.getReader();
+
+    // No replay events ahead of the heartbeat -- the cursor was
+    // unserviceable so the route emits nothing extra.
+    const heartbeat = await readFrame(reader);
+    expect(heartbeat).toBe(": heartbeat\n\n");
+
+    ac.abort();
+  });
+
+  test("omitting lastSeenSeq skips replay entirely (legacy live-only behavior)", async () => {
+    const { conversationId } = getOrCreateConversation("reconnect-noparam");
+
+    // Pre-fill the ring -- without the cursor, these MUST NOT be replayed.
+    stampAndBuffer(buildAssistantEvent({ type: "pong" }, conversationId));
+    stampAndBuffer(buildAssistantEvent({ type: "pong" }, conversationId));
+
+    const ac = new AbortController();
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    const stream = handleSubscribeAssistantEvents({
+      queryParams: { conversationKey: "reconnect-noparam" },
+      abortSignal: ac.signal,
+    });
+
+    const reader = stream.getReader();
+
+    // First frame is the heartbeat -- no replay events ahead of it.
+    const heartbeat = await readFrame(reader);
+    expect(heartbeat).toBe(": heartbeat\n\n");
+
+    ac.abort();
+  });
+
+  test("dedupes a buffered event when it also races through the live callback", async () => {
+    const { conversationId } = getOrCreateConversation("reconnect-dedup");
+
+    // Stamp two events. Seqs start at 1, so eventA=1 and eventB=2.
+    const eventA = buildAssistantEvent({ type: "pong" }, conversationId);
+    const eventB = buildAssistantEvent({ type: "pong" }, conversationId);
+    stampAndBuffer(eventA); // seq 1
+    stampAndBuffer(eventB); // seq 2
+
+    const ac = new AbortController();
+    const { AssistantEventHub } =
+      await import("../runtime/assistant-event-hub.js");
+    const testHub = new AssistantEventHub();
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    const stream = handleSubscribeAssistantEvents(
+      {
+        queryParams: {
+          conversationKey: "reconnect-dedup",
+          lastSeenSeq: "1",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub: testHub },
+    );
+
+    const reader = stream.getReader();
+
+    // First frame is the replay of seq=2 (the only one with seq > 1).
+    const replayed = await readFrame(reader);
+    expect(replayed).toContain('"seq":2');
+
+    // Then the heartbeat.
+    const heartbeat = await readFrame(reader);
+    expect(heartbeat).toBe(": heartbeat\n\n");
+
+    // Now publish eventB live (its seq is 2, already replayed). The
+    // callback's high-water dedup should drop it. Then publish a fresh
+    // event with seq=3 (via stampAndBuffer + manual publish), which
+    // SHOULD be delivered.
+    await testHub.publish(eventB);
+
+    const eventC = buildAssistantEvent({ type: "pong" }, conversationId);
+    stampAndBuffer(eventC); // seq 3
+    await testHub.publish(eventC);
+
+    const liveFrame = await readFrame(reader);
+    expect(liveFrame).toContain('"seq":3');
+
+    ac.abort();
+  });
+
+  test("clientSeq is gap-free when targeted events create seq gaps", async () => {
+    // Stamp three events: two untargeted (seq 1, 3) + one with a
+    // capability target (seq 2, host_bash). A process subscriber
+    // does NOT match capability targeting (matchesSubscriber requires
+    // type=client + matching capability), so the replay filters out
+    // seq 2. The subscriber receives seq 1 and 3 — a gap in raw seq
+    // — but clientSeq is 1, 2 — gap-free.
+    const { conversationId } = getOrCreateConversation("clientseq-gap");
+
+    stampAndBuffer(buildAssistantEvent({ type: "pong" }, conversationId));
+    stampAndBuffer(buildAssistantEvent({ type: "pong" }, conversationId), {
+      targeting: { targetCapability: "host_bash" },
+    });
+    stampAndBuffer(buildAssistantEvent({ type: "pong" }, conversationId));
+
+    const ac = new AbortController();
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    const stream = handleSubscribeAssistantEvents({
+      queryParams: {
+        conversationKey: "clientseq-gap",
+        lastSeenSeq: "0",
+      },
+      abortSignal: ac.signal,
+    });
+
+    const reader = stream.getReader();
+
+    // seq 2 (host_bash-targeted) is filtered out by replay.
+    // Only seq 1 and 3 are delivered, with gap-free clientSeq.
+    const f1 = await readFrame(reader);
+    expect(f1).toContain('"seq":1');
+    expect(f1).toContain('"clientSeq":1');
+
+    const f2 = await readFrame(reader);
+    expect(f2).toContain('"seq":3');
+    expect(f2).toContain('"clientSeq":2');
+
+    const heartbeat = await readFrame(reader);
+    expect(heartbeat).toBe(": heartbeat\n\n");
+
+    ac.abort();
+  });
+
+  test("live callback includes clientSeq on conversation-scoped events", async () => {
+    const { conversationId } = getOrCreateConversation("clientseq-live");
+
+    const ac = new AbortController();
+    const { AssistantEventHub } =
+      await import("../runtime/assistant-event-hub.js");
+    const testHub = new AssistantEventHub();
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    const stream = handleSubscribeAssistantEvents(
+      {
+        queryParams: { conversationKey: "clientseq-live" },
+        abortSignal: ac.signal,
+      },
+      { hub: testHub },
+    );
+
+    const reader = stream.getReader();
+
+    // Drain the initial heartbeat.
+    const heartbeat = await readFrame(reader);
+    expect(heartbeat).toBe(": heartbeat\n\n");
+
+    // Publish two live events with seq via stampAndBuffer.
+    const e1 = buildAssistantEvent({ type: "pong" }, conversationId);
+    const e2 = buildAssistantEvent({ type: "pong" }, conversationId);
+    stampAndBuffer(e1);
+    stampAndBuffer(e2);
+    await testHub.publish(e1);
+    await testHub.publish(e2);
+
+    const f1 = await readFrame(reader);
+    expect(f1).toContain('"seq":1');
+    expect(f1).toContain('"clientSeq":1');
+
+    const f2 = await readFrame(reader);
+    expect(f2).toContain('"seq":2');
+    expect(f2).toContain('"clientSeq":2');
+
+    ac.abort();
+  });
+
+  test("rejects empty lastSeenSeq", async () => {
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    expect(() =>
+      handleSubscribeAssistantEvents({
+        queryParams: {
+          conversationKey: "reconnect-empty",
+          lastSeenSeq: "",
+        },
+      }),
+    ).toThrow(/lastSeenSeq must not be empty/);
+  });
+
+  test("rejects non-integer lastSeenSeq", async () => {
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    expect(() =>
+      handleSubscribeAssistantEvents({
+        queryParams: {
+          conversationKey: "reconnect-float",
+          lastSeenSeq: "1.5",
+        },
+      }),
+    ).toThrow(/non-negative integer/);
+  });
+
+  test("rejects negative lastSeenSeq", async () => {
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    expect(() =>
+      handleSubscribeAssistantEvents({
+        queryParams: {
+          conversationKey: "reconnect-neg",
+          lastSeenSeq: "-1",
+        },
+      }),
+    ).toThrow(/non-negative integer/);
+  });
+});

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

@@ -11,10 +11,10 @@ const getOrCreateCalls: Array<{
   conversationId: string;
   options?: Record<string, unknown>;
 }> = [];
-const processCalls: Array<unknown[]> = [];
+const processCalls: Array<Record<string, unknown>> = [];
 let fakeConversation: {
   taskRunId?: string;
-  processMessage: (...args: unknown[]) => Promise<string>;
+  processMessage: (options: Record<string, unknown>) => Promise<string>;
 };
 
 function resetConversationMock() {
@@ -22,8 +22,8 @@ function resetConversationMock() {
   processCalls.length = 0;
   fakeConversation = {
     taskRunId: "stale-task-run",
-    async processMessage(...args: unknown[]) {
-      processCalls.push(args);
+    async processMessage(options: Record<string, unknown>) {
+      processCalls.push(options);
       return "message-id";
     },
   };
@@ -109,8 +109,8 @@ describe("schedule run-now trust propagation", () => {
       trustClass: "guardian",
     });
     expect(processCalls).toHaveLength(1);
-    expect(processCalls[0][0]).toBe("scan my inbox");
-    expect(processCalls[0][6]).toEqual({ isInteractive: false });
+    expect(processCalls[0].content).toBe("scan my inbox");
+    expect(processCalls[0].isInteractive).toBe(false);
     expect(fakeConversation.taskRunId).toBeUndefined();
   });
 
@@ -128,9 +128,9 @@ describe("schedule run-now trust propagation", () => {
     const observedTaskRunIds: Array<string | undefined> = [];
     fakeConversation = {
       taskRunId: undefined,
-      async processMessage(...args: unknown[]) {
+      async processMessage(options: Record<string, unknown>) {
         observedTaskRunIds.push(fakeConversation.taskRunId);
-        processCalls.push(args);
+        processCalls.push(options);
         return "message-id";
       },
     };
@@ -147,8 +147,8 @@ describe("schedule run-now trust propagation", () => {
       trustClass: "guardian",
     });
     expect(processCalls).toHaveLength(1);
-    expect(processCalls[0][0]).toBe("triage inbox in background");
-    expect(processCalls[0][6]).toEqual({ isInteractive: false });
+    expect(processCalls[0].content).toBe("triage inbox in background");
+    expect(processCalls[0].isInteractive).toBe(false);
     expect(typeof observedTaskRunIds[0]).toBe("string");
     expect(fakeConversation.taskRunId).toBeUndefined();
   });
@@ -538,3 +538,73 @@ describe("wake mode in schedule routes", () => {
     expect(wakeSchedule!.wakeConversationId).toBe("conv-abc");
   });
 });
+
+describe("PATCH /schedules/:id — timeout override", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  function listOne(): { id: string; timeoutMs: number | null } {
+    const route = findRoute("schedules", "GET");
+    const result = route.handler({}) as {
+      schedules: Array<{ id: string; timeoutMs: number | null }>;
+    };
+    return result.schedules[0];
+  }
+
+  test("sets and clears the script timeout, exposing it in the list", () => {
+    // GIVEN a script schedule with no timeout override
+    const schedule = createSchedule({
+      name: "Script job",
+      cronExpression: "0 9 * * *",
+      message: "",
+      script: "echo hi",
+      mode: "script",
+      syntax: "cron",
+    });
+    expect(listOne().timeoutMs).toBeNull();
+
+    const patch = findRoute("schedules/:id", "PATCH");
+
+    // WHEN the guardian sets a custom timeout
+    patch.handler({
+      pathParams: { id: schedule.id },
+      body: { timeoutMs: 5000 },
+    });
+
+    // THEN the list reflects the override
+    expect(listOne().timeoutMs).toBe(5000);
+
+    // AND WHEN the guardian clears it
+    patch.handler({
+      pathParams: { id: schedule.id },
+      body: { timeoutMs: null },
+    });
+
+    // THEN it reverts to null
+    expect(listOne().timeoutMs).toBeNull();
+  });
+
+  test("rejects an out-of-range timeout", () => {
+    // GIVEN a script schedule
+    const schedule = createSchedule({
+      name: "Guarded job",
+      cronExpression: "0 9 * * *",
+      message: "",
+      script: "echo hi",
+      mode: "script",
+      syntax: "cron",
+    });
+
+    const patch = findRoute("schedules/:id", "PATCH");
+
+    // WHEN/THEN patching with a below-minimum timeout throws a RouteError
+    expect(() =>
+      patch.handler({
+        pathParams: { id: schedule.id },
+        body: { timeoutMs: 10 },
+      }),
+    ).toThrow("timeout_ms must be between");
+    expect(listOne().timeoutMs).toBeNull();
+  });
+});