@vellumai/assistant 0.8.0 → 0.8.2

package/src/__tests__/provider-error-scenarios.test.ts

@@ -753,6 +753,117 @@ describe("RetryProvider — streaming response handling", () => {
     expect(callCount).toBe(2);
   });
 
+  test("retries transport-aborted stream (Anthropic 'Request was aborted' with no abortReason)", async () => {
+    let callCount = 0;
+    const inner: Provider = {
+      name: "retry-transport-abort",
+      async sendMessage() {
+        callCount++;
+        if (callCount <= 1) {
+          // Mirrors the ProviderError shape produced by the catch-site in
+          // providers/anthropic/client.ts when the SDK reports
+          // ``Anthropic.APIError(status === undefined, message: "Request
+          // was aborted.")`` and the daemon's AbortController was NOT the
+          // cause (i.e. abortReason is undefined). Empirically the #1
+          // daemon error by a factor of 5x — 1,344 events in 4d on the
+          // SSE chat path, all of which used to surface as a 45s blank
+          // screen on the web client via LUM-1431.
+          throw new ProviderError(
+            "Anthropic API error: Request was aborted.",
+            "anthropic",
+            undefined,
+          );
+        }
+        return successResponse();
+      },
+    };
+    const provider = new RetryProvider(inner);
+    await provider.sendMessage(MESSAGES);
+    expect(callCount).toBe(2);
+  });
+
+  test("does NOT retry caller-aborted stream (abortReason set short-circuits retry)", async () => {
+    let callCount = 0;
+    const abortError = new ProviderError(
+      "Anthropic API error: Request was aborted.",
+      "anthropic",
+      undefined,
+      // Tagging abortReason exactly matches what the catch-site does when
+      // signal.aborted was true at the moment of failure — i.e. the
+      // daemon (or the user) cancelled the request, not the transport.
+      // The retry layer must respect this and surface the error
+      // immediately without consuming retry budget.
+      { abortReason: "user-cancelled" },
+    );
+    const inner: Provider = {
+      name: "caller-abort",
+      async sendMessage() {
+        callCount++;
+        throw abortError;
+      },
+    };
+    const provider = new RetryProvider(inner);
+    await expect(provider.sendMessage(MESSAGES)).rejects.toBe(abortError);
+    expect(callCount).toBe(1);
+  });
+
+  test("does NOT retry inner-timeout stream (deterministic 30min deadline failure)", async () => {
+    let callCount = 0;
+    // When the inner streamTimeoutMs fires, the catch-site rewrites the
+    // message to "Anthropic stream timed out after Xs (inner
+    // streamTimeoutMs)" instead of "Request was aborted." That rewrite is
+    // what allows this branch to bypass the transport-abort retry —
+    // retrying a 30min-deadline failure would almost certainly hit the
+    // same deadline on the next attempt and waste retry budget.
+    const innerTimeoutError = new ProviderError(
+      "Anthropic API error: Anthropic stream timed out after 1800s (inner streamTimeoutMs)",
+      "anthropic",
+      undefined,
+    );
+    const inner: Provider = {
+      name: "inner-timeout",
+      async sendMessage() {
+        callCount++;
+        throw innerTimeoutError;
+      },
+    };
+    const provider = new RetryProvider(inner);
+    await expect(provider.sendMessage(MESSAGES)).rejects.toBe(
+      innerTimeoutError,
+    );
+    expect(callCount).toBe(1);
+  });
+
+  test("does NOT retry OpenAI/Gemini-shaped 'Request was aborted' (no inner-timeout rewrite at those catch-sites)", async () => {
+    // The OpenAI chat-completions, OpenAI responses, and Gemini catch-sites
+    // format their errors as `"<Provider> API error (undefined): Request
+    // was aborted."` (note the `(undefined)` parenthetical that the
+    // Anthropic catch-site intentionally omits) and — unlike the Anthropic
+    // catch-site — they do NOT rewrite their inner-streamTimeoutMs
+    // deadline failures. A provider-agnostic transport-abort predicate
+    // would burn three retries on what is by construction a deterministic
+    // 30-minute deadline failure that will fire again on every attempt.
+    // Scoping the predicate to the Anthropic message prefix avoids that
+    // wasted retry budget for non-Anthropic providers until their
+    // catch-sites grow the same `innerTimeoutFired` distinction.
+    const openaiAbortError = new ProviderError(
+      "OpenAI API error (undefined): Request was aborted.",
+      "openai",
+      undefined,
+    );
+    let callCount = 0;
+    const inner: Provider = {
+      name: "openai-aborted-stream",
+      async sendMessage() {
+        callCount++;
+        throw openaiAbortError;
+      },
+    };
+    const provider = new RetryProvider(inner);
+    await expect(provider.sendMessage(MESSAGES)).rejects.toBe(openaiAbortError);
+    expect(callCount).toBe(1);
+  });
+
   test("events accumulate across retries (each attempt delivers events independently)", async () => {
     let callCount = 0;
     const inner: Provider = {

package/src/__tests__/{provider-managed-proxy-integration.test.ts → provider-platform-proxy-integration.test.ts}

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { MANAGED_PROVIDER_META } from "../providers/managed-proxy/constants.js";
+import { PLATFORM_PROVIDER_META } from "../providers/platform-proxy/constants.js";
 import { credentialKey } from "../security/credential-key.js";
 
 // ---------------------------------------------------------------------------
@@ -63,11 +63,11 @@ mock.module("../security/secure-keys.js", () => ({
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     llm: mockLlmConfig,
-    services: { inference: { mode: "your-own" } },
+    services: { inference: {} },
   }),
 }));
 
-import { LLMSchema } from "../config/schemas/llm.js";
+import { type LLMConfigBase, LLMSchema } from "../config/schemas/llm.js";
 import type { ProvidersConfig } from "../providers/registry.js";
 import {
   getProvider,
@@ -77,9 +77,10 @@ import {
 } from "../providers/registry.js";
 
 function makeProvidersConfig(provider: string, model: string): ProvidersConfig {
+  const baseLlm = LLMSchema.parse({});
   return {
     services: {
-      inference: { mode: "your-own" },
+      inference: {},
       "image-generation": {
         mode: "your-own",
         provider: "gemini",
@@ -87,7 +88,14 @@ function makeProvidersConfig(provider: string, model: string): ProvidersConfig {
       },
       "web-search": { mode: "your-own", provider: "inference-provider-native" },
     },
-    llm: { default: { provider, model } },
+    llm: {
+      ...baseLlm,
+      default: {
+        ...baseLlm.default,
+        provider: provider as LLMConfigBase["provider"],
+        model,
+      },
+    },
   };
 }
 
@@ -428,7 +436,7 @@ describe("managed proxy integration — ollama exclusion", () => {
   });
 
   test("ollama metadata is marked as non-managed", () => {
-    const meta = MANAGED_PROVIDER_META.ollama;
+    const meta = PLATFORM_PROVIDER_META.ollama;
     expect(meta).toBeDefined();
     expect(meta.managed).toBe(false);
     expect(meta.proxyPath).toBeUndefined();
@@ -470,7 +478,7 @@ describe("config mode flip → provider reinit", () => {
 describe("managed proxy integration — constants integrity", () => {
   test("anthropic, openai, and gemini have metadata with managed=true and a proxyPath", () => {
     for (const provider of ["anthropic", "openai", "gemini"]) {
-      const meta = MANAGED_PROVIDER_META[provider];
+      const meta = PLATFORM_PROVIDER_META[provider];
       expect(meta).toBeDefined();
       expect(meta.managed).toBe(true);
       expect(meta.proxyPath).toBeTruthy();
@@ -479,27 +487,27 @@ describe("managed proxy integration — constants integrity", () => {
   });
 
   test("anthropic routes through anthropic proxy path", () => {
-    expect(MANAGED_PROVIDER_META.anthropic.proxyPath).toBe(
+    expect(PLATFORM_PROVIDER_META.anthropic.proxyPath).toBe(
       "/v1/runtime-proxy/anthropic",
     );
   });
 
   test("gemini routes through gemini proxy path", () => {
-    expect(MANAGED_PROVIDER_META.gemini.proxyPath).toBe(
+    expect(PLATFORM_PROVIDER_META.gemini.proxyPath).toBe(
       "/v1/runtime-proxy/gemini",
     );
   });
 
   test("openai routes through openai proxy path", () => {
-    expect(MANAGED_PROVIDER_META.openai.proxyPath).toBe(
+    expect(PLATFORM_PROVIDER_META.openai.proxyPath).toBe(
       "/v1/runtime-proxy/openai",
     );
   });
 
   test("fireworks and openrouter are not managed proxy capable", () => {
     for (const provider of ["fireworks", "openrouter"]) {
-      expect(MANAGED_PROVIDER_META[provider].managed).toBe(false);
-      expect(MANAGED_PROVIDER_META[provider].proxyPath).toBeUndefined();
+      expect(PLATFORM_PROVIDER_META[provider].managed).toBe(false);
+      expect(PLATFORM_PROVIDER_META[provider].proxyPath).toBeUndefined();
     }
   });
 });

package/src/__tests__/provider-registry-ollama.test.ts

@@ -7,19 +7,20 @@ mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: async () => undefined,
 }));
 
+import { LLMSchema } from "../config/schemas/llm.js";
 import {
   getProvider,
   initializeProviders,
   listProviders,
 } from "../providers/registry.js";
 
+const baseLlm = LLMSchema.parse({});
+
 describe("provider registry (ollama)", () => {
   test("registers ollama when selected provider has no API key", async () => {
     await initializeProviders({
       services: {
-        inference: {
-          mode: "your-own",
-        },
+        inference: {},
         "image-generation": {
           mode: "your-own",
           provider: "gemini",
@@ -30,7 +31,14 @@ describe("provider registry (ollama)", () => {
           provider: "inference-provider-native",
         },
       },
-      llm: { default: { provider: "ollama", model: "claude-opus-4-6" } },
+      llm: {
+        ...baseLlm,
+        default: {
+          ...baseLlm.default,
+          provider: "ollama" as const,
+          model: "claude-opus-4-6",
+        },
+      },
     });
 
     const provider = getProvider("ollama");

package/src/__tests__/provider-send-message-override-profile.test.ts

@@ -144,11 +144,15 @@ describe("SendMessageOptions.config.overrideProfile", () => {
     expect(captured?.callSite).toBeUndefined();
   });
 
-  test("CallSiteRoutingProvider switches transport when overrideProfile changes the provider", async () => {
+  test("CallSiteRoutingProvider switches transport when overrideProfile changes the provider (via provider_connection)", async () => {
     setLlmConfig({
       default: { provider: "anthropic", model: "claude-opus-4-7" },
       profiles: {
-        fast: { provider: "openai", model: "gpt-5.4" },
+        fast: {
+          provider: "openai",
+          provider_connection: "openai-conn",
+          model: "gpt-5.4",
+        },
       },
     });
 
@@ -168,8 +172,10 @@ describe("SendMessageOptions.config.overrideProfile", () => {
       },
     };
 
-    const wrapped = new CallSiteRoutingProvider(defaultProvider, (name) =>
-      name === "openai" ? altProvider : undefined,
+    const wrapped = new CallSiteRoutingProvider(
+      defaultProvider,
+      async (connectionName) =>
+        connectionName === "openai-conn" ? altProvider : null,
     );
 
     const response = await wrapped.sendMessage(

package/src/__tests__/relay-server.test.ts

@@ -2305,6 +2305,124 @@ describe("relay-server", () => {
     relay.destroy();
   });
 
+  test("inbound voice: guardian's unverified channel gets self-verify guidance", async () => {
+    ensureConversation("conv-unverified-guardian");
+    const session = createCallSession({
+      conversationId: "conv-unverified-guardian",
+      provider: "twilio",
+      fromNumber: "+15558886666",
+      toNumber: "+15551111111",
+    });
+
+    upsertContactChannel({
+      sourceChannel: "phone",
+      externalUserId: "+15558886666",
+      externalChatId: "+15558886666",
+      displayName: "Vargas",
+      role: "guardian",
+      status: "unverified",
+      policy: "allow",
+    });
+
+    const { ws, relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_unverified_guardian",
+        from: "+15558886666",
+        to: "+15551111111",
+      }),
+    );
+
+    // Should be disconnecting (not awaiting_name, not normal_call)
+    expect(relay.getConnectionState()).toBe("disconnecting");
+
+    const updated = getCallSession(session.id);
+    expect(updated).not.toBeNull();
+    expect(updated!.status).toBe("failed");
+
+    const textMessages = ws.sentMessages
+      .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+      .filter((m) => m.type === "text");
+    const promptText = textMessages.map((m) => m.token ?? "").join("");
+    expect(promptText).toContain("Vargas");
+    expect(promptText).toContain("has not been verified yet");
+    expect(promptText).toContain("contacts page");
+    expect(promptText).not.toContain("reach out to the account guardian");
+    expect(promptText).not.toContain("don't recognize");
+
+    const events = getCallEvents(session.id);
+    const aclEvent = events.find(
+      (e) => e.eventType === "inbound_acl_unverified_caller",
+    );
+    expect(aclEvent).toBeTruthy();
+    expect(
+      (JSON.parse(aclEvent!.payloadJson) as { isGuardian?: boolean })
+        .isGuardian,
+    ).toBe(true);
+
+    // Let delayed endSession callback flush
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    relay.destroy();
+  });
+
+  test("inbound voice: non-guardian contact with pending channel gets reach-out copy", async () => {
+    ensureConversation("conv-pending-contact");
+    const session = createCallSession({
+      conversationId: "conv-pending-contact",
+      provider: "twilio",
+      fromNumber: "+15558887777",
+      toNumber: "+15551111111",
+    });
+
+    upsertContactChannel({
+      sourceChannel: "phone",
+      externalUserId: "+15558887777",
+      externalChatId: "+15558887777",
+      displayName: "Pending Pat",
+      // role defaults to "contact" — exercises the non-guardian branch
+      status: "pending",
+      policy: "allow",
+    });
+
+    const { ws, relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_pending_contact",
+        from: "+15558887777",
+        to: "+15551111111",
+      }),
+    );
+
+    expect(relay.getConnectionState()).toBe("disconnecting");
+
+    const textMessages = ws.sentMessages
+      .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+      .filter((m) => m.type === "text");
+    const promptText = textMessages.map((m) => m.token ?? "").join("");
+    expect(promptText).toContain("Pending Pat");
+    expect(promptText).toContain("has not been verified yet");
+    expect(promptText).toContain("reach out to the account guardian");
+    expect(promptText).not.toContain("contacts page");
+
+    const events = getCallEvents(session.id);
+    const aclEvent = events.find(
+      (e) => e.eventType === "inbound_acl_unverified_caller",
+    );
+    expect(aclEvent).toBeTruthy();
+    expect(
+      (JSON.parse(aclEvent!.payloadJson) as { isGuardian?: boolean })
+        .isGuardian,
+    ).toBe(false);
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    relay.destroy();
+  });
+
   test("inbound voice: unknown caller name capture uses fallback when assistant name is unavailable", async () => {
     const prevName = mockAssistantName;
     mockAssistantName = null;

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

@@ -164,6 +164,21 @@ describe("retry normalization: thinking + forced tool_choice", () => {
     expect(lastConfig()?.thinking).toEqual({ type: "disabled" });
   });
 
+  test("normalizes raw { enabled: false } from pass-through callers to wire shape", async () => {
+    // Pass-through callers (e.g. host.providers.llm.complete) may forward the
+    // schema-shape `{ enabled: false }` without a callSite. The normalizer must
+    // 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, {
+      config: {
+        thinking: { enabled: false },
+        tool_choice: { type: "tool", name: "select_memories" },
+      },
+    });
+    expect(lastConfig()?.thinking).toEqual({ type: "disabled" });
+  });
+
   test("preserves resolved thinking: disabled with forced tool_choice", async () => {
     setLlmConfig({
       default: {

package/src/__tests__/scaffold-managed-skill-tool.test.ts

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
+const mockRefreshSkillCapabilityMemories = mock(() => {});
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -11,6 +12,11 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+mock.module("../daemon/skill-memory-refresh.js", () => ({
+  refreshSkillCapabilityMemories: mockRefreshSkillCapabilityMemories,
+}));
+
+import { loadSkillCatalog } from "../config/skills.js";
 import { executeScaffoldManagedSkill } from "../tools/skills/scaffold-managed.js";
 import type { ToolContext } from "../tools/types.js";
 
@@ -24,6 +30,7 @@ function makeContext(): ToolContext {
 
 beforeEach(() => {
   mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
+  mockRefreshSkillCapabilityMemories.mockClear();
 });
 
 afterEach(() => {
@@ -31,7 +38,29 @@ afterEach(() => {
 });
 
 describe("scaffold_managed_skill tool", () => {
-  test("creates a valid skill and index entry", async () => {
+  test("keeps legacy index control as a deprecated no-op schema field", () => {
+    const tools = JSON.parse(
+      readFileSync(
+        join(
+          import.meta.dirname,
+          "../config/bundled-skills/skill-management/TOOLS.json",
+        ),
+        "utf-8",
+      ),
+    );
+    const scaffoldTool = tools.tools.find(
+      (tool: { name: string }) => tool.name === "scaffold_managed_skill",
+    );
+
+    expect(scaffoldTool).toBeDefined();
+    expect(scaffoldTool.input_schema.properties.add_to_index).toEqual({
+      type: "boolean",
+      description:
+        "Deprecated no-op compatibility field. Skills are discovered from top-level SKILL.md files.",
+    });
+  });
+
+  test("creates a valid skill discovered from its SKILL.md directory", async () => {
     const result = await executeScaffoldManagedSkill(
       {
         skill_id: "test-skill",
@@ -46,18 +75,40 @@ describe("scaffold_managed_skill tool", () => {
     const parsed = JSON.parse(result.content);
     expect(parsed.created).toBe(true);
     expect(parsed.skill_id).toBe("test-skill");
-    expect(parsed.index_updated).toBe(true);
+    expect(parsed).not.toHaveProperty("index_updated");
 
     const skillFile = join(TEST_DIR, "skills", "test-skill", "SKILL.md");
     expect(existsSync(skillFile)).toBe(true);
     const content = readFileSync(skillFile, "utf-8");
     expect(content).toContain('name: "Test Skill"');
 
-    const indexContent = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
+    expect(existsSync(join(TEST_DIR, "skills", "SKILLS.md"))).toBe(false);
+
+    const catalog = loadSkillCatalog();
+    const skill = catalog.find((s) => s.id === "test-skill");
+    expect(skill).toBeDefined();
+    expect(skill!.name).toBe("Test Skill");
+    expect(mockRefreshSkillCapabilityMemories).toHaveBeenCalledTimes(1);
+  });
+
+  test("accepts legacy add_to_index input without returning index metadata", async () => {
+    const result = await executeScaffoldManagedSkill(
+      {
+        skill_id: "legacy-input",
+        name: "Legacy Input",
+        description: "A test skill",
+        body_markdown: "Do the thing.",
+        add_to_index: true,
+      },
+      makeContext(),
     );
-    expect(indexContent).toContain("- test-skill");
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.created).toBe(true);
+    expect(parsed).not.toHaveProperty("index_updated");
+    expect(existsSync(join(TEST_DIR, "skills", "SKILLS.md"))).toBe(false);
+    expect(mockRefreshSkillCapabilityMemories).toHaveBeenCalledTimes(1);
   });
 
   test("rejects duplicate unless overwrite=true", async () => {
@@ -258,7 +309,7 @@ describe("scaffold_managed_skill tool", () => {
     expect(result.content).toContain("traversal");
   });
 
-  test("e2e: scaffold child then parent with includes, verify files and index", async () => {
+  test("e2e: scaffold child then parent with includes, verify file discovery", async () => {
     const childResult = await executeScaffoldManagedSkill(
       {
         skill_id: "e2e-child",
@@ -288,11 +339,12 @@ describe("scaffold_managed_skill tool", () => {
     expect(parentContent).toContain("    includes:");
     expect(parentContent).toContain("      - e2e-child");
 
-    const indexContent = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    expect(indexContent).toContain("- e2e-child");
-    expect(indexContent).toContain("- e2e-parent");
+    expect(existsSync(join(TEST_DIR, "skills", "SKILLS.md"))).toBe(false);
+
+    const catalog = loadSkillCatalog();
+    expect(catalog.find((s) => s.id === "e2e-child")).toBeDefined();
+    const parent = catalog.find((s) => s.id === "e2e-parent");
+    expect(parent).toBeDefined();
+    expect(parent!.includes).toEqual(["e2e-child"]);
   });
 });

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

@@ -8,9 +8,39 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (value: string) => value,
 }));
 
-const mockEmitFeedEvent = mock(() => Promise.resolve());
-mock.module("../home/emit-feed-event.js", () => ({
-  emitFeedEvent: mockEmitFeedEvent,
+// The scheduler's fresh-bootstrap path routes through `runBackgroundJob`,
+// which invokes the real `processMessage` from `daemon/process-message.ts`
+// instead of the test-injected callback. To keep these tests focused on
+// the scheduler's retry policy (not on the runner's plumbing or on having
+// a real provider configured), redirect every `runBackgroundJob` call back
+// to the injected `processMessage` so a single test scenario controls
+// success-vs-failure deterministically.
+let injectedProcessMessageForRunner:
+  | ((conversationId: string, message: string) => Promise<unknown>)
+  | null = null;
+mock.module("../runtime/background-job-runner.js", () => ({
+  runBackgroundJob: async (opts: {
+    jobName: string;
+    prompt: string;
+    onConversationCreated?: (conversationId: string) => void;
+  }) => {
+    const conversationId = `mock-conv-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    opts.onConversationCreated?.(conversationId);
+    try {
+      if (injectedProcessMessageForRunner) {
+        await injectedProcessMessageForRunner(conversationId, opts.prompt);
+      }
+      return { conversationId, ok: true };
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      return {
+        conversationId,
+        ok: false,
+        error,
+        errorKind: "exception" as const,
+      };
+    }
+  },
 }));
 
 import { getDb } from "../memory/db-connection.js";
@@ -28,7 +58,29 @@ import {
   scheduleRetry,
 } from "../schedule/schedule-store.js";
 import type { SchedulerHandle } from "../schedule/scheduler.js";
-import { startScheduler } from "../schedule/scheduler.js";
+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.
+ */
+function startScheduler(
+  processMessage: ScheduleMessageProcessor,
+  notifyScheduleOneShot: Parameters<typeof startSchedulerReal>[1],
+  options?: Parameters<typeof startSchedulerReal>[2],
+): SchedulerHandle {
+  injectedProcessMessageForRunner = async (
+    conversationId: string,
+    message: string,
+  ) => {
+    await processMessage(conversationId, message, { trustClass: "guardian" });
+  };
+  return startSchedulerReal(processMessage, notifyScheduleOneShot, options);
+}
 
 initializeDb();