@vellumai/assistant 0.8.4 → 0.8.5

package/src/__tests__/checker.test.ts

@@ -133,13 +133,10 @@ const mockSkillTool: Tool = {
   description: "A test skill tool",
   category: "skill",
   defaultRiskLevel: RiskLevel.Low,
+  executionTarget: "sandbox",
   origin: "skill",
   ownerSkillId: "test-skill",
-  getDefinition: () => ({
-    name: "skill_test_tool",
-    description: "A test skill tool",
-    input_schema: { type: "object" as const, properties: {} },
-  }),
+  input_schema: { type: "object" as const, properties: {} },
   execute: async () => ({ content: "ok", isError: false }),
 };
 registerTool(mockSkillTool);
@@ -150,14 +147,11 @@ const mockBundledSkillTool: Tool = {
   description: "A test bundled skill tool",
   category: "skill",
   defaultRiskLevel: RiskLevel.Low,
+  executionTarget: "sandbox",
   origin: "skill",
   ownerSkillId: "gmail",
   ownerSkillBundled: true,
-  getDefinition: () => ({
-    name: "skill_bundled_test_tool",
-    description: "A test bundled skill tool",
-    input_schema: { type: "object" as const, properties: {} },
-  }),
+  input_schema: { type: "object" as const, properties: {} },
   execute: async () => ({ content: "ok", isError: false }),
 };
 registerTool(mockBundledSkillTool);
@@ -391,13 +385,10 @@ describe("Permission Checker", () => {
         description: "A medium-risk skill tool",
         category: "skill",
         defaultRiskLevel: RiskLevel.Medium,
+        executionTarget: "sandbox",
         origin: "skill",
         ownerSkillId: "test-skill",
-        getDefinition: () => ({
-          name: "skill_medium_tool",
-          description: "A medium-risk skill tool",
-          input_schema: { type: "object" as const, properties: {} },
-        }),
+        input_schema: { type: "object" as const, properties: {} },
         execute: async () => ({ content: "ok", isError: false }),
       };
       registerTool(mediumSkillTool);

package/src/__tests__/compaction-events.test.ts

@@ -129,6 +129,7 @@ mock.module("../security/secret-allowlist.js", () => ({
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
+  setConversationHistoryStrippedAt: () => {},
   deleteMessageById: () => {},
   provenanceFromTrustContext: () => ({
     source: "user",

package/src/__tests__/compactor-call-site-logging.test.ts

@@ -0,0 +1,214 @@
+/**
+ * Tests that successful compaction LLM calls land an `llm_request_logs`
+ * row with `call_site = "compactionAgent"`. The compactor opts out of
+ * automatic usage tracking (`usageTracking: "manual"`), so its calls
+ * otherwise never reach `recordRequestLog` via the agent-loop
+ * dispatcher. This test pins the explicit instrumentation in
+ * `compactor.ts` so visibility doesn't silently regress.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getMessages: () => [],
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  getAttachmentMetadataForMessage: () => [],
+  getAttachmentContent: () => null,
+}));
+
+const recordRequestLogCalls: Array<{
+  conversationId: string;
+  requestPayload: string;
+  responsePayload: string;
+  messageId: string | undefined;
+  provider: string | undefined;
+  callSite: string | undefined;
+}> = [];
+
+mock.module("../memory/llm-request-log-store.js", () => ({
+  recordRequestLog: (
+    conversationId: string,
+    requestPayload: string,
+    responsePayload: string,
+    messageId?: string,
+    provider?: string,
+    callSite?: string,
+  ): string => {
+    recordRequestLogCalls.push({
+      conversationId,
+      requestPayload,
+      responsePayload,
+      messageId,
+      provider,
+      callSite,
+    });
+    return `mock-log-${recordRequestLogCalls.length}`;
+  },
+}));
+
+import { runAssistantDrivenCompaction } from "../context/compactor.js";
+import type { Message, Provider } from "../providers/types.js";
+
+const TAIL_TIMESTAMP =
+  "2026-05-21 (Thursday) 10:00:00 -05:00 (America/Chicago)";
+
+const compactionResponse = `
+<compaction_result>
+<summary>
+Earlier turns summarized here.
+</summary>
+
+<key_state>
+- Nothing critical pending.
+</key_state>
+
+<tail_start timestamp="${TAIL_TIMESTAMP}" preview="tail anchor message" />
+</compaction_result>
+`;
+
+const RAW_REQUEST = { model: "mock-model", messages: [] };
+const RAW_RESPONSE = { id: "resp-1", content: compactionResponse };
+
+function makeProvider(): Provider {
+  return {
+    name: "mock-provider",
+    sendMessage: async () => ({
+      content: [{ type: "text", text: compactionResponse }],
+      model: "mock-model",
+      actualProvider: "actual-mock-provider",
+      usage: { inputTokens: 100, outputTokens: 50 },
+      stopReason: "end_turn",
+      rawRequest: RAW_REQUEST,
+      rawResponse: RAW_RESPONSE,
+    }),
+  };
+}
+
+function makeProviderWithoutRaw(): Provider {
+  return {
+    name: "mock-provider",
+    sendMessage: async () => ({
+      content: [{ type: "text", text: compactionResponse }],
+      model: "mock-model",
+      usage: { inputTokens: 100, outputTokens: 50 },
+      stopReason: "end_turn",
+      // rawRequest/rawResponse intentionally absent — best-effort skip path.
+    }),
+  };
+}
+
+const userText = (text: string): Message => ({
+  role: "user",
+  content: [{ type: "text", text }],
+});
+
+const userTextWithTurnContext = (text: string, timestamp: string): Message => ({
+  role: "user",
+  content: [
+    {
+      type: "text",
+      text: `<turn_context>\ncurrent_time: ${timestamp}\n</turn_context>\n${text}`,
+    },
+  ],
+});
+
+const assistantText = (text: string): Message => ({
+  role: "assistant",
+  content: [{ type: "text", text }],
+});
+
+function buildMessages(): Message[] {
+  return [
+    userText("old user turn 1"),
+    assistantText("old assistant reply 1"),
+    userText("old user turn 2"),
+    assistantText("old assistant reply 2"),
+    userTextWithTurnContext("tail anchor message", TAIL_TIMESTAMP),
+    assistantText("tail assistant reply"),
+  ];
+}
+
+const args = (provider: Provider) => ({
+  conversationId: "conv-compaction-log-1",
+  messages: buildMessages(),
+  provider,
+  systemPrompt: "you are a test assistant",
+  compaction: { enabled: true, autoThreshold: 0.7 },
+  maxInputTokens: 1000,
+  // Above threshold so the auto-check fires.
+  previousEstimatedInputTokens: 900,
+});
+
+describe("compactor records llm_request_logs with call_site=compactionAgent", () => {
+  beforeEach(() => {
+    recordRequestLogCalls.length = 0;
+  });
+
+  test("successful compaction call stamps call_site = compactionAgent", async () => {
+    await runAssistantDrivenCompaction(args(makeProvider()));
+
+    expect(recordRequestLogCalls.length).toBe(1);
+    expect(recordRequestLogCalls[0]!.callSite).toBe("compactionAgent");
+    expect(recordRequestLogCalls[0]!.conversationId).toBe(
+      "conv-compaction-log-1",
+    );
+    // Provider name comes from actualProvider when present.
+    expect(recordRequestLogCalls[0]!.provider).toBe("actual-mock-provider");
+    // Payloads should be JSON-stringified.
+    expect(recordRequestLogCalls[0]!.requestPayload).toBe(
+      JSON.stringify(RAW_REQUEST),
+    );
+    expect(recordRequestLogCalls[0]!.responsePayload).toBe(
+      JSON.stringify(RAW_RESPONSE),
+    );
+  });
+
+  test("skips persistence when provider returns no rawRequest/rawResponse", async () => {
+    await runAssistantDrivenCompaction(args(makeProviderWithoutRaw()));
+
+    // Helper short-circuits when raw payloads are absent — non-fatal.
+    expect(recordRequestLogCalls.length).toBe(0);
+  });
+
+  test("uses provider.name when actualProvider is absent", async () => {
+    const provider: Provider = {
+      name: "fallback-provider-name",
+      sendMessage: async () => ({
+        content: [{ type: "text", text: compactionResponse }],
+        model: "mock-model",
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: "end_turn",
+        rawRequest: RAW_REQUEST,
+        rawResponse: RAW_RESPONSE,
+      }),
+    };
+
+    await runAssistantDrivenCompaction(args(provider));
+
+    expect(recordRequestLogCalls.length).toBe(1);
+    expect(recordRequestLogCalls[0]!.provider).toBe("fallback-provider-name");
+    expect(recordRequestLogCalls[0]!.callSite).toBe("compactionAgent");
+  });
+});

package/src/__tests__/computer-use-skill-manifest-regression.test.ts

@@ -78,12 +78,11 @@ describe("computer-use skill manifest regression", () => {
     await initializeTools();
 
     for (const cuTool of allComputerUseTools) {
-      const def = cuTool.getDefinition();
       const manifestTool = manifest.tools.find(
-        (t: { name: string }) => t.name === def.name,
+        (t: { name: string }) => t.name === cuTool.name,
       );
       expect(manifestTool).toBeDefined();
-      expect(manifestTool.description).toBe(def.description);
+      expect(manifestTool.description).toBe(cuTool.description);
     }
   });
 
@@ -91,12 +90,11 @@ describe("computer-use skill manifest regression", () => {
     await initializeTools();
 
     for (const cuTool of allComputerUseTools) {
-      const def = cuTool.getDefinition();
       const manifestTool = manifest.tools.find(
-        (t: { name: string }) => t.name === def.name,
+        (t: { name: string }) => t.name === cuTool.name,
       );
       expect(manifestTool).toBeDefined();
-      expect(manifestTool.input_schema).toEqual(def.input_schema);
+      expect(manifestTool.input_schema).toEqual(cuTool.input_schema);
     }
   });
 
@@ -121,15 +119,11 @@ describe("computer-use skill manifest regression", () => {
       (entry: { name: string; description: string }) => ({
         name: entry.name,
         description: entry.description,
+        input_schema: { type: "object" as const, properties: {} },
         category: "computer-use",
         defaultRiskLevel: RiskLevel.Low,
         origin: "skill" as const,
         ownerSkillId: "computer-use",
-        getDefinition: () => ({
-          name: entry.name,
-          description: entry.description,
-          input_schema: { type: "object" as const, properties: {} },
-        }),
         execute: async () => ({ content: "stub", isError: false }),
       }),
     );

package/src/__tests__/computer-use-tools.test.ts

@@ -23,10 +23,8 @@ interface JsonSchema {
 }
 
 /** Cast a tool definition's input_schema to a usable JSON Schema shape. */
-function schema(tool: {
-  getDefinition(): { input_schema: object };
-}): JsonSchema {
-  return tool.getDefinition().input_schema as JsonSchema;
+function schema(tool: { input_schema: object }): JsonSchema {
+  return tool.input_schema as JsonSchema;
 }
 
 const ctx: ToolContext = {

package/src/__tests__/confirmation-request-guardian-bridge.test.ts

@@ -50,7 +50,6 @@ mock.module("../notifications/emit-signal.js", () => ({
       ],
     };
   },
-  registerBroadcastFn: () => {},
 }));
 
 // Mock channel guardian service — provide a guardian binding for 'self' + 'telegram'

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

@@ -86,7 +86,6 @@ mock.module("../daemon/disk-pressure-guard.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-  clearStrippedInjectionMetadataForConversation: () => {},
   getConversation: () => ({
     id: "conv-123",
     conversationType: "background",
@@ -98,6 +97,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversationOriginInterface: () => null,
   getConversationOverrideProfileFromRow: () => null,
   provenanceFromTrustContext: () => ({}),
+  setConversationHistoryStrippedAt: () => {},
   updateConversationContextWindow: () => {},
   updateConversationSlackContextWatermark: () => {},
 }));

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

@@ -145,9 +145,9 @@ let mockConversationRow: {
 
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
+  setConversationHistoryStrippedAt: () => {},
   updateConversationUsage: () => {},
   updateMessageMetadata: () => {},
-  clearStrippedInjectionMetadataForConversation: () => {},
   getMessages: () => [],
   getConversation: () => mockConversationRow,
   getConversationOverrideProfileFromRow: (

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

@@ -170,6 +170,7 @@ mock.module("../daemon/context-overflow-policy.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
+  setConversationHistoryStrippedAt: () => {},
   updateConversationUsage: () => {},
   getMessages: () => [],
   getConversation: () => ({
@@ -186,7 +187,7 @@ mock.module("../memory/conversation-crud.js", () => ({
     trustContext: undefined,
   }),
   getConversationOriginInterface: () => null,
-  addMessage: () => ({ id: "mock-msg-id" }),
+  addMessage: (...args: unknown[]) => addMessageMock(...args),
   deleteMessageById: () => {},
   updateConversationContextWindow: () => {},
   updateConversationTitle: () => {},
@@ -194,7 +195,6 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
   updateMessageContent: () => {},
   updateMessageMetadata: () => {},
-  clearStrippedInjectionMetadataForConversation: () => {},
   setLastNotifiedInferenceProfile: () => {},
   getLastUserTimestampBefore: () => 0,
   getConversationOverrideProfileFromRow: () => undefined,
@@ -305,6 +305,9 @@ mock.module("../daemon/history-repair.js", () => ({
 
 const recordUsageMock = mock((..._args: unknown[]) => {});
 const setAgentLoopExitReasonOnLatestLogMock = mock(() => {});
+const addMessageMock = mock(
+  (..._args: unknown[]) => ({ id: "mock-msg-id" }) as { id: string },
+);
 mock.module("../daemon/conversation-usage.js", () => ({
   recordUsage: recordUsageMock,
 }));
@@ -633,6 +636,7 @@ beforeEach(() => {
   mockApplyRuntimeInjections = (msgs) => msgs;
   recordUsageMock.mockClear();
   setAgentLoopExitReasonOnLatestLogMock.mockClear();
+  addMessageMock.mockClear();
   // Reset the plugin registry and re-register every default so the
   // orchestrator's pipelines (`overflowReduce`, `persistence`, …) dispatch to
   // the default middleware, which in turn hits the mocked collaborators
@@ -2234,4 +2238,195 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
     );
     expect(conversationError).toBeUndefined();
   });
+
+  // ── Test 9 ────────────────────────────────────────────────────────
+  // When the `auto_compress_latest_turn` rerun (the last layer of the
+  // overflow-recovery ladder) still yields at the mid-loop checkpoint,
+  // the turn cannot proceed. Before PR 1 of the Compaction Visibility
+  // workstream this terminated silently — no `agent_loop_exit_reason`,
+  // no client notice, no durable transcript row. Now the loop must:
+  //   1. emit a `conversation_error` event with code
+  //      `BUDGET_YIELD_UNRECOVERED`,
+  //   2. persist a `role="assistant"` notice via the persistence
+  //      pipeline (so reloads keep the message),
+  //   3. stamp `budget_yield_unrecovered` onto the latest llm_request_logs
+  //      row.
+  test("budget_yield_unrecovered: classified error emitted, persisted, and stamped", async () => {
+    const events: ServerMessage[] = [];
+
+    // Every estimate after the very first preflight is above the mid-loop
+    // threshold (190_000 × 0.85 = 161_500). This makes every checkpoint
+    // yield, including the one inside the auto_compress rerun.
+    let estimateCallCount = 0;
+    mockEstimateTokens = () => {
+      estimateCallCount++;
+      if (estimateCallCount === 1) return 100_000;
+      return 170_000;
+    };
+
+    // Convergence reducer becomes exhausted on the second tier so the
+    // loop escalates from convergence to the action-resolution block.
+    let reducerCallCount = 0;
+    mockReducerStepFn = (msgs: Message[]) => {
+      reducerCallCount++;
+      const exhausted = reducerCallCount >= 2;
+      return {
+        messages: msgs,
+        tier: exhausted ? "tool_result_truncation" : "forced_compaction",
+        state: {
+          appliedTiers: exhausted
+            ? ["forced_compaction", "tool_result_truncation"]
+            : ["forced_compaction"],
+          injectionMode: "full" as const,
+          exhausted,
+        },
+        estimatedTokens: exhausted ? 60_000 : 80_000,
+      };
+    };
+
+    // The overflow policy directs us into auto_compress_latest_turn so the
+    // emergency compaction + final agentLoop.run path executes.
+    mockOverflowAction = "auto_compress_latest_turn";
+
+    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,
+      });
+
+      // Every checkpoint yields — including the final auto_compress rerun.
+      if (onCheckpoint) {
+        const decision = await onCheckpoint({
+          turnIndex: 0,
+          toolCount: 1,
+          hasToolUse: true,
+          history: withProgress,
+        });
+        if (decision === "yield") {
+          return withProgress;
+        }
+      }
+
+      return withProgress;
+    };
+
+    const ctx = makeCtx({
+      agentLoopRun,
+      contextWindowManager: {
+        shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
+        // The compaction pipeline (default terminal) routes through this
+        // for the emergency `auto_compress_latest_turn` path.
+        maybeCompact: async () => ({
+          compacted: true,
+          messages: [
+            {
+              role: "user" as const,
+              content: [{ type: "text", text: "compacted" }],
+            },
+          ] as Message[],
+          compactedPersistedMessages: 5,
+          summaryText: "Emergency summary",
+          previousEstimatedInputTokens: 170_000,
+          estimatedInputTokens: 90_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));
+
+    // The classified error is emitted to the client.
+    const errorEvents = events.filter((e) => e.type === "conversation_error");
+    expect(errorEvents).toHaveLength(1);
+    const errorEvent = errorEvents[0];
+    if (errorEvent && "code" in errorEvent) {
+      expect(errorEvent.code).toBe("BUDGET_YIELD_UNRECOVERED");
+      expect(errorEvent.retryable).toBe(true);
+      expect(errorEvent.errorCategory).toBe("budget_yield_unrecovered");
+    } else {
+      throw new Error("conversation_error event missing `code` field");
+    }
+
+    // The exit reason is stamped onto the latest llm_request_logs row.
+    expect(setAgentLoopExitReasonOnLatestLogMock).toHaveBeenCalledWith(
+      "test-conv",
+      "budget_yield_unrecovered",
+    );
+
+    // A `role="assistant"` notice is persisted via the persistence pipeline.
+    // The default persistence terminal calls
+    // `addMessage(conversationId, role, content, metadata, addOptions)` —
+    // we look for the call whose role positional arg is "assistant" and
+    // whose content positional arg mentions compaction.
+    const assistantPersistCall = addMessageMock.mock.calls.find((call) => {
+      const role = call[1];
+      const content = call[2];
+      return (
+        role === "assistant" &&
+        typeof content === "string" &&
+        content.includes("compact")
+      );
+    });
+    expect(assistantPersistCall).toBeDefined();
+  });
 });