@vellumai/assistant 0.8.5 → 0.8.7

package/src/__tests__/parallel-tool.benchmark.test.ts

@@ -34,11 +34,13 @@ function createMockProvider(responses: ProviderResponse[]): {
     name: "mock",
     async sendMessage(
       messages: Message[],
-      tools?: ToolDefinition[],
-      systemPrompt?: string,
       options?: SendMessageOptions,
     ): Promise<ProviderResponse> {
-      calls.push({ messages: [...messages], tools, systemPrompt });
+      calls.push({
+        messages: [...messages],
+        tools: options?.tools,
+        systemPrompt: options?.systemPrompt,
+      });
       const response = responses[callIndex] ?? responses[responses.length - 1];
       callIndex++;
 
@@ -126,13 +128,10 @@ describe("Parallel tool execution benchmarks", () => {
       return { content: "ok", isError: false };
     };
 
-    const loop = new AgentLoop(
-      provider,
-      "system",
-      {},
-      dummyTools,
-      toolExecutor,
-    );
+    const loop = new AgentLoop(provider, "system", {
+      tools: dummyTools,
+      toolExecutor: toolExecutor,
+    });
     const start = Date.now();
     await loop.run([userMessage], () => {});
     const elapsed = Date.now() - start;
@@ -170,13 +169,10 @@ describe("Parallel tool execution benchmarks", () => {
       return { content: "ok", isError: false };
     };
 
-    const loop = new AgentLoop(
-      provider,
-      "system",
-      {},
-      dummyTools,
-      toolExecutor,
-    );
+    const loop = new AgentLoop(provider, "system", {
+      tools: dummyTools,
+      toolExecutor: toolExecutor,
+    });
     const start = Date.now();
     await loop.run([userMessage], () => {});
     const elapsed = Date.now() - start;
@@ -226,13 +222,10 @@ describe("Parallel tool execution benchmarks", () => {
       return { content: "ok", isError: false };
     };
 
-    const loop = new AgentLoop(
-      provider,
-      "system",
-      {},
-      dummyTools,
-      toolExecutor,
-    );
+    const loop = new AgentLoop(provider, "system", {
+      tools: dummyTools,
+      toolExecutor: toolExecutor,
+    });
     const events: AgentEvent[] = [];
     const start = Date.now();
     await loop.run([userMessage], collectEvents(events));
@@ -296,19 +289,14 @@ describe("Parallel tool execution benchmarks", () => {
         return { content: "should not return", isError: false };
       };
 
-      const loop = new AgentLoop(
-        provider,
-        "system",
-        {},
-        dummyTools,
-        toolExecutor,
-      );
+      const loop = new AgentLoop(provider, "system", {
+        tools: dummyTools,
+        toolExecutor: toolExecutor,
+      });
       const start = Date.now();
-      const history = await loop.run(
-        [userMessage],
-        () => {},
-        controller.signal,
-      );
+      const { history } = await loop.run([userMessage], () => {}, {
+        signal: controller.signal,
+      });
       const elapsed = Date.now() - start;
 
       // Should exit quickly after the 50ms abort, not wait 500ms

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

@@ -25,14 +25,14 @@ import {
   createConversation,
   getMessageById,
   getMessages,
+  reserveMessage,
+  updateMessageContent,
   updateMessageMetadata,
 } from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
-import {
-  defaultPersistencePlugin,
-  defaultPersistenceTerminal,
-} from "../plugins/defaults/persistence.js";
+import { defaultPersistencePlugin } from "../plugins/defaults/persistence/register.js";
+import { defaultPersistenceTerminal } from "../plugins/defaults/persistence/terminal.js";
 import { DEFAULT_TIMEOUTS, runPipeline } from "../plugins/pipeline.js";
 import {
   getMiddlewaresFor,
@@ -44,6 +44,7 @@ import type {
   PersistAddResult,
   PersistArgs,
   PersistDeleteResult,
+  PersistReserveResult,
   PersistResult,
   Plugin,
   TurnContext,
@@ -98,13 +99,10 @@ describe("persistence pipeline", () => {
     const conv = createConversation();
 
     // Baseline: what the direct call produces.
-    const direct = await addMessage(
-      conv.id,
-      "user",
-      "direct-content",
-      { role: "baseline" },
-      { skipIndexing: true },
-    );
+    const direct = await addMessage(conv.id, "user", "direct-content", {
+      metadata: { role: "baseline" },
+      skipIndexing: true,
+    });
     const directRow = getMessageById(direct.id, conv.id);
 
     // Through the pipeline: must produce a row with identical columns
@@ -143,13 +141,10 @@ describe("persistence pipeline", () => {
     registerPlugin(defaultPersistencePlugin);
 
     const conv = createConversation();
-    const msg = await addMessage(
-      conv.id,
-      "user",
-      "to-update",
-      { initial: true },
-      { skipIndexing: true },
-    );
+    const msg = await addMessage(conv.id, "user", "to-update", {
+      metadata: { initial: true },
+      skipIndexing: true,
+    });
 
     // Through the pipeline: result is the `update` envelope (no payload).
     const result = await runPipeline<PersistArgs, PersistResult>(
@@ -167,13 +162,10 @@ describe("persistence pipeline", () => {
     expect(result).toEqual({ op: "update" });
 
     // Direct equivalent call on a second message for parity comparison.
-    const baseline = await addMessage(
-      conv.id,
-      "user",
-      "to-update-direct",
-      { initial: true },
-      { skipIndexing: true },
-    );
+    const baseline = await addMessage(conv.id, "user", "to-update-direct", {
+      metadata: { initial: true },
+      skipIndexing: true,
+    });
     updateMessageMetadata(baseline.id, { extra: "added" });
 
     const pipelineRow = getMessageById(msg.id, conv.id);
@@ -193,7 +185,7 @@ describe("persistence pipeline", () => {
     registerPlugin(defaultPersistencePlugin);
 
     const conv = createConversation();
-    const msg = await addMessage(conv.id, "user", "to-delete", undefined, {
+    const msg = await addMessage(conv.id, "user", "to-delete", {
       skipIndexing: true,
     });
 
@@ -215,6 +207,80 @@ describe("persistence pipeline", () => {
     expect(getMessages(conv.id)).toHaveLength(0);
   });
 
+  test("default plugin: reserve op pre-allocates an empty assistant row", async () => {
+    registerPlugin(defaultPersistencePlugin);
+
+    const conv = createConversation();
+
+    const result = (await runPipeline<PersistArgs, PersistResult>(
+      "persistence",
+      getMiddlewaresFor("persistence"),
+      defaultPersistenceTerminal,
+      {
+        op: "reserve",
+        conversationId: conv.id,
+        role: "assistant",
+        metadata: { reservedFor: "anchor" },
+      },
+      makeCtx({ conversationId: conv.id }),
+      DEFAULT_TIMEOUTS.persistence,
+    )) as PersistReserveResult;
+
+    expect(result.op).toBe("reserve");
+    expect(result.message.id).toBeTruthy();
+    expect(result.message.role).toBe("assistant");
+    // Reserve places an empty JSON array so consumers that parse content
+    // observe a no-content payload.
+    expect(result.message.content).toBe("[]");
+
+    // Row must exist with the expected shape and live in the conversation.
+    const row = getMessageById(result.message.id, conv.id);
+    expect(row).not.toBeNull();
+    expect(row?.content).toBe("[]");
+    expect(JSON.parse(row!.metadata!)).toEqual({ reservedFor: "anchor" });
+    expect(getMessages(conv.id).map((m) => m.id)).toContain(result.message.id);
+  });
+
+  test("default plugin: updateContent op overwrites an existing row's content", async () => {
+    registerPlugin(defaultPersistencePlugin);
+
+    const conv = createConversation();
+
+    // Reserve first, then overwrite — exactly the B3 sequence consumers will
+    // follow.
+    const reserved = await reserveMessage(conv.id, "assistant");
+    expect(getMessageById(reserved.id, conv.id)?.content).toBe("[]");
+
+    const result = await runPipeline<PersistArgs, PersistResult>(
+      "persistence",
+      getMiddlewaresFor("persistence"),
+      defaultPersistenceTerminal,
+      {
+        op: "updateContent",
+        messageId: reserved.id,
+        content: JSON.stringify([{ type: "text", text: "Hello" }]),
+      },
+      makeCtx({ conversationId: conv.id }),
+      DEFAULT_TIMEOUTS.persistence,
+    );
+    expect(result).toEqual({ op: "updateContent" });
+
+    // Content updated in place; row id unchanged.
+    const row = getMessageById(reserved.id, conv.id);
+    expect(row).not.toBeNull();
+    expect(JSON.parse(row!.content)).toEqual([{ type: "text", text: "Hello" }]);
+
+    // Direct-call parity: a fresh reserve + direct updateMessageContent
+    // should land the same content shape.
+    const baselineReserved = await reserveMessage(conv.id, "assistant");
+    updateMessageContent(
+      baselineReserved.id,
+      JSON.stringify([{ type: "text", text: "Hello" }]),
+    );
+    const baselineRow = getMessageById(baselineReserved.id, conv.id);
+    expect(baselineRow?.content).toBe(row?.content);
+  });
+
   test("custom plugin: short-circuits every op onto a mock in-memory store", async () => {
     type Stored = {
       id: string;
@@ -249,6 +315,33 @@ describe("persistence pipeline", () => {
               },
             };
           }
+          case "reserve": {
+            const id = `mock-${nextId++}`;
+            mockStore.set(id, {
+              id,
+              conversationId: args.conversationId,
+              role: args.role,
+              content: "[]",
+              metadata: { ...(args.metadata ?? {}) },
+            });
+            return {
+              op: "reserve",
+              message: {
+                id,
+                conversationId: args.conversationId,
+                role: args.role,
+                content: "[]",
+                createdAt: 123,
+              },
+            };
+          }
+          case "updateContent": {
+            const existing = mockStore.get(args.messageId);
+            if (existing) {
+              existing.content = args.content;
+            }
+            return { op: "updateContent" };
+          }
           case "update": {
             const existing = mockStore.get(args.messageId);
             if (existing) {
@@ -298,6 +391,40 @@ describe("persistence pipeline", () => {
     expect(addResult.message.id).toBe("mock-1");
     expect(mockStore.size).toBe(1);
 
+    const reserveResult = (await runPipeline<PersistArgs, PersistResult>(
+      "persistence",
+      getMiddlewaresFor("persistence"),
+      defaultPersistenceTerminal,
+      {
+        op: "reserve",
+        conversationId: conv.id,
+        role: "assistant",
+        metadata: { reservedFor: "mock-anchor" },
+      },
+      makeCtx({ conversationId: conv.id }),
+      DEFAULT_TIMEOUTS.persistence,
+    )) as PersistReserveResult;
+    expect(reserveResult.op).toBe("reserve");
+    expect(reserveResult.message.id).toBe("mock-2");
+    expect(reserveResult.message.content).toBe("[]");
+    expect(mockStore.get("mock-2")?.content).toBe("[]");
+
+    await runPipeline<PersistArgs, PersistResult>(
+      "persistence",
+      getMiddlewaresFor("persistence"),
+      defaultPersistenceTerminal,
+      {
+        op: "updateContent",
+        messageId: "mock-2",
+        content: '[{"type":"text","text":"finalized"}]',
+      },
+      makeCtx({ conversationId: conv.id }),
+      DEFAULT_TIMEOUTS.persistence,
+    );
+    expect(mockStore.get("mock-2")?.content).toBe(
+      '[{"type":"text","text":"finalized"}]',
+    );
+
     await runPipeline<PersistArgs, PersistResult>(
       "persistence",
       getMiddlewaresFor("persistence"),
@@ -326,7 +453,7 @@ describe("persistence pipeline", () => {
     expect(delResult.op).toBe("delete");
     expect(mockStore.has("mock-1")).toBe(false);
 
-    // The real DB must not have been touched by any of the three ops.
+    // The real DB must not have been touched by any of the ops.
     expect(getMessages(conv.id)).toHaveLength(dbRowsBefore);
   });
 

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

@@ -40,6 +40,7 @@ mock.module("../config/loader.js", () => ({
 }));
 
 interface AddMessageCall {
+  id: string;
   conversationId: string;
   role: string;
   content: string;
@@ -51,15 +52,44 @@ mock.module("../memory/conversation-crud.js", () => ({
     conversationId: string,
     role: string,
     content: string,
-    metadata?: Record<string, unknown>,
+    options?: { metadata?: Record<string, unknown> },
   ) => {
-    addMessageCalls.push({ conversationId, role, content, metadata });
-    return { id: `mock-msg-${addMessageCalls.length}` };
+    const metadata = options?.metadata;
+    const id = `mock-msg-${addMessageCalls.length + 1}`;
+    addMessageCalls.push({ id, conversationId, role, content, metadata });
+    return { id };
   },
   getConversation: () => null,
   getMessageById: () => null,
-  updateMessageContent: () => {},
+  updateMessageContent: (messageId: string, content: string) => {
+    // Mirror updateContent into the same capture array so existing
+    // `lastPersisted("assistant")` assertions continue to find the row that
+    // was reserved at `llm_call_started` time.
+    const call = addMessageCalls.find((c) => c.id === messageId);
+    if (call) call.content = content;
+  },
   provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(
+    async (
+      conversationId: string,
+      role: string,
+      metadata?: Record<string, unknown>,
+    ) => {
+      // B3: production code creates the assistant row at `llm_call_started`
+      // via `reserveMessage`, stamping channel metadata at reserve time.
+      // Mirror that into the addMessage capture array so existing
+      // `lastPersisted("assistant")` assertions keep working.
+      const id = `mock-msg-${addMessageCalls.length + 1}-reserve`;
+      addMessageCalls.push({
+        id,
+        conversationId,
+        role,
+        content: "",
+        metadata,
+      });
+      return { id };
+    },
+  ),
 }));
 
 mock.module("../memory/llm-request-log-store.js", () => ({
@@ -84,6 +114,7 @@ import type {
 } from "../daemon/conversation-agent-loop-handlers.js";
 import {
   createEventHandlerState,
+  handleLlmCallStarted,
   handleMessageComplete,
 } from "../daemon/conversation-agent-loop-handlers.js";
 
@@ -164,7 +195,12 @@ describe("persistence-layer secret redaction", () => {
       isError: false,
     });
 
-    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent("done"));
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent("done"),
+    );
 
     const persisted = lastPersisted("user");
     const blocks = JSON.parse(persisted.content) as Array<{
@@ -183,7 +219,12 @@ describe("persistence-layer secret redaction", () => {
       isError: false,
     });
 
-    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent("done"));
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent("done"),
+    );
 
     const persisted = lastPersisted("user");
     const blocks = JSON.parse(persisted.content) as Array<{
@@ -195,13 +236,19 @@ describe("persistence-layer secret redaction", () => {
   });
 
   test("does not redact non-secret content (UUID, hex hash) in tool result", async () => {
-    const safe = "id=550e8400-e29b-41d4-a716-446655440000 sha=a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2";
+    const safe =
+      "id=550e8400-e29b-41d4-a716-446655440000 sha=a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2";
     state.pendingToolResults.set("tool-use-3", {
       content: safe,
       isError: false,
     });
 
-    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent("done"));
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent("done"),
+    );
 
     const persisted = lastPersisted("user");
     const blocks = JSON.parse(persisted.content) as Array<{
@@ -224,7 +271,12 @@ describe("persistence-layer secret redaction", () => {
     // Capture the content before handleMessageComplete clears pendingToolResults
     const contentSnapshot = state.pendingToolResults.get("tool-use-4")!.content;
 
-    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent("done"));
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent("done"),
+    );
 
     // The snapshot taken from live state before the call must be unmodified
     expect(contentSnapshot).toBe(originalContent);
@@ -239,7 +291,12 @@ describe("persistence-layer secret redaction", () => {
       "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
     const text = `Your API key is \`${secret}\`. Keep it safe.`;
 
-    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent(text));
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent(text),
+    );
 
     const persisted = lastPersisted("assistant");
     const blocks = JSON.parse(persisted.content) as Array<{
@@ -256,7 +313,12 @@ describe("persistence-layer secret redaction", () => {
     const secret = "sk-proj-ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrst";
     const text = `I found this key in the config: ${secret}`;
 
-    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent(text));
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent(text),
+    );
 
     const persisted = lastPersisted("assistant");
     const blocks = JSON.parse(persisted.content) as Array<{
@@ -271,7 +333,12 @@ describe("persistence-layer secret redaction", () => {
   test("does not redact non-secret text in assistant message", async () => {
     const safe = "Here is the file list: index.ts, util.ts, main.ts";
 
-    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent(safe));
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent(safe),
+    );
 
     const persisted = lastPersisted("assistant");
     const blocks = JSON.parse(persisted.content) as Array<{
@@ -286,7 +353,12 @@ describe("persistence-layer secret redaction", () => {
     // High-entropy but no known credential prefix — should NOT be redacted
     const text = "checksum: 8f14e45fceea167a5a36dedd4bea2543";
 
-    await handleMessageComplete(state, makeDeps(), makeMessageCompleteEvent(text));
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent(text),
+    );
 
     const persisted = lastPersisted("assistant");
     const blocks = JSON.parse(persisted.content) as Array<{

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

@@ -235,12 +235,12 @@ describe("runPipeline — timeout", () => {
       value: args.value,
     });
     const result = await runPipeline(
-      "historyRepair",
+      "tokenEstimate",
       [],
       terminal,
       { value: 42 },
       makeCtx(),
-      DEFAULT_TIMEOUTS.historyRepair,
+      DEFAULT_TIMEOUTS.tokenEstimate,
     );
     expect(result).toEqual({ value: 42 });
   });
@@ -550,7 +550,6 @@ describe("DEFAULT_TIMEOUTS", () => {
       llmCall: null,
       toolExecute: null,
       memoryRetrieval: null,
-      historyRepair: null,
       tokenEstimate: null,
       compaction: null,
       overflowReduce: null,