@vellumai/assistant 0.4.48 → 0.4.49

package/src/__tests__/onboarding-starter-tasks.test.ts

@@ -51,7 +51,6 @@ mock.module("../util/logger.js", () => ({
   ...realLogger,
   getLogger: () => noopLogger,
   getCliLogger: () => noopLogger,
-  isDebug: () => false,
   truncateForLog: (v: string) => v,
   initLogger: () => {},
   pruneOldLogFiles: () => 0,

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

@@ -3,7 +3,6 @@ import { describe, expect, mock, test } from "bun:test";
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-  isDebug: () => false,
 }));
 
 // Only mock sleep so retries complete instantly; keep real retry logic.

package/src/__tests__/provider-streaming.benchmark.test.ts

@@ -15,7 +15,6 @@ import { describe, expect, mock, test } from "bun:test";
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-  isDebug: () => false,
 }));
 
 import { FailoverProvider } from "../providers/failover.js";

package/src/__tests__/public-ingress-urls.test.ts

@@ -25,6 +25,7 @@ mock.module("../util/logger.js", () => ({
   getLogger: () => makeLoggerStub(),
 }));
 
+import { setIngressPublicBaseUrl } from "../config/env.js";
 import {
   getOAuthCallbackUrl,
   getPublicBaseUrl,
@@ -40,19 +41,12 @@ import {
 // ---------------------------------------------------------------------------
 
 describe("getPublicBaseUrl", () => {
-  let savedIngressEnv: string | undefined;
-
   beforeEach(() => {
-    savedIngressEnv = process.env.INGRESS_PUBLIC_BASE_URL;
-    delete process.env.INGRESS_PUBLIC_BASE_URL;
+    setIngressPublicBaseUrl(undefined);
   });
 
   afterEach(() => {
-    if (savedIngressEnv !== undefined) {
-      process.env.INGRESS_PUBLIC_BASE_URL = savedIngressEnv;
-    } else {
-      delete process.env.INGRESS_PUBLIC_BASE_URL;
-    }
+    setIngressPublicBaseUrl(undefined);
   });
 
   test("returns ingress.publicBaseUrl when set", () => {
@@ -62,16 +56,16 @@ describe("getPublicBaseUrl", () => {
     expect(result).toBe("https://ingress.example.com");
   });
 
-  test("falls back to INGRESS_PUBLIC_BASE_URL env var when ingress.publicBaseUrl is empty", () => {
-    process.env.INGRESS_PUBLIC_BASE_URL = "https://ingress-env.example.com/";
+  test("falls back to module-level ingress state when ingress.publicBaseUrl is empty", () => {
+    setIngressPublicBaseUrl("https://ingress-env.example.com/");
     const result = getPublicBaseUrl({
       ingress: { publicBaseUrl: "" },
     });
     expect(result).toBe("https://ingress-env.example.com");
   });
 
-  test("falls back to INGRESS_PUBLIC_BASE_URL env var when config is empty", () => {
-    process.env.INGRESS_PUBLIC_BASE_URL = "https://ingress-env.example.com";
+  test("falls back to module-level ingress state when config is empty", () => {
+    setIngressPublicBaseUrl("https://ingress-env.example.com");
     const result = getPublicBaseUrl({});
     expect(result).toBe("https://ingress-env.example.com");
   });
@@ -118,8 +112,8 @@ describe("getPublicBaseUrl", () => {
     expect(result).toBe("https://example.com");
   });
 
-  test("falls back to env var when enabled is undefined and no publicBaseUrl", () => {
-    process.env.INGRESS_PUBLIC_BASE_URL = "https://env-fallback.example.com";
+  test("falls back to module-level state when enabled is undefined and no publicBaseUrl", () => {
+    setIngressPublicBaseUrl("https://env-fallback.example.com");
     const result = getPublicBaseUrl({
       ingress: { enabled: undefined, publicBaseUrl: "" },
     });
@@ -140,22 +134,22 @@ describe("getPublicBaseUrl", () => {
     expect(result).toBe("https://example.com");
   });
 
-  test("skips whitespace-only ingress.publicBaseUrl and falls through to env", () => {
-    process.env.INGRESS_PUBLIC_BASE_URL = "https://ingress-env.example.com";
+  test("skips whitespace-only ingress.publicBaseUrl and falls through to module state", () => {
+    setIngressPublicBaseUrl("https://ingress-env.example.com");
     const result = getPublicBaseUrl({
       ingress: { publicBaseUrl: "   " },
     });
     expect(result).toBe("https://ingress-env.example.com");
   });
 
-  test("normalizes trailing slashes from INGRESS_PUBLIC_BASE_URL", () => {
-    process.env.INGRESS_PUBLIC_BASE_URL = "https://ingress-env.example.com///";
+  test("normalizes trailing slashes from module-level ingress state", () => {
+    setIngressPublicBaseUrl("https://ingress-env.example.com///");
     const result = getPublicBaseUrl({});
     expect(result).toBe("https://ingress-env.example.com");
   });
 
-  test("trims whitespace from INGRESS_PUBLIC_BASE_URL", () => {
-    process.env.INGRESS_PUBLIC_BASE_URL = "  https://ingress-env.example.com  ";
+  test("trims whitespace from module-level ingress state", () => {
+    setIngressPublicBaseUrl("  https://ingress-env.example.com  ");
     const result = getPublicBaseUrl({});
     expect(result).toBe("https://ingress-env.example.com");
   });

package/src/__tests__/recording-handler.test.ts

@@ -32,8 +32,9 @@ mock.module("../config/loader.js", () => ({
     contextWindow: {
       enabled: true,
       maxInputTokens: 180000,
-      targetBudgetRatio: 0.30,
-      compactThreshold: 0.8,      summaryBudgetRatio: 0.05,
+      targetBudgetRatio: 0.3,
+      compactThreshold: 0.8,
+      summaryBudgetRatio: 0.05,
     },
   }),
   invalidateConfigCache: noop,
@@ -167,8 +168,6 @@ function createCtx(): {
 
   const ctx: HandlerContext = {
     sessions: new Map(),
-    cuSessions: new Map(),
-    cuObservationParseSequence: new Map(),
     sharedRequestTimestamps: [],
     debounceTimers: new DebouncerMap({ defaultDelayMs: 200 }),
     suppressConfigReload: false,

package/src/__tests__/registry.test.ts

@@ -510,7 +510,7 @@ describe("computer-use registration split", () => {
   // Start each test from a completely empty registry so assertions are
   // non-vacuous — the split functions must actually register tools.
 
-  test("registerComputerUseActionTools registers all 10 CU action tools and nothing else", async () => {
+  test("registerComputerUseActionTools registers all 11 CU action tools and nothing else", async () => {
     const { registerComputerUseActionTools } =
       await import("../tools/computer-use/registry.js");
 
@@ -520,7 +520,7 @@ describe("computer-use registration split", () => {
     registerComputerUseActionTools();
 
     const registered = getAllTools();
-    expect(registered).toHaveLength(10);
+    expect(registered).toHaveLength(11);
     expect(registered.every((t) => t.name.startsWith("computer_use_"))).toBe(
       true,
     );

package/src/__tests__/runtime-events-sse.test.ts

@@ -3,8 +3,9 @@
  *
  * Tests:
  *   - 401 unauthorized (missing bearer token)
- *   - 400 when conversationKey is absent
+ *   - 200 when conversationKey is omitted (unfiltered subscription)
  *   - Happy path: stream receives a published AssistantEvent
+ *   - Unfiltered: streams events from multiple conversations
  */
 import { mkdtempSync, realpathSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -125,15 +126,13 @@ describe("SSE assistant-events endpoint", () => {
 
   // ── Validation ────────────────────────────────────────────────────────────
 
-  test("400 when conversationKey is missing", async () => {
+  test("200 when conversationKey is omitted (unfiltered subscription)", async () => {
     await startServer();
 
     const res = await fetch(eventsUrl(), { headers: AUTH_HEADERS });
-    expect(res.status).toBe(400);
-    const body = (await res.json()) as {
-      error: { message: string; code?: string };
-    };
-    expect(body.error.message).toContain("conversationKey");
+    expect(res.status).toBe(200);
+    expect(res.headers.get("content-type")).toContain("text/event-stream");
+    await res.body?.cancel();
 
     await stopServer();
   });
@@ -184,4 +183,53 @@ describe("SSE assistant-events endpoint", () => {
     expect(frame).toContain(`"sessionId":"${conversationId}"`);
     expect(frame).toContain('"type":"pong"');
   });
+
+  // ── Unfiltered subscription ──────────────────────────────────────────────
+
+  test("streams all events when conversationKey is omitted", async () => {
+    // Subscribe without a conversationKey — should receive events from any session.
+    const ac = new AbortController();
+    const req = new Request("http://localhost/v1/events", {
+      signal: ac.signal,
+    });
+
+    const { AssistantEventHub } =
+      await import("../runtime/assistant-event-hub.js");
+    const testHub = new AssistantEventHub();
+
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    const response = handleSubscribeAssistantEvents(req, new URL(req.url), {
+      hub: testHub,
+      skipActorVerification: true,
+    });
+
+    expect(response.status).toBe(200);
+
+    const reader = response.body!.getReader();
+
+    // Consume the initial heartbeat.
+    const heartbeat = await reader.read();
+    expect(heartbeat.done).toBe(false);
+    expect(new TextDecoder().decode(heartbeat.value)).toBe(": heartbeat\n\n");
+
+    // Publish events with two different sessionIds.
+    const eventA = buildAssistantEvent("self", { type: "pong" }, "session-aaa");
+    const eventB = buildAssistantEvent("self", { type: "pong" }, "session-bbb");
+    await testHub.publish(eventA);
+    await testHub.publish(eventB);
+
+    // Read both frames from the stream.
+    const frameA = await reader.read();
+    expect(frameA.done).toBe(false);
+    const textA = new TextDecoder().decode(frameA.value);
+    expect(textA).toContain("session-aaa");
+
+    const frameB = await reader.read();
+    expect(frameB.done).toBe(false);
+    const textB = new TextDecoder().decode(frameB.value);
+    expect(textB).toContain("session-bbb");
+
+    ac.abort();
+  });
 });

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

@@ -22,7 +22,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
   truncateForLog: (value: string) => value,
 }));
 

package/src/__tests__/scheduler-recurrence.test.ts

@@ -21,7 +21,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
   truncateForLog: (value: string) => value,
 }));
 

package/src/__tests__/scoped-approval-grants.test.ts

@@ -21,7 +21,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
   truncateForLog: (value: string) => value,
 }));
 

package/src/__tests__/scoped-grant-security-matrix.test.ts

@@ -46,7 +46,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
   truncateForLog: (value: string) => value,
 }));
 

package/src/__tests__/secret-ingress-handler.test.ts

@@ -22,7 +22,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
 }));
 
 const { checkIngressForSecrets } =

package/src/__tests__/send-endpoint-busy.test.ts

@@ -117,6 +117,7 @@ function makeCompletingSession(): Session {
     updateClient: () => {},
     setHostBashProxy: () => {},
     setHostFileProxy: () => {},
+    setHostCuProxy: () => {},
     hasAnyPendingConfirmation: () => false,
     hasPendingConfirmation: () => false,
     denyAllPendingConfirmations: () => {},
@@ -173,6 +174,7 @@ function makeHangingSession(): Session {
     updateClient: () => {},
     setHostBashProxy: () => {},
     setHostFileProxy: () => {},
+    setHostCuProxy: () => {},
     hasAnyPendingConfirmation: () => false,
     hasPendingConfirmation: () => false,
     denyAllPendingConfirmations: () => {},
@@ -257,6 +259,7 @@ function makePendingApprovalSession(
     updateClient: () => {},
     setHostBashProxy: () => {},
     setHostFileProxy: () => {},
+    setHostCuProxy: () => {},
     hasAnyPendingConfirmation: () => pending.size > 0,
     hasPendingConfirmation: (candidateRequestId: string) =>
       pending.has(candidateRequestId),
@@ -364,11 +367,17 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
         interface: "macos",
       }),
     });
-    const body = (await res.json()) as { accepted: boolean; messageId: string };
+    const body = (await res.json()) as {
+      accepted: boolean;
+      messageId: string;
+      conversationId: string;
+    };
 
     expect(res.status).toBe(202);
     expect(body.accepted).toBe(true);
     expect(body.messageId).toBeDefined();
+    expect(typeof body.conversationId).toBe("string");
+    expect(body.conversationId.length).toBeGreaterThan(0);
 
     await stopServer();
   });
@@ -485,8 +494,8 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
     createCanonicalGuardianRequest({
       id: requestId,
       kind: "tool_approval",
-      sourceType: "desktop",
-      sourceChannel: "vellum",
+      sourceType: "voice",
+      sourceChannel: "slack",
       conversationId,
       toolName: "call_start",
       status: "pending",
@@ -511,8 +520,8 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
       body: JSON.stringify({
         conversationKey,
         content: "sure let's do that",
-        sourceChannel: "vellum",
-        interface: "macos",
+        sourceChannel: "slack",
+        interface: "slack",
       }),
     });
     const body = (await res.json()) as {
@@ -808,11 +817,17 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
         interface: "macos",
       }),
     });
-    const body2 = (await res2.json()) as { accepted: boolean; queued: boolean };
+    const body2 = (await res2.json()) as {
+      accepted: boolean;
+      queued: boolean;
+      conversationId: string;
+    };
 
     expect(res2.status).toBe(202);
     expect(body2.accepted).toBe(true);
     expect(body2.queued).toBe(true);
+    expect(typeof body2.conversationId).toBe("string");
+    expect(body2.conversationId.length).toBeGreaterThan(0);
 
     await stopServer();
   });

package/src/__tests__/sequence-store.test.ts

@@ -22,7 +22,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
   truncateForLog: (value: string) => value,
 }));
 

package/src/__tests__/session-init.benchmark.test.ts

@@ -127,7 +127,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
   truncateForLog: (value: string, maxLen = 500) =>
     value.length > maxLen ? value.slice(0, maxLen) + "..." : value,
   initLogger: () => {},
@@ -342,7 +341,7 @@ describe("Session initialization benchmark", () => {
     }
 
     timings.sort((a, b) => a - b);
-    expect(median(timings)).toBeLessThan(10);
+    expect(median(timings)).toBeLessThan(15);
   });
 
   test("buildSystemPrompt assembles prompt under 50ms (median of 5)", () => {
@@ -384,9 +383,9 @@ describe("Session initialization benchmark", () => {
     await initializeTools();
     const definitions = getAllToolDefinitions();
 
-    // Sanity: we expect a meaningful number of core tools (at least 20)
+    // Sanity: we expect a meaningful number of core tools (at least 18)
     // but not an unreasonable explosion (under 200)
-    expect(definitions.length).toBeGreaterThanOrEqual(20);
+    expect(definitions.length).toBeGreaterThanOrEqual(18);
     expect(definitions.length).toBeLessThan(200);
   });
 });
@@ -548,6 +547,6 @@ describe("End-to-end session creation benchmark", () => {
     }
 
     timings.sort((a, b) => a - b);
-    expect(median(timings)).toBeLessThan(10);
+    expect(median(timings)).toBeLessThan(15);
   });
 });

package/src/__tests__/skill-include-graph.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import type { SkillSummary } from "../config/skills.js";
 import {
+  collectAllMissing,
   getImmediateChildren,
   indexCatalogById,
   traverseIncludes,
@@ -298,3 +299,68 @@ describe("validateIncludes — cycle detection", () => {
     }
   });
 });
+
+describe("collectAllMissing", () => {
+  test("returns empty set when skill has no includes", () => {
+    const catalog = [makeSkill("root")];
+    const index = indexCatalogById(catalog);
+    expect(collectAllMissing("root", index)).toEqual(new Set([]));
+  });
+
+  test("returns empty set when all includes are present", () => {
+    const catalog = [makeSkill("A", ["B"]), makeSkill("B")];
+    const index = indexCatalogById(catalog);
+    expect(collectAllMissing("A", index)).toEqual(new Set([]));
+  });
+
+  test("returns immediate missing children", () => {
+    const catalog = [makeSkill("A", ["B", "C"]), makeSkill("C")];
+    const index = indexCatalogById(catalog);
+    expect(collectAllMissing("A", index)).toEqual(new Set(["B"]));
+  });
+
+  test("returns transitive missing children", () => {
+    const catalog = [makeSkill("A", ["B"]), makeSkill("B", ["C"])];
+    const index = indexCatalogById(catalog);
+    expect(collectAllMissing("A", index)).toEqual(new Set(["C"]));
+  });
+
+  test("returns multiple missing at different levels", () => {
+    // A→B→C, B present but C missing
+    const catalog1 = [makeSkill("A", ["B"]), makeSkill("B", ["C"])];
+    const index1 = indexCatalogById(catalog1);
+    expect(collectAllMissing("A", index1)).toEqual(new Set(["C"]));
+
+    // A includes B and C, both missing
+    const catalog2 = [makeSkill("A", ["B", "C"])];
+    const index2 = indexCatalogById(catalog2);
+    expect(collectAllMissing("A", index2)).toEqual(new Set(["B", "C"]));
+  });
+
+  test("handles diamond with missing leaf", () => {
+    const catalog = [
+      makeSkill("A", ["B", "C"]),
+      makeSkill("B", ["D"]),
+      makeSkill("C", ["D"]),
+    ];
+    const index = indexCatalogById(catalog);
+    const result = collectAllMissing("A", index);
+    expect(result).toEqual(new Set(["D"]));
+    // Verify no duplicates (Set handles this, but confirm size)
+    expect(result.size).toBe(1);
+  });
+
+  test("does not loop infinitely on cycles", () => {
+    const catalog = [makeSkill("A", ["B"]), makeSkill("B", ["A"])];
+    const index = indexCatalogById(catalog);
+    expect(collectAllMissing("A", index)).toEqual(new Set([]));
+  });
+
+  test("handles cycle with missing node", () => {
+    const catalog = [makeSkill("A", ["B"]), makeSkill("B", ["C"])];
+    // C is missing, and if C referenced B it would be a cycle — but C isn't in catalog
+    // So A→B→C, C missing
+    const index = indexCatalogById(catalog);
+    expect(collectAllMissing("A", index)).toEqual(new Set(["C"]));
+  });
+});

package/src/__tests__/skill-load-feature-flag.test.ts

@@ -61,7 +61,6 @@ mock.module("../util/logger.js", () => ({
   ...realLogger,
   getLogger: () => noopLogger,
   getCliLogger: () => noopLogger,
-  isDebug: () => false,
   truncateForLog: (value: string) => value,
   initLogger: () => {},
   pruneOldLogFiles: () => 0,