@vellumai/assistant 0.8.4 → 0.8.6

package/src/__tests__/compaction-trail-store.test.ts

@@ -0,0 +1,264 @@
+/**
+ * Tests for the compaction-trail store helpers:
+ *   - `getCompactionLogsBetween` (windowed trail fetch)
+ *   - `getPreviousNonCompactionCallCreatedAt` (window-floor resolver)
+ *
+ * Exercises the SQL directly against a real in-memory DB — same pattern
+ * as `llm-request-log-turn-query.test.ts`. Each test sets up a small
+ * conversation, inserts a mix of `mainAgent` / `compactionAgent` /
+ * NULL-call-site rows with controlled `createdAt` timestamps, and
+ * asserts the right subset comes back.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import { eq } from "drizzle-orm";
+
+import { createConversation } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import {
+  getCompactionLogsBetween,
+  getPreviousNonCompactionCallCreatedAt,
+  recordRequestLog,
+} from "../memory/llm-request-log-store.js";
+import { llmRequestLogs } from "../memory/schema.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.delete(llmRequestLogs).run();
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+/**
+ * Insert a log row and overwrite its `createdAt` so tests can assert
+ * order/cutoff without relying on `Date.now()` timing.
+ */
+function insertLogAt(
+  conversationId: string,
+  createdAt: number,
+  callSite: "mainAgent" | "compactionAgent" | null,
+): string {
+  const id = recordRequestLog(
+    conversationId,
+    "{}",
+    "{}",
+    undefined,
+    "anthropic",
+    callSite ?? undefined,
+  );
+  // Use the Drizzle update builder rather than `db.run("UPDATE … ?")` —
+  // the drizzle wrapper doesn't accept positional parameters the same
+  // way `bun:sqlite` does, and a silent no-op there manifests as zero
+  // rows in the query under test (the inserted `created_at` keeps its
+  // `Date.now()` value and ends up far in the future of the cutoff).
+  const db = getDb();
+  db.update(llmRequestLogs)
+    .set({ createdAt })
+    .where(eq(llmRequestLogs.id, id))
+    .run();
+  return id;
+}
+
+describe("getCompactionLogsBetween", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("returns only compactionAgent rows in the conversation, in the (after, before) window", () => {
+    const conv = createConversation("test-conv");
+
+    // Timeline (createdAt in ms):
+    //   100 → compactionAgent  ← excluded (before the floor — would belong to an earlier turn)
+    //   150 ← floor (the prior real call's createdAt)
+    //   200 → mainAgent        ← excluded (wrong call site)
+    //   300 → compactionAgent  ← included
+    //   400 → null call site   ← excluded (pre-migration row, not a compaction)
+    //   500 ← ceiling (the selected call's createdAt)
+    //   600 → compactionAgent  ← excluded (after ceiling)
+    insertLogAt(conv.id, 100, "compactionAgent");
+    insertLogAt(conv.id, 200, "mainAgent");
+    insertLogAt(conv.id, 300, "compactionAgent");
+    insertLogAt(conv.id, 400, null);
+    insertLogAt(conv.id, 600, "compactionAgent");
+
+    const result = getCompactionLogsBetween(conv.id, 150, 500);
+    expect(result).toHaveLength(1);
+    expect(result[0]!.createdAt).toBe(300);
+    expect(result[0]!.callSite).toBe("compactionAgent");
+    expect(result[0]!.conversationId).toBe(conv.id);
+  });
+
+  test("null floor matches all compactions before the ceiling (first-real-call case)", () => {
+    const conv = createConversation("null-floor");
+
+    insertLogAt(conv.id, 100, "compactionAgent");
+    insertLogAt(conv.id, 200, "compactionAgent");
+    insertLogAt(conv.id, 300, "compactionAgent");
+    insertLogAt(conv.id, 600, "compactionAgent");
+
+    const result = getCompactionLogsBetween(conv.id, null, 500);
+    expect(result.map((r) => r.createdAt)).toEqual([100, 200, 300]);
+  });
+
+  test("uses strict < at the ceiling (a row exactly at the cutoff is excluded)", () => {
+    const conv = createConversation("strict-ceiling");
+
+    insertLogAt(conv.id, 100, "compactionAgent");
+    insertLogAt(conv.id, 500, "compactionAgent"); // exactly at the ceiling
+
+    const result = getCompactionLogsBetween(conv.id, null, 500);
+    expect(result).toHaveLength(1);
+    expect(result[0]!.createdAt).toBe(100);
+  });
+
+  test("uses strict > at the floor (a row exactly at the floor is excluded)", () => {
+    const conv = createConversation("strict-floor");
+
+    insertLogAt(conv.id, 150, "compactionAgent"); // exactly at the floor
+    insertLogAt(conv.id, 200, "compactionAgent");
+
+    const result = getCompactionLogsBetween(conv.id, 150, 500);
+    expect(result).toHaveLength(1);
+    expect(result[0]!.createdAt).toBe(200);
+  });
+
+  test("scopes by conversation_id (other conversations are invisible)", () => {
+    const a = createConversation("conv-a");
+    const b = createConversation("conv-b");
+
+    insertLogAt(a.id, 100, "compactionAgent");
+    insertLogAt(b.id, 150, "compactionAgent");
+    insertLogAt(a.id, 200, "compactionAgent");
+
+    const result = getCompactionLogsBetween(a.id, null, 500);
+    expect(result).toHaveLength(2);
+    for (const row of result) {
+      expect(row.conversationId).toBe(a.id);
+    }
+  });
+
+  test("returns rows in chronological order by createdAt then id", () => {
+    const conv = createConversation("ordered");
+
+    // Insert out of order to verify the ORDER BY clause does the work.
+    insertLogAt(conv.id, 300, "compactionAgent");
+    insertLogAt(conv.id, 100, "compactionAgent");
+    insertLogAt(conv.id, 200, "compactionAgent");
+
+    const result = getCompactionLogsBetween(conv.id, null, 500);
+    expect(result.map((r) => r.createdAt)).toEqual([100, 200, 300]);
+  });
+
+  test("returns an empty array when no compaction rows fall in the window", () => {
+    const conv = createConversation("empty");
+
+    // mainAgent (wrong site) + compactionAgent after the ceiling.
+    insertLogAt(conv.id, 100, "mainAgent");
+    insertLogAt(conv.id, 600, "compactionAgent");
+
+    const result = getCompactionLogsBetween(conv.id, null, 500);
+    expect(result).toEqual([]);
+  });
+
+  test("returns an empty array for an unknown conversation_id", () => {
+    const result = getCompactionLogsBetween("nonexistent-conv", null, 500);
+    expect(result).toEqual([]);
+  });
+});
+
+describe("getPreviousNonCompactionCallCreatedAt", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("returns the most recent non-compaction call's createdAt before the cutoff", () => {
+    const conv = createConversation("prior-call");
+
+    // Timeline:
+    //   100 → mainAgent
+    //   200 → compactionAgent  ← skipped (we want the previous *real* call)
+    //   300 → mainAgent        ← this should be the answer for cutoff=500
+    //   400 → compactionAgent  ← skipped
+    //   500 ← cutoff
+    //   600 → mainAgent        ← excluded (after cutoff)
+    insertLogAt(conv.id, 100, "mainAgent");
+    insertLogAt(conv.id, 200, "compactionAgent");
+    insertLogAt(conv.id, 300, "mainAgent");
+    insertLogAt(conv.id, 400, "compactionAgent");
+    insertLogAt(conv.id, 600, "mainAgent");
+
+    const result = getPreviousNonCompactionCallCreatedAt(conv.id, 500);
+    expect(result).toBe(300);
+  });
+
+  test("returns null when no non-compaction call exists before the cutoff", () => {
+    const conv = createConversation("no-prior");
+
+    // Only compactions before the cutoff.
+    insertLogAt(conv.id, 100, "compactionAgent");
+    insertLogAt(conv.id, 200, "compactionAgent");
+
+    const result = getPreviousNonCompactionCallCreatedAt(conv.id, 500);
+    expect(result).toBeNull();
+  });
+
+  test("returns null for an unknown conversation_id", () => {
+    const result = getPreviousNonCompactionCallCreatedAt("nope", 500);
+    expect(result).toBeNull();
+  });
+
+  test("treats NULL call_site (pre-migration-264) as a real agent call", () => {
+    const conv = createConversation("null-site");
+
+    // Pre-migration rows have NULL call_site. They were mainAgent calls
+    // in practice, so the floor walker must surface them.
+    insertLogAt(conv.id, 100, null);
+    insertLogAt(conv.id, 200, "compactionAgent");
+
+    const result = getPreviousNonCompactionCallCreatedAt(conv.id, 500);
+    expect(result).toBe(100);
+  });
+
+  test("uses strict < at the cutoff (a row exactly at the cutoff is excluded)", () => {
+    const conv = createConversation("strict-prior");
+
+    insertLogAt(conv.id, 100, "mainAgent");
+    insertLogAt(conv.id, 500, "mainAgent"); // exactly at the cutoff
+
+    const result = getPreviousNonCompactionCallCreatedAt(conv.id, 500);
+    expect(result).toBe(100);
+  });
+
+  test("scopes by conversation_id (a prior call in another conversation is invisible)", () => {
+    const a = createConversation("conv-a");
+    const b = createConversation("conv-b");
+
+    insertLogAt(b.id, 100, "mainAgent"); // wrong conversation
+    insertLogAt(a.id, 200, "compactionAgent");
+
+    const result = getPreviousNonCompactionCallCreatedAt(a.id, 500);
+    expect(result).toBeNull();
+  });
+});

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

@@ -0,0 +1,215 @@
+/**
+ * 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: () => [],
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+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__/compactor-preserved-tail-count.test.ts

@@ -23,6 +23,7 @@ mock.module("../util/logger.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   getMessages: () => [],
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/attachments-store.js", () => ({

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);
     }
   });
 
@@ -115,26 +113,24 @@ describe("computer-use skill manifest regression", () => {
     await initializeTools();
 
     // Simulate what projectSkillTools() does when the computer-use skill is
-    // activated: create skill-origin Tool objects matching the manifest names
-    // and register them. This must not throw.
+    // activated: create Tool objects matching the manifest names and register
+    // them through `registerSkillTools(skillId, tools)`, which records
+    // ownership in the registry's `ownersByName` map. This must not throw.
     const skillTools: Tool[] = manifest.tools.map(
       (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 }),
       }),
     );
 
-    expect(() => registerSkillTools(skillTools)).not.toThrow();
+    // Owner flows in through `registerSkillTools(skillId, tools)` and lands
+    // in the registry's `ownersByName` map — the tools themselves carry no
+    // per-tool owner field.
+    expect(() => registerSkillTools("computer-use", skillTools)).not.toThrow();
 
     // Clean up
     unregisterSkillTools("computer-use");

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 = {
@@ -42,12 +40,6 @@ describe("computer-use tool definitions", () => {
     expect(allComputerUseTools.length).toBe(11);
   });
 
-  test("all tools have proxy execution mode", () => {
-    for (const tool of allComputerUseTools) {
-      expect(tool.executionMode).toBe("proxy");
-    }
-  });
-
   test("all tools belong to computer-use category", () => {
     for (const tool of allComputerUseTools) {
       expect(tool.category).toBe("computer-use");
@@ -96,8 +88,10 @@ describe("computer_use_click (unified)", () => {
     expect(props.y.type).toBe("integer");
   });
 
-  test("execute throws proxy error", () => {
-    expect(() => computerUseClickTool.execute({}, ctx)).toThrow("Proxy tool");
+  test("execute returns isError when no proxy resolver is configured", async () => {
+    const result = await computerUseClickTool.execute({}, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toMatch(/No proxy resolver/);
   });
 });
 
@@ -109,10 +103,10 @@ describe("computer_use_type_text", () => {
     expect(schema(computerUseTypeTextTool).required).toContain("reasoning");
   });
 
-  test("execute throws proxy error", () => {
-    expect(() => computerUseTypeTextTool.execute({}, ctx)).toThrow(
-      "Proxy tool",
-    );
+  test("execute returns isError when no proxy resolver is configured", async () => {
+    const result = await computerUseTypeTextTool.execute({}, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toMatch(/No proxy resolver/);
   });
 });
 
@@ -124,8 +118,10 @@ describe("computer_use_key", () => {
     expect(schema(computerUseKeyTool).required).toContain("reasoning");
   });
 
-  test("execute throws proxy error", () => {
-    expect(() => computerUseKeyTool.execute({}, ctx)).toThrow("Proxy tool");
+  test("execute returns isError when no proxy resolver is configured", async () => {
+    const result = await computerUseKeyTool.execute({}, ctx);
+    expect(result.isError).toBe(true);
+    expect(result.content).toMatch(/No proxy resolver/);
   });
 });