@vellumai/assistant 0.4.17 → 0.4.18

package/src/__tests__/attachments.test.ts

@@ -1,68 +1,74 @@
-import { describe, expect,test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
-import { attachmentsToContentBlocks } from '../agent/attachments.js';
-import { createUserMessage } from '../agent/message-types.js';
+import { attachmentsToContentBlocks } from "../agent/attachments.js";
+import { createUserMessage } from "../agent/message-types.js";
 
 // ---------------------------------------------------------------------------
 // attachmentsToContentBlocks
 // ---------------------------------------------------------------------------
 
-describe('attachmentsToContentBlocks', () => {
-  test('creates image content block for image/jpeg', () => {
+describe("attachmentsToContentBlocks", () => {
+  test("creates image content block for image/jpeg", () => {
     const blocks = attachmentsToContentBlocks([
-      { filename: 'photo.jpg', mimeType: 'image/jpeg', data: 'base64data' },
+      { filename: "photo.jpg", mimeType: "image/jpeg", data: "base64data" },
     ]);
 
     expect(blocks).toHaveLength(1);
-    expect(blocks[0].type).toBe('image');
-    const block = blocks[0] as { type: 'image'; source: { type: string; media_type: string; data: string } };
-    expect(block.source.type).toBe('base64');
-    expect(block.source.media_type).toBe('image/jpeg');
-    expect(block.source.data).toBe('base64data');
+    expect(blocks[0].type).toBe("image");
+    const block = blocks[0] as {
+      type: "image";
+      source: { type: string; media_type: string; data: string };
+    };
+    expect(block.source.type).toBe("base64");
+    expect(block.source.media_type).toBe("image/jpeg");
+    expect(block.source.data).toBe("base64data");
   });
 
-  test('creates image content block for image/png', () => {
+  test("creates image content block for image/png", () => {
     const blocks = attachmentsToContentBlocks([
-      { filename: 'screenshot.png', mimeType: 'image/png', data: 'pngdata' },
+      { filename: "screenshot.png", mimeType: "image/png", data: "pngdata" },
     ]);
 
     expect(blocks).toHaveLength(1);
-    expect(blocks[0].type).toBe('image');
+    expect(blocks[0].type).toBe("image");
   });
 
-  test('creates image content block for image/webp', () => {
+  test("creates image content block for image/webp", () => {
     const blocks = attachmentsToContentBlocks([
-      { filename: 'sticker.webp', mimeType: 'image/webp', data: 'webpdata' },
+      { filename: "sticker.webp", mimeType: "image/webp", data: "webpdata" },
     ]);
 
     expect(blocks).toHaveLength(1);
-    expect(blocks[0].type).toBe('image');
+    expect(blocks[0].type).toBe("image");
   });
 
-  test('creates file content block for non-image mime types', () => {
+  test("creates file content block for non-image mime types", () => {
     const blocks = attachmentsToContentBlocks([
-      { filename: 'doc.pdf', mimeType: 'application/pdf', data: 'pdfdata' },
+      { filename: "doc.pdf", mimeType: "application/pdf", data: "pdfdata" },
     ]);
 
     expect(blocks).toHaveLength(1);
-    expect(blocks[0].type).toBe('file');
-    const block = blocks[0] as { type: 'file'; source: { filename: string; media_type: string; data: string } };
-    expect(block.source.filename).toBe('doc.pdf');
-    expect(block.source.media_type).toBe('application/pdf');
+    expect(blocks[0].type).toBe("file");
+    const block = blocks[0] as {
+      type: "file";
+      source: { filename: string; media_type: string; data: string };
+    };
+    expect(block.source.filename).toBe("doc.pdf");
+    expect(block.source.media_type).toBe("application/pdf");
   });
 
-  test('handles multiple attachments including mixed types', () => {
+  test("handles multiple attachments including mixed types", () => {
     const blocks = attachmentsToContentBlocks([
-      { filename: 'photo.jpg', mimeType: 'image/jpeg', data: 'imgdata' },
-      { filename: 'notes.txt', mimeType: 'text/plain', data: 'txtdata' },
+      { filename: "photo.jpg", mimeType: "image/jpeg", data: "imgdata" },
+      { filename: "notes.txt", mimeType: "text/plain", data: "txtdata" },
     ]);
 
     expect(blocks).toHaveLength(2);
-    expect(blocks[0].type).toBe('image');
-    expect(blocks[1].type).toBe('file');
+    expect(blocks[0].type).toBe("image");
+    expect(blocks[1].type).toBe("file");
   });
 
-  test('returns empty array for no attachments', () => {
+  test("returns empty array for no attachments", () => {
     const blocks = attachmentsToContentBlocks([]);
     expect(blocks).toHaveLength(0);
   });
@@ -72,64 +78,66 @@ describe('attachmentsToContentBlocks', () => {
 // createUserMessage with image attachments
 // ---------------------------------------------------------------------------
 
-describe('createUserMessage with image attachments', () => {
-  test('includes both text and image blocks', () => {
-    const msg = createUserMessage('what is this?', [
-      { filename: 'photo.jpg', mimeType: 'image/jpeg', data: 'base64img' },
+describe("createUserMessage with image attachments", () => {
+  test("includes both text and image blocks", () => {
+    const msg = createUserMessage("what is this?", [
+      { filename: "photo.jpg", mimeType: "image/jpeg", data: "base64img" },
     ]);
 
-    expect(msg.role).toBe('user');
+    expect(msg.role).toBe("user");
     expect(msg.content).toHaveLength(2);
-    expect(msg.content[0].type).toBe('text');
-    expect((msg.content[0] as { type: 'text'; text: string }).text).toBe('what is this?');
-    expect(msg.content[1].type).toBe('image');
+    expect(msg.content[0].type).toBe("text");
+    expect((msg.content[0] as { type: "text"; text: string }).text).toBe(
+      "what is this?",
+    );
+    expect(msg.content[1].type).toBe("image");
   });
 
-  test('includes only image block when text is empty', () => {
-    const msg = createUserMessage('', [
-      { filename: 'photo.jpg', mimeType: 'image/jpeg', data: 'base64img' },
+  test("includes only image block when text is empty", () => {
+    const msg = createUserMessage("", [
+      { filename: "photo.jpg", mimeType: "image/jpeg", data: "base64img" },
     ]);
 
-    expect(msg.role).toBe('user');
+    expect(msg.role).toBe("user");
     expect(msg.content).toHaveLength(1);
-    expect(msg.content[0].type).toBe('image');
+    expect(msg.content[0].type).toBe("image");
   });
 
-  test('includes only image block when text is whitespace', () => {
-    const msg = createUserMessage('   ', [
-      { filename: 'photo.jpg', mimeType: 'image/jpeg', data: 'base64img' },
+  test("includes only image block when text is whitespace", () => {
+    const msg = createUserMessage("   ", [
+      { filename: "photo.jpg", mimeType: "image/jpeg", data: "base64img" },
     ]);
 
-    expect(msg.role).toBe('user');
+    expect(msg.role).toBe("user");
     expect(msg.content).toHaveLength(1);
-    expect(msg.content[0].type).toBe('image');
+    expect(msg.content[0].type).toBe("image");
   });
 
-  test('includes multiple image blocks', () => {
-    const msg = createUserMessage('compare these', [
-      { filename: 'a.jpg', mimeType: 'image/jpeg', data: 'img1' },
-      { filename: 'b.png', mimeType: 'image/png', data: 'img2' },
+  test("includes multiple image blocks", () => {
+    const msg = createUserMessage("compare these", [
+      { filename: "a.jpg", mimeType: "image/jpeg", data: "img1" },
+      { filename: "b.png", mimeType: "image/png", data: "img2" },
     ]);
 
-    expect(msg.role).toBe('user');
+    expect(msg.role).toBe("user");
     expect(msg.content).toHaveLength(3);
-    expect(msg.content[0].type).toBe('text');
-    expect(msg.content[1].type).toBe('image');
-    expect(msg.content[2].type).toBe('image');
+    expect(msg.content[0].type).toBe("text");
+    expect(msg.content[1].type).toBe("image");
+    expect(msg.content[2].type).toBe("image");
   });
 
-  test('preserves base64 data in image content block', () => {
-    const base64 = 'dGVzdC1pbWFnZS1kYXRh';
-    const msg = createUserMessage('test', [
-      { filename: 'photo.jpg', mimeType: 'image/jpeg', data: base64 },
+  test("preserves base64 data in image content block", () => {
+    const base64 = "dGVzdC1pbWFnZS1kYXRh";
+    const msg = createUserMessage("test", [
+      { filename: "photo.jpg", mimeType: "image/jpeg", data: base64 },
     ]);
 
     const imageBlock = msg.content[1] as {
-      type: 'image';
+      type: "image";
       source: { type: string; media_type: string; data: string };
     };
     expect(imageBlock.source.data).toBe(base64);
-    expect(imageBlock.source.media_type).toBe('image/jpeg');
-    expect(imageBlock.source.type).toBe('base64');
+    expect(imageBlock.source.media_type).toBe("image/jpeg");
+    expect(imageBlock.source.type).toBe("base64");
   });
 });

package/src/__tests__/audit-log-rotation.test.ts

@@ -1,28 +1,31 @@
-import { randomBytes } from 'node:crypto';
-import { existsSync,mkdirSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { Database } from 'bun:sqlite';
-import { beforeAll, beforeEach, describe, expect, mock,test } from 'bun:test';
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Test setup — temp directory and mock modules
 // ---------------------------------------------------------------------------
 
-const TEST_DIR = join(tmpdir(), `vellum-rotation-test-${randomBytes(4).toString('hex')}`);
-const DB_PATH = join(TEST_DIR, 'assistant.db');
-
-mock.module('../util/logger.js', () => ({
-  getLogger: () => new Proxy({} as Record<string, unknown>, {
-    get: () => () => {},
-  }),
+const TEST_DIR = join(
+  tmpdir(),
+  `vellum-rotation-test-${randomBytes(4).toString("hex")}`,
+);
+const DB_PATH = join(TEST_DIR, "assistant.db");
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
 }));
 
-mock.module('../util/platform.js', () => ({
+mock.module("../util/platform.js", () => ({
   getDataDir: () => TEST_DIR,
   getDbPath: () => DB_PATH,
-  getLogPath: () => join(TEST_DIR, 'logs', 'vellum.log'),
+  getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),
   ensureDataDir: () => {
     if (!existsSync(TEST_DIR)) mkdirSync(TEST_DIR, { recursive: true });
   },
@@ -31,11 +34,11 @@ mock.module('../util/platform.js', () => ({
   isWindows: () => false,
 }));
 
-import { initializeDb, resetDb } from '../memory/db.js';
+import { initializeDb, resetDb } from "../memory/db.js";
 import {
   getRecentInvocations,
   rotateToolInvocations,
-} from '../memory/tool-usage-store.js';
+} from "../memory/tool-usage-store.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -44,18 +47,28 @@ import {
 function addInvocation(ageMs: number): void {
   // Insert directly with a specific timestamp in the past
   const db = new Database(DB_PATH);
-  const id = randomBytes(8).toString('hex');
+  const id = randomBytes(8).toString("hex");
   const createdAt = Date.now() - ageMs;
   db.prepare(
     `INSERT INTO tool_invocations (id, conversation_id, tool_name, input, result, decision, risk_level, duration_ms, created_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-  ).run(id, 'conv-1', 'bash', '{"command":"echo hi"}', 'hi', 'allow', 'Low', 100, createdAt);
+  ).run(
+    id,
+    "conv-1",
+    "bash",
+    '{"command":"echo hi"}',
+    "hi",
+    "allow",
+    "Low",
+    100,
+    createdAt,
+  );
   db.close();
 }
 
 function clearTable(): void {
   const db = new Database(DB_PATH);
-  db.run('DELETE FROM tool_invocations');
+  db.run("DELETE FROM tool_invocations");
   db.close();
 }
 
@@ -65,14 +78,16 @@ const ONE_DAY_MS = 24 * 60 * 60 * 1000;
 // Tests
 // ---------------------------------------------------------------------------
 
-describe('audit log rotation', () => {
+describe("audit log rotation", () => {
   beforeAll(() => {
-    mkdirSync(join(TEST_DIR, 'logs'), { recursive: true });
+    mkdirSync(join(TEST_DIR, "logs"), { recursive: true });
     resetDb();
     initializeDb();
     // Insert a conversations row so FK-enforced ORM inserts succeed
     const db = new Database(DB_PATH);
-    db.run(`INSERT INTO conversations (id, title, created_at, updated_at) VALUES ('conv-1', 'test', ${Date.now()}, ${Date.now()})`);
+    db.run(
+      `INSERT INTO conversations (id, title, created_at, updated_at) VALUES ('conv-1', 'test', ${Date.now()}, ${Date.now()})`,
+    );
     db.close();
   });
 
@@ -84,31 +99,31 @@ describe('audit log rotation', () => {
   // Deleting it here would trigger ENOENT in other test files because
   // the platform.js mock leaks getDataDir() → TEST_DIR globally.
 
-  test('returns 0 when retentionDays is 0 (retain forever)', () => {
+  test("returns 0 when retentionDays is 0 (retain forever)", () => {
     addInvocation(100 * ONE_DAY_MS); // 100 days old
     const deleted = rotateToolInvocations(0);
     expect(deleted).toBe(0);
     expect(getRecentInvocations(100).length).toBe(1);
   });
 
-  test('returns 0 when retentionDays is negative', () => {
+  test("returns 0 when retentionDays is negative", () => {
     addInvocation(100 * ONE_DAY_MS);
     const deleted = rotateToolInvocations(-5);
     expect(deleted).toBe(0);
     expect(getRecentInvocations(100).length).toBe(1);
   });
 
-  test('deletes records older than retentionDays', () => {
+  test("deletes records older than retentionDays", () => {
     addInvocation(10 * ONE_DAY_MS); // 10 days old — should be deleted with 7-day retention
-    addInvocation(3 * ONE_DAY_MS);  // 3 days old — should be kept
-    addInvocation(1 * ONE_DAY_MS);  // 1 day old — should be kept
+    addInvocation(3 * ONE_DAY_MS); // 3 days old — should be kept
+    addInvocation(1 * ONE_DAY_MS); // 1 day old — should be kept
 
     const deleted = rotateToolInvocations(7);
     expect(deleted).toBe(1);
     expect(getRecentInvocations(100).length).toBe(2);
   });
 
-  test('keeps all records when none exceed retention', () => {
+  test("keeps all records when none exceed retention", () => {
     addInvocation(1 * ONE_DAY_MS);
     addInvocation(2 * ONE_DAY_MS);
     addInvocation(3 * ONE_DAY_MS);
@@ -118,7 +133,7 @@ describe('audit log rotation', () => {
     expect(getRecentInvocations(100).length).toBe(3);
   });
 
-  test('deletes all records when all exceed retention', () => {
+  test("deletes all records when all exceed retention", () => {
     addInvocation(60 * ONE_DAY_MS);
     addInvocation(90 * ONE_DAY_MS);
     addInvocation(120 * ONE_DAY_MS);
@@ -128,13 +143,13 @@ describe('audit log rotation', () => {
     expect(getRecentInvocations(100).length).toBe(0);
   });
 
-  test('returns 0 when table is empty', () => {
+  test("returns 0 when table is empty", () => {
     const deleted = rotateToolInvocations(7);
     expect(deleted).toBe(0);
   });
 
-  test('handles 1-day retention (deletes everything older than 24h)', () => {
-    addInvocation(2 * ONE_DAY_MS);  // 2 days old — delete
+  test("handles 1-day retention (deletes everything older than 24h)", () => {
+    addInvocation(2 * ONE_DAY_MS); // 2 days old — delete
     addInvocation(12 * 60 * 60 * 1000); // 12 hours old — keep
 
     const deleted = rotateToolInvocations(1);
@@ -142,7 +157,7 @@ describe('audit log rotation', () => {
     expect(getRecentInvocations(100).length).toBe(1);
   });
 
-  test('works with recordToolInvocation (via ORM)', () => {
+  test("works with recordToolInvocation (via ORM)", () => {
     // Use raw SQL to insert (avoids db singleton issues in parallel test runs)
     // and verify the rotation/query functions work correctly with it
     addInvocation(0); // just-created record