@vellumai/assistant 0.8.6 → 0.8.7

package/src/__tests__/injector-background-turn.test.ts

@@ -23,7 +23,7 @@ mock.module("../config/loader.js", () => ({
 import {
   DEFAULT_INJECTOR_ORDER,
   defaultInjectorsPlugin,
-} from "../plugins/defaults/injectors.js";
+} from "../plugins/defaults/injectors/register.js";
 import {
   registerPlugin,
   resetPluginRegistryForTests,

package/src/__tests__/injector-chain.test.ts

@@ -45,7 +45,7 @@ mock.module("../config/loader.js", () => ({
 const { applyRuntimeInjections, composeInjectorChain } =
   await import("../daemon/conversation-runtime-assembly.js");
 const { DEFAULT_INJECTOR_ORDER, defaultInjectorsPlugin } =
-  await import("../plugins/defaults/injectors.js");
+  await import("../plugins/defaults/injectors/register.js");
 import {
   getInjectors,
   registerPlugin,

package/src/__tests__/injector-disk-pressure.test.ts

@@ -8,7 +8,7 @@ import {
   DEFAULT_INJECTOR_ORDER,
   defaultInjectorsPlugin,
   DISK_PRESSURE_WARNING_PROMPT,
-} from "../plugins/defaults/injectors.js";
+} from "../plugins/defaults/injectors/register.js";
 import {
   registerPlugin,
   resetPluginRegistryForTests,

package/src/__tests__/injector-document-comments.test.ts

@@ -9,7 +9,7 @@ mock.module("../documents/document-comments-store.js", () => ({
 }));
 
 const { DEFAULT_INJECTOR_ORDER, defaultInjectorsPlugin } =
-  await import("../plugins/defaults/injectors.js");
+  await import("../plugins/defaults/injectors/register.js");
 import type { Injector, TurnContext } from "../plugins/types.js";
 
 function findInjector(name: string): Injector {

package/src/__tests__/injector-pkb-v2-silenced.test.ts

@@ -30,7 +30,7 @@ mock.module("../memory/pkb/pkb-search.js", () => ({
 const { applyRuntimeInjections } =
   await import("../daemon/conversation-runtime-assembly.js");
 const { defaultInjectorsPlugin } =
-  await import("../plugins/defaults/injectors.js");
+  await import("../plugins/defaults/injectors/register.js");
 const { registerPlugin, resetPluginRegistryForTests } =
   await import("../plugins/registry.js");
 import type { TurnContext } from "../plugins/types.js";

package/src/__tests__/injector-v3-suppression.test.ts

@@ -0,0 +1,220 @@
+/**
+ * Tests for the memory-v3-live v2-suppression branch in
+ * `applyRuntimeInjections` (PR L6 of the memory-v3-live plan).
+ *
+ * When `suppressV2MemoryForV3` is on AND the v3 injector (id `memory-v3`,
+ * placement `after-memory-prefix`) actually produces a block, runtime
+ * assembly strips the v2 `<memory>` prefix from EVERY user message before
+ * splicing the v3 block — so v3 becomes the sole `<memory>` source and history
+ * is byte-stable for prompt caching.
+ *
+ * Keyed off whether v3 produced a block, NOT off the option alone: a v3
+ * failure (`produce()` → null) leaves v2's block intact (fallback-to-v2).
+ *
+ * The flag-off path must be byte-for-byte identical to today — that is the
+ * load-bearing regression guard.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getInjectors,
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import type {
+  InjectionBlock,
+  Injector,
+  Plugin,
+  TurnContext,
+} from "../plugins/types.js";
+import type { Message } from "../providers/types.js";
+
+const { applyRuntimeInjections } =
+  await import("../daemon/conversation-runtime-assembly.js");
+
+function makeTurnContext(): TurnContext {
+  return {
+    requestId: "req-test-1",
+    conversationId: "conv-test-1",
+    turnIndex: 0,
+    trust: { sourceChannel: "vellum", trustClass: "guardian" },
+  };
+}
+
+function wrapInPlugin(name: string, injectors: Injector[]): Plugin {
+  return { manifest: { name, version: "0.0.1" }, injectors };
+}
+
+/**
+ * A fake v3 injector that mirrors the real one's id + placement. The real
+ * injector's `renderMemoryBlock` already wraps its content in
+ * `<memory>\n…\n</memory>`, so the fake does too — `inner === null` means the
+ * injector produced nothing this turn (error/empty selection).
+ */
+function v3Injector(inner: string | null): Injector {
+  return {
+    name: "memory-v3-shadow",
+    order: 1000,
+    async produce(): Promise<InjectionBlock | null> {
+      if (inner === null) return null;
+      return {
+        id: "memory-v3",
+        text: `<memory>\n${inner}\n</memory>`,
+        placement: "after-memory-prefix",
+      };
+    },
+  };
+}
+
+/** Build a user message whose tail carries a v2 `<memory>` prefix block. */
+function userMsgWithV2Memory(memoryText: string, userText: string): Message {
+  return {
+    role: "user",
+    content: [
+      { type: "text", text: `<memory>\n${memoryText}\n</memory>` },
+      { type: "text", text: userText },
+    ],
+  };
+}
+
+/** Extract the tail user message's text blocks. */
+function tailTexts(messages: Message[]): string[] {
+  const tail = messages[messages.length - 1];
+  return tail.content
+    .filter((b): b is { type: "text"; text: string } => b.type === "text")
+    .map((b) => b.text);
+}
+
+describe("memory-v3-live v2 suppression", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+  });
+
+  test("flag ON + v3 produced a block → v2 stripped from all turns, exactly one <memory> (the v3 block)", async () => {
+    registerPlugin(wrapInPlugin("v3", [v3Injector("v3 working set")]));
+
+    // History: a prior user turn that still carries a v2 block (rehydrated),
+    // plus the current tail user turn with its own v2 block.
+    const runMessages: Message[] = [
+      userMsgWithV2Memory("old recalled fact", "earlier question"),
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "earlier answer" }],
+      },
+      userMsgWithV2Memory("fresh recalled fact", "current question"),
+    ];
+
+    const result = await applyRuntimeInjections(runMessages, {
+      turnContext: makeTurnContext(),
+      suppressV2MemoryForV3: true,
+    });
+
+    // Exactly one <memory> source across the WHOLE assembled context.
+    const allTexts = result.messages.flatMap((m) =>
+      m.content
+        .filter((b): b is { type: "text"; text: string } => b.type === "text")
+        .map((b) => b.text),
+    );
+    const memoryBlocks = allTexts.filter((t) => t.startsWith("<memory>"));
+    expect(memoryBlocks).toHaveLength(1);
+    // And it is the v3 block, not a v2 one.
+    expect(memoryBlocks[0]).toBe("<memory>\nv3 working set\n</memory>");
+
+    // The historical user turn no longer carries its v2 block (all-turns strip).
+    const firstUser = result.messages[0];
+    expect(
+      firstUser.content.every(
+        (b) => !(b.type === "text" && b.text.startsWith("<memory>")),
+      ),
+    ).toBe(true);
+
+    // The v3 block lands at the head of the tail user message; original user
+    // text is preserved right after it.
+    const texts = tailTexts(result.messages);
+    expect(texts[0]).toBe("<memory>\nv3 working set\n</memory>");
+    expect(texts[1]).toBe("current question");
+    expect(texts).toHaveLength(2);
+  });
+
+  test("flag ON but v3 produced NOTHING → v2 block left intact (fallback-to-v2)", async () => {
+    registerPlugin(wrapInPlugin("v3", [v3Injector(null)]));
+
+    const runMessages: Message[] = [
+      userMsgWithV2Memory("fresh recalled fact", "current question"),
+    ];
+
+    const result = await applyRuntimeInjections(runMessages, {
+      turnContext: makeTurnContext(),
+      suppressV2MemoryForV3: true,
+    });
+
+    // v2's block survives — the turn still ships memory.
+    const texts = tailTexts(result.messages);
+    expect(texts[0]).toBe("<memory>\nfresh recalled fact\n</memory>");
+    expect(texts[1]).toBe("current question");
+    // No v3 block was added.
+    expect(texts).toHaveLength(2);
+  });
+
+  test("flag OFF → byte-for-byte identical to today even when v3 would have produced a block", async () => {
+    registerPlugin(wrapInPlugin("v3", [v3Injector("v3 working set")]));
+
+    const runMessages: Message[] = [
+      userMsgWithV2Memory("old recalled fact", "earlier question"),
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "earlier answer" }],
+      },
+      userMsgWithV2Memory("fresh recalled fact", "current question"),
+    ];
+
+    // With suppression off, the v3 injector still runs through the chain
+    // (after-memory-prefix), but NO v2 stripping happens. This captures the
+    // exact pre-flag assembly behavior: v2 prefix stays, v3 splices after it.
+    const offResult = await applyRuntimeInjections(runMessages, {
+      turnContext: makeTurnContext(),
+      suppressV2MemoryForV3: false,
+    });
+
+    // The tail keeps v2's block AND gains v3's (the historical double-injection
+    // the suppression PR exists to prevent) — proving suppression is the ONLY
+    // behavior change and it is fully gated off here.
+    const texts = tailTexts(offResult.messages);
+    expect(texts[0]).toBe("<memory>\nfresh recalled fact\n</memory>");
+    expect(texts[1]).toBe("<memory>\nv3 working set\n</memory>");
+    expect(texts[2]).toBe("current question");
+
+    // Historical user turn keeps its v2 block (no all-turns strip when off).
+    const firstUserTexts = offResult.messages[0].content
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text);
+    expect(firstUserTexts[0]).toBe("<memory>\nold recalled fact\n</memory>");
+
+    // Strongest guard: omitting the option entirely yields the SAME result as
+    // passing it false — the default path is untouched by this PR.
+    resetPluginRegistryForTests();
+    registerPlugin(wrapInPlugin("v3", [v3Injector("v3 working set")]));
+    const defaultResult = await applyRuntimeInjections(runMessages, {
+      turnContext: makeTurnContext(),
+    });
+    expect(defaultResult.messages).toEqual(offResult.messages);
+  });
+
+  test("no v3 injector registered + flag ON → no stripping, messages untouched", async () => {
+    // No injector named memory-v3 at all (e.g. plugin not loaded): the
+    // suppression branch keys off the produced block, so nothing is stripped.
+    expect(getInjectors()).toHaveLength(0);
+
+    const runMessages: Message[] = [
+      userMsgWithV2Memory("fresh recalled fact", "current question"),
+    ];
+
+    const result = await applyRuntimeInjections(runMessages, {
+      turnContext: makeTurnContext(),
+      suppressV2MemoryForV3: true,
+    });
+
+    expect(result.messages).toEqual(runMessages);
+  });
+});

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

@@ -179,11 +179,10 @@ describe("handleListMessages no_response filtering", () => {
 
     const response = handleListMessages(createTestArgs(conv.id));
     const body = response as {
-      messages: { content: string; textSegments: string[] }[];
+      messages: { textSegments?: string[] }[];
     };
 
     expect(body.messages).toHaveLength(1);
-    expect(body.messages[0].content).toBe("");
     // textSegments is omitted from payload when empty
     expect(body.messages[0].textSegments).toBeUndefined();
   });
@@ -201,11 +200,10 @@ describe("handleListMessages no_response filtering", () => {
 
     const response = handleListMessages(createTestArgs(conv.id));
     const body = response as {
-      messages: { content: string; textSegments: string[] }[];
+      messages: { textSegments?: string[] }[];
     };
 
     expect(body.messages).toHaveLength(1);
-    expect(body.messages[0].content).toBe("Real reply.");
     expect(body.messages[0].textSegments).toEqual(["Real reply."]);
   });
 
@@ -231,7 +229,6 @@ describe("handleListMessages no_response filtering", () => {
     const response = handleListMessages(createTestArgs(conv.id));
     const body = response as {
       messages: {
-        content: string;
         textSegments: string[];
         contentOrder: string[];
       }[];
@@ -254,11 +251,13 @@ describe("handleListMessages no_response filtering", () => {
 
     const response = handleListMessages(createTestArgs(conv.id));
     const body = response as {
-      messages: { content: string }[];
+      messages: { textSegments?: string[] }[];
     };
 
     expect(body.messages).toHaveLength(1);
-    expect(body.messages[0].content).toBe("What does <no_response/> do?");
+    expect(body.messages[0].textSegments).toEqual([
+      "What does <no_response/> do?",
+    ]);
   });
 });
 
@@ -267,7 +266,7 @@ describe("handleListMessages no_response filtering", () => {
 // ---------------------------------------------------------------------------
 
 interface PaginatedResponse {
-  messages: { id: string; content: string; timestamp: string }[];
+  messages: { id: string; timestamp: string }[];
   hasMore?: boolean;
   oldestTimestamp?: number;
   oldestMessageId?: string;

package/src/__tests__/list-messages-hidden-metadata.test.ts

@@ -48,7 +48,12 @@ function resetTables() {
 
 interface MessagePayload {
   role: string;
-  content: string;
+  textSegments?: string[];
+}
+
+/** Flatten a payload's text segments to plain text for content assertions. */
+function plainText(message: MessagePayload): string {
+  return (message.textSegments ?? []).join("");
 }
 
 describe("handleListMessages metadata.hidden filtering", () => {
@@ -65,7 +70,7 @@ describe("handleListMessages metadata.hidden filtering", () => {
       conv.id,
       "assistant",
       JSON.stringify([{ type: "text", text: "internal scaffolding" }]),
-      { hidden: true },
+      { metadata: { hidden: true } },
     );
     await addMessage(
       conv.id,
@@ -79,10 +84,10 @@ describe("handleListMessages metadata.hidden filtering", () => {
     const body = response as { messages: MessagePayload[] };
 
     expect(body.messages).toHaveLength(2);
-    expect(body.messages[0].content).toBe("first visible");
-    expect(body.messages[1].content).toBe("second visible");
+    expect(plainText(body.messages[0])).toBe("first visible");
+    expect(plainText(body.messages[1])).toBe("second visible");
     expect(
-      body.messages.some((m) => m.content.includes("internal scaffolding")),
+      body.messages.some((m) => plainText(m).includes("internal scaffolding")),
     ).toBe(false);
 
     // LLM-side loader must include the hidden row so agent context is intact.
@@ -102,7 +107,7 @@ describe("handleListMessages metadata.hidden filtering", () => {
       conv.id,
       "assistant",
       JSON.stringify([{ type: "text", text: "hidden false" }]),
-      { hidden: false },
+      { metadata: { hidden: false } },
     );
 
     const response = handleListMessages({
@@ -131,7 +136,7 @@ describe("handleListMessages metadata.hidden filtering", () => {
         conv.id,
         "assistant",
         JSON.stringify([{ type: "text", text: `hidden ${i}` }]),
-        { hidden: true },
+        { metadata: { hidden: true } },
       );
     }
     for (let i = 0; i < 2; i++) {
@@ -151,7 +156,7 @@ describe("handleListMessages metadata.hidden filtering", () => {
       oldestMessageId: string | null;
     };
 
-    expect(latest.messages.map((m) => m.content)).toEqual([
+    expect(latest.messages.map(plainText)).toEqual([
       "new visible 0",
       "new visible 1",
     ]);
@@ -172,7 +177,7 @@ describe("handleListMessages metadata.hidden filtering", () => {
       hasMore: boolean;
     };
 
-    expect(older.messages.map((m) => m.content)).toEqual([
+    expect(older.messages.map(plainText)).toEqual([
       "old visible 2",
       "old visible 3",
     ]);
@@ -247,10 +252,7 @@ describe("handleListMessages metadata.hidden filtering", () => {
         },
       }) as { messages: MessagePayload[]; hasMore: boolean };
 
-      expect(older.messages.map((m) => m.content)).toEqual([
-        "visible 0",
-        "visible 1",
-      ]);
+      expect(older.messages.map(plainText)).toEqual(["visible 0", "visible 1"]);
       expect(older.hasMore).toBe(false);
     } finally {
       _setPaginationScanCapForTesting(undefined);
@@ -275,7 +277,7 @@ describe("handleListMessages metadata.hidden filtering", () => {
         conv.id,
         "assistant",
         JSON.stringify([{ type: "text", text: `hidden ${i}` }]),
-        { hidden: true },
+        { metadata: { hidden: true } },
       );
     }
 
@@ -287,7 +289,7 @@ describe("handleListMessages metadata.hidden filtering", () => {
       oldestTimestamp: number | null;
     };
 
-    expect(latest.messages.map((m) => m.content)).toEqual([
+    expect(latest.messages.map(plainText)).toEqual([
       "old visible 0",
       "old visible 1",
     ]);

package/src/__tests__/list-messages-page-latest.test.ts

@@ -90,7 +90,6 @@ function seedMessages(
 interface MessagePayload {
   id: string;
   role: string;
-  content: string;
   timestamp: string;
   slackMessage?: {
     channelId: string;

package/src/__tests__/list-messages-tool-merge.test.ts

@@ -52,8 +52,9 @@ interface ToolCallPayload {
 }
 
 interface MessagePayload {
+  id: string;
+  mergedMessageIds?: string[];
   role: string;
-  content: string;
   toolCalls?: ToolCallPayload[];
   textSegments?: string[];
 }
@@ -172,7 +173,36 @@ describe("handleListMessages tool_result merging", () => {
 
     expect(body.messages).toHaveLength(3);
     expect(body.messages[2].role).toBe("user");
-    expect(body.messages[2].content).toBe("how are you?");
+    expect(body.messages[2].textSegments).toEqual(["how are you?"]);
+  });
+
+  test("includes merged assistant ids for consecutive assistant history rows", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "start" }]),
+    );
+    const anchor = await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "Checking." }]),
+    );
+    const tail = await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "Done." }]),
+    );
+
+    const response = handleListMessages(createTestArgs(conv.id));
+    const body = response as { messages: MessagePayload[] };
+
+    expect(body.messages).toHaveLength(2);
+    expect(body.messages[1]).toMatchObject({
+      id: anchor.id,
+      role: "assistant",
+      mergedMessageIds: [tail.id],
+    });
   });
 
   test("orphan tool_result at pagination boundary is suppressed entirely", async () => {
@@ -205,7 +235,7 @@ describe("handleListMessages tool_result merging", () => {
     // User row dropped entirely; only the assistant survives.
     expect(body.messages).toHaveLength(1);
     expect(body.messages[0].role).toBe("assistant");
-    expect(body.messages[0].content).toBe("response");
+    expect(body.messages[0].textSegments).toEqual(["response"]);
   });
 
   test("mixed content at pagination boundary keeps real user text", async () => {
@@ -236,10 +266,10 @@ describe("handleListMessages tool_result merging", () => {
 
     expect(body.messages).toHaveLength(2);
     expect(body.messages[0].role).toBe("user");
-    expect(body.messages[0].content).toBe("what about this?");
+    expect(body.messages[0].textSegments).toEqual(["what about this?"]);
     expect(body.messages[0].toolCalls).toBeUndefined();
     expect(body.messages[1].role).toBe("assistant");
-    expect(body.messages[1].content).toBe("answering");
+    expect(body.messages[1].textSegments).toEqual(["answering"]);
   });
 
   test("orphan tool_result + system_notice at boundary is suppressed", async () => {
@@ -337,7 +367,7 @@ describe("handleListMessages tool_result merging", () => {
     expect(body.messages[1].toolCalls![1].name).toBe("file_read");
     expect(body.messages[1].toolCalls![1].result).toBe("file data");
     expect(body.messages[2].role).toBe("user");
-    expect(body.messages[2].content).toBe("thanks");
+    expect(body.messages[2].textSegments).toEqual(["thanks"]);
   });
 
   test("tool_result with is_error propagates error status", async () => {

package/src/__tests__/llm-call-pipeline.test.ts

@@ -14,7 +14,7 @@
 import { afterAll, beforeEach, describe, expect, test } from "bun:test";
 
 import type { TrustContext } from "../daemon/trust-context.js";
-import { defaultLlmCallPlugin } from "../plugins/defaults/llm-call.js";
+import { defaultLlmCallPlugin } from "../plugins/defaults/llm-call/register.js";
 import { DEFAULT_TIMEOUTS, runPipeline } from "../plugins/pipeline.js";
 import {
   getMiddlewaresFor,
@@ -32,6 +32,7 @@ import type {
   Message,
   Provider,
   ProviderResponse,
+  SendMessageOptions,
   ToolDefinition,
 } from "../providers/types.js";
 
@@ -80,8 +81,12 @@ function makeFakeProvider(
   return {
     name: "fake-provider",
     calls,
-    async sendMessage(messages, tools, systemPrompt, _options) {
-      calls.push({ messages, tools, systemPrompt });
+    async sendMessage(messages: Message[], options?: SendMessageOptions) {
+      calls.push({
+        messages,
+        tools: options?.tools,
+        systemPrompt: options?.systemPrompt,
+      });
       return response;
     },
   };
@@ -94,9 +99,7 @@ function makeArgs(
   return {
     provider,
     messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
-    tools: undefined,
-    systemPrompt: "you are a helpful assistant",
-    options: { config: {} },
+    options: { systemPrompt: "you are a helpful assistant", config: {} },
     ...overrides,
   };
 }
@@ -106,12 +109,7 @@ function makeArgs(
 // transformation. Keeping it identical here means the test exercises the
 // exact call shape the real loop uses.
 const terminal = (args: LLMCallArgs): Promise<LLMCallResult> =>
-  args.provider.sendMessage(
-    args.messages,
-    args.tools,
-    args.systemPrompt,
-    args.options,
-  );
+  args.provider.sendMessage(args.messages, args.options);
 
 // ─── Tests ──────────────────────────────────────────────────────────────────
 
@@ -177,7 +175,13 @@ describe("llmCall pipeline", () => {
         input_schema: { type: "object" },
       },
     ];
-    const args = makeArgs(provider, { tools });
+    const args = makeArgs(provider, {
+      options: {
+        tools,
+        systemPrompt: "you are a helpful assistant",
+        config: {},
+      },
+    });
 
     await runPipeline<LLMCallArgs, LLMCallResult>(
       "llmCall",
@@ -191,8 +195,10 @@ describe("llmCall pipeline", () => {
     expect(observed).toHaveLength(1);
     expect(observed[0]!.provider).toBe(provider);
     expect(observed[0]!.messages).toBe(args.messages);
-    expect(observed[0]!.tools).toBe(tools);
-    expect(observed[0]!.systemPrompt).toBe("you are a helpful assistant");
+    expect(observed[0]!.options?.tools).toBe(tools);
+    expect(observed[0]!.options?.systemPrompt).toBe(
+      "you are a helpful assistant",
+    );
     expect(provider.calls).toHaveLength(1);
   });