@vellumai/assistant 0.8.5 → 0.8.7

package/src/__tests__/tool-executor.test.ts

@@ -148,6 +148,16 @@ mock.module("../tools/registry.js", () => ({
     };
   },
   getAllTools: () => (getAllToolsOverride ? getAllToolsOverride() : []),
+  // Ownership lives on the registry post-refactor; production reads it via
+  // getToolOwner(name) rather than a field on the Tool object. Mirror that by
+  // surfacing the optional `owner`-shaped field from the override-produced
+  // tool so existing tests can encode owner inline.
+  getToolOwner: (name: string) => {
+    const t = getToolOverride?.(name) as
+      | { owner?: { kind: "skill" | "mcp" | "plugin"; id: string } }
+      | undefined;
+    return t?.owner;
+  },
 }));
 
 mock.module("../tools/shared/filesystem/path-policy.js", () => ({
@@ -224,6 +234,48 @@ describe("ToolExecutor allowedToolNames gating", () => {
     expect(result.content).toBe("ok");
   });
 
+  test("canonicalizes legacy computer_use_press_key alias before active-tool gating", async () => {
+    const executor = new ToolExecutor(makePrompter());
+    const allowed = new Set(["computer_use_key"]);
+    const result = await executor.execute(
+      "computer_use_press_key",
+      {
+        key: "Space",
+        modifiers: ["Command"],
+        reasoning: "Open Spotlight",
+      },
+      makeContext({ allowedToolNames: allowed }),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toBe("ok");
+    expect(lastCheckArgs?.toolName).toBe("computer_use_key");
+    expect(lastCheckArgs?.input).toEqual({
+      key: "cmd+space",
+      reasoning: "Open Spotlight",
+    });
+  });
+
+  test("lowercases legacy computer_use_press_key key-only input", async () => {
+    const executor = new ToolExecutor(makePrompter());
+    const allowed = new Set(["computer_use_key"]);
+    const result = await executor.execute(
+      "computer_use_press_key",
+      {
+        key: "Space",
+        reasoning: "Pause media",
+      },
+      makeContext({ allowedToolNames: allowed }),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(lastCheckArgs?.toolName).toBe("computer_use_key");
+    expect(lastCheckArgs?.input).toEqual({
+      key: "space",
+      reasoning: "Pause media",
+    });
+  });
+
   test("preserves exact active create_app tool before applying compatibility aliases", async () => {
     const executor = new ToolExecutor(makePrompter());
     const allowed = new Set(["create_app", "app_create"]);
@@ -334,8 +386,7 @@ describe("ToolExecutor allowedToolNames gating", () => {
         category: "skill",
         defaultRiskLevel: RiskLevel.Low,
         executionTarget: "sandbox" as const,
-        origin: "skill" as const,
-        ownerSkillId: "my-skill",
+        owner: { kind: "skill", id: "my-skill" },
         input_schema: { type: "object" as const, properties: {} },
         execute: async () => fakeToolResult,
       };
@@ -371,9 +422,7 @@ describe("ToolExecutor policy context plumbing", () => {
         description: "skill tool",
         category: "skill",
         defaultRiskLevel: RiskLevel.Low,
-        origin: "skill" as const,
-        ownerSkillId: "my-skill-123",
-        ownerSkillVersionHash: "abc123hash",
+        owner: { kind: "skill", id: "my-skill-123" },
         executionTarget: "sandbox" as const,
         input_schema: { type: "object" as const, properties: {} },
         execute: async () => fakeToolResult,
@@ -424,7 +473,6 @@ describe("ToolExecutor policy context plumbing", () => {
         category: "core",
         defaultRiskLevel: RiskLevel.Low,
         executionTarget: "sandbox" as const,
-        origin: "core" as const,
         input_schema: { type: "object" as const, properties: {} },
         execute: async () => fakeToolResult,
       };
@@ -453,9 +501,7 @@ describe("ToolExecutor policy context plumbing", () => {
         description: "host skill tool",
         category: "skill",
         defaultRiskLevel: RiskLevel.Low,
-        origin: "skill" as const,
-        ownerSkillId: "host-skill",
-        ownerSkillVersionHash: "host-hash",
+        owner: { kind: "skill", id: "host-skill" },
         executionTarget: "host" as const,
         input_schema: { type: "object" as const, properties: {} },
         execute: async () => fakeToolResult,
@@ -477,7 +523,6 @@ describe("ToolExecutor policy context plumbing", () => {
       executionTarget: "host",
     });
   });
-
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/tool-preview-lifecycle.test.ts

@@ -45,6 +45,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
   updateMessageContent: () => {},
   provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/llm-request-log-store.js", () => ({
@@ -91,16 +92,14 @@ function createMockDeps(
       emitActivityState: (
         phase: string,
         reason: string,
-        anchor?: string,
-        requestId?: string,
-        statusText?: string,
+        options?: { anchor?: string; requestId?: string; statusText?: string },
       ) => {
         emittedActivityStates.push({
           phase,
           reason,
-          anchor,
-          requestId,
-          statusText,
+          anchor: options?.anchor,
+          requestId: options?.requestId,
+          statusText: options?.statusText,
         });
       },
       markWorkspaceTopLevelDirty: () => {},
@@ -141,9 +140,7 @@ function createEventCollector(): {
   emitActivityState: (
     phase: string,
     reason: string,
-    anchor?: string,
-    requestId?: string,
-    statusText?: string,
+    options?: { anchor?: string; requestId?: string; statusText?: string },
   ) => void;
 } {
   const events: ServerMessage[] = [];
@@ -158,8 +155,14 @@ function createEventCollector(): {
     events,
     activityStates,
     onEvent: (msg: ServerMessage) => events.push(msg),
-    emitActivityState: (phase, reason, anchor, requestId, statusText) =>
-      activityStates.push({ phase, reason, anchor, requestId, statusText }),
+    emitActivityState: (phase, reason, options) =>
+      activityStates.push({
+        phase,
+        reason,
+        anchor: options?.anchor,
+        requestId: options?.requestId,
+        statusText: options?.statusText,
+      }),
   };
 }
 

package/src/__tests__/tool-result-metadata-plumbing.test.ts

@@ -44,6 +44,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
   updateMessageContent: () => {},
   provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/llm-request-log-store.js", () => ({

package/src/__tests__/tool-result-truncate-pipeline.test.ts

@@ -18,28 +18,25 @@
 
 import { beforeEach, describe, expect, test } from "bun:test";
 
+import type { TrustContext } from "../daemon/trust-context.js";
+import { defaultToolResultTruncatePlugin } from "../plugins/defaults/tool-result-truncate/register.js";
 import {
+  defaultToolResultTruncateTerminal,
   MIN_KEEP_CHARS,
   truncateToolResultText,
   TRUNCATION_SUFFIX,
-} from "../context/tool-result-truncation.js";
-import type { TrustContext } from "../daemon/trust-context.js";
-import {
-  defaultToolResultTruncatePlugin,
-  defaultToolResultTruncateTerminal,
-} from "../plugins/defaults/tool-result-truncate.js";
+} from "../plugins/defaults/tool-result-truncate/terminal.js";
+import type {
+  ToolResultTruncateArgs,
+  ToolResultTruncateResult,
+} from "../plugins/defaults/tool-result-truncate/types.js";
 import { DEFAULT_TIMEOUTS, runPipeline } from "../plugins/pipeline.js";
 import {
   getMiddlewaresFor,
   registerPlugin,
   resetPluginRegistryForTests,
 } from "../plugins/registry.js";
-import {
-  type Middleware,
-  type ToolResultTruncateArgs,
-  type ToolResultTruncateResult,
-  type TurnContext,
-} from "../plugins/types.js";
+import { type Middleware, type TurnContext } from "../plugins/types.js";
 
 // ---------------------------------------------------------------------------
 // Fixtures

package/src/__tests__/tool-result-truncation.test.ts

@@ -3,10 +3,12 @@ import { describe, expect, test } from "bun:test";
 import {
   calculateMaxToolResultChars,
   HARD_MAX_TOOL_RESULT_CHARS,
+} from "../context/tool-result-truncation.js";
+import {
   MIN_KEEP_CHARS,
   truncateToolResultText,
   TRUNCATION_SUFFIX,
-} from "../context/tool-result-truncation.js";
+} from "../plugins/defaults/tool-result-truncate/terminal.js";
 
 function hasOrphanedSurrogate(str: string): boolean {
   for (let i = 0; i < str.length; i++) {

package/src/__tests__/tools-audio-read.test.ts

@@ -0,0 +1,113 @@
+import {
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  truncateSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+
+import {
+  AUDIO_EXTENSIONS,
+  readAudioFile,
+} from "../tools/shared/filesystem/audio-read.js";
+
+let dir: string;
+beforeAll(() => {
+  dir = mkdtempSync(join(tmpdir(), "audio-read-"));
+});
+afterAll(() => {
+  rmSync(dir, { recursive: true, force: true });
+});
+
+describe("readAudioFile", () => {
+  test("reads an mp3 into a base64 file block with audio/mpeg", () => {
+    const p = join(dir, "clip.mp3");
+    const bytes = Buffer.from("fake-audio-bytes");
+    writeFileSync(p, bytes);
+
+    const result = readAudioFile(p);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Audio loaded");
+    expect(result.contentBlocks).toEqual([
+      {
+        type: "file",
+        source: {
+          type: "base64",
+          media_type: "audio/mpeg",
+          data: bytes.toString("base64"),
+          filename: "clip.mp3",
+        },
+      },
+    ]);
+  });
+
+  test("maps each extension to the canonical MIME (matches migration 191)", () => {
+    const cases: Record<string, string> = {
+      "a.mp3": "audio/mpeg",
+      "a.wav": "audio/wav",
+      "a.ogg": "audio/ogg",
+      "a.flac": "audio/flac",
+      "a.aac": "audio/aac",
+      "a.m4a": "audio/x-m4a",
+      "a.opus": "audio/opus",
+    };
+    for (const [name, mime] of Object.entries(cases)) {
+      const p = join(dir, name);
+      writeFileSync(p, Buffer.from("x"));
+      const result = readAudioFile(p);
+      expect(result.isError).toBe(false);
+      const block = result.contentBlocks?.[0] as {
+        source: { media_type: string };
+      };
+      expect(block.source.media_type).toBe(mime);
+    }
+  });
+
+  test("rejects audio larger than the 12 MB inline cap", () => {
+    const p = join(dir, "big.mp3");
+    writeFileSync(p, "");
+    truncateSync(p, 13 * 1024 * 1024); // sparse — no 13 MB allocation
+
+    const result = readAudioFile(p);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("too large");
+    expect(result.contentBlocks).toBeUndefined();
+  });
+
+  test("errors on a missing file", () => {
+    const result = readAudioFile(join(dir, "nope.mp3"));
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("not found");
+  });
+
+  test("errors when the path is a directory", () => {
+    const p = join(dir, "adir.mp3");
+    mkdirSync(p);
+    const result = readAudioFile(p);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("not a file");
+  });
+});
+
+describe("AUDIO_EXTENSIONS", () => {
+  test("covers the supported set and excludes non-audio", () => {
+    for (const ext of [
+      ".mp3",
+      ".wav",
+      ".ogg",
+      ".flac",
+      ".aac",
+      ".m4a",
+      ".opus",
+    ]) {
+      expect(AUDIO_EXTENSIONS.has(ext)).toBe(true);
+    }
+    expect(AUDIO_EXTENSIONS.has(".txt")).toBe(false);
+    expect(AUDIO_EXTENSIONS.has(".png")).toBe(false);
+  });
+});

package/src/__tests__/turn-boundary-resolution.test.ts

@@ -57,10 +57,10 @@ describe("getAssistantMessageIdsInTurn", () => {
 
   test("single-step turn: returns only the one assistant message", async () => {
     const conv = createConversation("single-step");
-    await addMessage(conv.id, "user", "Hello", undefined, {
+    await addMessage(conv.id, "user", "Hello", {
       skipIndexing: true,
     });
-    const a1 = await addMessage(conv.id, "assistant", "Hi there!", undefined, {
+    const a1 = await addMessage(conv.id, "assistant", "Hi there!", {
       skipIndexing: true,
     });
 
@@ -70,24 +70,16 @@ describe("getAssistantMessageIdsInTurn", () => {
 
   test("multi-step turn: user → A1 → tool_result → A2 → query A2 → returns [A1, A2]", async () => {
     const conv = createConversation("multi-step");
-    await addMessage(conv.id, "user", "Do the thing", undefined, {
+    await addMessage(conv.id, "user", "Do the thing", {
       skipIndexing: true,
     });
-    const a1 = await addMessage(
-      conv.id,
-      "assistant",
-      "Using tool...",
-      undefined,
-      { skipIndexing: true },
-    );
-    await addMessage(
-      conv.id,
-      "user",
-      toolResultContent(["tool-1"]),
-      undefined,
-      { skipIndexing: true },
-    );
-    const a2 = await addMessage(conv.id, "assistant", "Done!", undefined, {
+    const a1 = await addMessage(conv.id, "assistant", "Using tool...", {
+      skipIndexing: true,
+    });
+    await addMessage(conv.id, "user", toolResultContent(["tool-1"]), {
+      skipIndexing: true,
+    });
+    const a2 = await addMessage(conv.id, "assistant", "Done!", {
       skipIndexing: true,
     });
 
@@ -97,30 +89,22 @@ describe("getAssistantMessageIdsInTurn", () => {
 
   test("3-step turn: user → A1 → tool_result → A2 → tool_result → A3 → query A3 → returns [A1, A2, A3]", async () => {
     const conv = createConversation("three-step");
-    await addMessage(conv.id, "user", "Complex task", undefined, {
+    await addMessage(conv.id, "user", "Complex task", {
+      skipIndexing: true,
+    });
+    const a1 = await addMessage(conv.id, "assistant", "Step 1...", {
       skipIndexing: true,
     });
-    const a1 = await addMessage(conv.id, "assistant", "Step 1...", undefined, {
+    await addMessage(conv.id, "user", toolResultContent(["tool-1"]), {
       skipIndexing: true,
     });
-    await addMessage(
-      conv.id,
-      "user",
-      toolResultContent(["tool-1"]),
-      undefined,
-      { skipIndexing: true },
-    );
-    const a2 = await addMessage(conv.id, "assistant", "Step 2...", undefined, {
+    const a2 = await addMessage(conv.id, "assistant", "Step 2...", {
       skipIndexing: true,
     });
-    await addMessage(
-      conv.id,
-      "user",
-      toolResultContent(["tool-2"]),
-      undefined,
-      { skipIndexing: true },
-    );
-    const a3 = await addMessage(conv.id, "assistant", "All done!", undefined, {
+    await addMessage(conv.id, "user", toolResultContent(["tool-2"]), {
+      skipIndexing: true,
+    });
+    const a3 = await addMessage(conv.id, "assistant", "All done!", {
       skipIndexing: true,
     });
 
@@ -130,24 +114,16 @@ describe("getAssistantMessageIdsInTurn", () => {
 
   test("query intermediate message: query A1 in a 2-step turn → returns [A1, A2]", async () => {
     const conv = createConversation("intermediate");
-    await addMessage(conv.id, "user", "Start task", undefined, {
+    await addMessage(conv.id, "user", "Start task", {
+      skipIndexing: true,
+    });
+    const a1 = await addMessage(conv.id, "assistant", "Using tool...", {
+      skipIndexing: true,
+    });
+    await addMessage(conv.id, "user", toolResultContent(["tool-1"]), {
       skipIndexing: true,
     });
-    const a1 = await addMessage(
-      conv.id,
-      "assistant",
-      "Using tool...",
-      undefined,
-      { skipIndexing: true },
-    );
-    await addMessage(
-      conv.id,
-      "user",
-      toolResultContent(["tool-1"]),
-      undefined,
-      { skipIndexing: true },
-    );
-    const a2 = await addMessage(conv.id, "assistant", "Done!", undefined, {
+    const a2 = await addMessage(conv.id, "assistant", "Done!", {
       skipIndexing: true,
     });
 
@@ -164,42 +140,26 @@ describe("getAssistantMessageIdsInTurn", () => {
     const conv = createConversation("consecutive");
 
     // First turn
-    await addMessage(conv.id, "user", "First question", undefined, {
+    await addMessage(conv.id, "user", "First question", {
+      skipIndexing: true,
+    });
+    const a1 = await addMessage(conv.id, "assistant", "First answer", {
       skipIndexing: true,
     });
-    const a1 = await addMessage(
-      conv.id,
-      "assistant",
-      "First answer",
-      undefined,
-      { skipIndexing: true },
-    );
 
     // Second turn
-    await addMessage(conv.id, "user", "Second question", undefined, {
-      skipIndexing: true,
-    });
-    const a2 = await addMessage(
-      conv.id,
-      "assistant",
-      "Using tool...",
-      undefined,
-      { skipIndexing: true },
-    );
-    await addMessage(
-      conv.id,
-      "user",
-      toolResultContent(["tool-1"]),
-      undefined,
-      { skipIndexing: true },
-    );
-    const a3 = await addMessage(
-      conv.id,
-      "assistant",
-      "Done with second",
-      undefined,
-      { skipIndexing: true },
-    );
+    await addMessage(conv.id, "user", "Second question", {
+      skipIndexing: true,
+    });
+    const a2 = await addMessage(conv.id, "assistant", "Using tool...", {
+      skipIndexing: true,
+    });
+    await addMessage(conv.id, "user", toolResultContent(["tool-1"]), {
+      skipIndexing: true,
+    });
+    const a3 = await addMessage(conv.id, "assistant", "Done with second", {
+      skipIndexing: true,
+    });
 
     // Query second turn → should NOT include a1
     const result = getAssistantMessageIdsInTurn(a3.id);

package/src/__tests__/turn-events-store.test.ts

@@ -213,16 +213,20 @@ describe("queryUnreportedTurnEvents", () => {
     const conv = createConversation({ conversationType: "standard" });
 
     const macOsMsg = await addMessage(conv.id, "user", "hi from desktop", {
-      userMessageInterface: "macos",
-      userMessageChannel: "vellum",
-      client: {
-        os: "darwin",
-        interface_version: "0.8.2",
+      metadata: {
+        userMessageInterface: "macos",
+        userMessageChannel: "vellum",
+        client: {
+          os: "darwin",
+          interface_version: "0.8.2",
+        },
       },
     });
     const slackMsg = await addMessage(conv.id, "user", "hi from slack", {
-      userMessageInterface: "slack",
-      userMessageChannel: "slack",
+      metadata: {
+        userMessageInterface: "slack",
+        userMessageChannel: "slack",
+      },
     });
     const legacyMsg = await addMessage(conv.id, "user", "hi from the past");
 

package/src/__tests__/twilio-routes.test.ts

@@ -337,7 +337,7 @@ import {
   handleVoiceWebhook,
 } from "../calls/twilio-routes.js";
 import { DEFAULT_ELEVENLABS_VOICE_ID } from "../config/schemas/elevenlabs.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { conversations } from "../memory/schema.js";
 import {
@@ -347,6 +347,7 @@ import {
   handleSetTwilioCredentials,
 } from "../runtime/routes/integrations/twilio.js";
 import { credentialKey } from "../security/credential-key.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -487,7 +488,7 @@ describe("twilio webhook routes", () => {
 
   afterAll(() => {
     globalThis.fetch = originalFetch;
-    resetDb();
+    resetDbForTesting();
   });
 
   // ── Callback idempotency / replay tests ───────────────────────────