@vellumai/assistant 0.8.4 → 0.8.6

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

@@ -92,45 +92,35 @@ 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,
       description: entry.description,
       category: entry.category,
       defaultRiskLevel: RiskLevel.Medium,
-      origin: "skill" as const,
-      ownerSkillId: skillId,
-      ownerSkillVersionHash: versionHash,
-      ownerSkillBundled: bundled ?? undefined,
-      getDefinition: () => ({
-        name: entry.name,
-        description: entry.description,
-        input_schema: entry.input_schema as object,
-      }),
+      executionTarget: "sandbox" as const,
+      input_schema: entry.input_schema as object,
       execute: async () => ({ content: "", isError: false }),
     }));
   },
 }));
 
 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) => {
@@ -154,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()) {
@@ -1733,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.
   });
 });
 
@@ -2232,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" };
@@ -2241,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" };
@@ -2256,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

@@ -135,6 +135,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,7 +206,7 @@ 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[] = [];
@@ -223,7 +225,7 @@ mock.module("../agent/loop.js", () => ({
     }
     async run(
       messages: Message[],
-      onEvent: (event: AgentEvent) => void,
+      onEvent: (event: AgentEvent) => void | Promise<void>,
       _signal?: AbortSignal,
       _requestId?: string,
       _onCheckpoint?: (
@@ -333,21 +335,24 @@ 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]);
 }
 
@@ -398,17 +403,20 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
 
     // 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 +427,46 @@ 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("msg-1", [], () => {}, "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 () => {
@@ -440,15 +486,14 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     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 +508,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));
   });
 
@@ -483,18 +528,25 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     // 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 +555,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));
   });
 

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

@@ -136,6 +136,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", () => ({
@@ -254,6 +256,9 @@ mock.module("../agent/loop.js", () => ({
         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",

package/src/__tests__/conversation-speed-override.test.ts

@@ -150,6 +150,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   addMessage: () => ({ id: `msg-${Date.now()}` }),
   updateConversationUsage: () => {},
   updateConversationTitle: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

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

@@ -334,7 +334,7 @@ describe("attachment orphan cleanup", () => {
     const stored = uploadAttachment("doc.pdf", "application/pdf", "JVBER");
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
-    clearAll();
+    await clearAll();
 
     const raw = (
       getDb() as unknown as {

package/src/__tests__/conversation-surfaces-action-delivery.test.ts

@@ -182,6 +182,52 @@ describe("surface action delivery to assistant", () => {
     );
   });
 
+  test("history-restored relay action uses stored prompt data and can complete the surface", async () => {
+    const ctx = makeContext();
+    const surfaceId = "max-token-surface";
+    ctx.surfaceState.set(surfaceId, {
+      surfaceType: "card",
+      data: {
+        title: "Response limit reached",
+        body: "Continue from where the assistant stopped.",
+      },
+      actions: [
+        {
+          id: "relay_prompt",
+          label: "Continue",
+          style: "primary",
+          data: {
+            prompt: "Continue from where you stopped.",
+            _completeSurface: true,
+            _completionSummary: "Continue",
+          },
+        },
+      ],
+    });
+
+    await handleSurfaceAction(ctx, surfaceId, "relay_prompt");
+
+    expect(ctx.processMessageCalls).toHaveLength(1);
+    expect(ctx.processMessageCalls[0]!.content).toBe(
+      "Continue from where you stopped.",
+    );
+    expect(
+      broadcastedMessages.some(
+        (msg) =>
+          msg.type === "ui_surface_complete" &&
+          msg.surfaceId === surfaceId &&
+          msg.summary === "Continue",
+      ),
+    ).toBe(true);
+    expect(
+      broadcastedMessages.some(
+        (msg) =>
+          msg.type === "user_message_echo" &&
+          msg.text === "Continue from where you stopped.",
+      ),
+    ).toBe(true);
+  });
+
   test("action on history-restored surface (no pending) still processes", async () => {
     const sent: ServerMessage[] = [];
     const ctx = makeContext(sent);

package/src/__tests__/conversation-surfaces-data-persist.test.ts

@@ -29,6 +29,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessages: (conversationId: string) => getMessagesImpl(conversationId),
   updateMessageContent: (id: string, content: string) =>
     updateMessageContentSpy(id, content),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 // Imports must come AFTER mock.module so the surface module picks up

package/src/__tests__/conversation-surfaces-standalone-payloads.test.ts

@@ -72,9 +72,12 @@ function createMockContext(
     hostCuProxy: undefined,
     hasNoClient: overrides?.hasNoClient ?? false,
     isProcessing: () => false,
-    enqueueMessage: (content, _attachments, _onEvent, requestId) => {
-      const resolvedId = requestId ?? "mock-request-id";
-      enqueuedMessages.push({ content, requestId: resolvedId });
+    enqueueMessage: (options) => {
+      const resolvedId = options.requestId ?? "mock-request-id";
+      enqueuedMessages.push({
+        content: options.content,
+        requestId: resolvedId,
+      });
       return { queued: false, requestId: resolvedId };
     },
     getQueueDepth: () => 0,

package/src/__tests__/conversation-surfaces-standalone.test.ts

@@ -63,9 +63,12 @@ function createMockContext(
     hostCuProxy: undefined,
     hasNoClient: overrides?.hasNoClient ?? false,
     isProcessing: () => false,
-    enqueueMessage: (content, _attachments, _onEvent, requestId) => {
-      const resolvedId = requestId ?? "mock-request-id";
-      enqueuedMessages.push({ content, requestId: resolvedId });
+    enqueueMessage: (options) => {
+      const resolvedId = options.requestId ?? "mock-request-id";
+      enqueuedMessages.push({
+        content: options.content,
+        requestId: resolvedId,
+      });
       return { queued: false, requestId: resolvedId };
     },
     getQueueDepth: () => 0,

package/src/__tests__/conversation-surfaces-state-update.test.ts

@@ -45,9 +45,9 @@ function makeContext(opts?: {
     surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
     isProcessing: () => false,
-    enqueueMessage: (content, _attachments, _onEvent, requestId) => {
-      const resolvedId = requestId ?? "mock-request-id";
-      enqueueCalls.push({ content, requestId: resolvedId });
+    enqueueMessage: (options) => {
+      const resolvedId = options.requestId ?? "mock-request-id";
+      enqueueCalls.push({ content: options.content, requestId: resolvedId });
       return { queued: false, requestId: resolvedId };
     },
     getQueueDepth: () => 0,

package/src/__tests__/conversation-surfaces-table-action.test.ts

@@ -64,25 +64,15 @@ function makeContext(): SurfaceConversationContext & {
     surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
     isProcessing: () => false,
-    enqueueMessage: (
-      content,
-      attachments,
-      _onEvent,
-      requestId,
-      surfaceId,
-      _currentPage,
-      _metadata,
-      _options,
-      displayContent,
-    ) => {
+    enqueueMessage: (options) => {
       enqueueCalls.push({
-        content,
-        requestId: requestId ?? "enq-req",
-        attachments,
-        surfaceId,
-        displayContent,
+        content: options.content,
+        requestId: options.requestId ?? "enq-req",
+        attachments: options.attachments ?? [],
+        surfaceId: options.activeSurfaceId,
+        displayContent: options.displayContent,
       });
-      return { queued: false, requestId: requestId ?? "enq-req" };
+      return { queued: false, requestId: options.requestId ?? "enq-req" };
     },
     getQueueDepth: () => 0,
     processMessage: async (