@vellumai/assistant 0.4.55 → 0.4.57

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

@@ -50,7 +50,7 @@ mock.module("../config/loader.js", () => ({
         nonInteractiveLatestTurnCompression: "truncate",
       },
     },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     workspaceGit: { turnCommitMaxWaitMs: 10 },
     ui: {},
   }),
@@ -133,7 +133,7 @@ mock.module("../hooks/manager.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-  getConversationThreadType: () => "default",
+  getConversationType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
   updateConversationUsage: () => {},
   getMessages: () => [],
@@ -171,7 +171,7 @@ mock.module("../memory/retriever.js", () => ({
     injectedTokens: 0,
     latencyMs: 0,
   }),
-  stripMemoryRecallMessages: (msgs: Message[]) => msgs,
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
 mock.module("../memory/app-store.js", () => ({
@@ -184,7 +184,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,
@@ -208,7 +208,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,
 }));
@@ -230,12 +230,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,
 }));
 
@@ -244,7 +244,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: () => "",
@@ -262,7 +262,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,
@@ -282,9 +282,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",
@@ -295,12 +295,12 @@ 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) =>
@@ -309,7 +309,7 @@ mock.module("../daemon/session-error.js", () => ({
     ),
 }));
 
-mock.module("../daemon/session-slash.js", () => ({
+mock.module("../daemon/conversation-slash.js", () => ({
   isProviderOrderingError: (msg: string) =>
     /ordering|before.*after|messages.*order/i.test(msg),
 }));
@@ -332,9 +332,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 ─────────────────────────────────────────────────────
 
@@ -347,10 +347,10 @@ type AgentLoopRun = (
 ) => Promise<Message[]>;
 
 function makeCtx(
-  overrides?: Partial<AgentLoopSessionContext> & {
+  overrides?: Partial<AgentLoopConversationContext> & {
     agentLoopRun?: AgentLoopRun;
   },
-): AgentLoopSessionContext {
+): AgentLoopConversationContext {
   const agentLoopRun =
     overrides?.agentLoopRun ??
     (async (messages: Message[]) => [
@@ -373,7 +373,7 @@ function makeCtx(
     agentLoop: {
       run: agentLoopRun,
       getToolTokenBudget: () => 0,
-    } as unknown as AgentLoopSessionContext["agentLoop"],
+    } as unknown as AgentLoopConversationContext["agentLoop"],
     provider: {
       name: "mock-provider",
       sendMessage: async () => ({
@@ -382,13 +382,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,
 
@@ -413,15 +413,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,
@@ -434,8 +434,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 () => {},
@@ -454,7 +454,7 @@ function makeCtx(
     }),
 
     ...overrides,
-  } as AgentLoopSessionContext;
+  } as AgentLoopConversationContext;
 }
 
 /**
@@ -688,7 +688,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
         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));
@@ -698,10 +698,12 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
       // After PR 2 fix, the reducer SHOULD be called to attempt compaction.
       expect(reducerCalled).toBe(true);
 
-      // BUG: Currently a session_error IS emitted instead of retrying.
-      // After PR 2 fix, there should be no session_error.
-      const sessionError = events.find((e) => e.type === "session_error");
-      expect(sessionError).toBeUndefined();
+      // BUG: Currently a conversation_error IS emitted instead of retrying.
+      // After PR 2 fix, there should be no conversation_error.
+      const conversationError = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationError).toBeUndefined();
     },
   );
 
@@ -799,16 +801,18 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
         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));
 
       // The reducer should be called in the convergence loop
       expect(reducerCalled).toBe(true);
-      // Should recover without session_error
-      const sessionError = events.find((e) => e.type === "session_error");
-      expect(sessionError).toBeUndefined();
+      // Should recover without conversation_error
+      const conversationError = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationError).toBeUndefined();
       expect(callCount).toBe(2);
     },
   );
@@ -919,7 +923,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
         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));
@@ -940,9 +944,11 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
       );
       expect(capturedTargetTokens!).toBe(expectedCorrectedTarget);
 
-      // Should recover without session_error
-      const sessionError = events.find((e) => e.type === "session_error");
-      expect(sessionError).toBeUndefined();
+      // Should recover without conversation_error
+      const conversationError = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationError).toBeUndefined();
       expect(callCount).toBe(2);
     },
   );
@@ -1026,7 +1032,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
         contextWindowManager: {
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopSessionContext["contextWindowManager"],
+        } as unknown as AgentLoopConversationContext["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "analyze this", "msg-1", (msg) =>
@@ -1037,8 +1043,10 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
       expect(reducerCalled).toBe(true);
       // Should succeed
       expect(callCount).toBe(1);
-      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();
     },
@@ -1219,7 +1227,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
             }
             return { compacted: false };
           },
-        } as unknown as AgentLoopSessionContext["contextWindowManager"],
+        } as unknown as AgentLoopConversationContext["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1229,9 +1237,11 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
       // After PR 2 fix, emergency compaction should be attempted.
       expect(emergencyCompactCalled).toBe(true);
 
-      // BUG: Currently a session_error IS emitted.
-      const sessionError = events.find((e) => e.type === "session_error");
-      expect(sessionError).toBeUndefined();
+      // BUG: Currently a conversation_error IS emitted.
+      const conversationError = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationError).toBeUndefined();
     },
   );
 
@@ -1394,7 +1404,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
               summaryModel: "mock-model",
             };
           },
-        } as unknown as AgentLoopSessionContext["contextWindowManager"],
+        } as unknown as AgentLoopConversationContext["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1405,9 +1415,11 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
       // Agent loop should have been called twice: once before yield, once after compaction
       expect(agentLoopCallCount).toBe(2);
 
-      // No session_error should be emitted
-      const sessionError = events.find((e) => e.type === "session_error");
-      expect(sessionError).toBeUndefined();
+      // No conversation_error should be emitted
+      const conversationError = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationError).toBeUndefined();
 
       // A context_compacted event should have been emitted
       const compacted = events.find((e) => e.type === "context_compacted");
@@ -1568,16 +1580,16 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
               summaryModel: "mock-model",
             };
           },
-        } as unknown as AgentLoopSessionContext["contextWindowManager"],
+        } as unknown as AgentLoopConversationContext["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => {
         events.push(msg);
         // Track if context_too_large was ever emitted
         if (
-          msg.type === "session_error" &&
+          msg.type === "conversation_error" &&
           "code" in msg &&
-          msg.code === "SESSION_PROCESSING_FAILED"
+          msg.code === "CONVERSATION_PROCESSING_FAILED"
         ) {
           contextTooLargeEmitted = true;
         }
@@ -1592,9 +1604,11 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
       // Agent loop called twice: once (yielded at tool 3), once after compaction
       expect(agentLoopCallCount).toBe(2);
 
-      // No session_error
-      const sessionError = events.find((e) => e.type === "session_error");
-      expect(sessionError).toBeUndefined();
+      // No conversation_error
+      const conversationError = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationError).toBeUndefined();
     },
   );
 
@@ -1739,7 +1753,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
             summaryModel: "mock-model",
           };
         },
-      } as unknown as AgentLoopSessionContext["contextWindowManager"],
+      } as unknown as AgentLoopConversationContext["contextWindowManager"],
     });
 
     await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1754,4 +1768,165 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
     // have been triggered (contextTooLargeDetected set to true)
     expect(convergenceReducerCalled).toBe(true);
   });
+
+  // ── Test 9 ────────────────────────────────────────────────────────
+  // When the convergence loop reruns the agent loop and it still yields
+  // at checkpoint (yieldedForBudget), the loop must continue reducing
+  // through additional tiers instead of silently dropping the incomplete
+  // turn.
+  test("post-convergence yieldedForBudget continues reduction", async () => {
+    const events: ServerMessage[] = [];
+
+    // Budget = 200_000 * 0.95 = 190_000
+    // Mid-loop threshold = 190_000 * 0.85 = 161_500
+    let estimateCallCount = 0;
+    mockEstimateTokens = () => {
+      estimateCallCount++;
+      // Preflight: below budget
+      if (estimateCallCount === 1) return 100_000;
+      // Every checkpoint call: above threshold — always triggers yield
+      return 170_000;
+    };
+
+    let agentLoopCallCount = 0;
+    const agentLoopRun: AgentLoopRun = async (
+      messages,
+      onEvent,
+      _signal,
+      _requestId,
+      onCheckpoint,
+    ) => {
+      agentLoopCallCount++;
+
+      const withProgress: Message[] = [
+        ...messages,
+        {
+          role: "assistant" as const,
+          content: [
+            { type: "text", text: `Tool call ${agentLoopCallCount}` },
+            {
+              type: "tool_use",
+              id: `tu-${agentLoopCallCount}`,
+              name: "bash",
+              input: { command: "ls" },
+            },
+          ] as ContentBlock[],
+        },
+        {
+          role: "user" as const,
+          content: [
+            {
+              type: "tool_result",
+              tool_use_id: `tu-${agentLoopCallCount}`,
+              content: "output",
+              is_error: false,
+            },
+          ] as ContentBlock[],
+        },
+      ];
+
+      onEvent({
+        type: "message_complete",
+        message: {
+          role: "assistant",
+          content: [
+            { type: "text", text: `Tool call ${agentLoopCallCount}` },
+            {
+              type: "tool_use",
+              id: `tu-${agentLoopCallCount}`,
+              name: "bash",
+              input: { command: "ls" },
+            },
+          ],
+        },
+      });
+      onEvent({
+        type: "usage",
+        inputTokens: 100,
+        outputTokens: 50,
+        model: "test-model",
+        providerDurationMs: 100,
+      });
+
+      // Always yield at checkpoint — simulates reduction not helping enough
+      if (onCheckpoint) {
+        const decision = onCheckpoint({
+          turnIndex: 0,
+          toolCount: 1,
+          hasToolUse: true,
+          history: withProgress,
+        });
+        if (decision === "yield") {
+          return withProgress;
+        }
+      }
+
+      return withProgress;
+    };
+
+    // Convergence reducer: first call returns non-exhausted, second returns exhausted
+    let reducerCallCount = 0;
+    mockReducerStepFn = (msgs: Message[]) => {
+      reducerCallCount++;
+      if (reducerCallCount === 1) {
+        return {
+          messages: msgs,
+          tier: "forced_compaction",
+          state: {
+            appliedTiers: ["forced_compaction"],
+            injectionMode: "full",
+            exhausted: false,
+          },
+          estimatedTokens: 80_000,
+        };
+      }
+      // Second call: exhausted
+      return {
+        messages: msgs,
+        tier: "tool_result_truncation",
+        state: {
+          appliedTiers: ["forced_compaction", "tool_result_truncation"],
+          injectionMode: "full",
+          exhausted: true,
+        },
+        estimatedTokens: 60_000,
+      };
+    };
+
+    const ctx = makeCtx({
+      agentLoopRun,
+      contextWindowManager: {
+        shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
+        maybeCompact: async () => ({
+          compacted: true,
+          messages: [
+            {
+              role: "user" as const,
+              content: [{ type: "text", text: "Hello" }],
+            },
+          ] as Message[],
+          compactedPersistedMessages: 5,
+          summaryText: "Compaction summary",
+          previousEstimatedInputTokens: 170_000,
+          estimatedInputTokens: 165_000,
+          maxInputTokens: 200_000,
+          thresholdTokens: 160_000,
+          compactedMessages: 10,
+          summaryCalls: 1,
+          summaryInputTokens: 500,
+          summaryOutputTokens: 200,
+          summaryModel: "mock-model",
+        }),
+      } as unknown as AgentLoopConversationContext["contextWindowManager"],
+    });
+
+    await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+    // Reducer should have been called twice: once for first convergence tier,
+    // once more after yieldedForBudget triggered re-entry
+    expect(reducerCallCount).toBe(2);
+
+    // Agent loop: 1 initial + 3 mid-loop re-entries + 2 convergence re-runs = 6 calls
+    expect(agentLoopCallCount).toBe(6);
+  });
 });