@vellumai/assistant 0.8.5 → 0.8.7

package/src/__tests__/conversation-skill-tools.test.ts

@@ -92,12 +92,13 @@ mock.module("../skills/tool-manifest.js", () => ({
 }));
 
 mock.module("../tools/skills/skill-tool-factory.js", () => ({
+  // Mirrors the real factory: no skillId in/out — ownership is recorded by
+  // the registry at `registerSkillTools(skillId, tools)` time.
   createSkillToolsFromManifest: (
     entries: SkillToolManifest["tools"],
-    skillId: string,
     _skillDir: string,
-    versionHash: string,
-    bundled?: boolean,
+    _versionHash: string,
+    _bundled?: boolean,
   ): Tool[] => {
     return entries.map((entry) => ({
       name: entry.name,
@@ -105,10 +106,6 @@ mock.module("../tools/skills/skill-tool-factory.js", () => ({
       category: entry.category,
       defaultRiskLevel: RiskLevel.Medium,
       executionTarget: "sandbox" as const,
-      origin: "skill" as const,
-      ownerSkillId: skillId,
-      ownerSkillVersionHash: versionHash,
-      ownerSkillBundled: bundled ?? undefined,
       input_schema: entry.input_schema as object,
       execute: async () => ({ content: "", isError: false }),
     }));
@@ -116,18 +113,14 @@ mock.module("../tools/skills/skill-tool-factory.js", () => ({
 }));
 
 mock.module("../tools/registry.js", () => ({
-  registerSkillTools: (tools: Tool[]) => {
-    const skillIds = new Set<string>();
-    for (const tool of tools) {
-      const skillId = tool.ownerSkillId!;
-      skillIds.add(skillId);
-      const existing = mockRegisteredTools.get(skillId) ?? [];
-      existing.push(tool);
-      mockRegisteredTools.set(skillId, existing);
-    }
-    for (const id of skillIds) {
-      mockSkillRefCount.set(id, (mockSkillRefCount.get(id) ?? 0) + 1);
-    }
+  // Matches the new signature: `registerSkillTools(skillId, tools)`. The
+  // skillId comes from the caller (conversation-skill-tools) and is the
+  // sole source of truth for ownership.
+  registerSkillTools: (skillId: string, tools: Tool[]) => {
+    const existing = mockRegisteredTools.get(skillId) ?? [];
+    existing.push(...tools);
+    mockRegisteredTools.set(skillId, existing);
+    mockSkillRefCount.set(skillId, (mockSkillRefCount.get(skillId) ?? 0) + 1);
     return tools;
   },
   unregisterSkillTools: (skillId: string) => {
@@ -151,6 +144,22 @@ mock.module("../tools/registry.js", () => ({
     }
     return found;
   },
+  // Mirrors the registry's `ownersByName` accessor: the mock derives the
+  // owning skillId from `mockRegisteredTools` (which is keyed by skillId)
+  // and reports it back as the `OwnerInfo` shape production callers expect.
+  getToolOwner: (
+    name: string,
+  ): { kind: "skill" | "plugin" | "mcp"; id: string } | undefined => {
+    let ownerSkillId: string | undefined;
+    for (const [skillId, tools] of mockRegisteredTools.entries()) {
+      for (const tool of tools) {
+        if (tool.name === name) ownerSkillId = skillId;
+      }
+    }
+    return ownerSkillId === undefined
+      ? undefined
+      : { kind: "skill", id: ownerSkillId };
+  },
   getSkillToolNames: () => {
     const names: string[] = [];
     for (const tools of mockRegisteredTools.values()) {
@@ -1730,11 +1739,11 @@ describe("bundled skill: app-builder", () => {
     expect(tools).toBeDefined();
     expect(tools!.length).toBe(4);
 
-    // All tools should have skill origin metadata
-    for (const tool of tools!) {
-      expect(tool.origin).toBe("skill");
-      expect(tool.ownerSkillId).toBe("app-builder");
-    }
+    // Ownership is asserted by the fact that
+    // `mockRegisteredTools.get("app-builder")` returned the tools — i.e. the
+    // mock `registerSkillTools(skillId, tools)` was called with skillId
+    // "app-builder", which is what the registry would record in production.
+    // The Tool object itself no longer carries a kind/origin field.
   });
 });
 
@@ -2229,7 +2238,7 @@ describe("hash change re-prompt regressions (PR 35)", () => {
     expect(sessionState.get("oncall")).toBe("v2:oncall-edited");
   });
 
-  test("registered tools carry updated ownerSkillId after hash change re-registration", () => {
+  test("registered tools carry updated owner after hash change re-registration", () => {
     mockCatalog = [makeSkill("deploy")];
     mockManifests = { deploy: makeManifest(["deploy_run"]) };
     mockVersionHashes = { deploy: "v1:pre-edit" };
@@ -2238,12 +2247,14 @@ describe("hash change re-prompt regressions (PR 35)", () => {
       ...skillLoadMessages('<loaded_skill id="deploy" />'),
     ];
 
-    // Turn 1
+    // Turn 1: ownership is asserted by the mock registry's keying — the
+    // tools landing under skillId "deploy" in `mockRegisteredTools` means
+    // `registerSkillTools("deploy", tools)` was called, which is the only
+    // path that records ownership in the real registry.
     projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
     const toolsV1 = mockRegisteredTools.get("deploy");
     expect(toolsV1).toBeDefined();
     expect(toolsV1!.length).toBe(1);
-    expect(toolsV1![0].ownerSkillId).toBe("deploy");
 
     // Edit
     mockVersionHashes = { deploy: "v2:post-edit" };
@@ -2253,121 +2264,6 @@ describe("hash change re-prompt regressions (PR 35)", () => {
     const toolsV2 = mockRegisteredTools.get("deploy");
     expect(toolsV2).toBeDefined();
     expect(toolsV2!.length).toBeGreaterThanOrEqual(1);
-    expect(toolsV2![0].ownerSkillId).toBe("deploy");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Version hash plumbing regression tests
-// Verify that createSkillToolsFromManifest receives the computed hash and
-// that projected tools carry ownerSkillVersionHash, which downstream
-// components (executor.ts) use to build policy context.
-// ---------------------------------------------------------------------------
-
-describe("version hash plumbing to projected tools", () => {
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test("projected tools carry ownerSkillVersionHash matching the computed hash", () => {
-    mockCatalog = [makeSkill("deploy")];
-    mockManifests = { deploy: makeManifest(["deploy_run", "deploy_status"]) };
-    mockVersionHashes = { deploy: "v1:secure-hash-abc" };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    const tools = mockRegisteredTools.get("deploy");
-    expect(tools).toBeDefined();
-    expect(tools!.length).toBe(2);
-
-    // Every tool created for this skill must carry the version hash
-    for (const tool of tools!) {
-      expect(tool.ownerSkillVersionHash).toBe("v1:secure-hash-abc");
-    }
-  });
-
-  test("after hash change re-registration, new tools carry the updated hash", () => {
-    mockCatalog = [makeSkill("deploy")];
-    mockManifests = { deploy: makeManifest(["deploy_run"]) };
-    mockVersionHashes = { deploy: "v1:hash-before" };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    // Turn 1: register with original hash
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    const toolsV1 = mockRegisteredTools.get("deploy");
-    expect(toolsV1).toBeDefined();
-    expect(toolsV1![0].ownerSkillVersionHash).toBe("v1:hash-before");
-
-    // Simulate file edit — hash changes
-    mockVersionHashes = { deploy: "v2:hash-after" };
-
-    // Turn 2: re-registration with new hash
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-    const toolsV2 = mockRegisteredTools.get("deploy");
-    expect(toolsV2).toBeDefined();
-
-    // The most recently registered tool should carry the new hash
-    const lastTool = toolsV2![toolsV2!.length - 1];
-    expect(lastTool.ownerSkillVersionHash).toBe("v2:hash-after");
-  });
-
-  test("tools for multiple co-active skills each carry their own version hash", () => {
-    mockCatalog = [makeSkill("deploy"), makeSkill("oncall")];
-    mockManifests = {
-      deploy: makeManifest(["deploy_run"]),
-      oncall: makeManifest(["oncall_page"]),
-    };
-    mockVersionHashes = {
-      deploy: "v1:deploy-hash-123",
-      oncall: "v1:oncall-hash-456",
-    };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-      ...skillLoadMessages('<loaded_skill id="oncall" />'),
-    ];
-
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    const deployTools = mockRegisteredTools.get("deploy");
-    expect(deployTools).toBeDefined();
-    expect(deployTools![0].ownerSkillVersionHash).toBe("v1:deploy-hash-123");
-
-    const oncallTools = mockRegisteredTools.get("oncall");
-    expect(oncallTools).toBeDefined();
-    expect(oncallTools![0].ownerSkillVersionHash).toBe("v1:oncall-hash-456");
-  });
-
-  test("default hash is used and plumbed when no explicit hash override is set", () => {
-    mockCatalog = [makeSkill("deploy")];
-    mockManifests = { deploy: makeManifest(["deploy_run"]) };
-    // No mockVersionHashes override — mock returns 'v1:default-hash-deploy'
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="deploy" />'),
-    ];
-
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    const tools = mockRegisteredTools.get("deploy");
-    expect(tools).toBeDefined();
-    expect(tools![0].ownerSkillVersionHash).toBe("v1:default-hash-deploy");
   });
 });
 

package/src/__tests__/conversation-slash-queue.test.ts

@@ -1,14 +1,11 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type {
-  AgentEvent,
-  CheckpointDecision,
-  CheckpointInfo,
-} from "../agent/loop.js";
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
+import type { AgentEvent, AgentLoopRunResult } from "../agent/loop.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import {
   conversationMessagesSyncTag,
-  type SyncChangedMessage,
+  type SyncChangedEvent,
 } from "../daemon/message-types/sync.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
@@ -135,6 +132,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationTitle: () => {},
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  updateMessageContent: mock(() => {}),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -204,13 +203,14 @@ mock.module("../config/skill-state.js", () => ({
 interface PendingRun {
   resolve: (history: Message[]) => void;
   messages: Message[];
-  onEvent: (event: AgentEvent) => void;
+  onEvent: (event: AgentEvent) => void | Promise<void>;
 }
 
 let pendingRuns: PendingRun[] = [];
 
 mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
+    compactionCircuit = new CompactionCircuit("test-conv");
     constructor() {}
     getToolTokenBudget() {
       return 0;
@@ -223,16 +223,12 @@ mock.module("../agent/loop.js", () => ({
     }
     async run(
       messages: Message[],
-      onEvent: (event: AgentEvent) => void,
-      _signal?: AbortSignal,
-      _requestId?: string,
-      _onCheckpoint?: (
-        checkpoint: CheckpointInfo,
-      ) => CheckpointDecision | Promise<CheckpointDecision>,
-    ): Promise<Message[]> {
-      return new Promise<Message[]>((resolve) => {
+      onEvent: (event: AgentEvent) => void | Promise<void>,
+    ): Promise<AgentLoopRunResult> {
+      const history = await new Promise<Message[]>((resolve) => {
         pendingRuns.push({ resolve, messages, onEvent });
       });
+      return { history, exitReason: null };
     }
   },
 }));
@@ -304,9 +300,9 @@ function makeConversation(): Conversation {
     "conv-1",
     provider,
     "system prompt",
-    4096,
     () => {},
     "/tmp",
+    { maxTokens: 4096 },
   );
   // Bypass real workspace git init: with "/tmp" as the workspace dir, a real
   // ensureInitialized() walks all of /tmp and can exceed the 2s waitForPendingRun
@@ -333,29 +329,32 @@ async function waitForPendingRun(
   }
 }
 
-function resolveRun(index: number) {
+async function resolveRun(index: number) {
   const run = pendingRuns[index];
   if (!run) throw new Error(`No pending run at index ${index}`);
   const assistantMsg: Message = {
     role: "assistant",
     content: [{ type: "text", text: `reply-${index}` }],
   };
-  run.onEvent({
+  // Prime the assistant row anchor — production code emits this from
+  // `AgentLoop.run` just before `provider.sendMessage`.
+  await run.onEvent({ type: "llm_call_started" });
+  await run.onEvent({
     type: "usage",
     inputTokens: 10,
     outputTokens: 5,
     model: "mock",
     providerDurationMs: 100,
   });
-  run.onEvent({ type: "message_complete", message: assistantMsg });
+  await run.onEvent({ type: "message_complete", message: assistantMsg });
   run.resolve([...run.messages, assistantMsg]);
 }
 
 function syncChangedMessages(): {
-  messages: SyncChangedMessage[];
+  messages: SyncChangedEvent[];
   dispose: () => void;
 } {
-  const messages: SyncChangedMessage[] = [];
+  const messages: SyncChangedEvent[] = [];
   const subscription = assistantEventHub.subscribe({
     type: "process",
     callback: (event) => {
@@ -388,27 +387,30 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     const events3: ServerMessage[] = [];
 
     // Start first message — blocks on agent loop
-    const p1 = conversation.processMessage(
-      "msg-1",
-      [],
-      (e) => events1.push(e),
-      "req-1",
-    );
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: (e) => events1.push(e),
+      requestId: "req-1",
+    });
     await waitForPendingRun(1);
 
     // Enqueue a slash-like passthrough and a normal passthrough after it.
     // Both resolve to passthrough, so the batch builder groups them into one run.
-    conversation.enqueueMessage(
-      "/not-a-skill",
-      [],
-      (e) => eventsSlash.push(e),
-      "req-slash",
-    );
-    conversation.enqueueMessage("msg-3", [], (e) => events3.push(e), "req-3");
+    conversation.enqueueMessage({
+      content: "/not-a-skill",
+      onEvent: (e) => eventsSlash.push(e),
+      requestId: "req-slash",
+    });
+    conversation.enqueueMessage({
+      content: "msg-3",
+      onEvent: (e) => events3.push(e),
+      requestId: "req-3",
+    });
     expect(conversation.getQueueDepth()).toBe(2);
 
     // Complete first run — drain pulls both queued messages into one batched run.
-    resolveRun(0);
+    await resolveRun(0);
     await p1;
     await waitForPendingRun(2);
 
@@ -419,8 +421,50 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     // Exactly 2 runs total: msg-1 + batched [/not-a-skill, msg-3].
     expect(pendingRuns.length).toBe(2);
 
+    await resolveRun(1);
+    await new Promise((r) => setTimeout(r, 50));
+  });
+
+  test("batched queued messages with the same event sink do not duplicate assistant stream events", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const sharedEvents: ServerMessage[] = [];
+    const sharedOnEvent = (event: ServerMessage) => sharedEvents.push(event);
+
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    conversation.enqueueMessage({
+      content: "msg-2",
+      onEvent: sharedOnEvent,
+      requestId: "req-2",
+    });
+    conversation.enqueueMessage({
+      content: "msg-3",
+      onEvent: sharedOnEvent,
+      requestId: "req-3",
+    });
+
+    resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+
+    expect(
+      sharedEvents.filter((event) => event.type === "message_dequeued"),
+    ).toHaveLength(2);
+
+    sharedEvents.length = 0;
     resolveRun(1);
     await new Promise((r) => setTimeout(r, 50));
+
+    expect(
+      sharedEvents.filter((event) => event.type === "message_complete"),
+    ).toHaveLength(1);
   });
 
   test("queued skill-name slash passes through as-is", async () => {
@@ -431,24 +475,23 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     const eventsSlash: ServerMessage[] = [];
 
     // Start first message — blocks on agent loop
-    const p1 = conversation.processMessage(
-      "msg-1",
-      [],
-      (e) => events1.push(e),
-      "req-1",
-    );
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: (e) => events1.push(e),
+      requestId: "req-1",
+    });
     await waitForPendingRun(1);
 
     // Enqueue a slash command that matches a skill name — still passes through
-    conversation.enqueueMessage(
-      "/start-the-day",
-      [],
-      (e) => eventsSlash.push(e),
-      "req-slash",
-    );
+    conversation.enqueueMessage({
+      content: "/start-the-day",
+      onEvent: (e) => eventsSlash.push(e),
+      requestId: "req-slash",
+    });
 
     // Complete first run — triggers drain
-    resolveRun(0);
+    await resolveRun(0);
     await p1;
     await waitForPendingRun(2);
 
@@ -463,7 +506,7 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     // Content passes through as-is — no rewriting
     expect(text).toContain("/start-the-day");
 
-    resolveRun(1);
+    await resolveRun(1);
     await new Promise((r) => setTimeout(r, 50));
   });
 
@@ -476,25 +519,36 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     const eventsBye: ServerMessage[] = [];
 
     // Start in-flight message
-    const p1 = conversation.processMessage("msg-1", [], () => {}, "req-1");
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      requestId: "req-1",
+    });
     await waitForPendingRun(1);
 
     // Enqueue ["hi", "/compact", "bye"]. /compact is non-passthrough, so the
     // batch builder stops at "hi" (length-1 batch → drainSingleMessage). Then
     // /compact takes its short-circuit path (no new runAgentLoop), and "bye"
     // drains as its own run.
-    conversation.enqueueMessage("hi", [], (e) => eventsHi.push(e), "req-hi");
-    conversation.enqueueMessage(
-      "/compact",
-      [],
-      (e) => eventsCompact.push(e),
-      "req-compact",
-    );
-    conversation.enqueueMessage("bye", [], (e) => eventsBye.push(e), "req-bye");
+    conversation.enqueueMessage({
+      content: "hi",
+      onEvent: (e) => eventsHi.push(e),
+      requestId: "req-hi",
+    });
+    conversation.enqueueMessage({
+      content: "/compact",
+      onEvent: (e) => eventsCompact.push(e),
+      requestId: "req-compact",
+    });
+    conversation.enqueueMessage({
+      content: "bye",
+      onEvent: (e) => eventsBye.push(e),
+      requestId: "req-bye",
+    });
     expect(conversation.getQueueDepth()).toBe(3);
 
     // Resolve msg-1 → drain pulls only "hi" (batch builder stops at /compact).
-    resolveRun(0);
+    await resolveRun(0);
     await p1;
     await waitForPendingRun(2);
 
@@ -503,14 +557,14 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
 
     // Resolve "hi" → /compact short-circuits without a new runAgentLoop, then
     // drains "bye" as its own run.
-    resolveRun(1);
+    await resolveRun(1);
     await waitForPendingRun(3);
 
     expect(eventsCompact.some((e) => e.type === "message_complete")).toBe(true);
     expect(eventsBye.some((e) => e.type === "message_dequeued")).toBe(true);
     expect(pendingRuns.length).toBe(3);
 
-    resolveRun(2);
+    await resolveRun(2);
     await new Promise((r) => setTimeout(r, 50));
   });
 
@@ -524,7 +578,11 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     const sync = syncChangedMessages();
     try {
       await expect(
-        conversation.processMessage("/compact", [], () => {}, "req-compact"),
+        conversation.processMessage({
+          content: "/compact",
+          attachments: [],
+          requestId: "req-compact",
+        }),
       ).rejects.toThrow("compaction failed");
 
       await waitFor(

package/src/__tests__/conversation-slash-unknown.test.ts

@@ -1,10 +1,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type {
-  AgentEvent,
-  CheckpointDecision,
-  CheckpointInfo,
-} from "../agent/loop.js";
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
+import type { AgentEvent } from "../agent/loop.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
@@ -136,6 +133,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationTitle: () => {},
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  updateMessageContent: mock(() => {}),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -235,6 +234,7 @@ let agentLoopRunCalled = false;
 
 mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
+    compactionCircuit = new CompactionCircuit("test-conv");
     constructor() {}
     getToolTokenBudget() {
       return 0;
@@ -248,12 +248,10 @@ mock.module("../agent/loop.js", () => ({
     async run(
       messages: Message[],
       onEvent: (event: AgentEvent) => void,
-      _signal?: AbortSignal,
-      _requestId?: string,
-      _onCheckpoint?: (
-        checkpoint: CheckpointInfo,
-      ) => CheckpointDecision | Promise<CheckpointDecision>,
     ): Promise<Message[]> {
+      // Prime the assistant row anchor — production code emits this from
+      // `AgentLoop.run` just before `provider.sendMessage`.
+      await onEvent({ type: "llm_call_started" });
       agentLoopRunCalled = true;
       const assistantMsg: Message = {
         role: "assistant",
@@ -313,9 +311,9 @@ function makeConversation(): Conversation {
     "conv-1",
     provider,
     "system prompt",
-    4096,
     () => {},
     "/tmp",
+    { maxTokens: 4096 },
   );
 }
 
@@ -331,7 +329,10 @@ describe("Conversation slash command — passthrough for unknown tokens", () =>
 
   test("unknown slash-like input passes through to agent loop", async () => {
     const conversation = makeConversation();
-    await conversation.processMessage("/not-a-skill", [], () => {});
+    await conversation.processMessage({
+      content: "/not-a-skill",
+      attachments: [],
+    });
 
     // Should go through the normal agent loop path
     expect(agentLoopRunCalled).toBe(true);
@@ -340,9 +341,11 @@ describe("Conversation slash command — passthrough for unknown tokens", () =>
   test("normal messages still go through standard path", async () => {
     const conversation = makeConversation();
     const events: ServerMessage[] = [];
-    await conversation.processMessage("hello world", [], (msg) =>
-      events.push(msg),
-    );
+    await conversation.processMessage({
+      content: "hello world",
+      attachments: [],
+      onEvent: (msg) => events.push(msg),
+    });
     expect(agentLoopRunCalled).toBe(true);
   });
 });