@vellumai/assistant 0.8.5 → 0.8.6

package/src/__tests__/openai-responses-provider.test.ts

@@ -47,7 +47,7 @@ mock.module("openai", () => ({
       lastConstructorOptions = opts;
     }
     responses = {
-      stream: (
+      create: async (
         params: Record<string, unknown>,
         options?: Record<string, unknown>,
       ) => {
@@ -165,6 +165,26 @@ function completedEvent(
   };
 }
 
+function incompleteEvent(
+  reason: "max_output_tokens" | "content_filter",
+  inputTokens: number,
+  outputTokens: number,
+): FakeStreamEvent {
+  return {
+    type: "response.incomplete",
+    response: {
+      model: "gpt-5.2",
+      status: "incomplete",
+      incomplete_details: { reason },
+      output: [],
+      usage: {
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+      },
+    },
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -243,6 +263,21 @@ describe("OpenAIResponsesProvider", () => {
     expect(result.stopReason).toBe("stop");
   });
 
+  test("maps response.incomplete max output details to stopReason", async () => {
+    fakeStreamEvents = [
+      textDeltaEvent("Partial"),
+      incompleteEvent("max_output_tokens", 12, 8),
+    ];
+
+    const result = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "Hi" }] },
+    ]);
+
+    expect(result.content).toEqual([{ type: "text", text: "Partial" }]);
+    expect(result.usage).toEqual({ inputTokens: 12, outputTokens: 8 });
+    expect(result.stopReason).toBe("max_output_tokens");
+  });
+
   // -----------------------------------------------------------------------
   // Streaming events
   // -----------------------------------------------------------------------
@@ -1120,7 +1155,7 @@ describe("OpenAIResponsesProvider", () => {
       "System prompt",
     );
 
-    // rawRequest should contain the params sent to responses.stream()
+    // rawRequest should contain the params sent to responses.create()
     const rawReq = result.rawRequest as Record<string, unknown>;
     expect(rawReq.model).toBe("gpt-5.2");
     expect(rawReq.instructions).toBe("System prompt");
@@ -1679,7 +1714,7 @@ describe("OpenAIResponsesProvider — Native Web Search", () => {
     expect(lastStreamParams!.max_output_tokens).toBeUndefined();
   });
 
-  test("codexSubscription: strips reasoning param even when effort is set", async () => {
+  test("codexSubscription: forwards reasoning param when effort is set", async () => {
     const codexProvider = new OpenAIResponsesProvider("sk-test", "gpt-5.4", {
       codexSubscription: true,
     });
@@ -1692,10 +1727,10 @@ describe("OpenAIResponsesProvider — Native Web Search", () => {
       { config: { effort: "high" } },
     );
 
-    expect(lastStreamParams!.reasoning).toBeUndefined();
+    expect(lastStreamParams!.reasoning).toEqual({ effort: "high" });
   });
 
-  test("codexSubscription: strips text.verbosity param", async () => {
+  test("codexSubscription: forwards text.verbosity param", async () => {
     const codexProvider = new OpenAIResponsesProvider("sk-test", "gpt-5.4", {
       codexSubscription: true,
     });
@@ -1708,7 +1743,7 @@ describe("OpenAIResponsesProvider — Native Web Search", () => {
       { config: { verbosity: "low" } },
     );
 
-    expect(lastStreamParams!.text).toBeUndefined();
+    expect(lastStreamParams!.text).toEqual({ verbosity: "low" });
   });
 
   test("codexSubscription: uses Codex baseURL", async () => {
@@ -1721,7 +1756,7 @@ describe("OpenAIResponsesProvider — Native Web Search", () => {
     );
   });
 
-  test("codexSubscription: strips tools param", async () => {
+  test("codexSubscription: forwards tools param", async () => {
     const codexProvider = new OpenAIResponsesProvider("sk-test", "gpt-5.4", {
       codexSubscription: true,
     });
@@ -1737,7 +1772,32 @@ describe("OpenAIResponsesProvider — Native Web Search", () => {
       [sampleTool],
     );
 
-    expect(lastStreamParams!.tools).toBeUndefined();
+    expect(lastStreamParams!.tools).toEqual([
+      {
+        type: "function",
+        name: "test_tool",
+        description: "A test tool",
+        parameters: { type: "object", properties: {} },
+        strict: null,
+      },
+    ]);
+  });
+
+  test("codexSubscription: maps web_search to the Codex native web_search tool", async () => {
+    const codexProvider = new OpenAIResponsesProvider("sk-test", "gpt-5.4", {
+      codexSubscription: true,
+      useNativeWebSearch: true,
+    });
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await codexProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Search for cats" }] }],
+      [webSearchTool],
+    );
+
+    expect(lastStreamParams!.tools).toEqual([
+      { type: "web_search", external_web_access: false },
+    ]);
   });
 
   test("codexSubscription: still sends model, input, and instructions", async () => {
@@ -1756,7 +1816,7 @@ describe("OpenAIResponsesProvider — Native Web Search", () => {
     expect(lastStreamParams!.model).toBe("gpt-5.4");
     expect(lastStreamParams!.instructions).toBe("You are helpful.");
     expect(lastStreamParams!.max_output_tokens).toBeUndefined();
-    expect(lastStreamParams!.reasoning).toBeUndefined();
-    expect(lastStreamParams!.text).toBeUndefined();
+    expect(lastStreamParams!.reasoning).toEqual({ effort: "xhigh" });
+    expect(lastStreamParams!.text).toEqual({ verbosity: "high" });
   });
 });

package/src/__tests__/openrouter-provider-only.test.ts

@@ -101,19 +101,19 @@ describe("OpenRouter provider.only plumbing", () => {
         config: { openrouter: { only: ["xAI"] } },
       });
       expect(extras).toEqual({
-        reasoning: { enabled: false },
         provider: { only: ["xAI"] },
       });
     });
 
-    test("omits provider when openrouter.only is absent", () => {
+    test("omits reasoning and provider when config is empty", () => {
       const provider = new ProbeOpenRouterProvider(
         "fake-key",
         "x-ai/grok-4.20-beta",
       );
       const extras = provider.probeExtras({ config: {} });
-      expect(extras).toEqual({ reasoning: { enabled: false } });
+      expect(extras).toEqual({});
       expect(extras.provider).toBe(undefined);
+      expect(extras.reasoning).toBe(undefined);
     });
 
     test("enables thinking with default detailed summary alongside provider.only", () => {
@@ -133,7 +133,7 @@ describe("OpenRouter provider.only plumbing", () => {
       });
     });
 
-    test("disabled thinking keeps reasoning disabled and omits summary", () => {
+    test("disabled thinking omits reasoning entirely", () => {
       const provider = new ProbeOpenRouterProvider(
         "fake-key",
         "x-ai/grok-4.20-beta",
@@ -145,9 +145,9 @@ describe("OpenRouter provider.only plumbing", () => {
         },
       });
       expect(extras).toEqual({
-        reasoning: { enabled: false },
         provider: { only: ["xAI"] },
       });
+      expect(extras.reasoning).toBe(undefined);
     });
 
     test("nests effort under reasoning and maps `max` to xhigh", () => {
@@ -182,6 +182,28 @@ describe("OpenRouter provider.only plumbing", () => {
       });
     });
 
+    test("effort without thinking does not emit reasoning", () => {
+      const provider = new ProbeOpenRouterProvider(
+        "fake-key",
+        "x-ai/grok-4.20-beta",
+      );
+      const extras = provider.probeExtras({
+        config: { thinking: { type: "disabled" }, effort: "low" },
+      });
+      expect(extras.reasoning).toBe(undefined);
+    });
+
+    test("omitting reasoning avoids 400 from reasoning-only models like DeepSeek R1", () => {
+      const provider = new ProbeOpenRouterProvider(
+        "fake-key",
+        "deepseek/deepseek-r1-0528",
+      );
+      const extras = provider.probeExtras({
+        config: { thinking: { type: "disabled" } },
+      });
+      expect(extras.reasoning).toBe(undefined);
+    });
+
     test("ignores an invalid summary override and falls back to detailed", () => {
       const provider = new ProbeOpenRouterProvider(
         "fake-key",

package/src/__tests__/outbound-slack-persistence.test.ts

@@ -107,10 +107,47 @@ mock.module("../memory/conversation-crud.js", () => ({
         : {};
     row.metadata = JSON.stringify({ ...existing, ...updates });
   },
-  updateMessageContent: () => {},
+  updateMessageContent: (messageId: string, content: string) => {
+    // Mirror updateContent into the same capture array so existing
+    // `lastAssistantPersisted()` assertions continue to find the row that
+    // was reserved at `llm_call_started` time.
+    const row = persistedRows.find((candidate) => candidate.id === messageId);
+    if (row) row.content = content;
+    const call = addMessageCalls.find((c) => c.id === messageId);
+    if (call) call.content = content;
+  },
   // The handler treats provenance as a flat spread; returning {} keeps the
   // metadata snapshot focused on the fields under test.
   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
+      // `lastAssistantPersisted()` assertions keep working.
+      const id = `mock-msg-${addMessageCalls.length + 1}-reserve`;
+      addMessageCalls.push({
+        id,
+        conversationId,
+        role,
+        content: "",
+        metadata,
+      });
+      persistedRows.push({
+        id,
+        conversationId,
+        role,
+        content: "",
+        createdAt: Date.now(),
+        metadata: metadata ? JSON.stringify(metadata) : null,
+      });
+      return { id };
+    },
+  ),
 }));
 
 mock.module("../memory/llm-request-log-store.js", () => ({
@@ -147,6 +184,7 @@ import type {
 } from "../daemon/conversation-agent-loop-handlers.js";
 import {
   createEventHandlerState,
+  handleLlmCallStarted,
   handleMessageComplete,
 } from "../daemon/conversation-agent-loop-handlers.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
@@ -255,6 +293,7 @@ describe("outbound assistant Slack metadata persistence", () => {
       assistantMessageChannel: "slack",
       requesterChatId: channelId,
     });
+    await handleLlmCallStarted(state, deps);
     await handleMessageComplete(state, deps, makeMessageCompleteEvent("hi"));
 
     const persisted = lastAssistantPersisted();
@@ -296,6 +335,7 @@ describe("outbound assistant Slack metadata persistence", () => {
       requesterTimezoneLabel: "ET",
       clientTimezone: "America/Los_Angeles",
     });
+    await handleLlmCallStarted(state, deps);
     await handleMessageComplete(
       state,
       deps,
@@ -324,6 +364,7 @@ describe("outbound assistant Slack metadata persistence", () => {
       requesterChatId: channelId,
       clientTimezone: "America/Los_Angeles",
     });
+    await handleLlmCallStarted(state, deps);
     await handleMessageComplete(
       state,
       deps,
@@ -351,6 +392,7 @@ describe("outbound assistant Slack metadata persistence", () => {
       requesterChatId: channelId,
       requesterTimezoneLabel: "ET",
     });
+    await handleLlmCallStarted(state, deps);
     await handleMessageComplete(
       state,
       deps,
@@ -394,6 +436,7 @@ describe("outbound assistant Slack metadata persistence", () => {
       assistantMessageChannel: "slack",
       requesterChatId: channelId,
     });
+    await handleLlmCallStarted(state, deps);
     await handleMessageComplete(state, deps, makeMessageCompleteEvent("hello"));
 
     const persisted = lastAssistantPersisted();
@@ -425,6 +468,7 @@ describe("outbound assistant Slack metadata persistence", () => {
       assistantMessageChannel: "slack",
       requesterChatId: channelId,
     });
+    await handleLlmCallStarted(state, deps);
     await handleMessageComplete(
       state,
       deps,
@@ -446,6 +490,7 @@ describe("outbound assistant Slack metadata persistence", () => {
     const deps = makeDeps(conversationId, {
       assistantMessageChannel: "vellum",
     });
+    await handleLlmCallStarted(state, deps);
     await handleMessageComplete(
       state,
       deps,

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

@@ -25,6 +25,8 @@ import {
   createConversation,
   getMessageById,
   getMessages,
+  reserveMessage,
+  updateMessageContent,
   updateMessageMetadata,
 } from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
@@ -44,6 +46,7 @@ import type {
   PersistAddResult,
   PersistArgs,
   PersistDeleteResult,
+  PersistReserveResult,
   PersistResult,
   Plugin,
   TurnContext,
@@ -215,6 +218,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 +326,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 +402,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 +464,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;
@@ -53,13 +54,41 @@ mock.module("../memory/conversation-crud.js", () => ({
     content: string,
     metadata?: Record<string, unknown>,
   ) => {
-    addMessageCalls.push({ conversationId, role, content, metadata });
-    return { id: `mock-msg-${addMessageCalls.length}` };
+    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 +113,7 @@ import type {
 } from "../daemon/conversation-agent-loop-handlers.js";
 import {
   createEventHandlerState,
+  handleLlmCallStarted,
   handleMessageComplete,
 } from "../daemon/conversation-agent-loop-handlers.js";
 
@@ -164,7 +194,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 +218,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 +235,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 +270,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 +290,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 +312,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 +332,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 +352,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<{