@vellumai/assistant 0.8.6 → 0.8.7

package/src/__tests__/approval-cascade.test.ts

@@ -8,11 +8,8 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { Minimatch } from "minimatch";
 
-import type {
-  AgentEvent,
-  CheckpointDecision,
-  CheckpointInfo,
-} from "../agent/loop.js";
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
+import type { AgentEvent } from "../agent/loop.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { ConfirmationStateChanged } from "../daemon/message-types/messages.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
@@ -200,6 +197,7 @@ mock.module("../memory/llm-usage-store.js", () => ({
 
 mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
+    compactionCircuit = new CompactionCircuit("test-conv");
     constructor() {}
     getToolTokenBudget() {
       return 0;
@@ -213,11 +211,6 @@ mock.module("../agent/loop.js", () => ({
     async run(
       _messages: Message[],
       _onEvent: (event: AgentEvent) => void,
-      _signal?: AbortSignal,
-      _requestId?: string,
-      _onCheckpoint?: (
-        checkpoint: CheckpointInfo,
-      ) => CheckpointDecision | Promise<CheckpointDecision>,
     ): Promise<Message[]> {
       return [];
     }
@@ -279,9 +272,9 @@ function makeConversation(
     conversationId,
     makeProvider(),
     "system prompt",
-    4096,
     sendToClient ?? (() => {}),
     process.env.VELLUM_WORKSPACE_DIR!,
+    { maxTokens: 4096 },
   );
 }
 

package/src/__tests__/approval-routes-http.test.ts

@@ -181,8 +181,9 @@ function makeIdleSession(opts?: {
     runAgentLoop: async (
       _content: string,
       _messageId: string,
-      onEvent: (msg: ServerMessage) => void,
+      options?: { onEvent?: (msg: ServerMessage) => void },
     ) => {
+      const onEvent = options?.onEvent ?? (() => {});
       onEvent({ type: "assistant_text_delta", text: "Hello!" });
       onEvent({ type: "message_complete", conversationId: "test-session" });
       processing = false;
@@ -246,8 +247,9 @@ function makeConfirmationEmittingSession(opts?: {
     runAgentLoop: async (
       _content: string,
       _messageId: string,
-      onEvent: (msg: ServerMessage) => void,
+      options?: { onEvent?: (msg: ServerMessage) => void },
     ) => {
+      const onEvent = options?.onEvent ?? (() => {});
       // Simulate PermissionPrompter.prompt(): self-register in pendingInteractions
       // before emitting the SSE event (registration no longer happens via broadcastMessage).
       pendingInteractions.register(reqId, {

package/src/__tests__/assistant-event.test.ts

@@ -111,6 +111,21 @@ describe("formatSseFrame", () => {
     const frame = formatSseFrame(baseEvent);
     expect(frame.endsWith("\n\n")).toBe(true);
   });
+
+  test("seq lands in the JSON payload (envelope) when set, never in SSE id", () => {
+    const event: AssistantEvent = {
+      ...baseEvent,
+      id: "uuid-event-id",
+      seq: 42,
+    };
+    const frame = formatSseFrame(event);
+    // SSE wire id is always the UUID -- replay cursor is decoupled from
+    // the SSE protocol and lives on the envelope only.
+    const idLine = frame.split("\n").find((l) => l.startsWith("id: "))!;
+    expect(idLine).toBe("id: uuid-event-id");
+    // seq is on the envelope; consumers read it from the JSON payload.
+    expect(frame).toContain('"seq":42');
+  });
 });
 
 // ── Heartbeat tests ───────────────────────────────────────────────────────────

package/src/__tests__/assistant-feature-flags-integration.test.ts

@@ -12,7 +12,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 // Test-scoped config state
 // ---------------------------------------------------------------------------
 
-const DECLARED_FLAG_ID = "email-channel";
+const DECLARED_FLAG_ID = "a2a-channel";
 const DECLARED_FLAG_KEY = DECLARED_FLAG_ID;
 
 const { isAssistantFeatureFlagEnabled } =
@@ -56,7 +56,7 @@ describe("isAssistantFeatureFlagEnabled", () => {
 
   test("missing persisted value falls back to defaults registry defaultEnabled", () => {
     // No explicit config at all — should fall back to defaults registry
-    // which has defaultEnabled: false for email-channel
+    // which has defaultEnabled: false for a2a-channel
     const config = {} as any;
 
     expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(

package/src/__tests__/avatar-e2e.test.ts

@@ -6,10 +6,6 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 let mockGeminiKey: string | undefined = "test-gemini-key";
 
-const mkdirSyncFn = mock(() => {});
-const writeFileSyncFn = mock(() => {});
-const renameSyncFn = mock(() => {});
-
 let logInfoCalls: Array<[unknown, string]> = [];
 let logErrorCalls: Array<[unknown, string]> = [];
 
@@ -79,16 +75,6 @@ mock.module("pino-pretty", () => ({
   default: () => ({ write: () => true }),
 }));
 
-mock.module("node:fs", () => ({
-  mkdirSync: mkdirSyncFn,
-  writeFileSync: writeFileSyncFn,
-  renameSync: renameSyncFn,
-}));
-
-mock.module("node:crypto", () => ({
-  randomUUID: () => "00000000-0000-0000-0000-000000000000",
-}));
-
 mock.module("@google/genai", () => ({
   GoogleGenAI: class {
     models = {
@@ -105,14 +91,14 @@ mock.module("@google/genai", () => ({
 }));
 
 // Import after all mocks are set up
-import { generateAndSaveAvatar } from "../tools/system/avatar-generator.js";
+import { generateAvatarImage } from "../tools/system/avatar-generator.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
 function executeAvatar(description: string) {
-  return generateAndSaveAvatar(description);
+  return generateAvatarImage(description);
 }
 
 /** Standard successful Gemini generateContent response. */
@@ -135,8 +121,6 @@ function geminiContentResponse() {
   };
 }
 
-const expectedAvatarPath = `${process.env.VELLUM_WORKSPACE_DIR}/data/avatar/avatar-image.png`;
-
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -147,9 +131,6 @@ describe("avatar E2E integration", () => {
 
   beforeEach(() => {
     mockGeminiKey = "test-gemini-key";
-    mkdirSyncFn.mockClear();
-    writeFileSyncFn.mockClear();
-    renameSyncFn.mockClear();
     geminiGenerateContentFn.mockClear();
 
     logInfoCalls = [];
@@ -174,29 +155,18 @@ describe("avatar E2E integration", () => {
   // 1. Local Gemini success
   // -----------------------------------------------------------------------
 
-  test("local Gemini success — file written, correct content, success message", async () => {
+  test("local Gemini success — returns PNG bytes and success message", async () => {
     const result = await executeAvatar("a friendly robot");
 
     // Verify success message
     expect(result.isError).toBe(false);
     expect(result.content).toContain("Avatar updated");
 
-    // Verify file was written
-    expect(mkdirSyncFn).toHaveBeenCalledTimes(1);
-    expect(writeFileSyncFn).toHaveBeenCalledTimes(1);
-    expect(renameSyncFn).toHaveBeenCalledTimes(1);
-
-    // Verify rename target is the expected avatar path
-    expect((renameSyncFn.mock.calls[0] as unknown[])[1]).toBe(
-      expectedAvatarPath,
-    );
-
-    // Verify the written buffer content matches the base64 data
-    const writtenBuffer = (
-      writeFileSyncFn.mock.calls[0] as unknown[]
-    )[1] as Buffer;
+    // Verify the returned buffer content matches the base64 data. Persistence
+    // is the caller's job (the route routes these bytes through the store).
     const expectedBuffer = Buffer.from("iVBORw0KGgoAAAANSUhEUg==", "base64");
-    expect(writtenBuffer.equals(expectedBuffer)).toBe(true);
+    expect(result.pngBuffer).not.toBeNull();
+    expect(result.pngBuffer?.equals(expectedBuffer)).toBe(true);
 
     // Verify Gemini was called
     expect(geminiGenerateContentFn).toHaveBeenCalledTimes(1);

package/src/__tests__/avatar-generator.test.ts

@@ -12,10 +12,6 @@ const generateAvatarFn = mock(async () => {
   return mockRouterResult;
 });
 
-const mkdirSyncFn = mock(() => {});
-const writeFileSyncFn = mock(() => {});
-const renameSyncFn = mock(() => {});
-
 // ---------------------------------------------------------------------------
 // Mock modules — before importing module under test
 // ---------------------------------------------------------------------------
@@ -33,56 +29,51 @@ mock.module("../util/logger.js", () => ({
   }),
 }));
 
-mock.module("node:fs", () => ({
-  mkdirSync: mkdirSyncFn,
-  writeFileSync: writeFileSyncFn,
-  renameSync: renameSyncFn,
-}));
-
 // Import after mocking
-import { generateAndSaveAvatar } from "../tools/system/avatar-generator.js";
+import { generateAvatarImage } from "../tools/system/avatar-generator.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
+const PNG_BASE64 = "iVBORw0KGgoAAAANSUhEUg==";
+
 function successResult() {
   return {
-    imageBase64: "iVBORw0KGgoAAAANSUhEUg==",
+    imageBase64: PNG_BASE64,
     mimeType: "image/png",
   };
 }
 
 function executeAvatar(description: string) {
-  return generateAndSaveAvatar(description);
+  return generateAvatarImage(description);
 }
 
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
 
-describe("generateAndSaveAvatar", () => {
+describe("generateAvatarImage", () => {
   beforeEach(() => {
     mockRouterResult = successResult();
     mockRouterError = undefined;
     generateAvatarFn.mockClear();
-    mkdirSyncFn.mockClear();
-    writeFileSyncFn.mockClear();
-    renameSyncFn.mockClear();
   });
 
-  test("successful generation writes PNG and returns success message", async () => {
+  test("successful generation returns PNG bytes and success message", async () => {
     const result = await executeAvatar("a friendly purple cat");
 
     expect(result.isError).toBe(false);
     expect(result.content).toContain("Avatar updated");
+    expect(result.pngBuffer).toEqual(Buffer.from(PNG_BASE64, "base64"));
     expect(generateAvatarFn).toHaveBeenCalledTimes(1);
   });
 
-  test("empty description returns error", async () => {
+  test("empty description returns error and no buffer", async () => {
     const result = await executeAvatar("");
 
     expect(result.isError).toBe(true);
+    expect(result.pngBuffer).toBeNull();
     expect(result.content).toContain("description is required");
     expect(generateAvatarFn).not.toHaveBeenCalled();
   });
@@ -93,6 +84,7 @@ describe("generateAndSaveAvatar", () => {
     const result = await executeAvatar("a cat");
 
     expect(result.isError).toBe(true);
+    expect(result.pngBuffer).toBeNull();
     expect(result.content).toContain("No image data returned");
   });
 
@@ -104,31 +96,9 @@ describe("generateAndSaveAvatar", () => {
     const result = await executeAvatar("a cat");
 
     expect(result.isError).toBe(true);
+    expect(result.pngBuffer).toBeNull();
     expect(result.content).toContain(
       "Image generation failed: Network timeout",
     );
   });
-
-  test("atomic write — file is written to .tmp then renamed", async () => {
-    await executeAvatar("a friendly cat");
-
-    const expectedPath = `${process.env.VELLUM_WORKSPACE_DIR}/data/avatar/avatar-image.png`;
-
-    // Verify mkdirSync was called for the directory
-    expect(mkdirSyncFn).toHaveBeenCalledTimes(1);
-    expect((mkdirSyncFn.mock.calls[0] as unknown[])[1]).toEqual({
-      recursive: true,
-    });
-
-    // Verify writeFileSync writes to a unique tmp path
-    expect(writeFileSyncFn).toHaveBeenCalledTimes(1);
-    const tmpPath = (writeFileSyncFn.mock.calls[0] as unknown[])[0] as string;
-    expect(tmpPath).toStartWith(expectedPath + ".");
-    expect(tmpPath).toEndWith(".tmp");
-
-    // Verify renameSync moves tmp to final path
-    expect(renameSyncFn).toHaveBeenCalledTimes(1);
-    expect((renameSyncFn.mock.calls[0] as unknown[])[0]).toBe(tmpPath);
-    expect((renameSyncFn.mock.calls[0] as unknown[])[1]).toBe(expectedPath);
-  });
 });

package/src/__tests__/avatar-identity-sync.test.ts

@@ -4,7 +4,10 @@ import { SYNC_TAGS } from "../daemon/message-types/sync.js";
 import type { AssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES as AVATAR_ROUTES } from "../runtime/routes/avatar-routes.js";
-import { publishIdentityChanged } from "../runtime/sync/resource-sync-events.js";
+import {
+  publishIdentityChanged,
+  publishIdentityIntroChanged,
+} from "../runtime/sync/resource-sync-events.js";
 
 async function waitFor(predicate: () => boolean): Promise<void> {
   const deadline = Date.now() + 500;
@@ -49,7 +52,7 @@ describe("avatar and identity sync events", () => {
     }
   });
 
-  test("identity changes emit legacy identity event and sync tag", async () => {
+  test("identity changes emit legacy identity event and identity sync tags", async () => {
     const received: AssistantEvent[] = [];
     const subscription = assistantEventHub.subscribe({
       type: "process",
@@ -78,7 +81,29 @@ describe("avatar and identity sync events", () => {
       });
       expect(received[1].message).toEqual({
         type: "sync_changed",
-        tags: [SYNC_TAGS.assistantIdentity],
+        tags: [SYNC_TAGS.assistantIdentity, SYNC_TAGS.assistantIdentityIntro],
+      });
+    } finally {
+      subscription.dispose();
+    }
+  });
+
+  test("identity intro changes emit only the identity intro sync tag", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      publishIdentityIntroChanged();
+      await waitFor(() => received.length === 1);
+
+      expect(received[0].message).toEqual({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantIdentityIntro],
       });
     } finally {
       subscription.dispose();

package/src/__tests__/background-shell-bash.test.ts

@@ -2,7 +2,6 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { WakeOptions } from "../runtime/agent-wake.js";
 import type { BackgroundTool } from "../tools/background-tool-registry.js";
-import type { Tool } from "../tools/types.js";
 
 // ── Mock modules ────────────────────────────────────────────────────────────
 
@@ -88,6 +87,8 @@ mock.module("../tools/background-tool-registry.js", () => ({
 
 // ── Imports (after mocks) ───────────────────────────────────────────────────
 
+import { shellTool } from "../tools/terminal/shell.js";
+
 const baseContext = {
   workingDir: process.env.VELLUM_WORKSPACE_DIR ?? "/tmp",
   conversationId: "conv-bg-test",
@@ -117,9 +118,7 @@ function waitForWake(
 }
 
 describe("bash tool background mode", () => {
-  let shellTool: Tool;
-
-  beforeEach(async () => {
+  beforeEach(() => {
     mockWakeAgentForOpportunity.mockClear();
     mockRegisterBackgroundTool.mockClear();
     mockRemoveBackgroundTool.mockClear();
@@ -128,9 +127,6 @@ describe("bash tool background mode", () => {
     mockIsBackgroundToolLimitReached.mockClear();
     mockIsBackgroundToolLimitReached.mockReturnValue(false);
     registeredTools.length = 0;
-
-    const mod = await import("../tools/terminal/shell.js");
-    shellTool = mod.shellTool;
   });
 
   afterEach(() => {

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

@@ -131,16 +131,12 @@ import type { RouteHandlerArgs } from "../runtime/routes/types.js";
 function makeMockProvider(
   onSendMessage?: (
     messages: unknown[],
-    tools: unknown[],
-    systemPrompt: string | undefined,
-    options: SendMessageOptions | undefined,
+    options?: SendMessageOptions,
   ) => Promise<ProviderResponse>,
 ) {
   const defaultSendMessage = async (
     _messages: unknown[],
-    _tools: unknown[],
-    _systemPrompt: string | undefined,
-    options: SendMessageOptions | undefined,
+    options?: SendMessageOptions,
   ): Promise<ProviderResponse> => {
     options?.onEvent?.({ type: "text_delta", text: "hello" });
     return {
@@ -299,8 +295,7 @@ describe("POST /v1/btw", () => {
 
     expect(provider.sendMessage).toHaveBeenCalledTimes(1);
 
-    const [messages, tools, systemPrompt, options] =
-      provider.sendMessage.mock.calls[0];
+    const [messages, options] = provider.sendMessage.mock.calls[0];
 
     expect(messages).toHaveLength(3);
     expect(messages[0]).toEqual({
@@ -316,8 +311,8 @@ describe("POST /v1/btw", () => {
       content: [{ type: "text", text: "my question" }],
     });
 
-    expect(tools).toEqual(MOCK_TOOLS);
-    expect(systemPrompt).toBe(MOCK_SYSTEM_PROMPT);
+    expect(options!.tools).toEqual(MOCK_TOOLS);
+    expect(options!.systemPrompt).toBe(MOCK_SYSTEM_PROMPT);
     // Persona is resolved internally now; btw-routes no longer plumbs
     // it through to buildSystemPrompt.
     expect(mockBuildSystemPrompt).toHaveBeenCalledWith({
@@ -341,7 +336,7 @@ describe("POST /v1/btw", () => {
     await readStream(result as ReadableStream<Uint8Array>);
 
     expect(provider.sendMessage).toHaveBeenCalledTimes(1);
-    const [, , , options] = provider.sendMessage.mock.calls[0];
+    const [, options] = provider.sendMessage.mock.calls[0];
     expect(options!.config!.callSite).toBe("emptyStateGreeting");
   });
 
@@ -357,7 +352,7 @@ describe("POST /v1/btw", () => {
     await readStream(result as ReadableStream<Uint8Array>);
 
     expect(provider.sendMessage).toHaveBeenCalledTimes(1);
-    const [, , , options] = provider.sendMessage.mock.calls[0];
+    const [, options] = provider.sendMessage.mock.calls[0];
     expect(options!.config!.callSite).toBe("identityIntro");
   });
 

package/src/__tests__/call-pointer-messages.test.ts

@@ -314,7 +314,7 @@ describe("addPointerMessage", () => {
     ensureConversation(convId);
     // Add a user message with guardian provenance metadata
     await addMessage(convId, "user", "hello", {
-      provenanceTrustClass: "guardian",
+      metadata: { provenanceTrustClass: "guardian" },
     });
 
     let processorCalled = false;
@@ -331,7 +331,7 @@ describe("addPointerMessage", () => {
     ensureConversation(convId);
     // Add a user message with trusted_contact provenance metadata
     await addMessage(convId, "user", "hello", {
-      provenanceTrustClass: "trusted_contact",
+      metadata: { provenanceTrustClass: "trusted_contact" },
     });
 
     let processorCalled = false;
@@ -346,7 +346,9 @@ describe("addPointerMessage", () => {
   test("unknown provenance trust class does not grant trusted audience", () => {
     const convId = "conv-ptr-unknown-provenance";
     ensureConversation(convId);
-    addMessage(convId, "user", "hello", { provenanceTrustClass: "unknown" });
+    addMessage(convId, "user", "hello", {
+      metadata: { provenanceTrustClass: "unknown" },
+    });
 
     const processorCalled = { value: false };
     setPointerMessageProcessor(async () => {

package/src/__tests__/call-site-routing-provider.test.ts

@@ -58,7 +58,7 @@ function makeProvider(
 ): Provider {
   return {
     name,
-    async sendMessage(_messages, _tools, _systemPrompt, options) {
+    async sendMessage(_messages: Message[], options?: SendMessageOptions) {
       onCall(options);
       return makeResponse(name);
     },
@@ -118,10 +118,7 @@ describe("CallSiteRoutingProvider", () => {
     );
 
     const response = await wrapped.sendMessage(
-      DUMMY_MESSAGES,
-      undefined,
-      undefined,
-      // No callSite — must hit default even though `memoryRetrieval` is
+      DUMMY_MESSAGES, // No callSite — must hit default even though `memoryRetrieval` is
       // configured for openai.
       { config: {} },
     );
@@ -154,7 +151,7 @@ describe("CallSiteRoutingProvider", () => {
       makeConnectionHook({ "openai-conn": altProvider }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "memoryRetrieval" },
     });
 
@@ -190,12 +187,9 @@ describe("CallSiteRoutingProvider", () => {
       makeConnectionHook({ "openai-conn": altProvider }),
     );
 
-    const response = await wrapped.sendMessage(
-      DUMMY_MESSAGES,
-      undefined,
-      undefined,
-      { config: { callSite: "memoryRetrieval" } },
-    );
+    const response = await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "memoryRetrieval" },
+    });
 
     expect(calls.default).toBe(0);
     expect(calls.alt).toBe(1);
@@ -229,12 +223,9 @@ describe("CallSiteRoutingProvider", () => {
       async () => null,
     );
 
-    const response = await wrapped.sendMessage(
-      DUMMY_MESSAGES,
-      undefined,
-      undefined,
-      { config: { callSite: "memoryRetrieval" } },
-    );
+    const response = await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "memoryRetrieval" },
+    });
 
     expect(calls.default).toBe(1);
     expect(response.model).toBe("anthropic");
@@ -265,7 +256,7 @@ describe("CallSiteRoutingProvider", () => {
 
     let caught: unknown;
     try {
-      await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      await wrapped.sendMessage(DUMMY_MESSAGES, {
         config: { callSite: "memoryRetrieval" },
       });
     } catch (err) {
@@ -301,12 +292,9 @@ describe("CallSiteRoutingProvider", () => {
       makeConnectionHook({ "openai-conn": altProvider }),
     );
 
-    const response = await wrapped.sendMessage(
-      DUMMY_MESSAGES,
-      undefined,
-      undefined,
-      { config: { callSite: "memoryRetrieval" } },
-    );
+    const response = await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "memoryRetrieval" },
+    });
 
     // actualProvider must reflect the alternative, not the default, so that
     // loop.ts / emitUsage / llm_call_finished log and bill the correct
@@ -346,12 +334,9 @@ describe("CallSiteRoutingProvider", () => {
       makeConnectionHook({ "openai-conn": altProvider }),
     );
 
-    const response = await wrapped.sendMessage(
-      DUMMY_MESSAGES,
-      undefined,
-      undefined,
-      { config: { callSite: "memoryRetrieval" } },
-    );
+    const response = await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "memoryRetrieval" },
+    });
 
     expect(response.actualProvider).toBe("openai-via-proxy");
   });
@@ -368,12 +353,9 @@ describe("CallSiteRoutingProvider", () => {
       makeConnectionHook({}),
     );
 
-    const response = await wrapped.sendMessage(
-      DUMMY_MESSAGES,
-      undefined,
-      undefined,
-      { config: { callSite: "memoryRetrieval" } },
-    );
+    const response = await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "memoryRetrieval" },
+    });
 
     // No alternative was resolved — actualProvider should stay unset.
     expect(response.actualProvider).toBeUndefined();
@@ -434,7 +416,7 @@ describe("CallSiteRoutingProvider", () => {
     );
 
     expect(wrapped.name).toBe("anthropic"); // idle → default
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "memoryRetrieval" },
     });
     expect(namesDuringCall).toEqual(["openai"]); // mid-call → routed provider
@@ -511,10 +493,10 @@ describe("CallSiteRoutingProvider", () => {
     );
 
     // Start both calls concurrently (do not await yet).
-    const callA = wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    const callA = wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "memoryRetrieval" }, // → openai
     });
-    const callB = wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    const callB = wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "conversationTitle" }, // → fireworks
     });
 

package/src/__tests__/catalog-files.test.ts

@@ -963,6 +963,7 @@ describe("createVellumCatalogProvider", () => {
     expect(slim!.kind).toBe("catalog");
     expect(slim!.origin).toBe("vellum");
     expect(slim!.status).toBe("available");
+    expect(slim!.category).toBe("knowledge");
   });
 
   test("toSlimSkill returns null for unknown skill", async () => {