@vellumai/assistant 0.7.3 → 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

@@ -362,7 +362,9 @@ function getLatestAssistantText(conversationId: string): string | null {
     if (Array.isArray(parsed)) {
       return parsed
         .filter(
-          (block): block is {
+          (
+            block,
+          ): block is {
             type: string;
             text?: string;
             surfaceType?: string;
@@ -2303,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;
@@ -2332,7 +2452,7 @@ describe("relay-server", () => {
 
       expect(relay.getConnectionState()).toBe("awaiting_name");
 
-      // Fallback prompt should NOT include assistant name but should include guardian label
+      // Fallback prompt should use the existing guardian-label wording.
       const textMessages = ws.sentMessages
         .map((raw) => JSON.parse(raw) as { type: string; token?: string })
         .filter((m) => m.type === "text");
@@ -2348,6 +2468,48 @@ describe("relay-server", () => {
     }
   });
 
+  test("inbound voice: unknown caller name capture does not speak a UUID assistant name", async () => {
+    const prevName = mockAssistantName;
+    mockAssistantName = "11111111-2222-4333-8444-555555555555";
+    const db = getDb();
+    db.run("DELETE FROM contact_channels");
+    db.run("DELETE FROM contacts");
+    try {
+      ensureConversation("conv-invite-uuid-name");
+      const session = createCallSession({
+        conversationId: "conv-invite-uuid-name",
+        provider: "twilio",
+        fromNumber: "+12125550157",
+        toNumber: "+12125550111",
+      });
+
+      const { ws, relay } = createMockWs(session.id);
+
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "setup",
+          callSid: "CA_invite_uuid_name",
+          from: "+12125550157",
+          to: "+12125550111",
+        }),
+      );
+
+      expect(relay.getConnectionState()).toBe("awaiting_name");
+
+      const promptText = ws.sentMessages
+        .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+        .filter((m) => m.type === "text")
+        .map((m) => m.token ?? "")
+        .join("");
+      expect(promptText).toContain("Hi, this is my human's assistant.");
+      expect(promptText).not.toContain("11111111-2222-4333-8444-555555555555");
+
+      relay.destroy();
+    } finally {
+      mockAssistantName = prevName;
+    }
+  });
+
   // ── Friend-initiated in-call guardian approval flow ────────────────────
 
   test("name capture flow: caller provides name and enters guardian decision wait", async () => {

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: () => ({}),