@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

package/src/__tests__/persist-unsendable-image.test.ts

@@ -0,0 +1,215 @@
+/**
+ * Regression tests for the image-too-large persistence path (JARVIS-1037).
+ *
+ * An image the provider can never accept — over the per-side pixel cap or the
+ * per-image byte cap, and not shrinkable on this host — must be durably swapped
+ * for a text note in its stored message. If it stays in the stored content,
+ * every later turn rehydrates it from the DB and the model reports seeing both
+ * the rejected image and any smaller re-upload. `persistUnsendableImageDowngrades`
+ * makes the swap durable so the rejected upload cannot resurface.
+ *
+ * Uses the real SQLite DB wired up via `test-preload.ts` (per-file temp
+ * workspace).
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { persistUnsendableImageDowngrades } from "../daemon/persist-unsendable-image.js";
+import {
+  addMessage,
+  createConversation,
+  getMessages,
+} from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import type { ContentBlock } from "../providers/types.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM memory_segments");
+  db.run("DELETE FROM memory_embeddings");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+/**
+ * Build a minimal PNG whose IHDR declares the given dimensions. Only the
+ * 8-byte signature and the width/height fields (read by `parseImageDimensions`)
+ * need to be correct; the rest is padding. `optimizeImageForTransport` cannot
+ * downscale this off macOS (no `sips`), so it stays a no-op — exactly the
+ * host condition that produces an unsendable stored image.
+ */
+function makePngBase64(width: number, height: number, padBytes = 0): string {
+  const header = Buffer.from(
+    Uint8Array.from([
+      0x89,
+      0x50,
+      0x4e,
+      0x47,
+      0x0d,
+      0x0a,
+      0x1a,
+      0x0a, // PNG signature
+      0x00,
+      0x00,
+      0x00,
+      0x0d, // IHDR length (13)
+      0x49,
+      0x48,
+      0x44,
+      0x52, // "IHDR"
+      (width >>> 24) & 0xff,
+      (width >>> 16) & 0xff,
+      (width >>> 8) & 0xff,
+      width & 0xff,
+      (height >>> 24) & 0xff,
+      (height >>> 16) & 0xff,
+      (height >>> 8) & 0xff,
+      height & 0xff,
+      0x08,
+      0x06,
+      0x00,
+      0x00,
+      0x00, // bit depth / color type / etc.
+    ]),
+  ).toString("base64");
+  return padBytes > 0 ? header + "A".repeat(padBytes) : header;
+}
+
+function imageBlock(data: string): ContentBlock {
+  return {
+    type: "image",
+    source: { type: "base64", media_type: "image/png", data },
+  };
+}
+
+function storedContent(conversationId: string): ContentBlock[][] {
+  return getMessages(conversationId).map(
+    (row) => JSON.parse(row.content) as ContentBlock[],
+  );
+}
+
+const PROVIDER_MAX_IMAGE_DIMENSION = 8000;
+
+describe("persistUnsendableImageDowngrades", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  /** A stored image past the provider pixel cap is swapped for a text note. */
+  test("replaces an oversized image block with a text note", async () => {
+    // GIVEN a message holding text plus an image past the pixel cap
+    const conv = createConversation();
+    const oversized = makePngBase64(PROVIDER_MAX_IMAGE_DIMENSION + 1000, 6000);
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([
+        { type: "text", text: "look at this" },
+        imageBlock(oversized),
+      ]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN one message is rewritten with no image block left
+    expect(rewritten).toBe(1);
+    const [content] = storedContent(conv.id);
+    expect(content.some((b) => b.type === "image")).toBe(false);
+    // AND the original text is preserved alongside the substituted note
+    expect(content.filter((b) => b.type === "text")).toHaveLength(2);
+  });
+
+  /** The JARVIS-1037 scenario: the rejected original must not resurface next
+   *  to a valid re-upload. */
+  test("re-uploaded smaller image survives while the rejected original is removed", async () => {
+    // GIVEN turn 1 contains an oversized upload that was rejected
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([imageBlock(makePngBase64(12000, 9000))]),
+      { skipIndexing: true },
+    );
+    // AND turn 2 contains a properly sized re-upload
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([imageBlock(makePngBase64(800, 600))]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN only the rejected original is removed
+    expect(rewritten).toBe(1);
+    const [first, second] = storedContent(conv.id);
+    expect(first.some((b) => b.type === "image")).toBe(false);
+    // AND the valid re-upload is left intact
+    expect(second.some((b) => b.type === "image")).toBe(true);
+  });
+
+  /** Sendable images are never disturbed by the recovery path. */
+  test("leaves a normally-sized image untouched", async () => {
+    // GIVEN a message with an image well within provider limits
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([imageBlock(makePngBase64(1024, 768))]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN nothing is rewritten and the image remains
+    expect(rewritten).toBe(0);
+    const [content] = storedContent(conv.id);
+    expect(content.some((b) => b.type === "image")).toBe(true);
+  });
+
+  /** The byte-size cap is enforced independently of pixel dimensions. */
+  test("removes an image whose payload exceeds the per-image byte cap", async () => {
+    // GIVEN an image within the pixel cap but with a payload over 5 MB
+    const conv = createConversation();
+    const huge = makePngBase64(1000, 1000, 6 * 1024 * 1024);
+    await addMessage(conv.id, "user", JSON.stringify([imageBlock(huge)]), {
+      skipIndexing: true,
+    });
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN the oversized-payload image is removed
+    expect(rewritten).toBe(1);
+    const [content] = storedContent(conv.id);
+    expect(content.some((b) => b.type === "image")).toBe(false);
+  });
+
+  /** Re-running after a rewrite is a safe no-op (no image blocks remain). */
+  test("is idempotent — a second run rewrites nothing", async () => {
+    // GIVEN a conversation whose oversized image has already been downgraded
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([imageBlock(makePngBase64(10000, 10000))]),
+      { skipIndexing: true },
+    );
+    expect(persistUnsendableImageDowngrades(conv.id)).toBe(1);
+
+    // WHEN the downgrade runs a second time
+    const secondRun = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN nothing further is rewritten
+    expect(secondRun).toBe(0);
+  });
+});

package/src/__tests__/persistence-secret-redaction.test.ts

@@ -52,8 +52,9 @@ mock.module("../memory/conversation-crud.js", () => ({
     conversationId: string,
     role: string,
     content: string,
-    metadata?: Record<string, unknown>,
+    options?: { metadata?: Record<string, unknown> },
   ) => {
+    const metadata = options?.metadata;
     const id = `mock-msg-${addMessageCalls.length + 1}`;
     addMessageCalls.push({ id, conversationId, role, content, metadata });
     return { id };
@@ -148,6 +149,7 @@ function makeDeps(): EventHandlerDeps {
       userMessageInterface: "macos",
       assistantMessageInterface: "macos",
     } as EventHandlerDeps["turnInterfaceContext"],
+    applyCompaction: async () => {},
   } as EventHandlerDeps;
 }
 

package/src/__tests__/pipeline-runner.test.ts

@@ -170,12 +170,12 @@ describe("runPipeline — error propagation", () => {
 
     await expect(
       runPipeline(
-        "persistence",
+        "compaction",
         [thrower],
         terminal,
         { value: 1 },
         makeCtx(),
-        DEFAULT_TIMEOUTS.persistence,
+        DEFAULT_TIMEOUTS.compaction,
       ),
     ).rejects.toBeInstanceOf(Boom);
   });
@@ -187,12 +187,12 @@ describe("runPipeline — error propagation", () => {
 
     await expect(
       runPipeline(
-        "persistence",
+        "compaction",
         [],
         terminal,
         { value: 1 },
         makeCtx(),
-        DEFAULT_TIMEOUTS.persistence,
+        DEFAULT_TIMEOUTS.compaction,
       ),
     ).rejects.toBeInstanceOf(TypeError);
   });
@@ -210,7 +210,7 @@ describe("runPipeline — timeout", () => {
     let caught: unknown;
     try {
       await runPipeline(
-        "memoryRetrieval",
+        "compaction",
         [sleeper],
         terminal,
         { value: 1 },
@@ -223,10 +223,10 @@ describe("runPipeline — timeout", () => {
 
     expect(caught).toBeInstanceOf(PluginTimeoutError);
     const tErr = caught as PluginTimeoutError;
-    expect(tErr.pipeline).toBe("memoryRetrieval");
+    expect(tErr.pipeline).toBe("compaction");
     expect(tErr.pluginName).toBe("slow-plugin");
     expect(tErr.elapsedMs).toBeGreaterThanOrEqual(0);
-    expect(tErr.message).toContain("memoryRetrieval");
+    expect(tErr.message).toContain("compaction");
     expect(tErr.message).toContain("slow-plugin");
   });
 
@@ -235,32 +235,32 @@ describe("runPipeline — timeout", () => {
       value: args.value,
     });
     const result = await runPipeline(
-      "historyRepair",
+      "compaction",
       [],
       terminal,
       { value: 42 },
       makeCtx(),
-      DEFAULT_TIMEOUTS.historyRepair,
+      DEFAULT_TIMEOUTS.compaction,
     );
     expect(result).toEqual({ value: 42 });
   });
 
   test("null timeout skips the race entirely", async () => {
-    // llmCall has DEFAULT_TIMEOUTS.llmCall === null — runner must not arm a
-    // timer. We verify by completing after an artificial 30ms wait and
-    // confirming success without interference.
+    // compaction has DEFAULT_TIMEOUTS.compaction === null — runner must
+    // not arm a timer. We verify by completing after an artificial 30ms wait
+    // and confirming success without interference.
     const sleeper: Middleware<Args, Result> = async (args, next) =>
       new Promise<Result>((resolve) => {
         setTimeout(() => resolve(next(args)), 30);
       });
     const terminal = async (_args: Args): Promise<Result> => ({ value: 1 });
     const result = await runPipeline(
-      "llmCall",
+      "compaction",
       [sleeper],
       terminal,
       { value: 0 },
       makeCtx(),
-      DEFAULT_TIMEOUTS.llmCall,
+      DEFAULT_TIMEOUTS.compaction,
     );
     expect(result).toEqual({ value: 1 });
   });
@@ -356,8 +356,9 @@ describe("runPipeline — timeout aborts linked signal", () => {
   });
 
   test("args without an AbortSignal property is passed through unchanged", async () => {
-    // Sanity — pipelines that don't carry a signal (persistence, tokenEstimate)
-    // see identical args identity as before the abort-linking change.
+    // Sanity — args objects with no AbortSignal property pass through with
+    // identical identity (the abort-linking clone only fires when a signal
+    // is present).
     const args: Args = { value: 42 };
     let seen: Args | undefined;
     const terminal = async (innerArgs: Args): Promise<Result> => {
@@ -365,12 +366,12 @@ describe("runPipeline — timeout aborts linked signal", () => {
       return { value: innerArgs.value };
     };
     await runPipeline(
-      "persistence",
+      "compaction",
       [],
       terminal,
       args,
       makeCtx(),
-      DEFAULT_TIMEOUTS.persistence,
+      DEFAULT_TIMEOUTS.compaction,
     );
     expect(seen).toBe(args);
   });
@@ -428,19 +429,19 @@ describe("runPipeline — structured log record", () => {
 
     await expect(
       runPipeline(
-        "toolError",
+        "compaction",
         [thrower],
         terminal,
         { value: 1 },
         makeCtx({ pluginName: "noisy-plugin" }),
-        DEFAULT_TIMEOUTS.toolError,
+        DEFAULT_TIMEOUTS.compaction,
       ),
     ).rejects.toBeInstanceOf(Boom);
 
     expect(fakeLogger.calls.length).toBe(1);
     const [record] = fakeLogger.calls[0]!;
     expect(record.outcome).toBe("error");
-    expect(record.pipeline).toBe("toolError");
+    expect(record.pipeline).toBe("compaction");
     expect(record.errorName).toBe("BoomError");
     expect(record.errorMessage).toBe("kaboom");
     expect(typeof record.errorStack).toBe("string");
@@ -456,7 +457,7 @@ describe("runPipeline — structured log record", () => {
 
     await expect(
       runPipeline(
-        "emptyResponse",
+        "compaction",
         [sleeper],
         terminal,
         { value: 1 },
@@ -468,9 +469,9 @@ describe("runPipeline — structured log record", () => {
     expect(fakeLogger.calls.length).toBe(1);
     const [record] = fakeLogger.calls[0]!;
     expect(record.outcome).toBe("timeout");
-    expect(record.pipeline).toBe("emptyResponse");
+    expect(record.pipeline).toBe("compaction");
     expect(record.errorName).toBe("PluginTimeoutError");
-    expect(String(record.errorMessage)).toContain("emptyResponse");
+    expect(String(record.errorMessage)).toContain("compaction");
     expect(String(record.errorMessage)).toContain("slow-plugin");
     expect(record.timeoutMs).toBe(15);
     expect(record.pluginName).toBe("slow-plugin");
@@ -481,17 +482,17 @@ describe("runPipeline — structured log record", () => {
       value: args.value,
     });
     await runPipeline(
-      "llmCall",
+      "compaction",
       [],
       terminal,
       { value: 5 },
       makeCtx(),
-      DEFAULT_TIMEOUTS.llmCall,
+      DEFAULT_TIMEOUTS.compaction,
     );
 
     expect(fakeLogger.calls.length).toBe(1);
     const [record] = fakeLogger.calls[0]!;
-    expect(record.pipeline).toBe("llmCall");
+    expect(record.pipeline).toBe("compaction");
     expect(record.outcome).toBe("success");
     expect(record.timeoutMs).toBeUndefined();
   });
@@ -506,7 +507,7 @@ describe("runPipeline — structured log record", () => {
       logger: fakeLogger,
     } as TurnContext;
     await runPipeline(
-      "persistence",
+      "compaction",
       [],
       terminal,
       { value: 0 },
@@ -531,12 +532,12 @@ describe("runPipeline — structured log record", () => {
       value: args.value,
     });
     await runPipeline(
-      "tokenEstimate",
+      "compaction",
       [a, b, c],
       terminal,
       { value: 0 },
       makeCtx(),
-      DEFAULT_TIMEOUTS.tokenEstimate,
+      DEFAULT_TIMEOUTS.compaction,
     );
     const [record] = fakeLogger.calls[0]!;
     expect(record.chain).toEqual(["outerA", "middleB", "innerC"]);
@@ -546,20 +547,7 @@ describe("runPipeline — structured log record", () => {
 describe("DEFAULT_TIMEOUTS", () => {
   test("matches the design-doc table exactly", () => {
     expect(DEFAULT_TIMEOUTS).toEqual({
-      turn: null,
-      llmCall: null,
-      toolExecute: null,
-      memoryRetrieval: null,
-      historyRepair: null,
-      tokenEstimate: null,
       compaction: null,
-      overflowReduce: null,
-      persistence: null,
-      titleGenerate: null,
-      toolResultTruncate: null,
-      emptyResponse: null,
-      toolError: null,
-      circuitBreaker: null,
     });
   });
 });

package/src/__tests__/pkb-autoinject.test.ts

@@ -6,7 +6,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import {
   getPkbAutoInjectList,
   readAutoinjectList,
-} from "../daemon/conversation-runtime-assembly.js";
+} from "../memory/pkb/autoinject.js";
 
 const PKB_DEFAULT_FILES = [
   "INDEX.md",
@@ -80,10 +80,7 @@ describe("readAutoinjectList", () => {
       "INDEX.md\ncustom-topic.md\n",
       "utf-8",
     );
-    expect(readAutoinjectList(pkbDir)).toEqual([
-      "INDEX.md",
-      "custom-topic.md",
-    ]);
+    expect(readAutoinjectList(pkbDir)).toEqual(["INDEX.md", "custom-topic.md"]);
   });
 
   test("strips blank lines and whitespace", () => {