@vellumai/assistant 0.4.55 → 0.4.57

package/src/__tests__/{session-agent-loop.test.ts → conversation-agent-loop.test.ts}

@@ -38,7 +38,7 @@ mock.module("../config/loader.js", () => ({
         nonInteractiveLatestTurnCompression: "truncate",
       },
     },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     workspaceGit: { turnCommitMaxWaitMs: 10 },
     ui: {},
   }),
@@ -118,7 +118,7 @@ mock.module("../hooks/manager.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-  getConversationThreadType: () => "default",
+  getConversationType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
   updateConversationUsage: () => {},
   getMessages: () => [],
@@ -154,7 +154,7 @@ mock.module("../memory/retriever.js", () => ({
     injectedTokens: 0,
     latencyMs: 0,
   }),
-  stripMemoryRecallMessages: (msgs: Message[]) => msgs,
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
 mock.module("../memory/app-store.js", () => ({
@@ -167,7 +167,7 @@ mock.module("../memory/app-git-service.js", () => ({
   commitAppTurnChanges: () => Promise.resolve(),
 }));
 
-mock.module("../daemon/session-memory.js", () => ({
+mock.module("../daemon/conversation-memory.js", () => ({
   prepareMemoryContext: async (
     _ctx: unknown,
     _content: string,
@@ -191,7 +191,7 @@ mock.module("../daemon/session-memory.js", () => ({
   }),
 }));
 
-mock.module("../daemon/session-runtime-assembly.js", () => ({
+mock.module("../daemon/conversation-runtime-assembly.js", () => ({
   applyRuntimeInjections: (msgs: Message[]) => msgs,
   stripInjectedContext: (msgs: Message[]) => msgs,
 }));
@@ -213,12 +213,12 @@ mock.module("../daemon/history-repair.js", () => ({
   deepRepairHistory: (msgs: Message[]) => ({ messages: msgs, stats: {} }),
 }));
 
-mock.module("../daemon/session-history.js", () => ({
+mock.module("../daemon/conversation-history.js", () => ({
   consolidateAssistantMessages: () => {},
 }));
 
 const recordUsageMock = mock(() => {});
-mock.module("../daemon/session-usage.js", () => ({
+mock.module("../daemon/conversation-usage.js", () => ({
   recordUsage: recordUsageMock,
 }));
 
@@ -227,7 +227,7 @@ const resolveAssistantAttachmentsMock = mock(async () => ({
   emittedAttachments: [],
   directiveWarnings: [],
 }));
-mock.module("../daemon/session-attachments.js", () => ({
+mock.module("../daemon/conversation-attachments.js", () => ({
   resolveAssistantAttachments: resolveAssistantAttachmentsMock,
   approveHostAttachmentRead: async () => true,
   formatAttachmentWarnings: () => "",
@@ -245,7 +245,7 @@ mock.module("../daemon/assistant-attachments.js", () => ({
   }),
 }));
 
-mock.module("../daemon/session-media-retry.js", () => ({
+mock.module("../daemon/conversation-media-retry.js", () => ({
   stripMediaPayloadsForRetry: (msgs: Message[]) => ({
     messages: msgs,
     modified: false,
@@ -265,9 +265,9 @@ mock.module("../workspace/git-service.js", () => ({
   }),
 }));
 
-mock.module("../daemon/session-error.js", () => ({
-  classifySessionError: (_err: unknown, _ctx: unknown) => ({
-    code: "SESSION_PROCESSING_FAILED",
+mock.module("../daemon/conversation-error.js", () => ({
+  classifyConversationError: (_err: unknown, _ctx: unknown) => ({
+    code: "CONVERSATION_PROCESSING_FAILED",
     userMessage: "Something went wrong processing your message.",
     retryable: false,
     errorCategory: "processing_failed",
@@ -278,18 +278,18 @@ mock.module("../daemon/session-error.js", () => ({
     if (err instanceof Error && err.name === "AbortError") return true;
     return false;
   },
-  buildSessionErrorMessage: (
-    sessionId: string,
+  buildConversationErrorMessage: (
+    conversationId: string,
     classified: Record<string, unknown>,
   ) => ({
-    type: "session_error",
-    sessionId,
+    type: "conversation_error",
+    conversationId,
     ...classified,
   }),
   isContextTooLarge: (msg: string) => /context.?length.?exceeded/i.test(msg),
 }));
 
-mock.module("../daemon/session-slash.js", () => ({
+mock.module("../daemon/conversation-slash.js", () => ({
   isProviderOrderingError: (msg: string) =>
     /ordering|before.*after|messages.*order/i.test(msg),
 }));
@@ -312,9 +312,9 @@ mock.module("../memory/llm-request-log-store.js", () => ({
 // ── Imports (after mocks) ────────────────────────────────────────────
 
 import {
-  type AgentLoopSessionContext,
+  type AgentLoopConversationContext,
   runAgentLoopImpl,
-} from "../daemon/session-agent-loop.js";
+} from "../daemon/conversation-agent-loop.js";
 
 // ── Test helpers ─────────────────────────────────────────────────────
 
@@ -327,10 +327,10 @@ type AgentLoopRun = (
 ) => Promise<Message[]>;
 
 function makeCtx(
-  overrides?: Partial<AgentLoopSessionContext> & {
+  overrides?: Partial<AgentLoopConversationContext> & {
     agentLoopRun?: AgentLoopRun;
   },
-): AgentLoopSessionContext {
+): AgentLoopConversationContext {
   const agentLoopRun =
     overrides?.agentLoopRun ??
     (async (messages: Message[]) => [
@@ -353,7 +353,7 @@ function makeCtx(
     agentLoop: {
       run: agentLoopRun,
       getToolTokenBudget: () => 0,
-    } as unknown as AgentLoopSessionContext["agentLoop"],
+    } as unknown as AgentLoopConversationContext["agentLoop"],
     provider: {
       name: "mock-provider",
       sendMessage: async () => ({
@@ -362,13 +362,13 @@ function makeCtx(
         usage: { inputTokens: 0, outputTokens: 0 },
         stopReason: "end_turn",
       }),
-    } as unknown as AgentLoopSessionContext["provider"],
+    } as unknown as AgentLoopConversationContext["provider"],
     systemPrompt: "system prompt",
 
     contextWindowManager: {
       shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
       maybeCompact: async () => ({ compacted: false }),
-    } as unknown as AgentLoopSessionContext["contextWindowManager"],
+    } as unknown as AgentLoopConversationContext["contextWindowManager"],
     contextCompactedMessageCount: 0,
     contextCompactedAt: null,
 
@@ -393,15 +393,15 @@ function makeCtx(
     preactivatedSkillIds: undefined,
     skillProjectionState: new Map(),
     skillProjectionCache:
-      new Map() as unknown as AgentLoopSessionContext["skillProjectionCache"],
+      new Map() as unknown as AgentLoopConversationContext["skillProjectionCache"],
 
     traceEmitter: {
       emit: () => {},
-    } as unknown as AgentLoopSessionContext["traceEmitter"],
+    } as unknown as AgentLoopConversationContext["traceEmitter"],
     profiler: {
       startRequest: () => {},
       emitSummary: () => {},
-    } as unknown as AgentLoopSessionContext["profiler"],
+    } as unknown as AgentLoopConversationContext["profiler"],
     usageStats: {
       totalInputTokens: 0,
       totalOutputTokens: 0,
@@ -414,8 +414,8 @@ function makeCtx(
     lastAttachmentWarnings: [],
 
     hasNoClient: false,
-    prompter: {} as unknown as AgentLoopSessionContext["prompter"],
-    queue: {} as unknown as AgentLoopSessionContext["queue"],
+    prompter: {} as unknown as AgentLoopConversationContext["prompter"],
+    queue: {} as unknown as AgentLoopConversationContext["queue"],
 
     getWorkspaceGitService: () => ({ ensureInitialized: async () => {} }),
     commitTurnChanges: async () => {},
@@ -434,7 +434,7 @@ function makeCtx(
     }),
 
     ...overrides,
-  } as AgentLoopSessionContext;
+  } as AgentLoopConversationContext;
 }
 
 // ── Tests ────────────────────────────────────────────────────────────
@@ -545,11 +545,13 @@ describe("session-agent-loop", () => {
       const ctx = makeCtx({ agentLoopRun });
       await runAgentLoopImpl(ctx, "run ls", "msg-1", (msg) => events.push(msg));
 
-      const sessionError = events.find((e) => e.type === "session_error");
-      expect(sessionError).toBeDefined();
+      const conversationError = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationError).toBeDefined();
     });
 
-    test("non-error agent loop completion does not emit session_error", async () => {
+    test("non-error agent loop completion does not emit conversation_error", async () => {
       const events: ServerMessage[] = [];
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
@@ -579,8 +581,10 @@ describe("session-agent-loop", () => {
       const ctx = makeCtx({ agentLoopRun });
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
-      const sessionError = events.find((e) => e.type === "session_error");
-      expect(sessionError).toBeUndefined();
+      const conversationError = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationError).toBeUndefined();
       const complete = events.find((e) => e.type === "message_complete");
       expect(complete).toBeDefined();
     });
@@ -762,7 +766,7 @@ describe("session-agent-loop", () => {
         contextWindowManager: {
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopSessionContext["contextWindowManager"],
+        } as unknown as AgentLoopConversationContext["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -773,7 +777,7 @@ describe("session-agent-loop", () => {
       expect(compactEvent).toBeDefined();
     });
 
-    test("emits session_error when context stays too large after all recovery attempts", async () => {
+    test("emits conversation_error when context stays too large after all recovery attempts", async () => {
       const events: ServerMessage[] = [];
 
       const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
@@ -813,13 +817,15 @@ describe("session-agent-loop", () => {
             summaryOutputTokens: 200,
             summaryModel: "mock-model",
           }),
-        } as unknown as AgentLoopSessionContext["contextWindowManager"],
+        } as unknown as AgentLoopConversationContext["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
-      const sessionError = events.find((e) => e.type === "session_error");
-      expect(sessionError).toBeDefined();
+      const conversationError = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationError).toBeDefined();
     });
 
     test("bounded convergence loop applies reducer tiers and recovers", async () => {
@@ -889,20 +895,22 @@ describe("session-agent-loop", () => {
         contextWindowManager: {
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopSessionContext["contextWindowManager"],
+        } as unknown as AgentLoopConversationContext["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
       expect(reducerCalls).toBeGreaterThanOrEqual(1);
       expect(callCount).toBe(2);
-      const sessionError = events.find((e) => e.type === "session_error");
-      expect(sessionError).toBeUndefined();
+      const conversationError = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationError).toBeUndefined();
       const complete = events.find((e) => e.type === "message_complete");
       expect(complete).toBeDefined();
     });
 
-    test("interactive deny produces graceful assistant response instead of session_error", async () => {
+    test("interactive deny produces graceful assistant response instead of conversation_error", async () => {
       const events: ServerMessage[] = [];
 
       // Reducer exhausts all tiers but context is still too large
@@ -945,14 +953,16 @@ describe("session-agent-loop", () => {
         contextWindowManager: {
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopSessionContext["contextWindowManager"],
+        } as unknown as AgentLoopConversationContext["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
-      // Should NOT emit session_error
-      const sessionError = events.find((e) => e.type === "session_error");
-      expect(sessionError).toBeUndefined();
+      // Should NOT emit conversation_error
+      const conversationError = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationError).toBeUndefined();
 
       // Should emit a graceful assistant text delta instead
       const textDeltas = events.filter(
@@ -1051,14 +1061,16 @@ describe("session-agent-loop", () => {
             summaryOutputTokens: 100,
             summaryModel: "mock-model",
           }),
-        } as unknown as AgentLoopSessionContext["contextWindowManager"],
+        } as unknown as AgentLoopConversationContext["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
-      // Should not produce session_error since auto-compress recovered
-      const sessionError = events.find((e) => e.type === "session_error");
-      expect(sessionError).toBeUndefined();
+      // Should not produce conversation_error since auto-compress recovered
+      const conversationError = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationError).toBeUndefined();
       const complete = events.find((e) => e.type === "message_complete");
       expect(complete).toBeDefined();
     });
@@ -1103,7 +1115,7 @@ describe("session-agent-loop", () => {
         contextWindowManager: {
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopSessionContext["contextWindowManager"],
+        } as unknown as AgentLoopConversationContext["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1164,7 +1176,7 @@ describe("session-agent-loop", () => {
         contextWindowManager: {
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopSessionContext["contextWindowManager"],
+        } as unknown as AgentLoopConversationContext["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1250,8 +1262,10 @@ describe("session-agent-loop", () => {
       const ctx = makeCtx({ agentLoopRun });
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
-      const sessionError = events.find((e) => e.type === "session_error");
-      expect(sessionError).toBeDefined();
+      const conversationError = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationError).toBeDefined();
     });
   });
 
@@ -1317,7 +1331,7 @@ describe("session-agent-loop", () => {
       const ctx = makeCtx({
         agentLoopRun,
         canHandoffAtCheckpoint: () => true,
-      } as unknown as Partial<AgentLoopSessionContext>);
+      } as unknown as Partial<AgentLoopConversationContext>);
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
@@ -1376,7 +1390,7 @@ describe("session-agent-loop", () => {
       const ctx = makeCtx({
         agentLoopRun,
         canHandoffAtCheckpoint: () => false,
-      } as unknown as Partial<AgentLoopSessionContext>);
+      } as unknown as Partial<AgentLoopConversationContext>);
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
@@ -1443,7 +1457,7 @@ describe("session-agent-loop", () => {
       const ctx = makeCtx({
         agentLoopRun,
         canHandoffAtCheckpoint: () => true,
-      } as unknown as Partial<AgentLoopSessionContext>);
+      } as unknown as Partial<AgentLoopConversationContext>);
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
@@ -1506,9 +1520,11 @@ describe("session-agent-loop", () => {
 
       const cancelled = events.find((e) => e.type === "generation_cancelled");
       expect(cancelled).toBeDefined();
-      // Should NOT emit a session_error for user cancellation
-      const sessionError = events.find((e) => e.type === "session_error");
-      expect(sessionError).toBeUndefined();
+      // Should NOT emit a conversation_error for user cancellation
+      const conversationError = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationError).toBeUndefined();
     });
 
     test("skips resolveAssistantAttachments when cancelled", async () => {
@@ -1666,7 +1682,7 @@ describe("session-agent-loop", () => {
         drainQueue: (reason: string) => {
           drainReason = reason;
         },
-      } as unknown as Partial<AgentLoopSessionContext>);
+      } as unknown as Partial<AgentLoopConversationContext>);
 
       await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
 
@@ -1818,11 +1834,18 @@ describe("session-agent-loop", () => {
       const ctx = makeCtx({ agentLoopRun });
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
-      // The providerErrorUserMessage should trigger a synthesized assistant_text_delta
+      // The error should be sent as a conversation_error (not as an
+      // assistant_text_delta, which would cause duplicate text rendering
+      // alongside the InlineChatErrorAlert card).
       const textDeltas = events.filter(
         (e) => e.type === "assistant_text_delta",
       );
-      expect(textDeltas.length).toBeGreaterThanOrEqual(1);
+      expect(textDeltas).toHaveLength(0);
+
+      const conversationErrors = events.filter(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationErrors.length).toBeGreaterThanOrEqual(1);
     });
   });
 });

package/src/__tests__/{session-approval-overrides.test.ts → conversation-approval-overrides.test.ts}

@@ -7,9 +7,9 @@ import {
   clearMode,
   getEffectiveMode,
   hasActiveOverride,
-  setThreadMode,
+  setConversationMode,
   setTimedMode,
-} from "../runtime/session-approval-overrides.js";
+} from "../runtime/conversation-approval-overrides.js";
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -21,24 +21,24 @@ describe("session-approval-overrides", () => {
   });
 
   // -----------------------------------------------------------------------
-  // setThreadMode / getEffectiveMode
+  // setConversationMode / getEffectiveMode
   // -----------------------------------------------------------------------
-  describe("thread mode", () => {
-    test("setThreadMode stores a thread override", () => {
-      setThreadMode("conv-1");
+  describe("conversation mode", () => {
+    test("setConversationMode stores a conversation override", () => {
+      setConversationMode("conv-1");
       const mode = getEffectiveMode("conv-1");
       expect(mode).not.toBeUndefined();
-      expect(mode!.kind).toBe("thread");
+      expect(mode!.kind).toBe("conversation");
     });
 
-    test("thread mode persists across multiple reads", () => {
-      setThreadMode("conv-1");
+    test("conversation mode persists across multiple reads", () => {
+      setConversationMode("conv-1");
       expect(getEffectiveMode("conv-1")).not.toBeUndefined();
       expect(getEffectiveMode("conv-1")).not.toBeUndefined();
     });
 
-    test("thread mode is scoped to a specific conversationId", () => {
-      setThreadMode("conv-1");
+    test("conversation mode is scoped to a specific conversationId", () => {
+      setConversationMode("conv-1");
       expect(getEffectiveMode("conv-1")).not.toBeUndefined();
       expect(getEffectiveMode("conv-2")).toBeUndefined();
     });
@@ -102,8 +102,8 @@ describe("session-approval-overrides", () => {
   // Mode replacement
   // -----------------------------------------------------------------------
   describe("mode replacement", () => {
-    test("setTimedMode replaces an existing thread mode", () => {
-      setThreadMode("conv-1");
+    test("setTimedMode replaces an existing conversation mode", () => {
+      setConversationMode("conv-1");
       setTimedMode("conv-1", 60_000);
 
       const mode = getEffectiveMode("conv-1");
@@ -111,13 +111,13 @@ describe("session-approval-overrides", () => {
       expect(mode!.kind).toBe("timed");
     });
 
-    test("setThreadMode replaces an existing timed mode", () => {
+    test("setConversationMode replaces an existing timed mode", () => {
       setTimedMode("conv-1", 60_000);
-      setThreadMode("conv-1");
+      setConversationMode("conv-1");
 
       const mode = getEffectiveMode("conv-1");
       expect(mode).not.toBeUndefined();
-      expect(mode!.kind).toBe("thread");
+      expect(mode!.kind).toBe("conversation");
     });
   });
 
@@ -125,8 +125,8 @@ describe("session-approval-overrides", () => {
   // clearMode
   // -----------------------------------------------------------------------
   describe("clearMode", () => {
-    test("clearMode removes a thread override", () => {
-      setThreadMode("conv-1");
+    test("clearMode removes a conversation override", () => {
+      setConversationMode("conv-1");
       clearMode("conv-1");
       expect(getEffectiveMode("conv-1")).toBeUndefined();
     });
@@ -152,8 +152,8 @@ describe("session-approval-overrides", () => {
       expect(hasActiveOverride("conv-1")).toBe(false);
     });
 
-    test("returns true for active thread override", () => {
-      setThreadMode("conv-1");
+    test("returns true for active conversation override", () => {
+      setConversationMode("conv-1");
       expect(hasActiveOverride("conv-1")).toBe(true);
     });
 
@@ -169,7 +169,7 @@ describe("session-approval-overrides", () => {
     });
 
     test("returns false after clearMode", () => {
-      setThreadMode("conv-1");
+      setConversationMode("conv-1");
       clearMode("conv-1");
       expect(hasActiveOverride("conv-1")).toBe(false);
     });
@@ -180,9 +180,9 @@ describe("session-approval-overrides", () => {
   // -----------------------------------------------------------------------
   describe("clearAll", () => {
     test("clearAll removes all overrides", () => {
-      setThreadMode("conv-1");
+      setConversationMode("conv-1");
       setTimedMode("conv-2", 60_000);
-      setThreadMode("conv-3");
+      setConversationMode("conv-3");
 
       clearAll();