@vellumai/assistant 0.8.0 → 0.8.1

package/src/__tests__/provider-managed-proxy-integration.test.ts

@@ -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,
+      },
+    },
   };
 }
 

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__/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();
 

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

@@ -334,6 +334,110 @@ describe("schedule runs list — limit handling", () => {
   });
 });
 
+// ── POST /schedules — create ─────────────────────────────────────────────
+
+describe("POST /schedules — create", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  function postCreate(body: Record<string, unknown>) {
+    const route = findRoute("schedules", "POST");
+    return route.handler({ body }) as { schedules: Array<{ id: string }> };
+  }
+
+  test("creates a recurring execute schedule with defaults", () => {
+    const result = postCreate({
+      name: "Morning ping",
+      expression: "0 9 * * *",
+      message: "good morning",
+    });
+    expect(result.schedules).toHaveLength(1);
+    const job = listSchedules()[0];
+    expect(job.name).toBe("Morning ping");
+    expect(job.mode).toBe("execute");
+    expect(job.expression).toBe("0 9 * * *");
+    expect(job.syntax).toBe("cron");
+    expect(job.enabled).toBe(true);
+    expect(job.timezone).toBeNull();
+  });
+
+  test("trims whitespace and accepts an explicit timezone", () => {
+    postCreate({
+      name: "  Trimmed  ",
+      expression: "  0 9 * * *  ",
+      message: "hi",
+      timezone: " America/New_York ",
+    });
+    const job = listSchedules()[0];
+    expect(job.name).toBe("Trimmed");
+    expect(job.expression).toBe("0 9 * * *");
+    expect(job.timezone).toBe("America/New_York");
+  });
+
+  test("accepts an rrule expression and detects syntax", () => {
+    const expression = "DTSTART:20260101T000000Z\nRRULE:FREQ=WEEKLY;BYDAY=MO";
+    postCreate({
+      name: "Weekly",
+      expression,
+      message: "monday wake",
+    });
+    const job = listSchedules()[0];
+    expect(job.syntax).toBe("rrule");
+    expect(job.expression).toBe(expression);
+  });
+
+  test("rejects missing required fields", () => {
+    expect(() => postCreate({ expression: "* * * * *", message: "hi" })).toThrow(
+      "name is required",
+    );
+    expect(() => postCreate({ name: "x", message: "hi" })).toThrow(
+      "expression is required",
+    );
+    expect(() => postCreate({ name: "x", expression: "* * * * *" })).toThrow(
+      "message is required",
+    );
+  });
+
+  test("rejects non-execute modes", () => {
+    expect(() =>
+      postCreate({
+        name: "x",
+        expression: "* * * * *",
+        message: "hi",
+        mode: "notify",
+      }),
+    ).toThrow("Only 'execute' mode is supported");
+  });
+
+  test("rejects an unparseable expression", () => {
+    expect(() =>
+      postCreate({ name: "x", expression: "not-a-cron", message: "hi" }),
+    ).toThrow("could not be parsed");
+  });
+
+  test("surfaces invalid-cron errors from the store as 400s", () => {
+    expect(() =>
+      postCreate({
+        name: "x",
+        expression: "99 99 99 99 99",
+        message: "hi",
+      }),
+    ).toThrow();
+  });
+
+  test("respects enabled=false", () => {
+    postCreate({
+      name: "Off",
+      expression: "0 9 * * *",
+      message: "hi",
+      enabled: false,
+    });
+    const job = listSchedules()[0];
+    expect(job.enabled).toBe(false);
+  });
+});
+
 // ── Wake mode support ─────────────────────────────────────────────────────
 
 describe("wake mode in schedule routes", () => {

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

@@ -16,10 +16,6 @@ mock.module("../runtime/agent-wake.js", () => ({
   ),
 }));
 
-mock.module("../home/emit-feed-event.js", () => ({
-  emitFeedEvent: mock(() => Promise.resolve()),
-}));
-
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({}),
   loadConfig: () => ({}),

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();