@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/__tests__/attachments-store-heic-normalize.test.ts

@@ -100,8 +100,8 @@ describe("HEIC upload normalization wiring", () => {
     await initializeDb();
   }, 30_000);
 
-  test("uploadAttachmentFromBytes stores a JPEG master for HEIC", () => {
-    const stored = uploadAttachmentFromBytes(
+  test("uploadAttachmentFromBytes stores a JPEG master for HEIC", async () => {
+    const stored = await uploadAttachmentFromBytes(
       "IMG_5487.HEIC",
       "image/heic",
       HEIC_BYTES,
@@ -115,8 +115,8 @@ describe("HEIC upload normalization wiring", () => {
     expect(readFileSync(stagedPath!).equals(FAKE_JPEG)).toBe(true);
   });
 
-  test("uploadAttachmentFromBytes leaves non-HEIC uploads verbatim", () => {
-    const stored = uploadAttachmentFromBytes(
+  test("uploadAttachmentFromBytes leaves non-HEIC uploads verbatim", async () => {
+    const stored = await uploadAttachmentFromBytes(
       "photo.png",
       "image/png",
       HEIC_BYTES,
@@ -127,8 +127,8 @@ describe("HEIC upload normalization wiring", () => {
     expect(stored.sizeBytes).toBe(HEIC_BYTES.length);
   });
 
-  test("uploadAttachment (base64) stores a JPEG master for HEIC", () => {
-    const stored = uploadAttachment("IMG_1.heic", "image/heic", HEIC_B64);
+  test("uploadAttachment (base64) stores a JPEG master for HEIC", async () => {
+    const stored = await uploadAttachment("IMG_1.heic", "image/heic", HEIC_B64);
 
     expect(stored.originalFilename).toBe("IMG_1.jpg");
     expect(stored.mimeType).toBe("image/jpeg");
@@ -137,16 +137,20 @@ describe("HEIC upload normalization wiring", () => {
     expect(row?.dataBase64).toBe(FAKE_JPEG_B64);
   });
 
-  test("uploadAttachment (base64) leaves non-HEIC uploads verbatim", () => {
-    const stored = uploadAttachment("photo.png", "image/png", HEIC_B64);
+  test("uploadAttachment (base64) leaves non-HEIC uploads verbatim", async () => {
+    const stored = await uploadAttachment("photo.png", "image/png", HEIC_B64);
 
     expect(stored.originalFilename).toBe("photo.png");
     expect(stored.mimeType).toBe("image/png");
     expect(stored.sizeBytes).toBe(HEIC_BYTES.length);
   });
 
-  test("uploadAttachment (base64) propagates a MIME-only sniff correction", () => {
-    const stored = uploadAttachment("photo.png", "image/mislabeled", HEIC_B64);
+  test("uploadAttachment (base64) propagates a MIME-only sniff correction", async () => {
+    const stored = await uploadAttachment(
+      "photo.png",
+      "image/mislabeled",
+      HEIC_B64,
+    );
 
     // Corrected MIME is stored; filename and payload stay verbatim.
     expect(stored.originalFilename).toBe("photo.png");
@@ -163,7 +167,7 @@ describe("HEIC upload normalization wiring", () => {
       JSON.stringify([{ type: "text", text: "photos" }]),
     );
 
-    const normalized = attachInlineAttachmentToMessage(
+    const normalized = await attachInlineAttachmentToMessage(
       msg.id,
       0,
       "IMG_2.HEIC",
@@ -176,7 +180,7 @@ describe("HEIC upload normalization wiring", () => {
 
     // Assistant-outbound attachments are stored verbatim: no normalizeImage
     // flag, no rewrite, even for HEIC content.
-    const verbatim = attachInlineAttachmentToMessage(
+    const verbatim = await attachInlineAttachmentToMessage(
       msg.id,
       1,
       "IMG_3.HEIC",

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

@@ -65,8 +65,8 @@ function getLegacyConversationDirPath(
 describe("uploadAttachment", () => {
   beforeEach(resetTables);
 
-  test("stores attachment and returns metadata", () => {
-    const stored = uploadAttachment("chart.png", "image/png", "iVBORw0K");
+  test("stores attachment and returns metadata", async () => {
+    const stored = await uploadAttachment("chart.png", "image/png", "iVBORw0K");
 
     expect(stored.id).toBeDefined();
     expect(stored.originalFilename).toBe("chart.png");
@@ -76,16 +76,20 @@ describe("uploadAttachment", () => {
     expect(stored.createdAt).toBeGreaterThan(0);
   });
 
-  test("keeps uploads staged until linked", () => {
-    const stored = uploadAttachment("small.txt", "text/plain", "aGVsbG8=");
+  test("keeps uploads staged until linked", async () => {
+    const stored = await uploadAttachment(
+      "small.txt",
+      "text/plain",
+      "aGVsbG8=",
+    );
     const filePath = getFilePathForAttachment(stored.id);
 
     expect(filePath).toBeNull();
     expect(getAttachmentContent(stored.id)?.toString()).toBe("hello");
   });
 
-  test("stores base64 in the DB row until linked", () => {
-    const stored = uploadAttachment("test.txt", "text/plain", "dGVzdA==");
+  test("stores base64 in the DB row until linked", async () => {
+    const stored = await uploadAttachment("test.txt", "text/plain", "dGVzdA==");
 
     // Staged uploads keep the payload inline until they are attached to a message.
     const rawRow = rawGet<{ data_base64: string }>(
@@ -100,35 +104,43 @@ describe("uploadAttachment", () => {
     expect(row!.dataBase64).toBe("dGVzdA==");
   });
 
-  test("classifies image MIME as image kind", () => {
-    const stored = uploadAttachment("pic.jpg", "image/jpeg", "AAAA");
+  test("classifies image MIME as image kind", async () => {
+    const stored = await uploadAttachment("pic.jpg", "image/jpeg", "AAAA");
     expect(stored.kind).toBe("image");
   });
 
-  test("classifies non-image MIME as document kind", () => {
-    const stored = uploadAttachment("doc.pdf", "application/pdf", "JVBER");
+  test("classifies non-image MIME as document kind", async () => {
+    const stored = await uploadAttachment(
+      "doc.pdf",
+      "application/pdf",
+      "JVBER",
+    );
     expect(stored.kind).toBe("document");
   });
 
-  test("generates unique IDs for each upload", () => {
-    const a = uploadAttachment("a.txt", "text/plain", "AA==");
-    const b = uploadAttachment("b.txt", "text/plain", "QQ==");
+  test("generates unique IDs for each upload", async () => {
+    const a = await uploadAttachment("a.txt", "text/plain", "AA==");
+    const b = await uploadAttachment("b.txt", "text/plain", "QQ==");
     expect(a.id).not.toBe(b.id);
   });
 
-  test("computes sizeBytes from base64 correctly", () => {
+  test("computes sizeBytes from base64 correctly", async () => {
     // "hello" = "aGVsbG8=" (8 chars, 1 pad -> 5 bytes)
-    const stored = uploadAttachment("hello.txt", "text/plain", "aGVsbG8=");
+    const stored = await uploadAttachment(
+      "hello.txt",
+      "text/plain",
+      "aGVsbG8=",
+    );
     expect(stored.sizeBytes).toBe(5);
   });
 
-  test("does not deduplicate identical uploads before linking", () => {
-    const first = uploadAttachment(
+  test("does not deduplicate identical uploads before linking", async () => {
+    const first = await uploadAttachment(
       "photo.png",
       "image/png",
       "iVBORw0KGgoAAAANSUh",
     );
-    const second = uploadAttachment(
+    const second = await uploadAttachment(
       "photo.png",
       "image/png",
       "iVBORw0KGgoAAAANSUh",
@@ -136,13 +148,13 @@ describe("uploadAttachment", () => {
     expect(second.id).not.toBe(first.id);
   });
 
-  test("does not deduplicate identical content when filenames differ", () => {
-    const first = uploadAttachment(
+  test("does not deduplicate identical content when filenames differ", async () => {
+    const first = await uploadAttachment(
       "original.png",
       "image/png",
       "DUPECONTENT123",
     );
-    const second = uploadAttachment(
+    const second = await uploadAttachment(
       "renamed.png",
       "image/png",
       "DUPECONTENT123",
@@ -150,45 +162,47 @@ describe("uploadAttachment", () => {
     expect(second.id).not.toBe(first.id);
   });
 
-  test("does not deduplicate different content", () => {
-    const first = uploadAttachment("a.txt", "text/plain", "CONTENTA");
-    const second = uploadAttachment("b.txt", "text/plain", "CONTENTB");
+  test("does not deduplicate different content", async () => {
+    const first = await uploadAttachment("a.txt", "text/plain", "CONTENTA");
+    const second = await uploadAttachment("b.txt", "text/plain", "CONTENTB");
     expect(second.id).not.toBe(first.id);
   });
 
-  test("rejects payloads exceeding MAX_UPLOAD_BYTES", () => {
+  test("rejects payloads exceeding MAX_UPLOAD_BYTES", async () => {
     // Build a base64 string that decodes to just over the limit.
     // 4 base64 chars -> 3 bytes, so we need ceil((MAX_UPLOAD_BYTES+1)/3)*4 chars.
     const oversizedLength = Math.ceil((MAX_UPLOAD_BYTES + 1) / 3) * 4;
     const oversizedData = "A".repeat(oversizedLength);
 
-    expect(() =>
+    await expect(
       uploadAttachment("huge.bin", "application/octet-stream", oversizedData),
-    ).toThrow(AttachmentUploadError);
+    ).rejects.toThrow(AttachmentUploadError);
   });
 
-  test("rejects invalid base64 data", () => {
-    expect(() =>
+  test("rejects invalid base64 data", async () => {
+    await expect(
       uploadAttachment("bad.txt", "text/plain", "!!!not-base64!!!"),
-    ).toThrow(AttachmentUploadError);
+    ).rejects.toThrow(AttachmentUploadError);
   });
 
-  test("accepts base64 with non-standard padding/length", () => {
+  test("accepts base64 with non-standard padding/length", async () => {
     // Lenient on length -- only character set is validated
-    expect(() => uploadAttachment("ok.txt", "text/plain", "AAA")).not.toThrow();
+    await expect(
+      uploadAttachment("ok.txt", "text/plain", "AAA"),
+    ).resolves.toBeDefined();
   });
 
   // Inserting the 100 MB payload into SQLite can take several seconds on
   // slow CI runners, so this test needs more than the default 5s timeout.
-  test("accepts payload exactly at MAX_UPLOAD_BYTES", () => {
+  test("accepts payload exactly at MAX_UPLOAD_BYTES", async () => {
     // MAX_UPLOAD_BYTES (100 MB) is divisible by 3, so (MAX/3)*4 base64 chars
     // decodes to exactly MAX bytes with no padding.
     const exactLength = (MAX_UPLOAD_BYTES / 3) * 4;
     const exactData = "A".repeat(exactLength);
 
-    expect(() =>
+    await expect(
       uploadAttachment("exact.bin", "application/octet-stream", exactData),
-    ).not.toThrow();
+    ).resolves.toBeDefined();
   }, 30_000);
 });
 
@@ -199,8 +213,12 @@ describe("uploadAttachment", () => {
 describe("getAttachmentContent", () => {
   beforeEach(resetTables);
 
-  test("returns staged content before the attachment is linked", () => {
-    const stored = uploadAttachment("hello.txt", "text/plain", "aGVsbG8=");
+  test("returns staged content before the attachment is linked", async () => {
+    const stored = await uploadAttachment(
+      "hello.txt",
+      "text/plain",
+      "aGVsbG8=",
+    );
     const content = getAttachmentContent(stored.id);
 
     expect(content).not.toBeNull();
@@ -215,7 +233,7 @@ describe("getAttachmentContent", () => {
   test("returns null when a materialized on-disk file is missing (ENOENT)", async () => {
     const conv = createConversation();
     const msg = await addMessage(conv.id, "assistant", "File");
-    const stored = uploadAttachment("test.txt", "text/plain", "dGVzdA==");
+    const stored = await uploadAttachment("test.txt", "text/plain", "dGVzdA==");
     linkAttachmentToMessage(msg.id, stored.id, 0);
     const filePath = getFilePathForAttachment(stored.id);
 
@@ -259,8 +277,8 @@ describe("isValidBase64", () => {
 describe("deleteAttachment", () => {
   beforeEach(resetTables);
 
-  test("deletes existing attachment and returns deleted", () => {
-    const stored = uploadAttachment("file.txt", "text/plain", "dGVzdA==");
+  test("deletes existing attachment and returns deleted", async () => {
+    const stored = await uploadAttachment("file.txt", "text/plain", "dGVzdA==");
     const result = deleteAttachment(stored.id);
     expect(result).toBe("deleted");
 
@@ -271,7 +289,11 @@ describe("deleteAttachment", () => {
   test("cleans up on-disk file when deleting", async () => {
     const conv = createConversation();
     const msg = await addMessage(conv.id, "assistant", "cleanup");
-    const stored = uploadAttachment("cleanup.txt", "text/plain", "dGVzdA==");
+    const stored = await uploadAttachment(
+      "cleanup.txt",
+      "text/plain",
+      "dGVzdA==",
+    );
     linkAttachmentToMessage(msg.id, stored.id, 0);
     const filePath = getFilePathForAttachment(stored.id);
     expect(existsSync(filePath!)).toBe(true);
@@ -296,7 +318,11 @@ describe("deleteAttachment", () => {
     const msg1 = await addMessage(conv.id, "user", "First upload");
     const msg2 = await addMessage(conv.id, "user", "Duplicate upload");
 
-    const first = uploadAttachment("photo.png", "image/png", "SHAREDCONTENT1");
+    const first = await uploadAttachment(
+      "photo.png",
+      "image/png",
+      "SHAREDCONTENT1",
+    );
     linkAttachmentToMessage(msg1.id, first.id, 0);
     linkAttachmentToMessage(msg2.id, first.id, 0);
 
@@ -315,8 +341,12 @@ describe("deleteAttachment", () => {
     expect(linked2).toHaveLength(1);
   });
 
-  test("deletes attachment when no messages reference it", () => {
-    const stored = uploadAttachment("lonely.txt", "text/plain", "UNREFERENCED");
+  test("deletes attachment when no messages reference it", async () => {
+    const stored = await uploadAttachment(
+      "lonely.txt",
+      "text/plain",
+      "UNREFERENCED",
+    );
     // No linkAttachmentToMessage call -- zero references
     const result = deleteAttachment(stored.id);
     expect(result).toBe("deleted");
@@ -333,9 +363,9 @@ describe("deleteAttachment", () => {
 describe("getAttachmentsByIds", () => {
   beforeEach(resetTables);
 
-  test("returns matching attachments with hydrated dataBase64", () => {
-    const a = uploadAttachment("a.txt", "text/plain", "AAAA");
-    const b = uploadAttachment("b.txt", "text/plain", "BBBB");
+  test("returns matching attachments with hydrated dataBase64", async () => {
+    const a = await uploadAttachment("a.txt", "text/plain", "AAAA");
+    const b = await uploadAttachment("b.txt", "text/plain", "BBBB");
 
     const results = getAttachmentsByIds([a.id, b.id], {
       hydrateFileData: true,
@@ -350,8 +380,8 @@ describe("getAttachmentsByIds", () => {
     expect(results).toHaveLength(0);
   });
 
-  test("skips IDs that do not exist", () => {
-    const a = uploadAttachment("a.txt", "text/plain", "AAAA");
+  test("skips IDs that do not exist", async () => {
+    const a = await uploadAttachment("a.txt", "text/plain", "AAAA");
     const results = getAttachmentsByIds([a.id, "nonexistent"]);
     expect(results).toHaveLength(1);
   });
@@ -364,8 +394,12 @@ describe("getAttachmentsByIds", () => {
 describe("getAttachmentById", () => {
   beforeEach(resetTables);
 
-  test("returns attachment with hydrated dataBase64 when found", () => {
-    const stored = uploadAttachment("report.pdf", "application/pdf", "JVBER");
+  test("returns attachment with hydrated dataBase64 when found", async () => {
+    const stored = await uploadAttachment(
+      "report.pdf",
+      "application/pdf",
+      "JVBER",
+    );
     const result = getAttachmentById(stored.id, { hydrateFileData: true });
 
     expect(result).not.toBeNull();
@@ -392,7 +426,7 @@ describe("createInlineAttachment (workspace_ref persistence)", () => {
     const msg = await addMessage(conv.id, "user", "hi");
 
     // "aGVsbG8=" = "hello"
-    const stored = createInlineAttachment(
+    const stored = await createInlineAttachment(
       conv.id,
       conv.createdAt,
       "note.txt",
@@ -431,14 +465,14 @@ describe("attachInlineAttachmentToMessage filename collisions", () => {
     const msg2 = await addMessage(conv.id, "user", "re-upload after editing");
 
     // "aGVsbG8=" = "hello", "d29ybGQ=" = "world"
-    const first = attachInlineAttachmentToMessage(
+    const first = await attachInlineAttachmentToMessage(
       msg1.id,
       0,
       "report.csv",
       "text/csv",
       "aGVsbG8=",
     );
-    const second = attachInlineAttachmentToMessage(
+    const second = await attachInlineAttachmentToMessage(
       msg2.id,
       0,
       "report.csv",
@@ -463,7 +497,7 @@ describe("linkAttachmentToMessage + getAttachmentsForMessage", () => {
   test("links attachment and retrieves it by message", async () => {
     const conv = createConversation();
     const msg = await addMessage(conv.id, "assistant", "Here is a chart");
-    const stored = uploadAttachment("chart.png", "image/png", "iVBORw0K");
+    const stored = await uploadAttachment("chart.png", "image/png", "iVBORw0K");
 
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
@@ -482,7 +516,11 @@ describe("linkAttachmentToMessage + getAttachmentsForMessage", () => {
     const legacyDir = getLegacyConversationDirPath(conv.id, conv.createdAt);
     rmSync(legacyDir, { recursive: true, force: true });
 
-    const stored = uploadAttachment("repaired.png", "image/png", "iVBORw0K");
+    const stored = await uploadAttachment(
+      "repaired.png",
+      "image/png",
+      "iVBORw0K",
+    );
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
     const filePath = getFilePathForAttachment(stored.id);
@@ -501,7 +539,11 @@ describe("linkAttachmentToMessage + getAttachmentsForMessage", () => {
     rmSync(canonicalDir, { recursive: true, force: true });
     mkdirSync(legacyDir, { recursive: true });
 
-    const stored = uploadAttachment("legacy.png", "image/png", "iVBORw0K");
+    const stored = await uploadAttachment(
+      "legacy.png",
+      "image/png",
+      "iVBORw0K",
+    );
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
     const filePath = getFilePathForAttachment(stored.id);
@@ -514,8 +556,8 @@ describe("linkAttachmentToMessage + getAttachmentsForMessage", () => {
   test("returns attachments in position order", async () => {
     const conv = createConversation();
     const msg = await addMessage(conv.id, "assistant", "Multiple files");
-    const a = uploadAttachment("first.txt", "text/plain", "AAAA");
-    const b = uploadAttachment("second.txt", "text/plain", "BBBB");
+    const a = await uploadAttachment("first.txt", "text/plain", "AAAA");
+    const b = await uploadAttachment("second.txt", "text/plain", "BBBB");
 
     // Link in reverse order
     linkAttachmentToMessage(msg.id, b.id, 1);
@@ -543,8 +585,12 @@ describe("linkAttachmentToMessage + getAttachmentsForMessage", () => {
 describe("deleteOrphanAttachments", () => {
   beforeEach(resetTables);
 
-  test("removes candidate attachments with no message links", () => {
-    const stored = uploadAttachment("orphan.txt", "text/plain", "ZGF0YQ==");
+  test("removes candidate attachments with no message links", async () => {
+    const stored = await uploadAttachment(
+      "orphan.txt",
+      "text/plain",
+      "ZGF0YQ==",
+    );
 
     const removed = deleteOrphanAttachments([stored.id]);
     expect(removed).toBe(1);
@@ -553,7 +599,11 @@ describe("deleteOrphanAttachments", () => {
   test("cleans up on-disk files when removing orphaned materialized attachments", async () => {
     const conv = createConversation();
     const msg = await addMessage(conv.id, "assistant", "Orphan me");
-    const stored = uploadAttachment("orphan.txt", "text/plain", "ZGF0YQ==");
+    const stored = await uploadAttachment(
+      "orphan.txt",
+      "text/plain",
+      "ZGF0YQ==",
+    );
     linkAttachmentToMessage(msg.id, stored.id, 0);
     const filePath = getFilePathForAttachment(stored.id);
     expect(existsSync(filePath!)).toBe(true);
@@ -571,7 +621,11 @@ describe("deleteOrphanAttachments", () => {
   test("preserves attachments that are still linked", async () => {
     const conv = createConversation();
     const msg = await addMessage(conv.id, "assistant", "With attachment");
-    const stored = uploadAttachment("linked.txt", "text/plain", "ZGF0YQ==");
+    const stored = await uploadAttachment(
+      "linked.txt",
+      "text/plain",
+      "ZGF0YQ==",
+    );
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
     const removed = deleteOrphanAttachments([stored.id]);
@@ -584,8 +638,8 @@ describe("deleteOrphanAttachments", () => {
   test("removes only orphans when mixed candidates provided", async () => {
     const conv = createConversation();
     const msg = await addMessage(conv.id, "assistant", "Mixed");
-    const linked = uploadAttachment("linked.txt", "text/plain", "AAAA");
-    const orphan = uploadAttachment("orphan.txt", "text/plain", "BBBB");
+    const linked = await uploadAttachment("linked.txt", "text/plain", "AAAA");
+    const orphan = await uploadAttachment("orphan.txt", "text/plain", "BBBB");
     linkAttachmentToMessage(msg.id, linked.id, 0);
 
     const removed = deleteOrphanAttachments([linked.id, orphan.id]);
@@ -600,9 +654,17 @@ describe("deleteOrphanAttachments", () => {
     expect(removed).toBe(0);
   });
 
-  test("does not delete attachments outside the candidate set", () => {
-    const unrelated = uploadAttachment("unrelated.txt", "text/plain", "AAAA");
-    const candidate = uploadAttachment("candidate.txt", "text/plain", "BBBB");
+  test("does not delete attachments outside the candidate set", async () => {
+    const unrelated = await uploadAttachment(
+      "unrelated.txt",
+      "text/plain",
+      "AAAA",
+    );
+    const candidate = await uploadAttachment(
+      "candidate.txt",
+      "text/plain",
+      "BBBB",
+    );
 
     const removed = deleteOrphanAttachments([candidate.id]);
     expect(removed).toBe(1);