@vellumai/assistant 0.7.0 → 0.7.1

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

@@ -12,7 +12,6 @@ describe("AssistantEvent shape", () => {
   test("accepts a minimal valid event", () => {
     const event: AssistantEvent = {
       id: "evt_001",
-      assistantId: "ast_123",
       emittedAt: "2026-02-18T21:20:00.000Z",
       message: {
         type: "assistant_text_delta",
@@ -22,7 +21,6 @@ describe("AssistantEvent shape", () => {
     };
 
     expect(event.id).toBe("evt_001");
-    expect(event.assistantId).toBe("ast_123");
     expect(event.conversationId).toBeUndefined();
     expect(event.emittedAt).toBe("2026-02-18T21:20:00.000Z");
     expect(event.message.type).toBe("assistant_text_delta");
@@ -31,7 +29,6 @@ describe("AssistantEvent shape", () => {
   test("accepts a full event with conversationId", () => {
     const event: AssistantEvent = {
       id: "evt_002",
-      assistantId: "ast_123",
       conversationId: "conv_456",
       emittedAt: "2026-02-18T21:20:00.000Z",
       message: {
@@ -50,7 +47,6 @@ describe("AssistantEvent shape", () => {
 describe("formatSseFrame", () => {
   const baseEvent: AssistantEvent = {
     id: "evt_003",
-    assistantId: "ast_abc",
     conversationId: "sess_xyz",
     emittedAt: "2026-02-18T00:00:00.000Z",
     message: {
@@ -80,7 +76,6 @@ describe("formatSseFrame", () => {
     ) as AssistantEvent;
 
     expect(parsed.id).toBe(baseEvent.id);
-    expect(parsed.assistantId).toBe(baseEvent.assistantId);
     expect(parsed.conversationId).toBe(baseEvent.conversationId);
     expect(parsed.emittedAt).toBe(baseEvent.emittedAt);
     expect(parsed.message.type).toBe("assistant_text_delta");

package/src/__tests__/assistant-events-sse-hardening.test.ts

@@ -32,9 +32,7 @@ mock.module("../config/loader.js", () => ({
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
-import {
-  ServiceUnavailableError,
-} from "../runtime/routes/errors.js";
+import { ServiceUnavailableError } from "../runtime/routes/errors.js";
 import { handleSubscribeAssistantEvents } from "../runtime/routes/events-routes.js";
 
 initializeDb();
@@ -54,14 +52,18 @@ describe("AssistantEventHub — subscriber cap", () => {
     const hub = new AssistantEventHub({ maxSubscribers: 1 });
     const evicted: string[] = [];
 
-    const sub1 = hub.subscribe({ assistantId: "ast_1" }, () => {}, {
+    const sub1 = hub.subscribe({
+      type: "process",
+      callback: () => {},
       onEvict: () => evicted.push("sub1"),
     });
     expect(hub.subscriberCount()).toBe(1);
     expect(sub1.active).toBe(true);
 
     // Adding sub2 evicts sub1 to make room.
-    const sub2 = hub.subscribe({ assistantId: "ast_1" }, () => {}, {
+    const sub2 = hub.subscribe({
+      type: "process",
+      callback: () => {},
       onEvict: () => evicted.push("sub2"),
     });
 
@@ -77,15 +79,21 @@ describe("AssistantEventHub — subscriber cap", () => {
     const hub = new AssistantEventHub({ maxSubscribers: 2 });
     const evicted: number[] = [];
 
-    const sub1 = hub.subscribe({ assistantId: "ast_1" }, () => {}, {
+    const sub1 = hub.subscribe({
+      type: "process",
+      callback: () => {},
       onEvict: () => evicted.push(1),
     });
-    const sub2 = hub.subscribe({ assistantId: "ast_1" }, () => {}, {
+    const sub2 = hub.subscribe({
+      type: "process",
+      callback: () => {},
       onEvict: () => evicted.push(2),
     });
 
     // 3rd subscriber evicts oldest (sub1)
-    const sub3 = hub.subscribe({ assistantId: "ast_1" }, () => {}, {
+    const sub3 = hub.subscribe({
+      type: "process",
+      callback: () => {},
       onEvict: () => evicted.push(3),
     });
     expect(evicted).toEqual([1]);
@@ -93,7 +101,9 @@ describe("AssistantEventHub — subscriber cap", () => {
     expect(sub2.active).toBe(true);
 
     // 4th subscriber evicts next oldest (sub2)
-    const sub4 = hub.subscribe({ assistantId: "ast_1" }, () => {}, {
+    const sub4 = hub.subscribe({
+      type: "process",
+      callback: () => {},
       onEvict: () => evicted.push(4),
     });
     expect(evicted).toEqual([1, 2]);
@@ -107,19 +117,28 @@ describe("AssistantEventHub — subscriber cap", () => {
 
   test("maxSubscribers: 0 throws RangeError (nothing to evict)", () => {
     const hub = new AssistantEventHub({ maxSubscribers: 0 });
-    expect(() => hub.subscribe({ assistantId: "ast_1" }, () => {})).toThrow(
-      RangeError,
-    );
+    expect(() =>
+      hub.subscribe({
+        type: "process",
+        callback: () => {},
+      }),
+    ).toThrow(RangeError);
   });
 
   test("subscribe succeeds after disposal frees a slot", () => {
     const hub = new AssistantEventHub({ maxSubscribers: 1 });
-    const sub = hub.subscribe({ assistantId: "ast_1" }, () => {});
+    const sub = hub.subscribe({
+      type: "process",
+      callback: () => {},
+    });
     sub.dispose();
 
     // Should not throw now that the slot is free.
     expect(() =>
-      hub.subscribe({ assistantId: "ast_1" }, () => {}),
+      hub.subscribe({
+        type: "process",
+        callback: () => {},
+      }),
     ).not.toThrow();
   });
 
@@ -127,7 +146,10 @@ describe("AssistantEventHub — subscriber cap", () => {
     const hub = new AssistantEventHub();
     const N = 50;
     const subs = Array.from({ length: N }, () =>
-      hub.subscribe({ assistantId: "ast_1" }, () => {}),
+      hub.subscribe({
+        type: "process",
+        callback: () => {},
+      }),
     );
     expect(hub.subscriberCount()).toBe(N);
     subs.forEach((s) => s.dispose());

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

@@ -98,32 +98,3 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
     ).toBe(true);
   });
 });
-
-// ---------------------------------------------------------------------------
-// compaction-v2 flag (opt-in): ensures registry-declared defaultEnabled=false
-// is honored and that an explicit override can flip it on. Guards the rollout
-// gate for the boundary-message-based compaction pipeline introduced in
-// later PRs.
-// ---------------------------------------------------------------------------
-
-describe("compaction-v2 flag", () => {
-  test("defaults to false (disabled) when no override is set", () => {
-    const config = {} as any;
-
-    expect(isAssistantFeatureFlagEnabled("compaction-v2", config)).toBe(false);
-  });
-
-  test("returns true when explicitly overridden to true", () => {
-    _setOverridesForTesting({ "compaction-v2": true });
-    const config = {} as any;
-
-    expect(isAssistantFeatureFlagEnabled("compaction-v2", config)).toBe(true);
-  });
-
-  test("returns false when explicitly overridden to false", () => {
-    _setOverridesForTesting({ "compaction-v2": false });
-    const config = {} as any;
-
-    expect(isAssistantFeatureFlagEnabled("compaction-v2", config)).toBe(false);
-  });
-});

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

@@ -66,8 +66,6 @@ const mockConfig = {
   rateLimit: { maxRequestsPerMinute: 0 },
   secretDetection: {
     enabled: true,
-    action: "warn" as const,
-    entropyThreshold: 4.0,
   },
   auditLog: { retentionDays: 0 },
 };
@@ -90,12 +88,24 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-mock.module("../tools/terminal/sandbox.js", () => ({
-  wrapCommand: (...args: unknown[]) => ({
-    command: "bash",
-    args: ["-c", "--", args[0]],
-    sandboxed: false,
-  }),
+// Mock HostBashProxy singleton — proxy delegation tests configure this.
+let mockProxyAvailable = false;
+let mockProxyRequestImpl: (
+  input: { command: string; working_dir?: string; timeout_seconds?: number; env?: Record<string, string> },
+  conversationId: string,
+  signal?: AbortSignal,
+) => Promise<ToolExecutionResult> = () => Promise.resolve({ content: "", isError: false });
+
+mock.module("../daemon/host-bash-proxy.js", () => ({
+  HostBashProxy: {
+    get instance() {
+      return {
+        isAvailable: () => mockProxyAvailable,
+        request: (...args: Parameters<typeof mockProxyRequestImpl>) =>
+          mockProxyRequestImpl(...args),
+      };
+    },
+  },
 }));
 
 // ---------------------------------------------------------------------------
@@ -118,7 +128,7 @@ function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
   };
 }
 
-function makeMockProxy(result: ToolExecutionResult) {
+function setupMockProxy(result: ToolExecutionResult) {
   const requestMock = mock(
     (
       _input: {
@@ -132,17 +142,10 @@ function makeMockProxy(result: ToolExecutionResult) {
     ) => Promise.resolve(result),
   );
 
-  return {
-    proxy: {
-      isAvailable: () => true,
-      request: requestMock,
-      updateSender: () => {},
-      dispose: () => {},
-      resolve: () => {},
-      hasPendingRequest: () => false,
-    },
-    requestMock,
-  };
+  mockProxyAvailable = true;
+  mockProxyRequestImpl = requestMock;
+
+  return requestMock;
 }
 
 // ---------------------------------------------------------------------------
@@ -158,10 +161,13 @@ beforeEach(() => {
   mockIsBackgroundToolLimitReached.mockClear();
   mockIsBackgroundToolLimitReached.mockReturnValue(false);
   latestChild = undefined;
+  mockProxyAvailable = false;
+  mockProxyRequestImpl = () => Promise.resolve({ content: "", isError: false });
 });
 
 afterEach(() => {
   latestChild = undefined;
+  mockProxyAvailable = false;
 });
 
 // ---------------------------------------------------------------------------
@@ -174,10 +180,9 @@ describe("host_bash background mode — proxy path", () => {
       content: "proxy output",
       isError: false,
     };
-    const { proxy } = makeMockProxy(proxyResult);
+    setupMockProxy(proxyResult);
 
     const ctx = makeContext({
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
     });
 
     const result = await hostShellTool.execute(
@@ -196,10 +201,9 @@ describe("host_bash background mode — proxy path", () => {
       content: "proxy output",
       isError: false,
     };
-    const { proxy } = makeMockProxy(proxyResult);
+    setupMockProxy(proxyResult);
 
     const ctx = makeContext({
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
     });
 
     await hostShellTool.execute(
@@ -221,10 +225,9 @@ describe("host_bash background mode — proxy path", () => {
       content: "proxy success output",
       isError: false,
     };
-    const { proxy } = makeMockProxy(proxyResult);
+    setupMockProxy(proxyResult);
 
     const ctx = makeContext({
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
     });
 
     await hostShellTool.execute(
@@ -252,10 +255,9 @@ describe("host_bash background mode — proxy path", () => {
       content: "command not found",
       isError: true,
     };
-    const { proxy } = makeMockProxy(proxyResult);
+    setupMockProxy(proxyResult);
 
     const ctx = makeContext({
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
     });
 
     await hostShellTool.execute(
@@ -274,21 +276,11 @@ describe("host_bash background mode — proxy path", () => {
   });
 
   test("calls wakeAgentForOpportunity on proxy rejection", async () => {
-    const requestMock = mock(() =>
-      Promise.reject(new Error("proxy transport error")),
-    );
-
-    const proxy = {
-      isAvailable: () => true,
-      request: requestMock,
-      updateSender: () => {},
-      dispose: () => {},
-      resolve: () => {},
-      hasPendingRequest: () => false,
-    };
+    mockProxyAvailable = true;
+    mockProxyRequestImpl = () =>
+      Promise.reject(new Error("proxy transport error"));
 
     const ctx = makeContext({
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
     });
 
     await hostShellTool.execute(
@@ -311,10 +303,9 @@ describe("host_bash background mode — proxy path", () => {
       content: "done",
       isError: false,
     };
-    const { proxy } = makeMockProxy(proxyResult);
+    setupMockProxy(proxyResult);
 
     const ctx = makeContext({
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
     });
 
     const result = await hostShellTool.execute(

package/src/__tests__/call-controller.test.ts

@@ -243,7 +243,6 @@ import {
 import type { CallTransport } from "../calls/call-transport.js";
 import { resolveCallTtsProvider } from "../calls/resolve-call-tts-provider.js";
 import { loadConfig } from "../config/loader.js";
-import { createGuardianBinding } from "../contacts/contacts-write.js";
 import {
   getCanonicalGuardianRequest,
   getPendingCanonicalRequestByCallSessionId,
@@ -253,6 +252,7 @@ import { getDb, resetDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { resetTestTables } from "../memory/raw-query.js";
 import { conversations } from "../memory/schema.js";
+import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
 initializeDb();
 

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

@@ -194,6 +194,91 @@ describe("CallSiteRoutingProvider", () => {
     expect(response.model).toBe("anthropic");
   });
 
+  test("stamps actualProvider when routing to an alternative provider", async () => {
+    setLlmConfig({
+      default: { provider: "anthropic", model: "claude-opus-4-7" },
+      callSites: {
+        memoryRetrieval: { provider: "openai", model: "gpt-5.5" },
+      },
+    });
+
+    const defaultProvider = makeProvider("anthropic", () => {});
+    const altProvider = makeProvider("openai", () => {});
+
+    const wrapped = new CallSiteRoutingProvider(defaultProvider, (name) =>
+      name === "openai" ? altProvider : undefined,
+    );
+
+    const response = await wrapped.sendMessage(
+      DUMMY_MESSAGES,
+      undefined,
+      undefined,
+      { config: { callSite: "memoryRetrieval" } },
+    );
+
+    // actualProvider must reflect the alternative, not the default, so that
+    // loop.ts / emitUsage / llm_call_finished log and bill the correct
+    // provider (fixes gpt-5.5 showing as "anthropic" with $0 cost).
+    expect(response.actualProvider).toBe("openai");
+  });
+
+  test("does not overwrite actualProvider already set by the alternative provider", async () => {
+    setLlmConfig({
+      default: { provider: "anthropic", model: "claude-opus-4-7" },
+      callSites: {
+        memoryRetrieval: { provider: "openai", model: "gpt-5.5" },
+      },
+    });
+
+    const defaultProvider = makeProvider("anthropic", () => {});
+    // Simulate a wrapper provider that sets actualProvider itself
+    const altProvider: Provider = {
+      name: "openai",
+      async sendMessage() {
+        return {
+          ...makeResponse("openai"),
+          actualProvider: "openai-via-proxy",
+        };
+      },
+    };
+
+    const wrapped = new CallSiteRoutingProvider(defaultProvider, (name) =>
+      name === "openai" ? altProvider : undefined,
+    );
+
+    const response = await wrapped.sendMessage(
+      DUMMY_MESSAGES,
+      undefined,
+      undefined,
+      { config: { callSite: "memoryRetrieval" } },
+    );
+
+    expect(response.actualProvider).toBe("openai-via-proxy");
+  });
+
+  test("does not set actualProvider when routing to the default provider", async () => {
+    setLlmConfig({
+      default: { provider: "anthropic", model: "claude-opus-4-7" },
+    });
+
+    const defaultProvider = makeProvider("anthropic", () => {});
+
+    const wrapped = new CallSiteRoutingProvider(
+      defaultProvider,
+      () => undefined,
+    );
+
+    const response = await wrapped.sendMessage(
+      DUMMY_MESSAGES,
+      undefined,
+      undefined,
+      { config: { callSite: "memoryRetrieval" } },
+    );
+
+    // No alternative was resolved — actualProvider should stay unset.
+    expect(response.actualProvider).toBeUndefined();
+  });
+
   test("delegates `name` and `tokenEstimationProvider` to the default provider", () => {
     const defaultProvider: Provider = {
       name: "anthropic",
@@ -211,4 +296,112 @@ describe("CallSiteRoutingProvider", () => {
     expect(wrapped.name).toBe("anthropic");
     expect(wrapped.tokenEstimationProvider).toBe("anthropic");
   });
+
+  test("name getter reflects the routed provider during sendMessage and reverts after", async () => {
+    // Regression: emitLlmCallStartedIfNeeded fires on the first text_delta,
+    // *during* the sendMessage call (before the response completes). It reads
+    // provider.name directly — if that's always the default name the trace
+    // event says "LLM call to anthropic" even when the call went to openai.
+    setLlmConfig({
+      default: { provider: "anthropic", model: "claude-opus-4-7" },
+      callSites: {
+        memoryRetrieval: { provider: "openai", model: "gpt-5.5" },
+      },
+    });
+
+    const defaultProvider = makeProvider("anthropic", () => {});
+    const namesDuringCall: string[] = [];
+
+    const altProvider: Provider = {
+      name: "openai",
+      async sendMessage() {
+        // Simulate reading provider.name mid-stream (as handleTextDelta does).
+        namesDuringCall.push(wrapped.name);
+        return makeResponse("openai");
+      },
+    };
+
+    const wrapped = new CallSiteRoutingProvider(defaultProvider, (name) =>
+      name === "openai" ? altProvider : undefined,
+    );
+
+    expect(wrapped.name).toBe("anthropic"); // idle → default
+    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { callSite: "memoryRetrieval" },
+    });
+    expect(namesDuringCall).toEqual(["openai"]); // mid-call → routed provider
+    expect(wrapped.name).toBe("anthropic"); // after call → reverted to default
+  });
+
+  test("concurrent sendMessage calls each see their own provider name (no clobbering)", async () => {
+    // Regression: if _routedProviderName were a plain instance field, concurrent
+    // calls (e.g. main turn + title-gen both in-flight) would clobber each
+    // other. AsyncLocalStorage gives each call its own async-context slot.
+    setLlmConfig({
+      default: { provider: "anthropic", model: "claude-opus-4-7" },
+      callSites: {
+        memoryRetrieval: { provider: "openai", model: "gpt-5.5" },
+        conversationTitle: { provider: "fireworks", model: "qwen3-235b" },
+      },
+    });
+
+    const defaultProvider = makeProvider("anthropic", () => {});
+    const nameSeenByOpenAI: string[] = [];
+    const nameSeenByFireworks: string[] = [];
+
+    // Shared resolve handles so we can interleave the two calls:
+    // openAI starts → fireworks starts → openAI resolves → fireworks resolves
+    let resolveOpenAI!: () => void;
+    let resolveFireworks!: () => void;
+
+    const openAIProvider: Provider = {
+      name: "openai",
+      async sendMessage() {
+        // Yield so fireworks call can start before we complete.
+        await new Promise<void>((r) => {
+          resolveOpenAI = r;
+        });
+        nameSeenByOpenAI.push(wrapped.name);
+        return makeResponse("openai");
+      },
+    };
+
+    const fireworksProvider: Provider = {
+      name: "fireworks",
+      async sendMessage() {
+        await new Promise<void>((r) => {
+          resolveFireworks = r;
+        });
+        nameSeenByFireworks.push(wrapped.name);
+        return makeResponse("fireworks");
+      },
+    };
+
+    const wrapped = new CallSiteRoutingProvider(defaultProvider, (name) => {
+      if (name === "openai") return openAIProvider;
+      if (name === "fireworks") return fireworksProvider;
+      return undefined;
+    });
+
+    // Start both calls concurrently (do not await yet).
+    const callA = wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { callSite: "memoryRetrieval" }, // → openai
+    });
+    const callB = wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { callSite: "conversationTitle" }, // → fireworks
+    });
+
+    // Let both reach their suspension point, then resolve in order.
+    await Promise.resolve(); // flush microtasks so both calls are in-flight
+    resolveOpenAI();
+    resolveFireworks();
+
+    await Promise.all([callA, callB]);
+
+    // Each call must have seen its own provider, not the other's.
+    expect(nameSeenByOpenAI).toEqual(["openai"]);
+    expect(nameSeenByFireworks).toEqual(["fireworks"]);
+    // And the idle name reverts to the default.
+    expect(wrapped.name).toBe("anthropic");
+  });
 });