@vellumai/assistant 0.7.0 → 0.7.1

package/src/__tests__/app-conversation-ids.test.ts

@@ -0,0 +1,151 @@
+import { existsSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  addAppConversationId,
+  createApp,
+  getApp,
+  listAppsByConversation,
+} from "../memory/app-store.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let testDataDir: string;
+
+function freshTempDir(): string {
+  return join(
+    tmpdir(),
+    `vellum-app-conv-id-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+}
+
+function makeAppParams(name: string) {
+  return {
+    name,
+    schemaJson: "{}",
+    htmlDefinition: "<h1>Hello</h1>",
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Setup / teardown
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  testDataDir = freshTempDir();
+  process.env.VELLUM_WORKSPACE_DIR = testDataDir;
+});
+
+afterEach(() => {
+  if (existsSync(testDataDir)) {
+    rmSync(testDataDir, { recursive: true, force: true });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// addAppConversationId
+// ---------------------------------------------------------------------------
+
+describe("addAppConversationId", () => {
+  test("appends conversationId and returns true", () => {
+    const app = createApp(makeAppParams("Test App"));
+    const result = addAppConversationId(app.id, "conv-abc");
+    expect(result).toBe(true);
+
+    const loaded = getApp(app.id);
+    expect(loaded?.conversationIds).toEqual(["conv-abc"]);
+  });
+
+  test("deduplicates — returns false when conversationId already present", () => {
+    const app = createApp(makeAppParams("Test App"));
+    addAppConversationId(app.id, "conv-abc");
+    const result = addAppConversationId(app.id, "conv-abc");
+    expect(result).toBe(false);
+
+    const loaded = getApp(app.id);
+    expect(loaded?.conversationIds).toEqual(["conv-abc"]);
+  });
+
+  test("returns false for non-existent app", () => {
+    const result = addAppConversationId("nonexistent-id", "conv-abc");
+    expect(result).toBe(false);
+  });
+
+  test("does not change updatedAt", () => {
+    const app = createApp(makeAppParams("Test App"));
+    const originalUpdatedAt = app.updatedAt;
+
+    // Wait a tick so Date.now() would differ if updatedAt were bumped
+    const before = Date.now();
+    while (Date.now() === before) {
+      // busy-wait for at least 1ms
+    }
+
+    addAppConversationId(app.id, "conv-abc");
+
+    const loaded = getApp(app.id);
+    expect(loaded?.updatedAt).toBe(originalUpdatedAt);
+  });
+
+  test("initializes conversationIds from undefined", () => {
+    const app = createApp(makeAppParams("Fresh App"));
+    // Verify the app has no conversationIds initially
+    const initial = getApp(app.id);
+    expect(initial?.conversationIds).toBeUndefined();
+
+    addAppConversationId(app.id, "conv-xyz");
+
+    const loaded = getApp(app.id);
+    expect(loaded?.conversationIds).toEqual(["conv-xyz"]);
+  });
+
+  test("appends multiple distinct conversationIds", () => {
+    const app = createApp(makeAppParams("Multi Conv App"));
+    addAppConversationId(app.id, "conv-1");
+    addAppConversationId(app.id, "conv-2");
+    addAppConversationId(app.id, "conv-3");
+
+    const loaded = getApp(app.id);
+    expect(loaded?.conversationIds).toEqual(["conv-1", "conv-2", "conv-3"]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// listAppsByConversation
+// ---------------------------------------------------------------------------
+
+describe("listAppsByConversation", () => {
+  test("filters apps by conversationId", () => {
+    const app1 = createApp(makeAppParams("App One"));
+    const app2 = createApp(makeAppParams("App Two"));
+    createApp(makeAppParams("App Three"));
+
+    addAppConversationId(app1.id, "conv-shared");
+    addAppConversationId(app2.id, "conv-shared");
+    addAppConversationId(app1.id, "conv-only-one");
+
+    const shared = listAppsByConversation("conv-shared");
+    expect(shared).toHaveLength(2);
+    const ids = shared.map((a) => a.id).sort();
+    expect(ids).toEqual([app1.id, app2.id].sort());
+
+    const onlyOne = listAppsByConversation("conv-only-one");
+    expect(onlyOne).toHaveLength(1);
+    expect(onlyOne[0].id).toBe(app1.id);
+  });
+
+  test("returns empty array for unknown conversationId", () => {
+    createApp(makeAppParams("Some App"));
+    const result = listAppsByConversation("conv-nonexistent");
+    expect(result).toEqual([]);
+  });
+
+  test("returns empty array when no apps exist", () => {
+    const result = listAppsByConversation("conv-any");
+    expect(result).toEqual([]);
+  });
+});

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

@@ -313,13 +313,11 @@ function seedPendingConfirmation(
  * confirmation details.
  */
 function registerPendingInteraction(
-  conversation: Conversation,
   requestId: string,
   conversationId: string,
   confirmationDetails?: ConfirmationDetails,
 ): void {
   pendingInteractions.register(requestId, {
-    conversation,
     conversationId,
     kind: "confirmation",
     confirmationDetails,
@@ -349,12 +347,6 @@ beforeEach(() => {
 // ---------------------------------------------------------------------------
 
 describe("approval cascading", () => {
-
-
-
-
-
-
   test("allow (one-time) does NOT cascade", () => {
     const emitted: ServerMessage[] = [];
     const conversationObj = makeConversation(
@@ -366,13 +358,11 @@ describe("approval cascading", () => {
     seedPendingConfirmation(conversationObj, "req-2");
 
     registerPendingInteraction(
-      conversationObj,
       "req-1",
       CONV_ID,
       makeConfirmationDetails(["bash:echo hello"]),
     );
     registerPendingInteraction(
-      conversationObj,
       "req-2",
       CONV_ID,
       makeConfirmationDetails(["bash:echo world"]),
@@ -402,13 +392,11 @@ describe("approval cascading", () => {
     seedPendingConfirmation(conversationObj, "req-2");
 
     registerPendingInteraction(
-      conversationObj,
       "req-1",
       CONV_ID,
       makeConfirmationDetails(["bash:echo hello"]),
     );
     registerPendingInteraction(
-      conversationObj,
       "req-2",
       CONV_ID,
       makeConfirmationDetails(["bash:echo world"]),
@@ -427,7 +415,6 @@ describe("approval cascading", () => {
     expect(confirmMsgs[0].requestId).toBe("req-1");
   });
 
-
   test("already-resolved request handled gracefully", () => {
     const emitted: ServerMessage[] = [];
     const conversationObj = makeConversation(
@@ -439,7 +426,6 @@ describe("approval cascading", () => {
     seedPendingConfirmation(conversationObj, "req-stale");
 
     registerPendingInteraction(
-      conversationObj,
       "req-primary",
       CONV_ID,
       makeConfirmationDetails(["bash:echo primary"]),
@@ -448,7 +434,6 @@ describe("approval cascading", () => {
     // in the prompter. We'll remove it from the prompter before cascading
     // reaches it to simulate a stale/already-resolved request.
     registerPendingInteraction(
-      conversationObj,
       "req-stale",
       CONV_ID,
       makeConfirmationDetails(["bash:echo stale"]),

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

@@ -120,6 +120,11 @@ mock.module("../permissions/trust-store.js", () => ({
 let _conversationFactory: (() => Conversation) | undefined;
 
 mock.module("../daemon/conversation-store.js", () => ({
+  findConversation: () => {
+    // Return the current test session for any conversation ID lookup.
+    if (!_conversationFactory) return undefined;
+    return _conversationFactory();
+  },
   getOrCreateConversation: async () => {
     if (!_conversationFactory)
       throw new Error("_conversationFactory not set in test");
@@ -171,11 +176,7 @@ function makeIdleSession(opts?: {
     getMessages: () => [],
     usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     updateClient: () => {},
-    setHostBashProxy: () => {},
     setHostBrowserProxy: () => {},
-    setHostFileProxy: () => {},
-    setHostTransferProxy: () => {},
-    getHostTransferProxy: () => undefined,
     setHostCuProxy: () => {},
     addPreactivatedSkillId: () => {},
     enqueueMessage: () => ({ queued: false, requestId: "noop" }),
@@ -238,11 +239,7 @@ function makeConfirmationEmittingSession(opts?: {
     getMessages: () => [],
     usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     updateClient: () => {},
-    setHostBashProxy: () => {},
     setHostBrowserProxy: () => {},
-    setHostFileProxy: () => {},
-    setHostTransferProxy: () => {},
-    getHostTransferProxy: () => undefined,
     setHostCuProxy: () => {},
     addPreactivatedSkillId: () => {},
     enqueueMessage: () => ({ queued: false, requestId: "noop" }),
@@ -257,6 +254,7 @@ function makeConfirmationEmittingSession(opts?: {
       onEvent({
         type: "confirmation_request",
         requestId: reqId,
+        conversationId: "conv-auto",
         toolName: tool,
         input: { command: "ls" },
         riskLevel: "medium",
@@ -335,7 +333,6 @@ describe("standalone approval endpoints — HTTP layer", () => {
 
       // Manually register a pending interaction
       pendingInteractions.register("req-abc", {
-        conversation: session,
         conversationId: "conv-1",
         kind: "confirmation",
         confirmationDetails: {
@@ -384,7 +381,6 @@ describe("standalone approval endpoints — HTTP layer", () => {
       await startServer(() => session);
 
       pendingInteractions.register("req-once", {
-        conversation: session,
         conversationId: "conv-1",
         kind: "confirmation",
       });
@@ -427,7 +423,6 @@ describe("standalone approval endpoints — HTTP layer", () => {
       await startServer(() => session);
 
       pendingInteractions.register("req-1", {
-        conversation: session,
         conversationId: "conv-1",
         kind: "confirmation",
         confirmationDetails: {
@@ -462,7 +457,6 @@ describe("standalone approval endpoints — HTTP layer", () => {
       await startServer(() => session);
 
       pendingInteractions.register("req-host-access", {
-        conversation: session,
         conversationId: "conv-1",
         kind: "confirmation",
         confirmationDetails: {
@@ -500,7 +494,6 @@ describe("standalone approval endpoints — HTTP layer", () => {
       await startServer(() => session);
 
       pendingInteractions.register("req-v2-invalid", {
-        conversation: session,
         conversationId: "conv-1",
         kind: "confirmation",
         confirmationDetails: {
@@ -549,7 +542,6 @@ describe("standalone approval endpoints — HTTP layer", () => {
       await startServer(() => session);
 
       pendingInteractions.register("secret-req-1", {
-        conversation: session,
         conversationId: "conv-1",
         kind: "secret",
       });
@@ -691,17 +683,14 @@ describe("standalone approval endpoints — HTTP layer", () => {
       await startServer(() => session);
 
       pendingInteractions.register("req-a", {
-        conversation: session,
         conversationId: "conv-x",
         kind: "confirmation",
       });
       pendingInteractions.register("req-b", {
-        conversation: session,
         conversationId: "conv-x",
         kind: "secret",
       });
       pendingInteractions.register("req-c", {
-        conversation: session,
         conversationId: "conv-y",
         kind: "confirmation",
       });

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

@@ -6,7 +6,6 @@ import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
 function makeEvent(overrides: Partial<AssistantEvent> = {}): AssistantEvent {
   return {
     id: "evt_test",
-    assistantId: "ast_1",
     conversationId: "sess_1",
     emittedAt: "2026-02-18T00:00:00.000Z",
     message: {
@@ -25,8 +24,11 @@ describe("AssistantEventHub — fanout", () => {
     const hub = new AssistantEventHub();
     const received: AssistantEvent[] = [];
 
-    hub.subscribe({ assistantId: "ast_1" }, (e) => {
-      received.push(e);
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        received.push(e);
+      },
     });
     await hub.publish(makeEvent());
 
@@ -38,14 +40,23 @@ describe("AssistantEventHub — fanout", () => {
     const hub = new AssistantEventHub();
     const order: string[] = [];
 
-    hub.subscribe({ assistantId: "ast_1" }, () => {
-      order.push("first");
+    hub.subscribe({
+      type: "process",
+      callback: () => {
+        order.push("first");
+      },
     });
-    hub.subscribe({ assistantId: "ast_1" }, () => {
-      order.push("second");
+    hub.subscribe({
+      type: "process",
+      callback: () => {
+        order.push("second");
+      },
     });
-    hub.subscribe({ assistantId: "ast_1" }, () => {
-      order.push("third");
+    hub.subscribe({
+      type: "process",
+      callback: () => {
+        order.push("third");
+      },
     });
 
     await hub.publish(makeEvent());
@@ -53,28 +64,24 @@ describe("AssistantEventHub — fanout", () => {
     expect(order).toEqual(["first", "second", "third"]);
   });
 
-  test("does not deliver event to subscriber for a different assistantId", async () => {
-    const hub = new AssistantEventHub();
-    const received: AssistantEvent[] = [];
-
-    hub.subscribe({ assistantId: "ast_OTHER" }, (e) => {
-      received.push(e);
-    });
-    await hub.publish(makeEvent({ assistantId: "ast_1" }));
-
-    expect(received).toHaveLength(0);
-  });
-
   test("conversationId filter further restricts delivery", async () => {
     const hub = new AssistantEventHub();
     const receivedA: AssistantEvent[] = [];
     const receivedB: AssistantEvent[] = [];
 
-    hub.subscribe({ assistantId: "ast_1", conversationId: "sess_A" }, (e) => {
-      receivedA.push(e);
+    hub.subscribe({
+      type: "process",
+      filter: { conversationId: "sess_A" },
+      callback: (e) => {
+        receivedA.push(e);
+      },
     });
-    hub.subscribe({ assistantId: "ast_1", conversationId: "sess_B" }, (e) => {
-      receivedB.push(e);
+    hub.subscribe({
+      type: "process",
+      filter: { conversationId: "sess_B" },
+      callback: (e) => {
+        receivedB.push(e);
+      },
     });
 
     await hub.publish(makeEvent({ conversationId: "sess_A" }));
@@ -83,12 +90,15 @@ describe("AssistantEventHub — fanout", () => {
     expect(receivedB).toHaveLength(0);
   });
 
-  test("subscriber without conversationId filter receives all sessions for that assistant", async () => {
+  test("subscriber without conversationId filter receives all conversations", async () => {
     const hub = new AssistantEventHub();
     const received: AssistantEvent[] = [];
 
-    hub.subscribe({ assistantId: "ast_1" }, (e) => {
-      received.push(e);
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        received.push(e);
+      },
     });
 
     await hub.publish(makeEvent({ conversationId: "sess_A" }));
@@ -103,13 +113,12 @@ describe("AssistantEventHub — fanout", () => {
     await expect(hub.publish(makeEvent())).resolves.toBeUndefined();
   });
 
-  test("hasSubscribersForEvent returns true for assistant-wide subscribers", () => {
+  test("hasSubscribersForEvent returns true for unscoped subscribers", () => {
     const hub = new AssistantEventHub();
-    hub.subscribe({ assistantId: "ast_1" }, () => {});
+    hub.subscribe({ type: "process", callback: () => {} });
 
     expect(
       hub.hasSubscribersForEvent({
-        assistantId: "ast_1",
         conversationId: "sess_A",
       }),
     ).toBe(true);
@@ -117,17 +126,19 @@ describe("AssistantEventHub — fanout", () => {
 
   test("hasSubscribersForEvent honors conversation scoping", () => {
     const hub = new AssistantEventHub();
-    hub.subscribe({ assistantId: "ast_1", conversationId: "sess_A" }, () => {});
+    hub.subscribe({
+      type: "process",
+      filter: { conversationId: "sess_A" },
+      callback: () => {},
+    });
 
     expect(
       hub.hasSubscribersForEvent({
-        assistantId: "ast_1",
         conversationId: "sess_A",
       }),
     ).toBe(true);
     expect(
       hub.hasSubscribersForEvent({
-        assistantId: "ast_1",
         conversationId: "sess_B",
       }),
     ).toBe(false);
@@ -141,46 +152,49 @@ describe("AssistantEventHub — unsubscribe cleanup", () => {
     const hub = new AssistantEventHub();
     const received: AssistantEvent[] = [];
 
-    const sub = hub.subscribe({ assistantId: "ast_1" }, (e) => {
-      received.push(e);
+    const s = hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        received.push(e);
+      },
     });
     await hub.publish(makeEvent());
     expect(received).toHaveLength(1);
 
-    sub.dispose();
+    s.dispose();
     await hub.publish(makeEvent());
     expect(received).toHaveLength(1); // no new events
   });
 
   test("dispose is idempotent", () => {
     const hub = new AssistantEventHub();
-    const sub = hub.subscribe({ assistantId: "ast_1" }, () => {});
+    const s = hub.subscribe({ type: "process", callback: () => {} });
 
-    sub.dispose();
-    sub.dispose(); // must not throw
-    expect(sub.active).toBe(false);
+    s.dispose();
+    s.dispose(); // must not throw
+    expect(s.active).toBe(false);
   });
 
   test("active reflects subscription state", () => {
     const hub = new AssistantEventHub();
-    const sub = hub.subscribe({ assistantId: "ast_1" }, () => {});
-    expect(sub.active).toBe(true);
+    const s = hub.subscribe({ type: "process", callback: () => {} });
+    expect(s.active).toBe(true);
 
-    sub.dispose();
-    expect(sub.active).toBe(false);
+    s.dispose();
+    expect(s.active).toBe(false);
   });
 
   test("subscriberCount reflects live subscriptions only", () => {
     const hub = new AssistantEventHub();
 
-    const sub1 = hub.subscribe({ assistantId: "ast_1" }, () => {});
-    const sub2 = hub.subscribe({ assistantId: "ast_1" }, () => {});
+    const s1 = hub.subscribe({ type: "process", callback: () => {} });
+    const s2 = hub.subscribe({ type: "process", callback: () => {} });
     expect(hub.subscriberCount()).toBe(2);
 
-    sub1.dispose();
+    s1.dispose();
     expect(hub.subscriberCount()).toBe(1);
 
-    sub2.dispose();
+    s2.dispose();
     expect(hub.subscriberCount()).toBe(0);
   });
 
@@ -189,14 +203,20 @@ describe("AssistantEventHub — unsubscribe cleanup", () => {
     const received1: AssistantEvent[] = [];
     const received2: AssistantEvent[] = [];
 
-    const sub1 = hub.subscribe({ assistantId: "ast_1" }, (e) => {
-      received1.push(e);
+    const s1 = hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        received1.push(e);
+      },
     });
-    hub.subscribe({ assistantId: "ast_1" }, (e) => {
-      received2.push(e);
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        received2.push(e);
+      },
     });
 
-    sub1.dispose();
+    s1.dispose();
     await hub.publish(makeEvent());
 
     expect(received1).toHaveLength(0);
@@ -211,11 +231,17 @@ describe("AssistantEventHub — exception isolation", () => {
     const hub = new AssistantEventHub();
     let secondCalled = false;
 
-    hub.subscribe({ assistantId: "ast_1" }, () => {
-      throw new Error("subscriber boom");
+    hub.subscribe({
+      type: "process",
+      callback: () => {
+        throw new Error("subscriber boom");
+      },
     });
-    hub.subscribe({ assistantId: "ast_1" }, () => {
-      secondCalled = true;
+    hub.subscribe({
+      type: "process",
+      callback: () => {
+        secondCalled = true;
+      },
     });
 
     await expect(hub.publish(makeEvent())).rejects.toBeInstanceOf(
@@ -227,11 +253,17 @@ describe("AssistantEventHub — exception isolation", () => {
   test("all subscriber errors are collected into AggregateError", async () => {
     const hub = new AssistantEventHub();
 
-    hub.subscribe({ assistantId: "ast_1" }, () => {
-      throw new Error("err-1");
+    hub.subscribe({
+      type: "process",
+      callback: () => {
+        throw new Error("err-1");
+      },
     });
-    hub.subscribe({ assistantId: "ast_1" }, () => {
-      throw new Error("err-2");
+    hub.subscribe({
+      type: "process",
+      callback: () => {
+        throw new Error("err-2");
+      },
     });
 
     const caught = await hub.publish(makeEvent()).catch((e) => e);
@@ -244,11 +276,17 @@ describe("AssistantEventHub — exception isolation", () => {
     const hub = new AssistantEventHub();
     let syncRan = false;
 
-    hub.subscribe({ assistantId: "ast_1" }, async () => {
-      throw new Error("async-err");
+    hub.subscribe({
+      type: "process",
+      callback: async () => {
+        throw new Error("async-err");
+      },
     });
-    hub.subscribe({ assistantId: "ast_1" }, () => {
-      syncRan = true;
+    hub.subscribe({
+      type: "process",
+      callback: () => {
+        syncRan = true;
+      },
     });
 
     const caught = await hub.publish(makeEvent()).catch((e) => e);
@@ -259,7 +297,7 @@ describe("AssistantEventHub — exception isolation", () => {
 
   test("publish resolves when all subscribers succeed", async () => {
     const hub = new AssistantEventHub();
-    hub.subscribe({ assistantId: "ast_1" }, () => {});
+    hub.subscribe({ type: "process", callback: () => {} });
     await expect(hub.publish(makeEvent())).resolves.toBeUndefined();
   });
 });
@@ -271,11 +309,16 @@ describe("AssistantEventHub — re-entrancy / snapshot isolation", () => {
     const hub = new AssistantEventHub();
     const lateReceived: AssistantEvent[] = [];
 
-    hub.subscribe({ assistantId: "ast_1" }, () => {
-      // Add a new subscriber mid-fanout
-      hub.subscribe({ assistantId: "ast_1" }, (e) => {
-        lateReceived.push(e);
-      });
+    hub.subscribe({
+      type: "process",
+      callback: () => {
+        hub.subscribe({
+          type: "process",
+          callback: (e) => {
+            lateReceived.push(e);
+          },
+        });
+      },
     });
 
     await hub.publish(makeEvent());
@@ -287,14 +330,20 @@ describe("AssistantEventHub — re-entrancy / snapshot isolation", () => {
   test("subscriber that disposes itself mid-publish does not affect remaining subscribers", async () => {
     const hub = new AssistantEventHub();
     const received: AssistantEvent[] = [];
-    let sub: ReturnType<typeof hub.subscribe>;
+    let s: ReturnType<typeof hub.subscribe>;
 
     // eslint-disable-next-line prefer-const
-    sub = hub.subscribe({ assistantId: "ast_1" }, () => {
-      sub.dispose();
+    s = hub.subscribe({
+      type: "process",
+      callback: () => {
+        s.dispose();
+      },
     });
-    hub.subscribe({ assistantId: "ast_1" }, (e) => {
-      received.push(e);
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        received.push(e);
+      },
     });
 
     await hub.publish(makeEvent());