@vellumai/assistant 0.8.4 → 0.8.5

package/src/__tests__/conversation-agent-loop.test.ts

@@ -159,8 +159,8 @@ mock.module("../daemon/disk-pressure-policy.js", () => ({
 const updateMessageMetadataMock = mock(
   (_id: string, _updates: Record<string, unknown>) => {},
 );
-const clearStrippedInjectionMetadataForConversationMock = mock(
-  (_conversationId: string) => {},
+const setConversationHistoryStrippedAtMock = mock(
+  (_conversationId: string, _historyStrippedAt: number | null) => {},
 );
 const updateConversationSlackContextWatermarkMock = mock(
   (_conversationId: string, _watermarkTs: string, _compactedAt?: number) => {},
@@ -180,8 +180,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
   updateConversationUsage: () => {},
   updateMessageMetadata: updateMessageMetadataMock,
-  clearStrippedInjectionMetadataForConversation:
-    clearStrippedInjectionMetadataForConversationMock,
+  setConversationHistoryStrippedAt: setConversationHistoryStrippedAtMock,
   getMessages: () => [],
   getConversation: () => mockConversationRow,
   provenanceFromTrustContext: () => ({
@@ -684,10 +683,8 @@ beforeEach(() => {
   mockHasProactiveArtifactCompleted = true;
   mockTryClaimProactiveArtifactTrigger = false;
   runProactiveArtifactJobMock.mockClear();
-  clearStrippedInjectionMetadataForConversationMock.mockClear();
-  clearStrippedInjectionMetadataForConversationMock.mockImplementation(
-    () => {},
-  );
+  setConversationHistoryStrippedAtMock.mockClear();
+  setConversationHistoryStrippedAtMock.mockImplementation(() => {});
   applyRuntimeInjectionsMock.mockClear();
   buildUnifiedTurnContextBlockMock.mockClear();
   resolveTurnTimezoneContextMock.mockClear();
@@ -1218,20 +1215,8 @@ describe("session-agent-loop", () => {
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
       expect(recordRequestLogMock).toHaveBeenCalledTimes(1);
-      const call = recordRequestLogMock.mock.calls[0] as unknown as [
-        string,
-        string,
-        string,
-        undefined,
-        string,
-      ];
-      expect(call).toEqual([
-        "test-conv",
-        JSON.stringify(rawRequest),
-        JSON.stringify(rawResponse),
-        undefined,
-        "fireworks",
-      ]);
+      const call = recordRequestLogMock.mock.calls[0] as unknown as unknown[];
+      expect(call[4]).toBe("fireworks");
     });
 
     test("record request log falls back to the runtime provider when no actual provider is supplied", async () => {
@@ -1377,20 +1362,9 @@ describe("session-agent-loop", () => {
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
       expect(recordRequestLogMock).toHaveBeenCalledTimes(1);
-      const call = recordRequestLogMock.mock.calls[0] as unknown as [
-        string,
-        string,
-        string,
-        undefined,
-        string,
-      ];
-      expect(call).toEqual([
-        "test-conv",
-        JSON.stringify(rawRequest),
-        JSON.stringify(rawResponse),
-        undefined,
-        "openai",
-      ]);
+      const call = recordRequestLogMock.mock.calls[0] as unknown as unknown[];
+      expect(call[1]).toBe(JSON.stringify(rawRequest));
+      expect(call[2]).toBe(JSON.stringify(rawResponse));
     });
   });
 
@@ -2042,6 +2016,154 @@ describe("session-agent-loop", () => {
       expect(complete).toBeDefined();
     });
 
+    test("emits budget_yield_unrecovered when auto_compress rerun yields at mid-loop budget", async () => {
+      // Regression test for the silent-stall failure mode:
+      // when every recovery layer has been applied (tier reducer
+      // exhausted + auto_compress_latest_turn emergency compaction)
+      // and the final `agentLoop.run` STILL yields at the mid-loop
+      // budget checkpoint, the orchestrator used to fall through to
+      // post-turn cleanup with NO `agent_loop_exit_reason` emitted —
+      // the turn just stopped mid-action and `llm_request_logs` showed
+      // a NULL exit reason on the final row. We now emit
+      // `budget_yield_unrecovered` so the inspector and dashboards can
+      // attribute the silent stall.
+      const events: ServerMessage[] = [];
+      let callCount = 0;
+
+      // Reducer exhausts all 4 tiers on first call so the convergence
+      // loop runs exactly one iteration before falling through to
+      // the auto_compress_latest_turn branch.
+      mockReducerStepFn = (msgs: Message[]) => ({
+        messages: msgs,
+        tier: "injection_downgrade",
+        state: {
+          appliedTiers: [
+            "forced_compaction",
+            "tool_result_truncation",
+            "media_stubbing",
+            "injection_downgrade",
+          ],
+          injectionMode: "minimal",
+          exhausted: true,
+        },
+        estimatedTokens: 120_000,
+      });
+
+      mockOverflowAction = "auto_compress_latest_turn";
+
+      // Sits between the preflight budget (preflightBudget =
+      // 100k * 0.95 = 95k — anything above triggers preflight reducer
+      // *before* we get to the convergence/auto_compress path under
+      // test) and the mid-loop threshold (preflightBudget * 0.85 =
+      // ≈80.75k — anything above flips yieldedForBudget on a checkpoint
+      // call). 90k satisfies both so the path reaches call 3.
+      mockEstimateTokens = 90_000;
+
+      const agentLoopRun: AgentLoopRun = async (
+        messages,
+        onEvent,
+        _signal,
+        _reqId,
+        onCheckpoint,
+      ) => {
+        callCount++;
+        if (callCount <= 2) {
+          // Calls 1 (initial) and 2 (convergence rerun): error so
+          // `state.contextTooLargeDetected` stays true through
+          // convergence exit and we enter the auto_compress branch.
+          onEvent({
+            type: "error",
+            error: new Error("context_length_exceeded"),
+          });
+          onEvent({
+            type: "usage",
+            inputTokens: 100,
+            outputTokens: 0,
+            model: "test-model",
+            providerDurationMs: 50,
+          });
+          return messages;
+        }
+        // Call 3: the auto_compress_latest_turn rerun. Invoke
+        // onCheckpoint so the orchestrator's mid-loop budget check
+        // flips `yieldedForBudget` to true, then return without
+        // finishing — mirroring what AgentLoop.run does when its
+        // checkpoint returns "yield".
+        if (onCheckpoint) {
+          await onCheckpoint({
+            turnIndex: 0,
+            toolCount: 1,
+            hasToolUse: true,
+            history: messages,
+          });
+        }
+        return messages;
+      };
+
+      const ctx = makeCtx({
+        agentLoopRun,
+        hasNoClient: true,
+        contextWindowManager: {
+          shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
+          maybeCompact: async () => ({
+            compacted: true,
+            messages: [
+              { role: "user", content: [{ type: "text", text: "Hello" }] },
+            ] as Message[],
+            compactedPersistedMessages: 3,
+            summaryText: "Compressed summary",
+            previousEstimatedInputTokens: 120000,
+            estimatedInputTokens: 30000,
+            maxInputTokens: 100000,
+            thresholdTokens: 80000,
+            compactedMessages: 5,
+            summaryCalls: 1,
+            summaryInputTokens: 300,
+            summaryOutputTokens: 100,
+            summaryModel: "mock-model",
+          }),
+        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+      // Observability emit: exit reason was stamped onto the latest
+      // llm_request_logs row.
+      expect(setAgentLoopExitReasonOnLatestLogMock).toHaveBeenCalledWith(
+        "test-conv",
+        "budget_yield_unrecovered",
+      );
+
+      // We did NOT also emit context_too_large — the auto_compress
+      // branch resets `contextTooLargeDetected` before its rerun and
+      // the rerun's yield-for-budget keeps it false, so the error
+      // branch above stays skipped.
+      expect(setAgentLoopExitReasonOnLatestLogMock).not.toHaveBeenCalledWith(
+        "test-conv",
+        "context_too_large",
+      );
+
+      // User-facing emit: the classified BUDGET_YIELD_UNRECOVERED
+      // error is sent to the client so the UI can render a notice
+      // instead of leaving the turn looking like a silent ghost. The
+      // assistant-side notice persistence is exercised in the overflow
+      // suite (`conversation-agent-loop-overflow.test.ts`); this test
+      // owns the observability + emit contract.
+      const conversationError = events.find(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationError).toBeDefined();
+      if (conversationError && "code" in conversationError) {
+        expect(conversationError.code).toBe("BUDGET_YIELD_UNRECOVERED");
+        expect(conversationError.retryable).toBe(true);
+        expect(conversationError.errorCategory).toBe(
+          "budget_yield_unrecovered",
+        );
+      } else {
+        throw new Error("conversation_error missing `code` field");
+      }
+    });
+
     test("recovery loop is bounded by maxAttempts", async () => {
       const events: ServerMessage[] = [];
       let reducerCalls = 0;
@@ -3769,8 +3891,8 @@ describe("session-agent-loop", () => {
     });
   });
 
-  describe("compaction-strip metadata consistency", () => {
-    test("clears pkbSystemReminderBlock metadata when convergence strip runs", async () => {
+  describe("compaction-strip marker persistence", () => {
+    test("records historyStrippedAt when convergence strip runs", async () => {
       // Reducer: succeed on first call, returning reduced messages.
       mockReducerStepFn = (msgs: Message[]) => ({
         messages: msgs,
@@ -3841,91 +3963,10 @@ describe("session-agent-loop", () => {
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
 
-      // The bulk-clear helper must have been called with the conversation id
-      // at least once (one of the three strip sites fired).
-      const clearCalls =
-        clearStrippedInjectionMetadataForConversationMock.mock.calls.filter(
-          (call) => call[0] === "test-conv",
-        );
-      expect(clearCalls.length).toBeGreaterThanOrEqual(1);
-    });
-
-    test("strip-site clear is non-fatal when the helper throws", async () => {
-      clearStrippedInjectionMetadataForConversationMock.mockImplementation(
-        () => {
-          throw new Error("db write failed");
-        },
+      const stripCalls = setConversationHistoryStrippedAtMock.mock.calls.filter(
+        (call) => call[0] === "test-conv",
       );
-
-      mockReducerStepFn = (msgs: Message[]) => ({
-        messages: msgs,
-        tier: "forced_compaction",
-        state: {
-          appliedTiers: ["forced_compaction"],
-          injectionMode: "full",
-          exhausted: false,
-        },
-        estimatedTokens: 5000,
-      });
-
-      let callCount = 0;
-      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
-        callCount++;
-        if (callCount === 1) {
-          onEvent({
-            type: "error",
-            error: new Error("context_length_exceeded"),
-          });
-          onEvent({
-            type: "usage",
-            inputTokens: 100,
-            outputTokens: 0,
-            model: "test-model",
-            providerDurationMs: 50,
-          });
-          return [
-            ...messages,
-            {
-              role: "assistant" as const,
-              content: [{ type: "text", text: "partial" }] as ContentBlock[],
-            },
-          ];
-        }
-        onEvent({
-          type: "message_complete",
-          message: {
-            role: "assistant",
-            content: [{ type: "text", text: "recovered" }],
-          },
-        });
-        onEvent({
-          type: "usage",
-          inputTokens: 50,
-          outputTokens: 25,
-          model: "test-model",
-          providerDurationMs: 100,
-        });
-        return [
-          ...messages,
-          {
-            role: "assistant" as const,
-            content: [{ type: "text", text: "recovered" }] as ContentBlock[],
-          },
-        ];
-      };
-
-      const ctx = makeCtx({
-        agentLoopRun,
-        contextWindowManager: {
-          shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
-          maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
-      });
-
-      // Must not throw — the strip-site clear is wrapped in try/catch.
-      await expect(
-        runAgentLoopImpl(ctx, "hello", "msg-1", () => {}),
-      ).resolves.toBeUndefined();
+      expect(stripCalls.length).toBeGreaterThanOrEqual(1);
     });
   });
 });

package/src/__tests__/conversation-app-control-instantiation.test.ts

@@ -110,15 +110,12 @@ mock.module("../tools/skills/skill-tool-factory.js", () => ({
       description: entry.description,
       category: entry.category,
       defaultRiskLevel: RiskLevel.Medium,
+      executionTarget: "sandbox" as const,
       origin: "skill" as const,
       ownerSkillId: skillId,
       ownerSkillVersionHash: versionHash,
       ownerSkillBundled: bundled ?? undefined,
-      getDefinition: () => ({
-        name: entry.name,
-        description: entry.description,
-        input_schema: entry.input_schema as object,
-      }),
+      input_schema: entry.input_schema as object,
       execute: async () => ({ content: "", isError: false }),
     })),
 }));

package/src/__tests__/conversation-clear-safety.test.ts

@@ -27,8 +27,8 @@ mock.module("../config/env.js", () => ({
 
 mock.module("../daemon/handlers/conversations.js", () => ({
   cancelGeneration: () => true,
-  clearAllConversations: () => {
-    clearAll();
+  clearAllConversations: async () => {
+    await clearAll();
     return 0;
   },
   switchConversation: async () => null,
@@ -129,26 +129,28 @@ describe("DELETE /v1/conversations — route handler", () => {
     (r) => r.operationId === "clearAllConversations",
   )!;
 
-  test("missing X-Confirm-Destructive header throws BadRequestError", () => {
-    expect(() =>
-      clearRoute.handler({
-        pathParams: {},
-        body: {},
-        headers: {},
-  
-      }),
-    ).toThrow(BadRequestError);
+  test("missing X-Confirm-Destructive header throws BadRequestError", async () => {
+    await expect(
+      Promise.resolve().then(() =>
+        clearRoute.handler({
+          pathParams: {},
+          body: {},
+          headers: {},
+        }),
+      ),
+    ).rejects.toThrow(BadRequestError);
   });
 
-  test("wrong X-Confirm-Destructive header value throws BadRequestError", () => {
-    expect(() =>
-      clearRoute.handler({
-        pathParams: {},
-        body: {},
-        headers: { "x-confirm-destructive": "wrong-value" },
-  
-      }),
-    ).toThrow(BadRequestError);
+  test("wrong X-Confirm-Destructive header value throws BadRequestError", async () => {
+    await expect(
+      Promise.resolve().then(() =>
+        clearRoute.handler({
+          pathParams: {},
+          body: {},
+          headers: { "x-confirm-destructive": "wrong-value" },
+        }),
+      ),
+    ).rejects.toThrow(BadRequestError);
   });
 
   test("correct header clears data", async () => {
@@ -156,23 +158,21 @@ describe("DELETE /v1/conversations — route handler", () => {
     await addMessage(conv.id, "user", "hello from safety test");
     expect(getConversation(conv.id)).not.toBeNull();
 
-    const result = clearRoute.handler({
+    const result = await clearRoute.handler({
       pathParams: {},
       body: {},
       headers: { "x-confirm-destructive": "clear-all-conversations" },
-
     });
     expect(result).toBeUndefined();
 
     expect(getConversation(conv.id)).toBeNull();
   });
 
-  test("lifecycle_events contains conversations_clear_all after successful clear", () => {
-    clearRoute.handler({
+  test("lifecycle_events contains conversations_clear_all after successful clear", async () => {
+    await clearRoute.handler({
       pathParams: {},
       body: {},
       headers: { "x-confirm-destructive": "clear-all-conversations" },
-
     });
 
     const raw = (

package/src/__tests__/conversation-delete-schedule-cleanup.test.ts

@@ -23,7 +23,7 @@ mock.module("../daemon/conversation-store.js", () => ({
 
 mock.module("../daemon/handlers/conversations.js", () => ({
   cancelGeneration: () => true,
-  clearAllConversations: () => 0,
+  clearAllConversations: async () => 0,
   switchConversation: async () => null,
   undoLastMessage: async () => null,
   regenerateResponse: async () => null,

package/src/__tests__/conversation-disk-view-integration.test.ts

@@ -231,7 +231,7 @@ describe("clearAll → disk view", () => {
     resetConversationsDir();
   });
 
-  test("empties the conversations directory", () => {
+  test("empties the conversations directory", async () => {
     // Create two conversations
     createConversation("Conv A");
     createConversation("Conv B");
@@ -241,7 +241,7 @@ describe("clearAll → disk view", () => {
     expect(entries.length).toBe(2);
 
     // Clear all
-    clearAll();
+    await clearAll();
 
     // Conversations directory should exist but be empty
     expect(existsSync(conversationsDir)).toBe(true);

package/src/__tests__/conversation-error.test.ts

@@ -9,6 +9,7 @@ mock.module("../providers/registry.js", () => ({
 
 import type { ErrorContext } from "../daemon/conversation-error.js";
 import {
+  budgetYieldUnrecoveredClassification,
   buildConversationErrorMessage,
   classifyConversationError,
   isUserCancellation,
@@ -947,3 +948,33 @@ describe("buildConversationErrorMessage", () => {
     expect(msg.code).toBe("PROVIDER_WEB_SEARCH");
   });
 });
+
+describe("budgetYieldUnrecoveredClassification", () => {
+  it("returns the BUDGET_YIELD_UNRECOVERED code and retryable=true", () => {
+    const classified = budgetYieldUnrecoveredClassification();
+    expect(classified.code).toBe("BUDGET_YIELD_UNRECOVERED");
+    expect(classified.retryable).toBe(true);
+    expect(classified.errorCategory).toBe("budget_yield_unrecovered");
+  });
+
+  it("returns a user-facing message that explains the situation", () => {
+    const classified = budgetYieldUnrecoveredClassification();
+    // The message must communicate (a) compaction was attempted, (b) send
+    // another message to continue. Avoid asserting exact wording so copy
+    // tweaks don't trip the test, but lock down the two semantic anchors
+    // a downstream client could test against.
+    expect(classified.userMessage).toContain("compact");
+    expect(classified.userMessage).toContain("Send another message");
+  });
+
+  it("survives the buildConversationErrorMessage envelope unchanged", () => {
+    const classified = budgetYieldUnrecoveredClassification();
+    const envelope = buildConversationErrorMessage("conv-1", classified);
+    expect(envelope.type).toBe("conversation_error");
+    expect(envelope.conversationId).toBe("conv-1");
+    expect(envelope.code).toBe("BUDGET_YIELD_UNRECOVERED");
+    expect(envelope.retryable).toBe(true);
+    expect(envelope.errorCategory).toBe("budget_yield_unrecovered");
+    expect(envelope.userMessage).toBe(classified.userMessage);
+  });
+});