@vellumai/assistant 0.8.5 → 0.8.6

package/src/__tests__/checker.test.ts

@@ -109,7 +109,7 @@ import {
 } from "../permissions/checker.js";
 import { _clearGlobalCacheForTesting } from "../permissions/gateway-threshold-reader.js";
 import { RiskLevel } from "../permissions/types.js";
-import { registerTool } from "../tools/registry.js";
+import { registerSkillTools, registerTool } from "../tools/registry.js";
 import type { Tool } from "../tools/types.js";
 import * as platformModule from "../util/platform.js";
 
@@ -128,33 +128,35 @@ const STRICT_GATEWAY_THRESHOLDS = {
 } as const;
 
 // Register a mock skill-origin tool for testing default-ask policy.
+// Ownership is recorded by `registerSkillTools(skillId, tools)`, not by
+// stamping a field on the `Tool` object — `isToolOwnerSkillBundled()` reads
+// from the registry via `getToolOwner(name)` to find the owning skill id.
 const mockSkillTool: Tool = {
   name: "skill_test_tool",
   description: "A test skill tool",
   category: "skill",
   defaultRiskLevel: RiskLevel.Low,
   executionTarget: "sandbox",
-  origin: "skill",
-  ownerSkillId: "test-skill",
   input_schema: { type: "object" as const, properties: {} },
   execute: async () => ({ content: "ok", isError: false }),
 };
-registerTool(mockSkillTool);
+registerSkillTools("test-skill", [mockSkillTool]);
 
-// Register a mock bundled skill-origin tool for testing strict mode + bundled policy.
+// Register a mock bundled skill-origin tool for testing strict mode + bundled
+// policy. `app-builder` is a real entry under `bundled-skills/`, so
+// `loadSkillCatalog()` reports it as `bundled: true` and the permission
+// checker derives `isSkillBundled = true` from the registry's ownersByName
+// map (populated by `registerSkillTools`) without any per-tool stamp.
 const mockBundledSkillTool: Tool = {
   name: "skill_bundled_test_tool",
   description: "A test bundled skill tool",
   category: "skill",
   defaultRiskLevel: RiskLevel.Low,
   executionTarget: "sandbox",
-  origin: "skill",
-  ownerSkillId: "gmail",
-  ownerSkillBundled: true,
   input_schema: { type: "object" as const, properties: {} },
   execute: async () => ({ content: "ok", isError: false }),
 };
-registerTool(mockBundledSkillTool);
+registerSkillTools("app-builder", [mockBundledSkillTool]);
 
 // Register CU tools so check() can look them up in the tool registry
 // instead of falling through to Medium (unknown tool).
@@ -386,12 +388,10 @@ describe("Permission Checker", () => {
         category: "skill",
         defaultRiskLevel: RiskLevel.Medium,
         executionTarget: "sandbox",
-        origin: "skill",
-        ownerSkillId: "test-skill",
         input_schema: { type: "object" as const, properties: {} },
         execute: async () => ({ content: "ok", isError: false }),
       };
-      registerTool(mediumSkillTool);
+      registerSkillTools("test-skill", [mediumSkillTool]);
       const result = await check("skill_medium_tool", {}, "/tmp");
       expect(result.decision).toBe("prompt");
       expect(result.reason).toContain("Skill tool");

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

@@ -150,6 +150,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   addMessage: () => ({ id: `msg-${Date.now()}` }),
   updateConversationUsage: () => {},
   updateConversationTitle: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

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

@@ -31,6 +31,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__/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

@@ -113,8 +113,9 @@ 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,
@@ -122,13 +123,14 @@ describe("computer-use skill manifest regression", () => {
         input_schema: { type: "object" as const, properties: {} },
         category: "computer-use",
         defaultRiskLevel: RiskLevel.Low,
-        origin: "skill" as const,
-        ownerSkillId: "computer-use",
         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

@@ -40,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");
@@ -94,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/);
   });
 });
 
@@ -107,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/);
   });
 });
 
@@ -122,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/);
   });
 });
 

package/src/__tests__/config-loader-backfill.test.ts

@@ -82,7 +82,7 @@ import { migrateProviderConnectionStatusLabel } from "../memory/migrations/244-p
 import { migrateProviderConnectionBaseUrlAndModels } from "../memory/migrations/250-provider-connection-base-url-and-models.js";
 import * as schema from "../memory/schema.js";
 import { getConnection } from "../providers/inference/connections.js";
-import { _setStorePath } from "../security/encrypted-store.js";
+import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -328,14 +328,14 @@ describe("loadConfig startup behavior", () => {
     const updatesPath = join(WORKSPACE_DIR, "UPDATES.md");
     if (existsSync(updatesPath)) rmSync(updatesPath, { force: true });
     ensureTestDir();
-    _setStorePath(join(WORKSPACE_DIR, "keys.enc"));
+    setStorePathForTesting(join(WORKSPACE_DIR, "keys.enc"));
     delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
     delete process.env.IS_PLATFORM;
     invalidateConfigCache();
   });
 
   afterEach(() => {
-    _setStorePath(null);
+    setStorePathForTesting(null);
     delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
     delete process.env.IS_PLATFORM;
     invalidateConfigCache();
@@ -943,14 +943,14 @@ describe("seedInferenceProfiles BYOK-mode managed profile labels", () => {
       }
     }
     ensureTestDir();
-    _setStorePath(join(WORKSPACE_DIR, "keys.enc"));
+    setStorePathForTesting(join(WORKSPACE_DIR, "keys.enc"));
     delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
     delete process.env.IS_PLATFORM;
     invalidateConfigCache();
   });
 
   afterEach(() => {
-    _setStorePath(null);
+    setStorePathForTesting(null);
     delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
     delete process.env.IS_PLATFORM;
     invalidateConfigCache();
@@ -1037,9 +1037,10 @@ describe("seedInferenceProfiles BYOK-mode managed profile labels", () => {
       "anthropic-managed",
     );
     expect("status" in raw.llm.profiles.balanced).toBe(false);
-    expect(getConnection(db, "anthropic-managed")?.status).toBe("active");
-    expect(getConnection(db, "openai-managed")?.status).toBe("disabled");
-    expect(getConnection(db, "gemini-managed")?.status).toBe("disabled");
+    // Connections exist (status is no longer a connection-level concept).
+    expect(getConnection(db, "anthropic-managed")).not.toBeNull();
+    expect(getConnection(db, "openai-managed")).not.toBeNull();
+    expect(getConnection(db, "gemini-managed")).not.toBeNull();
   });
 
   test("off-platform managed-inference hatch respects explicit non-managed active connection", () => {
@@ -1075,26 +1076,10 @@ describe("seedInferenceProfiles BYOK-mode managed profile labels", () => {
     expect(raw.llm.profiles.balanced.provider_connection).toBe(
       "anthropic-personal",
     );
-    expect(getConnection(db, "anthropic-managed")?.status).toBe("disabled");
-    expect(getConnection(db, "openai-managed")?.status).toBe("disabled");
-    expect(getConnection(db, "gemini-managed")?.status).toBe("disabled");
-  });
-
-  test("off-platform BYOK hatch still disables managed connections", () => {
-    const overlayPath = join(WORKSPACE_DIR, "hatch-overlay.json");
-    writeFileSync(
-      overlayPath,
-      JSON.stringify({ llm: { default: { provider: "anthropic" } } }, null, 2) +
-        "\n",
-    );
-    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = overlayPath;
-    const db = createProviderConnectionsDb();
-
-    mergeDefaultConfigAndSeedInferenceProfiles(db);
-
-    expect(getConnection(db, "anthropic-managed")?.status).toBe("disabled");
-    expect(getConnection(db, "openai-managed")?.status).toBe("disabled");
-    expect(getConnection(db, "gemini-managed")?.status).toBe("disabled");
+    // Connections exist (status is no longer a connection-level concept).
+    expect(getConnection(db, "anthropic-managed")).not.toBeNull();
+    expect(getConnection(db, "openai-managed")).not.toBeNull();
+    expect(getConnection(db, "gemini-managed")).not.toBeNull();
   });
 
   test("non-hatch off-platform boot does NOT auto-disable freshly-materialized managed profiles", () => {

package/src/__tests__/config-loader-corrupt.test.ts

@@ -23,7 +23,7 @@ import {
   loadConfig,
   loadRawConfig,
 } from "../config/loader.js";
-import { _setStorePath } from "../security/encrypted-store.js";
+import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -65,12 +65,12 @@ function listQuarantinedFiles(): string[] {
 describe("loadConfig corrupt-file recovery", () => {
   beforeEach(() => {
     resetWorkspace();
-    _setStorePath(join(WORKSPACE_DIR, "keys.enc"));
+    setStorePathForTesting(join(WORKSPACE_DIR, "keys.enc"));
     invalidateConfigCache();
   });
 
   afterEach(() => {
-    _setStorePath(null);
+    setStorePathForTesting(null);
     invalidateConfigCache();
   });
 
@@ -187,12 +187,12 @@ describe("loadConfig corrupt-file recovery", () => {
 describe("loadRawConfig corrupt-file recovery", () => {
   beforeEach(() => {
     resetWorkspace();
-    _setStorePath(join(WORKSPACE_DIR, "keys.enc"));
+    setStorePathForTesting(join(WORKSPACE_DIR, "keys.enc"));
     invalidateConfigCache();
   });
 
   afterEach(() => {
-    _setStorePath(null);
+    setStorePathForTesting(null);
     invalidateConfigCache();
   });