@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/__tests__/agent-loop-compacted-history-transform.test.ts

@@ -0,0 +1,304 @@
+/**
+ * The agent loop's post-compaction history transform.
+ *
+ * In-place compaction rebuilds history from the stored rows, so it can
+ * reintroduce content the caller had already trimmed out of the array it handed
+ * to `run()`. The rebuilt array is installed and sent on the very next request
+ * of the same turn, so the caller's trim has to be re-applied at the
+ * installation site rather than only before the run. The loop stays
+ * conversation-ignorant: the caller injects a closure, and this suite drives
+ * that seam with the real camera-frame retention transform.
+ */
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import type { PostCompactContext } from "@vellumai/plugin-api";
+
+import { AgentLoop } from "../agent/loop.js";
+import type { ContextWindowConfig } from "../config/types.js";
+import { stripAgedSightFrames } from "../daemon/conversation-sight-frames.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
+import { HOOKS } from "../plugin-api/constants.js";
+import {
+  createContextWindowManager,
+  disposeContextWindowManager,
+  getContextWindowManager,
+} from "../plugins/defaults/compaction/manager-store.js";
+import {
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import type {
+  ContentBlock,
+  Message,
+  Provider,
+  ProviderResponse,
+} from "../providers/types.js";
+import { ContextOverflowError } from "../providers/types.js";
+
+const testPostCompactPlugin = {
+  manifest: { name: "test-post-compact-transform", version: "0.0.0" },
+  hooks: {
+    [HOOKS.POST_COMPACT]: async (input: PostCompactContext): Promise<void> => {
+      void input;
+    },
+  },
+};
+
+const CONVERSATION_ID = "compacted-history-transform-conversation";
+
+/** Capture times one second apart, the shape the row read produces. */
+const CAPTURE_TIMES = new Map<string, number>([
+  ["f1", 1000],
+  ["f2", 2000],
+  ["f3", 3000],
+  ["f4", 4000],
+]);
+
+/** A retained frame as `buildRetainedImageBlocks` rebuilds it: inline + id. */
+function retainedFrame(
+  attachmentId: string,
+): Extract<ContentBlock, { type: "image" }> {
+  return {
+    type: "image",
+    source: { type: "base64", media_type: "image/png", data: "AAAAAAAA" },
+    _attachmentId: attachmentId,
+  };
+}
+
+/**
+ * The history compaction rebuilds here: four tagged frames in one synthetic
+ * message, which is two more than the retention bound allows.
+ */
+function compactedHistoryWithFourFrames(): Message[] {
+  return [
+    {
+      role: "user",
+      content: [
+        { type: "text", text: "Images retained from the compacted portion:" },
+        retainedFrame("f1"),
+        retainedFrame("f2"),
+        retainedFrame("f3"),
+        retainedFrame("f4"),
+      ],
+    },
+  ];
+}
+
+function textResponse(text: string): ProviderResponse {
+  return {
+    content: [{ type: "text", text }],
+    model: "mock-model",
+    usage: { inputTokens: 10, outputTokens: 5 },
+    stopReason: "end_turn",
+  };
+}
+
+/** Records every history the provider is asked to send. */
+function createRecordingProvider(requests: Message[][]): Provider {
+  return {
+    name: "mock",
+    async sendMessage(messages: Message[]): Promise<ProviderResponse> {
+      requests.push(messages);
+      return textResponse("done");
+    },
+  };
+}
+
+/** A provider that rejects once as context-too-large, then answers. */
+function createOverflowingProvider(requests: Message[][]): Provider {
+  let throwOnce = true;
+  return {
+    name: "mock",
+    async sendMessage(messages: Message[]): Promise<ProviderResponse> {
+      requests.push(messages);
+      if (throwOnce) {
+        throwOnce = false;
+        throw new ContextOverflowError("prompt too long", "mock", {
+          actualTokens: 999_999,
+        });
+      }
+      return textResponse("done after overflow recovery");
+    },
+  };
+}
+
+/**
+ * Install a manager whose compaction returns the four-frame history, so the
+ * loop installs more frames than the bound allows.
+ */
+function installOverfullCompactionManager(): { trust: TrustContext } {
+  createContextWindowManager({
+    provider: { name: "mock-provider" } as unknown as Provider,
+    config: {} as unknown as ContextWindowConfig,
+    conversationId: CONVERSATION_ID,
+  });
+  const manager = getContextWindowManager(CONVERSATION_ID);
+  if (manager) {
+    const rebuild = async () => ({
+      messages: compactedHistoryWithFourFrames(),
+      compacted: true,
+      exhausted: false,
+    });
+    manager.maybeCompact = rebuild as unknown as typeof manager.maybeCompact;
+    manager.recoverContextOverflow =
+      rebuild as unknown as typeof manager.recoverContextOverflow;
+  }
+  return { trust: { sourceChannel: "vellum", trustClass: "unknown" } };
+}
+
+/** Image blocks in the last history the provider was asked to send. */
+function imagesInLastRequest(requests: Message[][]): ContentBlock[] {
+  const last = requests.at(-1) ?? [];
+  return last.flatMap((message) =>
+    message.content.filter((block) => block.type === "image"),
+  );
+}
+
+function frameStubsInLastRequest(requests: Message[][]): string[] {
+  const last = requests.at(-1) ?? [];
+  return last.flatMap((message) =>
+    message.content
+      .filter((block) => block.type === "text")
+      .map((block) => block.text)
+      .filter((text) => text.startsWith("[Camera frame omitted from context:")),
+  );
+}
+
+describe("AgentLoop post-compaction history transform", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    registerPlugin(testPostCompactPlugin);
+  });
+
+  afterEach(() => {
+    disposeContextWindowManager(CONVERSATION_ID);
+  });
+
+  test("trims a budget-gate compaction before the next provider call", async () => {
+    const requests: Message[][] = [];
+    const loop = new AgentLoop({
+      provider: createRecordingProvider(requests),
+      systemPrompt: "system",
+      conversationId: CONVERSATION_ID,
+      tools: [],
+      toolExecutor: async () => ({ content: "ok", isError: false }),
+      transformCompactedHistory: (messages) =>
+        stripAgedSightFrames(messages, CAPTURE_TIMES).messages,
+    });
+
+    await loop.run({
+      requestId: "req",
+      messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      onEvent: () => {},
+      modelProfileKey: "balanced",
+      resolveContextWindow: () => ({
+        maxInputTokens: 10,
+        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+      }),
+      compactInPlace: true,
+      ...installOverfullCompactionManager(),
+    });
+
+    // The request that went out after compaction carries the bound, not the
+    // four frames compaction rebuilt.
+    expect(imagesInLastRequest(requests)).toHaveLength(2);
+    expect(frameStubsInLastRequest(requests)).toHaveLength(2);
+    // The newest two survived.
+    expect(imagesInLastRequest(requests)).toEqual([
+      retainedFrame("f3"),
+      retainedFrame("f4"),
+    ]);
+  });
+
+  test("trims an overflow-driven compaction before the retry", async () => {
+    const requests: Message[][] = [];
+    const loop = new AgentLoop({
+      provider: createOverflowingProvider(requests),
+      systemPrompt: "system",
+      conversationId: CONVERSATION_ID,
+      tools: [],
+      toolExecutor: async () => ({ content: "ok", isError: false }),
+      transformCompactedHistory: (messages) =>
+        stripAgedSightFrames(messages, CAPTURE_TIMES).messages,
+    });
+    // Blocks the budget gate so only the overflow rejection drives compaction.
+    loop.compactionCircuit.lastPostCompactionEstimate = 0;
+
+    await loop.run({
+      requestId: "req",
+      messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      onEvent: () => {},
+      modelProfileKey: "balanced",
+      resolveContextWindow: () => ({
+        maxInputTokens: 10,
+        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+      }),
+      compactInPlace: false,
+      ...installOverfullCompactionManager(),
+    });
+
+    // The overflow retry is a second provider call, and it too is bounded.
+    expect(requests.length).toBeGreaterThan(1);
+    expect(imagesInLastRequest(requests)).toHaveLength(2);
+    expect(frameStubsInLastRequest(requests)).toHaveLength(2);
+  });
+
+  test("installs the compacted history as built when no transform is configured", async () => {
+    // The workflow leaf runner builds a loop with no conversation behind it.
+    const requests: Message[][] = [];
+    const loop = new AgentLoop({
+      provider: createRecordingProvider(requests),
+      systemPrompt: "system",
+      conversationId: CONVERSATION_ID,
+      tools: [],
+      toolExecutor: async () => ({ content: "ok", isError: false }),
+    });
+
+    await loop.run({
+      requestId: "req",
+      messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      onEvent: () => {},
+      modelProfileKey: "balanced",
+      resolveContextWindow: () => ({
+        maxInputTokens: 10,
+        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+      }),
+      compactInPlace: true,
+      ...installOverfullCompactionManager(),
+    });
+
+    expect(imagesInLastRequest(requests)).toHaveLength(4);
+    expect(frameStubsInLastRequest(requests)).toHaveLength(0);
+  });
+
+  test("keeps the compacted history when the transform throws", async () => {
+    const requests: Message[][] = [];
+    const loop = new AgentLoop({
+      provider: createRecordingProvider(requests),
+      systemPrompt: "system",
+      conversationId: CONVERSATION_ID,
+      tools: [],
+      toolExecutor: async () => ({ content: "ok", isError: false }),
+      transformCompactedHistory: () => {
+        throw new Error("row read failed");
+      },
+    });
+
+    await loop.run({
+      requestId: "req",
+      messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      onEvent: () => {},
+      modelProfileKey: "balanced",
+      resolveContextWindow: () => ({
+        maxInputTokens: 10,
+        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+      }),
+      compactInPlace: true,
+      ...installOverfullCompactionManager(),
+    });
+
+    // The turn still completed against the untrimmed compacted history.
+    expect(requests.length).toBeGreaterThan(0);
+    expect(imagesInLastRequest(requests)).toHaveLength(4);
+  });
+});

package/src/__tests__/agent-wake-disk-pressure-callsite.test.ts

@@ -78,6 +78,9 @@ function makeTarget(): Conversation {
       }),
     },
     messages,
+    // The wake trims its own run input; no row here is tagged as a camera
+    // frame, so the real pass would return the array unchanged too.
+    trimAgedSightFrames: (msgs: Message[]) => msgs,
     getMessages: () => messages,
     isProcessing: () => processing,
     waitForIdle: async () => !processing,

package/src/__tests__/agent-wake-override-profile.test.ts

@@ -90,6 +90,9 @@ function makeTarget(): {
       },
     },
     messages,
+    // The wake trims its own run input; no row here is tagged as a camera
+    // frame, so the real pass would return the array unchanged too.
+    trimAgedSightFrames: (msgs: Message[]) => msgs,
     getMessages: () => messages,
     isProcessing: () => processing,
     waitForIdle: async () => !processing,

package/src/__tests__/anthropic-provider.test.ts

@@ -2973,6 +2973,62 @@ describe("AnthropicProvider — Managed Proxy Fallback", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Tests - internal `_attachmentId` never reaches the wire
+// ---------------------------------------------------------------------------
+
+describe("AnthropicProvider - internal attachment id", () => {
+  let provider: AnthropicProvider;
+
+  beforeEach(() => {
+    lastStreamParams = null;
+    provider = new AnthropicProvider("sk-ant-test", "claude-sonnet-4-6");
+  });
+
+  test("drops _attachmentId from image and file blocks", async () => {
+    // The declared media type matches the bytes, so `resolveMediaReferences`
+    // takes its identity fast path and hands the block through untouched. What
+    // keeps the field off the wire is the client rebuilding each payload out of
+    // `source` alone.
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "what is this" },
+          {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: "image/png",
+              data: PNG_B64,
+            },
+            _attachmentId: "att-image-1",
+          },
+          {
+            type: "file",
+            source: {
+              type: "base64",
+              media_type: "application/pdf",
+              data: "cGRm",
+              filename: "notes.pdf",
+            },
+            _attachmentId: "att-file-1",
+          },
+        ],
+      },
+    ];
+
+    await provider.sendMessage(messages);
+
+    const sent = JSON.stringify(lastStreamParams!.messages);
+    expect(sent).not.toContain("_attachmentId");
+    expect(sent).not.toContain("att-image-1");
+    expect(sent).not.toContain("att-file-1");
+    // The image itself still went out.
+    expect(sent).toContain(PNG_B64);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Tests — Orphaned UTF-16 surrogate sanitization
 // ---------------------------------------------------------------------------

package/src/__tests__/approval-cascade.test.ts

@@ -95,19 +95,6 @@ mock.module("../persistence/attachments-store.js", () => ({
   linkAttachmentToMessage: () => {},
 }));
 
-mock.module("../memory/retriever.js", () => ({
-  buildMemoryRecall: async () => ({
-    enabled: false,
-    degraded: false,
-    injectedText: "",
-
-    semanticHits: 0,
-    injectedTokens: 0,
-    latencyMs: 0,
-  }),
-  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
-}));
-
 mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
     estimateInputTokens() {

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

@@ -16,12 +16,14 @@ import {
   isValidBase64,
   linkAttachmentToMessage,
   MAX_UPLOAD_BYTES,
+  resolveAttachmentsForPersist,
   uploadAttachment,
   validateAttachmentUpload,
 } from "../persistence/attachments-store.js";
 import {
   addMessage,
   createConversation,
+  deleteMessageById,
 } from "../persistence/conversation-crud.js";
 import { getConversationDirPath } from "../persistence/conversation-disk-view.js";
 import { getDb } from "../persistence/db-connection.js";
@@ -675,6 +677,115 @@ describe("deleteOrphanAttachments", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// resolveAttachmentsForPersist
+// ---------------------------------------------------------------------------
+
+describe("resolveAttachmentsForPersist", () => {
+  beforeEach(resetTables);
+
+  // One implementation behind every send path that turns ids into a persisted
+  // user message (HTTP send, processMessage, the voice bridge), so its shape is
+  // pinned here rather than at each caller.
+  test("hydrates ids into the shape a persisted message stores", async () => {
+    const stored = await uploadAttachment("photo.png", "image/png", "ZnJhbWU=");
+
+    expect(resolveAttachmentsForPersist([stored.id])).toEqual([
+      {
+        id: stored.id,
+        filename: "photo.png",
+        mimeType: "image/png",
+        data: "ZnJhbWU=",
+      },
+    ]);
+  });
+
+  test("carries the source path only for attachments that have one", async () => {
+    const withPath = await uploadAttachment(
+      "from-disk.txt",
+      "text/plain",
+      "AA==",
+    );
+    const plain = await uploadAttachment("typed.txt", "text/plain", "BB==");
+    rawRun(
+      "test:setSourcePath",
+      "UPDATE attachments SET source_path = ? WHERE id = ?",
+      "/tmp/from-disk.txt",
+      withPath.id,
+    );
+
+    const resolved = resolveAttachmentsForPersist([withPath.id, plain.id]);
+
+    expect(resolved[0]).toMatchObject({ filePath: "/tmp/from-disk.txt" });
+    expect(resolved[1]).not.toHaveProperty("filePath");
+  });
+
+  test("drops ids with no attachment row", async () => {
+    const stored = await uploadAttachment("kept.txt", "text/plain", "AA==");
+
+    const resolved = resolveAttachmentsForPersist([stored.id, "att-missing"]);
+
+    expect(resolved.map((a) => a.id)).toEqual([stored.id]);
+  });
+
+  test("returns nothing for an empty id list", () => {
+    expect(resolveAttachmentsForPersist([])).toEqual([]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// deleteMessageById orphan cleanup
+// ---------------------------------------------------------------------------
+
+describe("deleteMessageById attachment cleanup", () => {
+  beforeEach(resetTables);
+
+  test("collects an attachment the deleted message alone referenced", async () => {
+    const conv = createConversation();
+    const msg = await addMessage(conv.id, "user", "With attachment");
+    const stored = await uploadAttachment("shot.txt", "text/plain", "ZGF0YQ==");
+    linkAttachmentToMessage(msg.id, stored.id, 0);
+    const filePath = getFilePathForAttachment(stored.id);
+
+    deleteMessageById(msg.id);
+
+    expect(getAttachmentById(stored.id)).toBeNull();
+    expect(existsSync(filePath!)).toBe(false);
+  });
+
+  test("retained ids survive the delete, row and bytes", async () => {
+    // A caller rolling a message back rather than deleting it: the attachment
+    // returns to the uploaded-but-unlinked state every attachment sits in
+    // between upload and send, so a later message can still reference it.
+    const conv = createConversation();
+    const msg = await addMessage(conv.id, "user", "Rolled back");
+    const stored = await uploadAttachment("shot.txt", "text/plain", "ZGF0YQ==");
+    linkAttachmentToMessage(msg.id, stored.id, 0);
+    const filePath = getFilePathForAttachment(stored.id);
+
+    deleteMessageById(msg.id, { retainAttachmentIds: [stored.id] });
+
+    expect(getAttachmentById(stored.id)).not.toBeNull();
+    expect(existsSync(filePath!)).toBe(true);
+    // The row is gone even though its attachment stayed.
+    expect(getAttachmentsForMessage(msg.id)).toHaveLength(0);
+  });
+
+  test("retaining one id does not spare the others on the row", async () => {
+    const conv = createConversation();
+    const msg = await addMessage(conv.id, "user", "Two attachments");
+    const kept = await uploadAttachment("kept.txt", "text/plain", "AAAA");
+    const dropped = await uploadAttachment("dropped.txt", "text/plain", "BBBB");
+    linkAttachmentToMessage(msg.id, kept.id, 0);
+    linkAttachmentToMessage(msg.id, dropped.id, 1);
+
+    deleteMessageById(msg.id, { retainAttachmentIds: [kept.id] });
+
+    expect(getAttachmentById(kept.id)).not.toBeNull();
+    expect(getAttachmentById(dropped.id)).toBeNull();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // validateAttachmentUpload
 // ---------------------------------------------------------------------------
@@ -735,9 +846,9 @@ describe("validateAttachmentUpload", () => {
   test("accepts shell scripts as text attachments", () => {
     expect(validateAttachmentUpload("script.sh", "text/plain").ok).toBe(true);
     expect(validateAttachmentUpload("script.SH", "text/plain").ok).toBe(true);
-    expect(
-      validateAttachmentUpload("setup.sh", "application/x-sh").ok,
-    ).toBe(true);
+    expect(validateAttachmentUpload("setup.sh", "application/x-sh").ok).toBe(
+      true,
+    );
     expect(
       validateAttachmentUpload("run.sh", "application/x-shellscript").ok,
     ).toBe(true);
@@ -760,9 +871,9 @@ describe("validateAttachmentUpload", () => {
     expect(
       validateAttachmentUpload("PROGRAM.EXE", "application/octet-stream").ok,
     ).toBe(false);
-    expect(validateAttachmentUpload("INSTALL.DMG", "application/octet-stream").ok).toBe(
-      false,
-    );
+    expect(
+      validateAttachmentUpload("INSTALL.DMG", "application/octet-stream").ok,
+    ).toBe(false);
   });
 
   test("rejects unsupported MIME types", () => {