@vellumai/assistant 0.4.55 → 0.4.57

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

@@ -2,7 +2,7 @@
  * Tests for cascading approval decisions to matching pending confirmations.
  *
  * When a user resolves one confirmation with a broad decision (allow_10m,
- * allow_thread, always_allow, always_deny), other pending confirmations in
+ * allow_conversation, always_allow, always_deny), other pending confirmations in
  * the same conversation that match are auto-resolved.
  */
 import { mkdtempSync, rmSync } from "node:fs";
@@ -25,7 +25,7 @@ import type { ConfirmationDetails } from "../runtime/pending-interactions.js";
 const testDir = mkdtempSync(join(tmpdir(), "approval-cascade-test-"));
 
 // ---------------------------------------------------------------------------
-// Mocks — must precede Session import
+// Mocks — must precede Conversation import
 // ---------------------------------------------------------------------------
 
 function makeLoggerStub(): Record<string, unknown> {
@@ -76,7 +76,7 @@ mock.module("../config/loader.js", () => ({
       summaryModel: "mock-model",
       maxSummaryTokens: 512,
     },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     timeouts: { permissionTimeoutSec: 300 },
     skills: { entries: {}, allowBundled: true },
     permissions: { mode: "workspace" },
@@ -100,13 +100,6 @@ mock.module("../config/skill-state.js", () => ({
   resolveSkillStates: () => [],
 }));
 
-mock.module("../skills/slash-commands.js", () => ({
-  buildInvocableSlashCatalog: () => new Map(),
-  resolveSlashSkillCommand: () => ({ kind: "not_slash" }),
-  rewriteKnownSlashCommandPrompt: () => "",
-  parseSlashCandidate: () => ({ kind: "not_slash" }),
-}));
-
 // Trust store mock — uses real minimatch for patternMatchesCandidate so the
 // mock doesn't break trust-store-pattern-matches.test.ts when both files run
 // in the same Bun process (mock.module leaks across test files).
@@ -128,7 +121,7 @@ mock.module("../security/secret-allowlist.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-  getConversationThreadType: () => "default",
+  getConversationType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},
@@ -173,7 +166,7 @@ mock.module("../memory/retriever.js", () => ({
     injectedTokens: 0,
     latencyMs: 0,
   }),
-  stripMemoryRecallMessages: (msgs: Message[]) => msgs,
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
 mock.module("../context/window-manager.js", () => ({
@@ -237,10 +230,10 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 }));
 
 // ---------------------------------------------------------------------------
-// Import Session and pendingInteractions AFTER mocks
+// Import Conversation and pendingInteractions AFTER mocks
 // ---------------------------------------------------------------------------
 
-import { Session } from "../daemon/session.js";
+import { Conversation } from "../daemon/conversation.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 
 // ---------------------------------------------------------------------------
@@ -263,11 +256,11 @@ function makeProvider() {
   };
 }
 
-function makeSession(
+function makeConversation(
   sendToClient?: (msg: ServerMessage) => void,
   conversationId = CONV_ID,
-): Session {
-  return new Session(
+): Conversation {
+  return new Conversation(
     conversationId,
     makeProvider(),
     "system prompt",
@@ -280,8 +273,11 @@ function makeSession(
 /**
  * Seed a pending confirmation directly in the prompter's internal map.
  */
-function seedPendingConfirmation(session: Session, requestId: string): void {
-  const prompter = session["prompter"] as unknown as {
+function seedPendingConfirmation(
+  conversation: Conversation,
+  requestId: string,
+): void {
+  const prompter = conversation["prompter"] as unknown as {
     pending: Map<
       string,
       {
@@ -303,13 +299,13 @@ function seedPendingConfirmation(session: Session, requestId: string): void {
  * confirmation details.
  */
 function registerPendingInteraction(
-  session: Session,
+  conversation: Conversation,
   requestId: string,
   conversationId: string,
   confirmationDetails?: ConfirmationDetails,
 ): void {
   pendingInteractions.register(requestId, {
-    session,
+    conversation,
     conversationId,
     kind: "confirmation",
     confirmationDetails,
@@ -349,35 +345,38 @@ beforeEach(() => {
 describe("approval cascading", () => {
   test("allow_10m cascades to all pending in same conversation", () => {
     const emitted: ServerMessage[] = [];
-    const session = makeSession((msg) => emitted.push(msg), CONV_ID);
+    const conversationObj = makeConversation(
+      (msg) => emitted.push(msg),
+      CONV_ID,
+    );
 
     // Seed 3 pending confirmations
-    seedPendingConfirmation(session, "req-1");
-    seedPendingConfirmation(session, "req-2");
-    seedPendingConfirmation(session, "req-3");
+    seedPendingConfirmation(conversationObj, "req-1");
+    seedPendingConfirmation(conversationObj, "req-2");
+    seedPendingConfirmation(conversationObj, "req-3");
 
     // Register in pending-interactions tracker
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-1",
       CONV_ID,
       makeConfirmationDetails(["bash:echo hello"]),
     );
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-2",
       CONV_ID,
       makeConfirmationDetails(["bash:ls -la"]),
     );
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-3",
       CONV_ID,
       makeConfirmationDetails(["bash:cat file"]),
     );
 
     // Resolve the first with allow_10m
-    session.handleConfirmationResponse("req-1", "allow_10m");
+    conversationObj.handleConfirmationResponse("req-1", "allow_10m");
 
     // All 3 should be resolved (approved)
     const confirmMsgs = emitted.filter(
@@ -392,34 +391,37 @@ describe("approval cascading", () => {
     expect(resolvedIds).toEqual(["req-1", "req-2", "req-3"]);
   });
 
-  test("allow_thread cascades to all pending in same conversation", () => {
+  test("allow_conversation cascades to all pending in same conversation", () => {
     const emitted: ServerMessage[] = [];
-    const session = makeSession((msg) => emitted.push(msg), CONV_ID);
+    const conversationObj = makeConversation(
+      (msg) => emitted.push(msg),
+      CONV_ID,
+    );
 
-    seedPendingConfirmation(session, "req-a");
-    seedPendingConfirmation(session, "req-b");
-    seedPendingConfirmation(session, "req-c");
+    seedPendingConfirmation(conversationObj, "req-a");
+    seedPendingConfirmation(conversationObj, "req-b");
+    seedPendingConfirmation(conversationObj, "req-c");
 
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-a",
       CONV_ID,
       makeConfirmationDetails(["bash:echo a"]),
     );
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-b",
       CONV_ID,
       makeConfirmationDetails(["bash:echo b"]),
     );
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-c",
       CONV_ID,
       makeConfirmationDetails(["bash:echo c"]),
     );
 
-    session.handleConfirmationResponse("req-a", "allow_thread");
+    conversationObj.handleConfirmationResponse("req-a", "allow_conversation");
 
     const confirmMsgs = emitted.filter(
       (m) =>
@@ -435,36 +437,39 @@ describe("approval cascading", () => {
 
   test("temporary override does NOT cascade to different conversation", () => {
     const emitted: ServerMessage[] = [];
-    const session = makeSession((msg) => emitted.push(msg), CONV_ID);
+    const conversationObj = makeConversation(
+      (msg) => emitted.push(msg),
+      CONV_ID,
+    );
 
-    seedPendingConfirmation(session, "req-same");
-    seedPendingConfirmation(session, "req-diff");
+    seedPendingConfirmation(conversationObj, "req-same");
+    seedPendingConfirmation(conversationObj, "req-diff");
 
     // Same conversation
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-same",
       CONV_ID,
       makeConfirmationDetails(["bash:echo same"]),
     );
     // Different conversation
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-diff",
       "different-conv",
       makeConfirmationDetails(["bash:echo diff"]),
     );
 
     // Seed a primary request
-    seedPendingConfirmation(session, "req-primary");
+    seedPendingConfirmation(conversationObj, "req-primary");
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-primary",
       CONV_ID,
       makeConfirmationDetails(["bash:echo primary"]),
     );
 
-    session.handleConfirmationResponse("req-primary", "allow_10m");
+    conversationObj.handleConfirmationResponse("req-primary", "allow_10m");
 
     const confirmMsgs = emitted.filter(
       (m) =>
@@ -481,43 +486,46 @@ describe("approval cascading", () => {
 
   test("always_allow cascades to pattern-matching pending", () => {
     const emitted: ServerMessage[] = [];
-    const session = makeSession((msg) => emitted.push(msg), CONV_ID);
+    const conversationObj = makeConversation(
+      (msg) => emitted.push(msg),
+      CONV_ID,
+    );
 
     // Two with matching patterns (asset_materialize:doc.pdf)
-    seedPendingConfirmation(session, "req-match-1");
-    seedPendingConfirmation(session, "req-match-2");
+    seedPendingConfirmation(conversationObj, "req-match-1");
+    seedPendingConfirmation(conversationObj, "req-match-2");
     // One with non-overlapping pattern
-    seedPendingConfirmation(session, "req-nomatch");
+    seedPendingConfirmation(conversationObj, "req-nomatch");
 
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-match-1",
       CONV_ID,
       makeConfirmationDetails(["asset_materialize:doc.pdf"]),
     );
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-match-2",
       CONV_ID,
       makeConfirmationDetails(["asset_materialize:report.pdf"]),
     );
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-nomatch",
       CONV_ID,
       makeConfirmationDetails(["bash:rm -rf"]),
     );
 
     // Primary request
-    seedPendingConfirmation(session, "req-primary");
+    seedPendingConfirmation(conversationObj, "req-primary");
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-primary",
       CONV_ID,
       makeConfirmationDetails(["asset_materialize:image.png"]),
     );
 
-    session.handleConfirmationResponse(
+    conversationObj.handleConfirmationResponse(
       "req-primary",
       "always_allow",
       "asset_materialize:**",
@@ -538,20 +546,23 @@ describe("approval cascading", () => {
 
   test("always_allow does NOT cascade to high-risk pending confirmations", () => {
     const emitted: ServerMessage[] = [];
-    const session = makeSession((msg) => emitted.push(msg), CONV_ID);
+    const conversationObj = makeConversation(
+      (msg) => emitted.push(msg),
+      CONV_ID,
+    );
 
     // Medium-risk pending — should cascade
-    seedPendingConfirmation(session, "req-medium");
+    seedPendingConfirmation(conversationObj, "req-medium");
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-medium",
       CONV_ID,
       makeConfirmationDetails(["asset_materialize:report.pdf"]),
     );
 
     // High-risk pending — should NOT cascade via always_allow
-    seedPendingConfirmation(session, "req-high");
-    registerPendingInteraction(session, "req-high", CONV_ID, {
+    seedPendingConfirmation(conversationObj, "req-high");
+    registerPendingInteraction(conversationObj, "req-high", CONV_ID, {
       toolName: "bash",
       input: { command: "rm -rf /" },
       riskLevel: "high",
@@ -566,15 +577,15 @@ describe("approval cascading", () => {
     });
 
     // Primary request
-    seedPendingConfirmation(session, "req-primary");
+    seedPendingConfirmation(conversationObj, "req-primary");
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-primary",
       CONV_ID,
       makeConfirmationDetails(["asset_materialize:image.png"]),
     );
 
-    session.handleConfirmationResponse(
+    conversationObj.handleConfirmationResponse(
       "req-primary",
       "always_allow",
       "asset_materialize:**",
@@ -600,33 +611,36 @@ describe("approval cascading", () => {
 
   test("always_deny cascades deny to pattern-matching pending", () => {
     const emitted: ServerMessage[] = [];
-    const session = makeSession((msg) => emitted.push(msg), CONV_ID);
+    const conversationObj = makeConversation(
+      (msg) => emitted.push(msg),
+      CONV_ID,
+    );
 
-    seedPendingConfirmation(session, "req-match-1");
-    seedPendingConfirmation(session, "req-nomatch");
+    seedPendingConfirmation(conversationObj, "req-match-1");
+    seedPendingConfirmation(conversationObj, "req-nomatch");
 
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-match-1",
       CONV_ID,
       makeConfirmationDetails(["asset_materialize:doc.pdf"]),
     );
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-nomatch",
       CONV_ID,
       makeConfirmationDetails(["bash:rm -rf"]),
     );
 
-    seedPendingConfirmation(session, "req-primary");
+    seedPendingConfirmation(conversationObj, "req-primary");
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-primary",
       CONV_ID,
       makeConfirmationDetails(["asset_materialize:image.png"]),
     );
 
-    session.handleConfirmationResponse(
+    conversationObj.handleConfirmationResponse(
       "req-primary",
       "always_deny",
       "asset_materialize:**",
@@ -652,25 +666,28 @@ describe("approval cascading", () => {
 
   test("allow (one-time) does NOT cascade", () => {
     const emitted: ServerMessage[] = [];
-    const session = makeSession((msg) => emitted.push(msg), CONV_ID);
+    const conversationObj = makeConversation(
+      (msg) => emitted.push(msg),
+      CONV_ID,
+    );
 
-    seedPendingConfirmation(session, "req-1");
-    seedPendingConfirmation(session, "req-2");
+    seedPendingConfirmation(conversationObj, "req-1");
+    seedPendingConfirmation(conversationObj, "req-2");
 
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-1",
       CONV_ID,
       makeConfirmationDetails(["bash:echo hello"]),
     );
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-2",
       CONV_ID,
       makeConfirmationDetails(["bash:echo world"]),
     );
 
-    session.handleConfirmationResponse("req-1", "allow");
+    conversationObj.handleConfirmationResponse("req-1", "allow");
 
     const confirmMsgs = emitted.filter(
       (m) =>
@@ -685,25 +702,28 @@ describe("approval cascading", () => {
 
   test("deny (one-time) does NOT cascade", () => {
     const emitted: ServerMessage[] = [];
-    const session = makeSession((msg) => emitted.push(msg), CONV_ID);
+    const conversationObj = makeConversation(
+      (msg) => emitted.push(msg),
+      CONV_ID,
+    );
 
-    seedPendingConfirmation(session, "req-1");
-    seedPendingConfirmation(session, "req-2");
+    seedPendingConfirmation(conversationObj, "req-1");
+    seedPendingConfirmation(conversationObj, "req-2");
 
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-1",
       CONV_ID,
       makeConfirmationDetails(["bash:echo hello"]),
     );
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-2",
       CONV_ID,
       makeConfirmationDetails(["bash:echo world"]),
     );
 
-    session.handleConfirmationResponse("req-1", "deny");
+    conversationObj.handleConfirmationResponse("req-1", "deny");
 
     const confirmMsgs = emitted.filter(
       (m) =>
@@ -718,25 +738,28 @@ describe("approval cascading", () => {
 
   test("cascaded events have source 'system' and causedByRequestId", () => {
     const emitted: ServerMessage[] = [];
-    const session = makeSession((msg) => emitted.push(msg), CONV_ID);
+    const conversationObj = makeConversation(
+      (msg) => emitted.push(msg),
+      CONV_ID,
+    );
 
-    seedPendingConfirmation(session, "req-primary");
-    seedPendingConfirmation(session, "req-cascaded");
+    seedPendingConfirmation(conversationObj, "req-primary");
+    seedPendingConfirmation(conversationObj, "req-cascaded");
 
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-primary",
       CONV_ID,
       makeConfirmationDetails(["bash:echo primary"]),
     );
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-cascaded",
       CONV_ID,
       makeConfirmationDetails(["bash:echo cascaded"]),
     );
 
-    session.handleConfirmationResponse("req-primary", "allow_10m");
+    conversationObj.handleConfirmationResponse("req-primary", "allow_10m");
 
     const cascadedMsg = emitted.find(
       (m) =>
@@ -751,13 +774,16 @@ describe("approval cascading", () => {
 
   test("already-resolved request handled gracefully", () => {
     const emitted: ServerMessage[] = [];
-    const session = makeSession((msg) => emitted.push(msg), CONV_ID);
+    const conversationObj = makeConversation(
+      (msg) => emitted.push(msg),
+      CONV_ID,
+    );
 
-    seedPendingConfirmation(session, "req-primary");
-    seedPendingConfirmation(session, "req-stale");
+    seedPendingConfirmation(conversationObj, "req-primary");
+    seedPendingConfirmation(conversationObj, "req-stale");
 
     registerPendingInteraction(
-      session,
+      conversationObj,
       "req-primary",
       CONV_ID,
       makeConfirmationDetails(["bash:echo primary"]),
@@ -766,7 +792,7 @@ 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(
-      session,
+      conversationObj,
       "req-stale",
       CONV_ID,
       makeConfirmationDetails(["bash:echo stale"]),
@@ -774,14 +800,14 @@ describe("approval cascading", () => {
 
     // Remove req-stale from the prompter's pending map (simulating it was
     // already resolved by another path before cascade reaches it)
-    const prompter = session["prompter"] as unknown as {
+    const prompter = conversationObj["prompter"] as unknown as {
       pending: Map<string, unknown>;
     };
     prompter.pending.delete("req-stale");
 
     // This should not throw — cascade should skip req-stale gracefully
     expect(() => {
-      session.handleConfirmationResponse("req-primary", "allow_10m");
+      conversationObj.handleConfirmationResponse("req-primary", "allow_10m");
     }).not.toThrow();
 
     // Only the primary should be resolved

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

@@ -54,7 +54,7 @@ afterAll(() => {
 // ---------------------------------------------------------------------------
 
 function mintParams(overrides: Partial<MintGrantParams> = {}): MintGrantParams {
-  const futureExpiry = new Date(Date.now() + 60_000).toISOString();
+  const futureExpiry = Date.now() + 60_000;
   return {
     scopeMode: "request_id",
     requestChannel: "telegram",
@@ -293,7 +293,7 @@ describe("approval-primitive / consumeGrantForInvocation", () => {
   });
 
   test("miss: grant expired", async () => {
-    const pastExpiry = new Date(Date.now() - 60_000).toISOString();
+    const pastExpiry = Date.now() - 60_000;
     mintGrantFromDecision(
       mintParams({
         scopeMode: "request_id",