@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/__tests__/list-messages-attachments.test.ts

@@ -5,6 +5,8 @@
  * - User message image attachments include base64 data for client thumbnail generation
  * - User message non-image attachments stay metadata-only (no base64 blob)
  * - Assistant message image attachments include base64 data (same as user messages)
+ * - Stored HEIF/HEIC rows are hydrated as JPEG display data (Chromium cannot
+ *   decode HEIF); undecodable content falls back to the stored bytes
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -26,6 +28,8 @@ mock.module("../config/loader.js", () => ({
   }),
 }));
 
+import { randomUUID } from "node:crypto";
+
 import {
   linkAttachmentToMessage,
   uploadAttachment,
@@ -36,7 +40,9 @@ import {
 } from "../persistence/conversation-crud.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
+import { rawRun } from "../persistence/raw-query.js";
 import { handleListMessages } from "../runtime/routes/conversation-routes.js";
+import { fakeHeifHeaderBytes, makeHeicFixtureBytes } from "./heic-fixture.js";
 
 await initializeDb();
 
@@ -56,10 +62,41 @@ function createTestArgs(conversationId: string) {
 
 interface AttachmentPayload {
   data?: string;
+  filename?: string;
   mimeType: string;
+  kind?: string;
   thumbnailData?: string;
 }
 
+/**
+ * Insert an attachment row directly, bypassing upload-time HEIF
+ * normalization — simulates rows stored before normalization existed (or
+ * where conversion was unavailable).
+ */
+function insertLegacyAttachmentRow(
+  messageId: string,
+  filename: string,
+  mimeType: string,
+  dataBase64: string,
+  kind = "image",
+): string {
+  const id = randomUUID();
+  rawRun(
+    "test:insertAttachment",
+    `INSERT INTO attachments (id, original_filename, mime_type, size_bytes, kind, data_base64, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    id,
+    filename,
+    mimeType,
+    Buffer.from(dataBase64, "base64").length,
+    kind,
+    dataBase64,
+    Date.now(),
+  );
+  linkAttachmentToMessage(messageId, id, 0);
+  return id;
+}
+
 interface MessagePayload {
   attachments?: AttachmentPayload[];
 }
@@ -210,6 +247,128 @@ describe("handleListMessages attachments", () => {
   });
 });
 
+describe("handleListMessages HEIC display normalization", () => {
+  beforeEach(resetTables);
+
+  test("undecodable HEIC data is served unchanged (conversion fallback)", async () => {
+    const conv = createConversation();
+    const msg = await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "photo" }]),
+    );
+    const heicB64 = fakeHeifHeaderBytes().toString("base64");
+    insertLegacyAttachmentRow(msg.id, "IMG_1.HEIC", "image/heic", heicB64);
+
+    const response = handleListMessages(createTestArgs(conv.id));
+    const body = response as { messages: MessagePayload[] };
+
+    const attachments = body.messages[0].attachments!;
+    expect(attachments).toHaveLength(1);
+    expect(attachments[0].mimeType).toBe("image/heic");
+    expect(attachments[0].data).toBe(heicB64);
+  });
+
+  test("octet-stream HEIC stays metadata-only when conversion is unavailable", async () => {
+    const conv = createConversation();
+    const msg = await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "photo" }]),
+    );
+    // Web-uploader fallback for an empty File.type: HEIC bytes land under
+    // application/octet-stream and classify as a document. Fake header bytes
+    // never convert, so the row must stay metadata-only rather than ship
+    // unrenderable bytes as display data.
+    const heicB64 = fakeHeifHeaderBytes().toString("base64");
+    insertLegacyAttachmentRow(
+      msg.id,
+      "IMG_3.HEIC",
+      "application/octet-stream",
+      heicB64,
+      "document",
+    );
+
+    const response = handleListMessages(createTestArgs(conv.id));
+    const body = response as { messages: MessagePayload[] };
+
+    const attachments = body.messages[0].attachments!;
+    expect(attachments).toHaveLength(1);
+    expect(attachments[0].mimeType).toBe("application/octet-stream");
+    expect(attachments[0].kind).toBe("document");
+    expect(attachments[0].data).toBeUndefined();
+  });
+
+  describe.skipIf(process.platform !== "darwin")(
+    "real conversion (sips)",
+    () => {
+      test("legacy HEIC rows are hydrated as JPEG display data", async () => {
+        const heic = makeHeicFixtureBytes();
+        expect(heic).not.toBeNull();
+
+        const conv = createConversation();
+        const msg = await addMessage(
+          conv.id,
+          "user",
+          JSON.stringify([{ type: "text", text: "photo" }]),
+        );
+        insertLegacyAttachmentRow(
+          msg.id,
+          "IMG_2.HEIC",
+          "image/heic",
+          heic!.toString("base64"),
+        );
+
+        const response = handleListMessages(createTestArgs(conv.id));
+        const body = response as { messages: MessagePayload[] };
+
+        const attachments = body.messages[0].attachments!;
+        expect(attachments).toHaveLength(1);
+        expect(attachments[0].mimeType).toBe("image/jpeg");
+        // JPEG SOI marker (FF D8 FF) base64-encodes to "/9j/".
+        expect(attachments[0].data!.startsWith("/9j/")).toBe(true);
+        // Metadata keeps describing the stored original, which the content
+        // endpoint serves verbatim for downloads.
+        expect(attachments[0].filename).toBe("IMG_2.HEIC");
+      });
+
+      test("legacy octet-stream HEIC rows hydrate as JPEG display data", async () => {
+        const heic = makeHeicFixtureBytes();
+        expect(heic).not.toBeNull();
+
+        const conv = createConversation();
+        const msg = await addMessage(
+          conv.id,
+          "user",
+          JSON.stringify([{ type: "text", text: "photo" }]),
+        );
+        // Real HEIC bytes stored under application/octet-stream (empty
+        // File.type fallback) and classified as a document — the row is
+        // detected by its filename extension and converted for display.
+        insertLegacyAttachmentRow(
+          msg.id,
+          "IMG_4.HEIC",
+          "application/octet-stream",
+          heic!.toString("base64"),
+          "document",
+        );
+
+        const response = handleListMessages(createTestArgs(conv.id));
+        const body = response as { messages: MessagePayload[] };
+
+        const attachments = body.messages[0].attachments!;
+        expect(attachments).toHaveLength(1);
+        expect(attachments[0].mimeType).toBe("image/jpeg");
+        expect(attachments[0].data!.startsWith("/9j/")).toBe(true);
+        // The converted row presents as an image so clients render it inline.
+        expect(attachments[0].kind).toBe("image");
+        // The stored original filename is preserved for verbatim download.
+        expect(attachments[0].filename).toBe("IMG_4.HEIC");
+      });
+    },
+  );
+});
+
 describe("handleListMessages no_response filtering", () => {
   beforeEach(resetTables);
 

package/src/__tests__/list-messages-background-tool-completion.test.ts

@@ -0,0 +1,141 @@
+/**
+ * Tests for handleListMessages background-tool completion projection.
+ *
+ * A backgrounded bash/host_bash run posts a `<background_event
+ * source="background-tool">` wake on completion, stamped with
+ * `metadata.backgroundToolCompletion`. The history projection must surface
+ * that structured record (and the `backgroundEventNotification` flag) so the
+ * web can rebuild a terminal inline card after a daemon restart.
+ */
+
+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 },
+  }),
+}));
+
+import { ConversationMessageSchema } from "../api/responses/conversation-message.js";
+import {
+  addMessage,
+  createConversation,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { handleListMessages } from "../runtime/routes/conversation-routes.js";
+
+await initializeDb();
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+interface ProjectedMessage {
+  role: string;
+  backgroundEventNotification?: boolean;
+  backgroundToolCompletion?: Record<string, unknown>;
+}
+
+describe("handleListMessages background-tool completion projection", () => {
+  beforeEach(resetTables);
+
+  test("projects backgroundToolCompletion from the wake row metadata", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "run a long command" }]),
+    );
+
+    const completion = {
+      id: "bg-1",
+      toolName: "bash",
+      conversationId: conv.id,
+      command: "sleep 5 && echo done",
+      startedAt: 1000,
+      status: "completed" as const,
+      exitCode: 0,
+      output: "done\n",
+      completedAt: 2000,
+    };
+    // Mirror persistWakeTriggerMessage: a user-role
+    // `<background_event source="background-tool">` row carrying the structured
+    // completion. The client suppresses it from the transcript via
+    // `backgroundEventNotification`.
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([
+        {
+          type: "text",
+          text: '<background_event source="background-tool">Background command completed (id=bg-1, exit=0):</background_event>',
+        },
+      ]),
+      {
+        metadata: {
+          kind: "background-event",
+          backgroundEventSource: "background-tool",
+          automated: true,
+          backgroundToolCompletion: completion,
+        },
+      },
+    );
+
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    }) as { messages: ProjectedMessage[] };
+
+    // Every projected message validates against the wire schema.
+    for (const message of response.messages) {
+      expect(() => ConversationMessageSchema.parse(message)).not.toThrow();
+    }
+
+    const wakeRow = response.messages.find(
+      (m) => m.backgroundToolCompletion !== undefined,
+    );
+    expect(wakeRow).toBeDefined();
+    expect(wakeRow?.backgroundEventNotification).toBe(true);
+    expect(wakeRow?.backgroundToolCompletion).toEqual(completion);
+  });
+
+  test("omits backgroundToolCompletion when the row carries no completion metadata", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "hello" }]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "hi there" }]),
+    );
+
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    }) as { messages: ProjectedMessage[] };
+
+    expect(response.messages).toHaveLength(2);
+    for (const message of response.messages) {
+      expect(message.backgroundToolCompletion).toBeUndefined();
+      expect(message.backgroundEventNotification).toBeUndefined();
+      expect(() => ConversationMessageSchema.parse(message)).not.toThrow();
+    }
+  });
+});

package/src/__tests__/list-messages-queued.test.ts

@@ -178,6 +178,31 @@ describe("handleListMessages in-memory queue", () => {
     expect(att?.id).toBe("req-att:attachment:0");
   });
 
+  test("filters hidden queued messages from the snapshot, keeping positions contiguous", async () => {
+    // A hidden send (e.g. the channel-setup wizard-close marker) that queued
+    // behind an in-flight turn must not surface as a queued bubble on a
+    // reload/reconnect fetch; visible siblings keep 1-based positions.
+    const conv = createConversation();
+    registerLiveConversation(conv.id, [
+      makeQueued({
+        requestId: "req-hidden",
+        content:
+          "[User action on channel_setup surface: closed the slack setup wizard]",
+        metadata: { hidden: true },
+      }),
+      makeQueued({ requestId: "req-visible", content: "a real message" }),
+    ]);
+
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    expect(body.messages).toHaveLength(1);
+    expect(body.messages[0].id).toBe("req-visible");
+    expect(body.messages[0].queuePosition).toBe(1);
+  });
+
   test("does not append queued messages to an older-history page", async () => {
     // GIVEN history requested with beforeTimestamp (older page)
     const conv = createConversation();

package/src/__tests__/managed-store.test.ts

@@ -192,6 +192,37 @@ describe("buildSkillMarkdown", () => {
     expect(parsed.metadata.vellum.includes).toEqual(["child-a", "child-b"]);
   });
 
+  test("activation-hints and avoid-when emit kebab-case YAML lists in metadata.vellum", () => {
+    const result = buildSkillMarkdown({
+      name: "Hinted Skill",
+      description: "Has trigger phrases",
+      bodyMarkdown: "Body.",
+      activationHints: ["user asks to deploy staging", "needs a release cut"],
+      avoidWhen: ["local-only changes"],
+    });
+    const fmMatch = result.match(/^---\n([\s\S]*?)\n---/);
+    const parsed = parseYaml(fmMatch![1]);
+    // Kebab-case keys are what parseFrontmatter reads back (config/skills.ts).
+    expect(parsed.metadata.vellum["activation-hints"]).toEqual([
+      "user asks to deploy staging",
+      "needs a release cut",
+    ]);
+    expect(parsed.metadata.vellum["avoid-when"]).toEqual([
+      "local-only changes",
+    ]);
+  });
+
+  test("omits activation-hints / avoid-when when empty and no other vellum fields", () => {
+    const result = buildSkillMarkdown({
+      name: "Empty Hints",
+      description: "Empty arrays",
+      bodyMarkdown: "Body.",
+      activationHints: [],
+      avoidWhen: [],
+    });
+    expect(result).not.toContain("metadata:");
+  });
+
   test("includes optional category in metadata.vellum", () => {
     const result = buildSkillMarkdown({
       name: "Categorized Skill",
@@ -453,7 +484,12 @@ describe("validateCompanionPath", () => {
   });
 
   test("rejects store-owned top-level files", () => {
-    for (const reserved of ["SKILL.md", "install-meta.json", "version.json"]) {
+    for (const reserved of [
+      "SKILL.md",
+      "install-meta.json",
+      "version.json",
+      "TOOLS.json",
+    ]) {
       expect(validateCompanionPath(skillDir, reserved).error).toContain(
         "store-owned",
       );
@@ -463,6 +499,38 @@ describe("validateCompanionPath", () => {
       validateCompanionPath(skillDir, "references/SKILL.md").error,
     ).toBeUndefined();
   });
+
+  test("rejects a top-level TOOLS.json companion to block planting executable tools", () => {
+    // TOOLS.json is the manifest the skill loader scans to register (and
+    // dynamically import) executable tools. A scaffold author must never be
+    // able to plant one — otherwise an instruction-only managed skill becomes a
+    // code-injection surface.
+    expect(validateCompanionPath(skillDir, "TOOLS.json").error).toContain(
+      "store-owned",
+    );
+  });
+
+  test("rejects case variants of reserved names (case-insensitive filesystems)", () => {
+    // On macOS (case-insensitive FS), `tools.json` resolves to the same file
+    // the scanner reads as `TOOLS.json`, so a varied-case name must be rejected
+    // too — otherwise the guard is trivially bypassed. Same for SKILL.md.
+    for (const variant of [
+      "tools.json",
+      "Tools.json",
+      "TOOLS.JSON",
+      "skill.md",
+      "Skill.MD",
+      "INSTALL-META.JSON",
+    ]) {
+      expect(validateCompanionPath(skillDir, variant).error).toContain(
+        "store-owned",
+      );
+    }
+    // Nested case variants remain allowed — only top-level is scanned.
+    expect(
+      validateCompanionPath(skillDir, "references/tools.json").error,
+    ).toBeUndefined();
+  });
 });
 
 describe("createManagedSkill companion files", () => {
@@ -604,6 +672,43 @@ describe("createManagedSkill companion files", () => {
     ).toBe(false);
   });
 
+  test("rejects a TOOLS.json companion and writes nothing", () => {
+    // Planting a TOOLS.json declaring execution_target/risk would let a
+    // scaffolded skill register attacker-controlled tools. The reserved-name
+    // check must reject it before any write, leaving no SKILL.md or manifest.
+    const result = createManagedSkill({
+      id: "tools-manifest",
+      name: "Tools Manifest",
+      description: "Tries to plant a tool manifest",
+      bodyMarkdown: "Body.",
+      files: [
+        {
+          path: "TOOLS.json",
+          content: JSON.stringify({
+            version: 1,
+            tools: [
+              {
+                name: "pwn",
+                description: "x",
+                category: "x",
+                risk: "low",
+                input_schema: { type: "object" },
+                executor: "tools/pwn.ts",
+                execution_target: "host",
+              },
+            ],
+          }),
+        },
+      ],
+    });
+
+    expect(result.created).toBe(false);
+    expect(result.error).toContain("store-owned");
+    const skillDir = join(TEST_DIR, "skills", "tools-manifest");
+    expect(existsSync(join(skillDir, "TOOLS.json"))).toBe(false);
+    expect(existsSync(join(skillDir, "SKILL.md"))).toBe(false);
+  });
+
   test("overwrite re-writes companion files", () => {
     createManagedSkill({
       id: "overwrite-files",
@@ -1003,6 +1108,29 @@ describe("YAML metadata round-trip", () => {
     expect(skill!.includes).toEqual(["child-a", "child-b"]);
   });
 
+  test("activation hints and avoid-when round-trip into SkillSummary", () => {
+    // An assistant-authored (retrospective) skill written via createManagedSkill
+    // carries activation hints so the memory seeder emits a "Use when:" clause
+    // for it, just like bundled skills.
+    createManagedSkill({
+      id: "hints-roundtrip",
+      name: "Hints Roundtrip",
+      description: "Trigger phrases round-trip through write and load",
+      bodyMarkdown: "Body.",
+      activationHints: ["user asks to deploy staging", "needs a release cut"],
+      avoidWhen: ["local-only changes"],
+    });
+
+    const catalog = loadSkillCatalog(undefined, [join(TEST_DIR, "skills")]);
+    const skill = catalog.find((s) => s.id === "hints-roundtrip");
+    expect(skill).toBeDefined();
+    expect(skill!.activationHints).toEqual([
+      "user asks to deploy staging",
+      "needs a release cut",
+    ]);
+    expect(skill!.avoidWhen).toEqual(["local-only changes"]);
+  });
+
   test("hand-authored YAML nested metadata parses correctly", () => {
     // Manually write a SKILL.md with YAML-style nested metadata matching
     // the format used in skills/ directory (bundled skills format)

package/src/__tests__/media-stream-audio-transcode.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  mulawToPcm16,
+  pcm16ToMulaw,
+  resamplePcm16,
+} from "../calls/media-stream-audio-transcode.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function pcm16Buffer(samples: number[]): Buffer {
+  const buf = Buffer.alloc(samples.length * 2);
+  samples.forEach((s, i) => buf.writeInt16LE(s, i * 2));
+  return buf;
+}
+
+function readSamples(pcm: Buffer): number[] {
+  const samples: number[] = [];
+  for (let i = 0; i + 1 < pcm.length; i += 2) {
+    samples.push(pcm.readInt16LE(i));
+  }
+  return samples;
+}
+
+// ---------------------------------------------------------------------------
+// mulawToPcm16
+// ---------------------------------------------------------------------------
+
+describe("mulawToPcm16", () => {
+  test("output length is 2x input length", () => {
+    const mulaw = new Uint8Array([0xff, 0x7f, 0x00, 0x80, 0x55]);
+    const pcm = mulawToPcm16(mulaw);
+    expect(pcm.length).toBe(mulaw.length * 2);
+  });
+
+  test("empty input decodes to empty output", () => {
+    expect(mulawToPcm16(new Uint8Array(0)).length).toBe(0);
+  });
+
+  test("mu-law silence (0xFF and 0x7F) decodes to 0", () => {
+    const pcm = mulawToPcm16(new Uint8Array([0xff, 0x7f]));
+    expect(readSamples(pcm)).toEqual([0, 0]);
+  });
+
+  test("round-trip PCM16 -> mu-law -> PCM16 has bounded error", () => {
+    const samples = [
+      0, 1, -1, 8, -8, 33, -33, 100, -100, 500, -500, 1000, -1000, 4000, -4000,
+      8191, -8191, 16000, -16000, 24000, -24000, 32000, -32000, 32635, -32635,
+    ];
+    const original = pcm16Buffer(samples);
+    const decoded = readSamples(mulawToPcm16(pcm16ToMulaw(original)));
+
+    expect(decoded.length).toBe(samples.length);
+    for (let i = 0; i < samples.length; i++) {
+      // Mu-law quantization error scales with magnitude (~4%), floor of 16.
+      const tolerance = Math.max(16, Math.abs(samples[i]) * 0.04);
+      expect(Math.abs(decoded[i] - samples[i])).toBeLessThanOrEqual(tolerance);
+    }
+  });
+
+  test("round-trip preserves sign", () => {
+    const original = pcm16Buffer([12345, -12345]);
+    const [pos, neg] = readSamples(mulawToPcm16(pcm16ToMulaw(original)));
+    expect(pos).toBeGreaterThan(0);
+    expect(neg).toBeLessThan(0);
+    expect(pos).toBe(-neg);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resamplePcm16
+// ---------------------------------------------------------------------------
+
+describe("resamplePcm16", () => {
+  test("8k -> 16k doubles the sample count", () => {
+    const input = pcm16Buffer([0, 100, 200, 300]);
+    const output = resamplePcm16(input, 8000, 16000);
+    expect(output.length).toBe(input.length * 2);
+  });
+
+  test("8k -> 16k interpolates linearly between samples", () => {
+    const output = resamplePcm16(pcm16Buffer([0, 100, 200]), 8000, 16000);
+    expect(readSamples(output)).toEqual([0, 50, 100, 150, 200, 200]);
+  });
+
+  test("same-rate input is returned unchanged", () => {
+    const input = pcm16Buffer([1, -2, 3]);
+    const output = resamplePcm16(input, 16000, 16000);
+    expect(output).toBe(input);
+  });
+
+  test("empty input yields empty output", () => {
+    expect(resamplePcm16(Buffer.alloc(0), 8000, 16000).length).toBe(0);
+  });
+
+  test("preserves extreme sample values without overflow", () => {
+    const output = resamplePcm16(pcm16Buffer([32767, -32768]), 8000, 16000);
+    const samples = readSamples(output);
+    expect(samples[0]).toBe(32767);
+    expect(samples[2]).toBe(-32768);
+    for (const s of samples) {
+      expect(s).toBeGreaterThanOrEqual(-32768);
+      expect(s).toBeLessThanOrEqual(32767);
+    }
+  });
+
+  test("throws on non-positive sample rates", () => {
+    expect(() => resamplePcm16(pcm16Buffer([0]), 0, 16000)).toThrow();
+    expect(() => resamplePcm16(pcm16Buffer([0]), 8000, -1)).toThrow();
+  });
+});