@vellumai/assistant 0.8.4 → 0.8.6

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

@@ -42,7 +42,7 @@ mock.module("../oauth/credential-token-resolver.js", () => ({
 
 import { eq } from "drizzle-orm";
 
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { getSqliteFrom } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { migrateOAuthProvidersTokenAuthMethodDefault } from "../memory/migrations/216-oauth-providers-token-auth-method.js";
@@ -70,6 +70,7 @@ import {
   upsertApp,
 } from "../oauth/oauth-store.js";
 import { seedOAuthProviders } from "../oauth/seed-providers.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 import { getMockFetchCalls, mockFetch, resetMockFetch } from "./mock-fetch.js";
 
 initializeDb();
@@ -103,7 +104,7 @@ beforeEach(() => {
 });
 
 afterAll(() => {
-  resetDb();
+  resetDbForTesting();
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/onboarding-template-contract.test.ts

@@ -44,7 +44,7 @@ describe("onboarding template contracts", () => {
     test("instructs saving to IDENTITY.md, SOUL.md, and user persona file via file_edit", () => {
       expect(bootstrap).toContain("IDENTITY.md");
       expect(bootstrap).toContain("SOUL.md");
-      expect(bootstrap).toContain("{{USER_PERSONA_FILE}}");
+      expect(bootstrap).toContain("{{userSlug}}.md");
       expect(bootstrap).toContain("file_edit");
     });
 
@@ -111,8 +111,9 @@ describe("onboarding template contracts", () => {
       expect(identity).toContain("**Emoji:**");
     });
 
-    test("contains parsed field format guidance", () => {
-      expect(identity).toContain("parsed by the app");
+    test("does not invite assistant-owned identity restructuring", () => {
+      expect(identity).not.toContain("This file is yours");
+      expect(identity).not.toContain("parsed by the app");
     });
   });
 

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

@@ -56,6 +56,7 @@ let lastCreateParams: Record<string, unknown> | null = null;
 let lastCreateOptions: Record<string, unknown> | null = null;
 let lastConstructorOptions: Record<string, unknown> | null = null;
 let shouldThrow: Error | null = null;
+const DEFAULT_SDK_TIMEOUT_MS = 1_860_000;
 
 function userMsg(text: string): Message {
   return { role: "user", content: [{ type: "text", text }] };
@@ -102,6 +103,7 @@ mock.module("openai", () => ({
 
 // Import after mocking
 import { FireworksProvider } from "../providers/fireworks/client.js";
+import { MinimaxProvider } from "../providers/minimax/client.js";
 import { OllamaProvider } from "../providers/ollama/client.js";
 import { OpenAIChatCompletionsProvider } from "../providers/openai/chat-completions-provider.js";
 import { OpenAIProvider } from "../providers/openai/client.js";
@@ -307,6 +309,7 @@ describe("OpenAIProvider", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "sk-local",
       baseURL: "http://127.0.0.1:11434/v1",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 
@@ -319,6 +322,7 @@ describe("OpenAIProvider", () => {
       expect(lastConstructorOptions).toEqual({
         apiKey: "ollama",
         baseURL: "http://127.0.0.1:11434/v1",
+        timeout: DEFAULT_SDK_TIMEOUT_MS,
       });
     } finally {
       if (previousBaseUrl !== undefined) {
@@ -338,6 +342,7 @@ describe("OpenAIProvider", () => {
       expect(lastConstructorOptions).toEqual({
         apiKey: "ollama",
         baseURL: "http://127.0.0.1:11434/v1",
+        timeout: DEFAULT_SDK_TIMEOUT_MS,
       });
     } finally {
       if (previousBaseUrl !== undefined) {
@@ -1280,6 +1285,7 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "ast-key-123",
       baseURL: "https://platform.example.com/v1/runtime-proxy/openai",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 
@@ -1289,6 +1295,19 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "sk-user-key",
       baseURL: undefined,
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
+    });
+  });
+
+  test("OpenAIProvider passes configured stream timeout plus buffer to SDK", () => {
+    new OpenAIProvider("sk-user-key", "gpt-4o", {
+      streamTimeoutMs: 300_000,
+    });
+
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "sk-user-key",
+      baseURL: undefined,
+      timeout: 360_000,
     });
   });
 
@@ -1305,6 +1324,7 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "ast-key-123",
       baseURL: "https://platform.example.com/v1/runtime-proxy/fireworks",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 
@@ -1317,6 +1337,7 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "fw-user-key",
       baseURL: "https://api.fireworks.ai/inference/v1",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 
@@ -1329,6 +1350,7 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "ast-key-123",
       baseURL: "https://platform.example.com/v1/runtime-proxy/openrouter",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 
@@ -1338,6 +1360,30 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "or-user-key",
       baseURL: "https://openrouter.ai/api/v1",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
+    });
+  });
+
+  test("MinimaxProvider forwards a custom baseURL", () => {
+    const managed = new MinimaxProvider("ast-key-123", "MiniMax-M2.7", {
+      baseURL: "https://platform.example.com/v1/runtime-proxy/minimax",
+    });
+
+    expect(managed.name).toBe("minimax");
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "ast-key-123",
+      baseURL: "https://platform.example.com/v1/runtime-proxy/minimax",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
+    });
+  });
+
+  test("MinimaxProvider without custom baseURL uses default MiniMax URL", () => {
+    new MinimaxProvider("mm-user-key", "MiniMax-M2.7");
+
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "mm-user-key",
+      baseURL: "https://api.minimax.io/v1",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 });
@@ -1511,32 +1557,32 @@ describe("OpenRouterProvider reasoning", () => {
     });
   });
 
-  test("sends reasoning.enabled=false when thinking is explicitly disabled", async () => {
+  test("omits reasoning when thinking is explicitly disabled", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
     await provider.sendMessage([userMsg("hi")], undefined, undefined, {
       config: { thinking: { type: "disabled" } },
     });
 
     expect(lastCreateParams).toBeTruthy();
-    expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
+    expect(lastCreateParams!.reasoning).toBeUndefined();
   });
 
-  test("sends reasoning.enabled=false when thinking config is absent", async () => {
+  test("omits reasoning when thinking config is absent", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
     await provider.sendMessage([userMsg("hi")], undefined, undefined, {
       config: {},
     });
 
     expect(lastCreateParams).toBeTruthy();
-    expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
+    expect(lastCreateParams!.reasoning).toBeUndefined();
   });
 
-  test("sends reasoning.enabled=false when no options are provided", async () => {
+  test("omits reasoning when no options are provided", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
     await provider.sendMessage([userMsg("hi")]);
 
     expect(lastCreateParams).toBeTruthy();
-    expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
+    expect(lastCreateParams!.reasoning).toBeUndefined();
   });
 
   test("sends OpenRouter app-attribution headers on OpenAI-compatible requests", async () => {
@@ -1577,15 +1623,14 @@ describe("OpenRouterProvider reasoning", () => {
     });
   });
 
-  test("RetryProvider + OpenRouterProvider disables thinking end-to-end", async () => {
+  test("RetryProvider + OpenRouterProvider omits reasoning when thinking disabled", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
     const retry = new RetryProvider(provider);
 
-    // thinking disabled at loop-level can arrive as an explicit disabled config.
     await retry.sendMessage([userMsg("hi")], undefined, undefined, {
       config: { thinking: { type: "disabled" } },
     });
-    expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
+    expect(lastCreateParams!.reasoning).toBeUndefined();
   });
 
   test("nests effort under reasoning and omits top-level reasoning_effort", async () => {

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

@@ -22,6 +22,7 @@ let lastStreamParams: Record<string, unknown> | null = null;
 let lastStreamOptions: Record<string, unknown> | null = null;
 let lastConstructorOptions: Record<string, unknown> | null = null;
 let shouldThrow: Error | null = null;
+const DEFAULT_SDK_TIMEOUT_MS = 1_860_000;
 
 // Simulate OpenAI.APIError
 class FakeAPIError extends Error {
@@ -46,7 +47,7 @@ mock.module("openai", () => ({
       lastConstructorOptions = opts;
     }
     responses = {
-      stream: (
+      create: async (
         params: Record<string, unknown>,
         options?: Record<string, unknown>,
       ) => {
@@ -164,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
 // ---------------------------------------------------------------------------
@@ -200,6 +221,19 @@ describe("OpenAIResponsesProvider", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "sk-custom",
       baseURL: "https://proxy.example.com/v1",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
+    });
+  });
+
+  test("passes configured stream timeout plus buffer to OpenAI client", () => {
+    new OpenAIResponsesProvider("sk-custom", "gpt-5.4", {
+      streamTimeoutMs: 300_000,
+    });
+
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "sk-custom",
+      baseURL: undefined,
+      timeout: 360_000,
     });
   });
 
@@ -229,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
   // -----------------------------------------------------------------------
@@ -273,18 +322,6 @@ describe("OpenAIResponsesProvider", () => {
     }
   });
 
-  test("strips SYSTEM_PROMPT_CACHE_BOUNDARY from system prompt", async () => {
-    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
-
-    await provider.sendMessage(
-      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
-      undefined,
-      "Before\n<!-- SYSTEM_PROMPT_CACHE_BOUNDARY -->\nAfter",
-    );
-
-    expect(lastStreamParams!.instructions).toBe("Before\nAfter");
-  });
-
   // -----------------------------------------------------------------------
   // Tool definitions
   // -----------------------------------------------------------------------
@@ -1118,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");
@@ -1657,4 +1694,129 @@ describe("OpenAIResponsesProvider — Native Web Search", () => {
       text: "No search needed.",
     });
   });
+
+  // -----------------------------------------------------------------------
+  // codexSubscription — parameter stripping
+  // -----------------------------------------------------------------------
+  test("codexSubscription: strips max_output_tokens from params", async () => {
+    const codexProvider = new OpenAIResponsesProvider("sk-test", "gpt-5.4", {
+      codexSubscription: true,
+    });
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await codexProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { max_tokens: 64000 } },
+    );
+
+    expect(lastStreamParams!.max_output_tokens).toBeUndefined();
+  });
+
+  test("codexSubscription: forwards reasoning param when effort is set", async () => {
+    const codexProvider = new OpenAIResponsesProvider("sk-test", "gpt-5.4", {
+      codexSubscription: true,
+    });
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await codexProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { effort: "high" } },
+    );
+
+    expect(lastStreamParams!.reasoning).toEqual({ effort: "high" });
+  });
+
+  test("codexSubscription: forwards text.verbosity param", async () => {
+    const codexProvider = new OpenAIResponsesProvider("sk-test", "gpt-5.4", {
+      codexSubscription: true,
+    });
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await codexProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { verbosity: "low" } },
+    );
+
+    expect(lastStreamParams!.text).toEqual({ verbosity: "low" });
+  });
+
+  test("codexSubscription: uses Codex baseURL", async () => {
+    new OpenAIResponsesProvider("sk-test", "gpt-5.4", {
+      codexSubscription: true,
+    });
+
+    expect(lastConstructorOptions!.baseURL).toBe(
+      "https://chatgpt.com/backend-api/codex",
+    );
+  });
+
+  test("codexSubscription: forwards tools param", async () => {
+    const codexProvider = new OpenAIResponsesProvider("sk-test", "gpt-5.4", {
+      codexSubscription: true,
+    });
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    const sampleTool: ToolDefinition = {
+      name: "test_tool",
+      description: "A test tool",
+      input_schema: { type: "object", properties: {} },
+    };
+    await codexProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      [sampleTool],
+    );
+
+    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 () => {
+    const codexProvider = new OpenAIResponsesProvider("sk-test", "gpt-5.4", {
+      codexSubscription: true,
+    });
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await codexProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      "You are helpful.",
+      { config: { effort: "max", verbosity: "high", max_tokens: 64000 } },
+    );
+
+    expect(lastStreamParams!.model).toBe("gpt-5.4");
+    expect(lastStreamParams!.instructions).toBe("You are helpful.");
+    expect(lastStreamParams!.max_output_tokens).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__/pending-interactions-resolved-event.test.ts

@@ -54,7 +54,6 @@ describe("pendingInteractions.resolve emits interaction_resolved", () => {
     expect(returned).toBeDefined();
     const evt = lastResolvedEvent();
     expect(evt.requestId).toBe("req-1");
-    expect(evt.conversationKey).toBe("conv-1");
     expect(evt.conversationId).toBe("conv-1");
     expect(evt.state).toBe("cancelled");
     expect(evt.kind).toBe("confirmation");