@vellumai/assistant 0.8.6 → 0.8.7

package/src/__tests__/terminal-tools.test.ts

@@ -1,8 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { ShellOutputResult } from "../tools/shared/shell-output.js";
-import type { Tool } from "../tools/types.js";
+import { afterEach, describe, expect, mock, test } from "bun:test";
 
 // ── Mock modules ────────────────────────────────────────────────────────────
 
@@ -64,6 +61,7 @@ mock.module("../tools/network/script-proxy/index.js", () => ({
 
 // ── Imports (after mocks) ───────────────────────────────────────────────────
 
+import { formatShellOutput } from "../tools/shared/shell-output.js";
 import {
   ALWAYS_INJECTED_ENV_VARS,
   buildSanitizedEnv,
@@ -71,6 +69,7 @@ import {
   KATA_SAFE_ENV_VARS,
   SAFE_ENV_VARS,
 } from "../tools/terminal/safe-env.js";
+import { shellTool } from "../tools/terminal/shell.js";
 
 // ═══════════════════════════════════════════════════════════════════════════
 //  Safe Environment — buildSanitizedEnv()
@@ -210,13 +209,6 @@ describe("buildSanitizedEnv", () => {
 // ═══════════════════════════════════════════════════════════════════════════
 
 describe("Shell tool input validation", () => {
-  let shellTool: Tool;
-
-  beforeEach(async () => {
-    const mod = await import("../tools/terminal/shell.js");
-    shellTool = mod.shellTool;
-  });
-
   const baseContext = {
     workingDir: testTmpDir,
     conversationId: "test-conv-1",
@@ -308,19 +300,6 @@ describe("Shell tool input validation", () => {
 // ═══════════════════════════════════════════════════════════════════════════
 
 describe("formatShellOutput", () => {
-  let formatShellOutput: (
-    stdout: string,
-    stderr: string,
-    code: number | null,
-    timedOut: boolean,
-    timeoutSec: number,
-  ) => ShellOutputResult;
-
-  beforeEach(async () => {
-    const mod = await import("../tools/shared/shell-output.js");
-    formatShellOutput = mod.formatShellOutput;
-  });
-
   test("successful command with output", () => {
     const result = formatShellOutput("hello world", "", 0, false, 120);
     expect(result.content).toBe("hello world");

package/src/__tests__/thread-backfill.test.ts

@@ -1284,7 +1284,7 @@ describe("triggerSlackThreadBackfillIfNeeded — gap detection and persistence",
         content: [
           {
             type: "text",
-            text: "[mar 4 2026 8:38 PM MT assistant] earlier assistant reply",
+            text: "earlier assistant reply",
           },
         ],
       },
@@ -2028,6 +2028,7 @@ function buildSlackDmRequest(
 }
 
 interface SlackInboundProcessOptions {
+  attachmentIds?: string[];
   displayContent?: string;
   transport?: {
     channelId?: string;
@@ -2111,7 +2112,6 @@ function flattenText(messages: Message[]): string {
 interface CapturedSlackProcessMessage {
   conversationId: string;
   content: string;
-  attachmentIds?: string[];
   options?: SlackInboundProcessOptions;
 }
 
@@ -2146,10 +2146,9 @@ async function handleAndCaptureLiveSlackProcessMessage(
   const processMessage = async (
     conversationId: string,
     content: string,
-    attachmentIds?: string[],
     options?: SlackInboundProcessOptions,
   ): Promise<{ messageId: string }> => {
-    captured = { conversationId, content, attachmentIds, options };
+    captured = { conversationId, content, options };
     const messageId = persistSlackInboundFromProcessMessage(
       conversationId,
       content,
@@ -2212,7 +2211,6 @@ describe("handleChannelInbound — Slack thread backfill wiring", () => {
     const processMessage = async (
       _conversationId: string,
       _content: string,
-      _attachmentIds?: string[],
       options?: {
         transport?: { hints?: string[] };
       },
@@ -2327,7 +2325,7 @@ describe("handleChannelInbound — Slack thread backfill wiring", () => {
     expect(captured.content.match(/<external_content/g)?.length).toBe(1);
     expect(captured.content).toContain('<external_content source="slack"');
     expect(captured.content).toContain("\n\n</external_content>");
-    expect(captured.attachmentIds).toEqual(["att-slack-file"]);
+    expect(captured.options?.attachmentIds).toEqual(["att-slack-file"]);
     expect(captured.options?.displayContent).toBe("");
 
     const persisted = readMessagesByConversation(captured.conversationId);
@@ -2370,7 +2368,6 @@ describe("handleChannelInbound — Slack thread backfill wiring", () => {
     const processMessage = async (
       conversationId: string,
       content: string,
-      _attachmentIds?: string[],
       options?: SlackInboundProcessOptions,
     ): Promise<{ messageId: string }> => {
       const messageId = persistSlackInboundFromProcessMessage(
@@ -2495,7 +2492,6 @@ describe("handleChannelInbound — Slack thread backfill wiring", () => {
     const processMessage = async (
       conversationId: string,
       content: string,
-      _attachmentIds?: string[],
       options?: SlackInboundProcessOptions,
     ): Promise<{ messageId: string }> => ({
       messageId: persistSlackInboundFromProcessMessage(
@@ -2551,7 +2547,6 @@ describe("handleChannelInbound — Slack thread backfill wiring", () => {
     const processMessage = async (
       conversationId: string,
       content: string,
-      _attachmentIds?: string[],
       options?: SlackInboundProcessOptions,
     ): Promise<{ messageId: string }> => ({
       messageId: persistSlackInboundFromProcessMessage(

package/src/__tests__/title-generate-pipeline.test.ts

@@ -36,7 +36,7 @@ mock.module("../memory/conversation-title-service.js", () => ({
   queueGenerateConversationTitle: queueGenerateConversationTitleMock,
 }));
 
-import { defaultTitleGenerateTerminal } from "../plugins/defaults/title-generate.js";
+import { defaultTitleGenerateTerminal } from "../plugins/defaults/title-generate/terminal.js";
 import { DEFAULT_TIMEOUTS, runPipeline } from "../plugins/pipeline.js";
 import {
   getMiddlewaresFor,

package/src/__tests__/token-estimate-pipeline.test.ts

@@ -30,10 +30,8 @@ import {
   estimateToolsTokens,
 } from "../context/token-estimator.js";
 import type { TrustContext } from "../daemon/trust-context.js";
-import {
-  defaultTokenEstimatePlugin,
-  defaultTokenEstimateTerminal,
-} from "../plugins/defaults/token-estimate.js";
+import { defaultTokenEstimatePlugin } from "../plugins/defaults/token-estimate/register.js";
+import { defaultTokenEstimateTerminal } from "../plugins/defaults/token-estimate/terminal.js";
 import { DEFAULT_TIMEOUTS, runPipeline } from "../plugins/pipeline.js";
 import {
   getMiddlewaresFor,

package/src/__tests__/tool-error-pipeline.test.ts

@@ -16,11 +16,11 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
 import type { TrustContext } from "../daemon/trust-context.js";
+import { defaultToolErrorPlugin } from "../plugins/defaults/tool-error/register.js";
 import {
   DEFAULT_TOOL_ERROR_NUDGE_TEXT,
-  defaultToolErrorPlugin,
   defaultToolErrorTerminal,
-} from "../plugins/defaults/tool-error.js";
+} from "../plugins/defaults/tool-error/terminal.js";
 import { runPipeline } from "../plugins/pipeline.js";
 import {
   getMiddlewaresFor,

package/src/__tests__/tool-execute-pipeline.test.ts

@@ -139,7 +139,7 @@ mock.module("../security/token-manager.js", () => ({
 
 // ── Imports — after mock.module so the executor under test picks them up ──
 import { PermissionPrompter } from "../permissions/prompter.js";
-import { defaultToolExecutePlugin } from "../plugins/defaults/tool-execute.js";
+import { defaultToolExecutePlugin } from "../plugins/defaults/tool-execute/register.js";
 import {
   getMiddlewaresFor,
   registerPlugin,

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

@@ -92,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: () => {},
@@ -142,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[] = [];
@@ -159,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-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__/voice-scoped-grant-consumer.test.ts

@@ -145,17 +145,19 @@ function createMockSession(opts?: {
     handleConfirmationResponse: (
       reqId: string,
       decision: string,
-      _pattern?: string,
-      _scope?: string,
-      reason?: string,
+      options?: { decisionContext?: string },
     ) => {
-      confirmationDecision = { requestId: reqId, decision, reason };
+      confirmationDecision = {
+        requestId: reqId,
+        decision,
+        reason: options?.decisionContext,
+      };
     },
     handleSecretResponse: () => {},
     runAgentLoop: async (
       _content: string,
       _messageId: string,
-      broadcastFn: (msg: ServerMessage) => void,
+      options?: { onEvent?: (msg: ServerMessage) => void },
     ) => {
       // Emit a confirmation_request through the client callback
       if (clientCallback) {
@@ -170,7 +172,7 @@ function createMockSession(opts?: {
         } as ServerMessage);
       }
       // Then complete the turn
-      broadcastFn({ type: "message_complete" } as ServerMessage);
+      options?.onEvent?.({ type: "message_complete" } as ServerMessage);
     },
   };