@runtypelabs/persona 3.28.0 → 3.29.1

package/src/session.webmcp.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 
 import { AgentWidgetSession } from "./session";
 import type {
@@ -80,6 +80,10 @@ describe("AgentWidgetSession — WebMCP resolve", () => {
     vi.clearAllMocks();
   });
 
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
   it("posts result to /resume on the happy path", async () => {
     const { session, executeSpy, resumeSpy } = makeSession({
       executeReturn: {
@@ -97,6 +101,33 @@ describe("AgentWidgetSession — WebMCP resolve", () => {
     );
   });
 
+  it("records the elapsed time of the resolved browser WebMCP promise", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(1_000);
+    const { session } = makeSession({
+      executeImpl: async () => {
+        vi.advanceTimersByTime(1_250);
+        return { content: [{ type: "text", text: "loaded jade" }] };
+      },
+    });
+
+    await session.resolveWebMcpToolCall(
+      awaitingMessage("tool-1", "webmcp:get_product_by_url"),
+    );
+
+    const stored = (
+      session as unknown as { messages: AgentWidgetMessage[] }
+    ).messages.find((m) => m.toolCall?.id === "tool-1");
+    expect(stored?.agentMetadata?.awaitingLocalTool).toBe(false);
+    expect(stored?.toolCall?.status).toBe("complete");
+    expect(stored?.toolCall?.startedAt).toBe(1_000);
+    expect(stored?.toolCall?.completedAt).toBe(2_250);
+    expect(stored?.toolCall?.durationMs).toBe(1_250);
+    expect(stored?.toolCall?.result).toEqual({
+      content: [{ type: "text", text: "loaded jade" }],
+    });
+  });
+
   it("still resumes (with isError) when the bridge is not operational", async () => {
     // BugBot finding #1: previously, handleEvent skipped resolveWebMcpToolCall
     // entirely when `isWebMcpOperational()` was false — leaving the dispatch
@@ -152,6 +183,13 @@ describe("AgentWidgetSession — WebMCP resolve", () => {
 
     const msg = awaitingMessage("tool-1", "webmcp:search");
     await session.resolveWebMcpToolCall(msg);
+    const afterFailedResume = (
+      session as unknown as { messages: AgentWidgetMessage[] }
+    ).messages.find((m) => m.toolCall?.id === "tool-1");
+    expect(afterFailedResume?.toolCall?.status).toBe("running");
+    expect(afterFailedResume?.toolCall?.result).toBeUndefined();
+    expect(afterFailedResume?.toolCall?.durationMs).toBeUndefined();
+
     await session.resolveWebMcpToolCall(msg); // retry — must be allowed
     await session.resolveWebMcpToolCall(msg); // post-success — must be blocked
 
@@ -159,6 +197,29 @@ describe("AgentWidgetSession — WebMCP resolve", () => {
     expect(resumeSpy).toHaveBeenCalledTimes(2);
   });
 
+  it("marks the bubble complete with an error when browser execution throws before /resume", async () => {
+    const { session, resumeSpy } = makeSession({
+      executeImpl: async () => {
+        throw new Error("page tool exploded");
+      },
+    });
+
+    await session.resolveWebMcpToolCall(
+      awaitingMessage("tool-1", "webmcp:search"),
+    );
+
+    const stored = (
+      session as unknown as { messages: AgentWidgetMessage[] }
+    ).messages.find((m) => m.toolCall?.id === "tool-1");
+    expect(resumeSpy).not.toHaveBeenCalled();
+    expect(stored?.toolCall?.status).toBe("complete");
+    expect(stored?.toolCall?.durationMs).toBeGreaterThanOrEqual(0);
+    expect(stored?.toolCall?.result).toMatchObject({
+      isError: true,
+      content: [{ type: "text", text: "page tool exploded" }],
+    });
+  });
+
   it("threads an AbortSignal into resumeFlow", async () => {
     // BugBot finding #6: cancel() needs to propagate into /resume.
     const { session, resumeSpy } = makeSession();
@@ -189,6 +250,14 @@ describe("AgentWidgetSession — WebMCP resolve", () => {
     release();
     await inflight;
     expect(resumeSpy).not.toHaveBeenCalled();
+    const stored = (
+      session as unknown as { messages: AgentWidgetMessage[] }
+    ).messages.find((m) => m.toolCall?.id === "tool-1");
+    expect(stored?.toolCall?.status).toBe("complete");
+    expect(stored?.toolCall?.result).toMatchObject({
+      isError: true,
+      content: [{ type: "text", text: "Aborted by cancel()" }],
+    });
   });
 
   it("does NOT abort the shared session abortController", async () => {
@@ -282,11 +351,12 @@ describe("AgentWidgetSession — WebMCP resolve", () => {
     expect(executeSpy).not.toHaveBeenCalled();
   });
 
-  it("a stale step_await re-emit does not resurrect awaitingLocalTool once resolved", () => {
+  it("a stale step_await re-emit does not resurrect awaitingLocalTool or reset completed tool state once resolved", () => {
     // BugBot: a duplicate step_await (awaitingLocalTool:true) for an
     // already-resolved webmcp tool must not flip the message back to awaiting
-    // and show a stuck local-tool wait. upsertMessage clears it when the
-    // tool's `${executionId}:${toolCallId}` key is inflight/resolved.
+    // or running and show a stuck local-tool wait / lose the measured duration.
+    // upsertMessage clears it when the tool's `${executionId}:${toolCallId}`
+    // key is inflight/resolved.
     const session = makeSession().session;
     const s = session as unknown as {
       webMcpResolvedKeys: Set<string>;
@@ -298,11 +368,182 @@ describe("AgentWidgetSession — WebMCP resolve", () => {
     s.upsertMessage({
       ...awaitingMessage("tool-1", "webmcp:search"),
       agentMetadata: { executionId: "exec-1", awaitingLocalTool: false },
+      streaming: false,
+      toolCall: {
+        id: "tool-1",
+        name: "webmcp:search",
+        status: "complete",
+        args: { q: "shoes" },
+        result: { content: [{ type: "text", text: "ok" }] },
+        startedAt: 1_000,
+        completedAt: 2_200,
+        durationMs: 1_200,
+      },
+    });
+    // Stale re-emit flips awaiting back to true and carries the running state
+    // emitted by client.ts for WebMCP step_await events.
+    s.upsertMessage({
+      ...awaitingMessage("tool-1", "webmcp:search"),
+      streaming: false,
+      toolCall: {
+        id: "tool-1",
+        name: "webmcp:search",
+        status: "running",
+        args: { q: "shoes" },
+        startedAt: 3_000,
+      },
+    });
+    const stored = s.messages.find((m) => m.toolCall?.id === "tool-1");
+    expect(stored?.agentMetadata?.awaitingLocalTool).toBe(false);
+    expect(stored?.streaming).toBe(false);
+    expect(stored?.toolCall?.status).toBe("complete");
+    expect(stored?.toolCall?.result).toEqual({
+      content: [{ type: "text", text: "ok" }],
+    });
+    expect(stored?.toolCall?.startedAt).toBe(1_000);
+    expect(stored?.toolCall?.completedAt).toBe(2_200);
+    expect(stored?.toolCall?.durationMs).toBe(1_200);
+  });
+
+  it("a stale step_await re-emit does not reset in-flight WebMCP tool timing", () => {
+    const session = makeSession().session;
+    const s = session as unknown as {
+      webMcpInflightKeys: Set<string>;
+      upsertMessage: (m: AgentWidgetMessage) => void;
+      messages: AgentWidgetMessage[];
+    };
+    s.webMcpInflightKeys.add("exec-1:tool-1");
+    s.upsertMessage({
+      ...awaitingMessage("tool-1", "webmcp:search"),
+      agentMetadata: { executionId: "exec-1", awaitingLocalTool: false },
+      streaming: true,
+      toolCall: {
+        id: "tool-1",
+        name: "webmcp:search",
+        status: "running",
+        args: { q: "shoes" },
+        startedAt: 1_000,
+      },
+    });
+
+    s.upsertMessage({
+      ...awaitingMessage("tool-1", "webmcp:search"),
+      streaming: false,
+      toolCall: {
+        id: "tool-1",
+        name: "webmcp:search",
+        status: "running",
+        args: { q: "shoes" },
+        startedAt: 3_000,
+      },
     });
-    // Stale re-emit flips awaiting back to true on the wire.
-    s.upsertMessage(awaitingMessage("tool-1", "webmcp:search"));
+
     const stored = s.messages.find((m) => m.toolCall?.id === "tool-1");
     expect(stored?.agentMetadata?.awaitingLocalTool).toBe(false);
+    expect(stored?.streaming).toBe(true);
+    expect(stored?.toolCall?.status).toBe("running");
+    expect(stored?.toolCall?.startedAt).toBe(1_000);
+    expect(stored?.toolCall?.durationMs).toBeUndefined();
+  });
+
+  it("a stale step_await re-emit does not reset completed WebMCP local-error state", () => {
+    const session = makeSession().session;
+    const s = session as unknown as {
+      upsertMessage: (m: AgentWidgetMessage) => void;
+      messages: AgentWidgetMessage[];
+    };
+    s.upsertMessage({
+      ...awaitingMessage("tool-1", "webmcp:search"),
+      agentMetadata: { executionId: "exec-1", awaitingLocalTool: false },
+      streaming: false,
+      toolCall: {
+        id: "tool-1",
+        name: "webmcp:search",
+        status: "complete",
+        args: { q: "shoes" },
+        result: {
+          isError: true,
+          content: [{ type: "text", text: "page tool exploded" }],
+        },
+        startedAt: 1_000,
+        completedAt: 1_500,
+        durationMs: 500,
+      },
+    });
+
+    s.upsertMessage({
+      ...awaitingMessage("tool-1", "webmcp:search"),
+      streaming: false,
+      toolCall: {
+        id: "tool-1",
+        name: "webmcp:search",
+        status: "running",
+        args: { q: "shoes" },
+        startedAt: 3_000,
+      },
+    });
+
+    const stored = s.messages.find((m) => m.toolCall?.id === "tool-1");
+    expect(stored?.agentMetadata?.awaitingLocalTool).toBe(false);
+    expect(stored?.streaming).toBe(false);
+    expect(stored?.toolCall?.status).toBe("complete");
+    expect(stored?.toolCall?.result).toEqual({
+      isError: true,
+      content: [{ type: "text", text: "page tool exploded" }],
+    });
+    expect(stored?.toolCall?.startedAt).toBe(1_000);
+    expect(stored?.toolCall?.completedAt).toBe(1_500);
+    expect(stored?.toolCall?.durationMs).toBe(500);
+  });
+
+  it("a new execution reusing a completed tool id is not treated as stale", () => {
+    const session = makeSession().session;
+    const s = session as unknown as {
+      upsertMessage: (m: AgentWidgetMessage) => void;
+      messages: AgentWidgetMessage[];
+    };
+    s.upsertMessage({
+      ...awaitingMessage("tool-1", "webmcp:search"),
+      id: "tool-tool-1",
+      agentMetadata: { executionId: "exec-1", awaitingLocalTool: false },
+      streaming: false,
+      toolCall: {
+        id: "tool-1",
+        name: "webmcp:search",
+        status: "complete",
+        args: { q: "shoes" },
+        result: {
+          isError: true,
+          content: [{ type: "text", text: "page tool exploded" }],
+        },
+        startedAt: 1_000,
+        completedAt: 1_500,
+        durationMs: 500,
+      },
+    });
+
+    s.upsertMessage({
+      ...awaitingMessage("tool-1", "webmcp:search", "exec-2"),
+      id: "tool-tool-1",
+      streaming: false,
+      toolCall: {
+        id: "tool-1",
+        name: "webmcp:search",
+        status: "running",
+        args: { q: "boots" },
+        startedAt: 3_000,
+      },
+    });
+
+    const stored = s.messages.find((m) => m.id === "tool-tool-1");
+    expect(stored?.agentMetadata?.executionId).toBe("exec-2");
+    expect(stored?.agentMetadata?.awaitingLocalTool).toBe(true);
+    expect(stored?.toolCall?.status).toBe("running");
+    expect(stored?.toolCall?.args).toEqual({ q: "boots" });
+    expect(stored?.toolCall?.startedAt).toBe(3_000);
+    expect(stored?.toolCall?.result).toBeUndefined();
+    expect(stored?.toolCall?.completedAt).toBeUndefined();
+    expect(stored?.toolCall?.durationMs).toBeUndefined();
   });
 
   it("an error event does not clear streaming while a webmcp resolve is in flight", () => {
@@ -576,6 +817,10 @@ describe("AgentWidgetSession — WebMCP parallel batched resume (core#3878)", ()
     vi.clearAllMocks();
   });
 
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
   // A `step_await(local_tool_required)` message as client.ts emits it for a
   // PARALLEL local-tool call: the per-call `toolCallId` is both the toolCall.id
   // AND `agentMetadata.webMcpToolCallId`. Two of these for one executionId share
@@ -705,6 +950,81 @@ describe("AgentWidgetSession — WebMCP parallel batched resume (core#3878)", ()
     expect(Object.keys(toolOutputs).sort()).toEqual(["toolu_A", "toolu_B"]);
   });
 
+  it("records elapsed time for each resolved tool in a batched WebMCP resume", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(1_000);
+
+    let releaseA: (r: WebMcpToolResult) => void = () => undefined;
+    let releaseB: (r: WebMcpToolResult) => void = () => undefined;
+    const pA = new Promise<WebMcpToolResult>((r) => (releaseA = r));
+    const pB = new Promise<WebMcpToolResult>((r) => (releaseB = r));
+    const { session, resumeSpy } = makeSession();
+    const client = (session as unknown as { client: Record<string, unknown> })
+      .client;
+    (client.executeWebMcpToolCall as ReturnType<typeof vi.fn>).mockImplementation(
+      (_name: string, args: { sku: string }) =>
+        args.sku === "SHOE-001" ? pA : pB,
+    );
+
+    feed(session, parallelAwait("toolu_A", "SHOE-001"));
+    feed(session, parallelAwait("toolu_B", "SHOE-007"));
+    endStream(session);
+    await flushMicrotasks();
+
+    vi.setSystemTime(1_800);
+    releaseA({ content: [{ type: "text", text: "a" }] });
+    await flushMicrotasks();
+
+    let messages = (session as unknown as { messages: AgentWidgetMessage[] })
+      .messages;
+    const toolA = messages.find((m) => m.toolCall?.id === "toolu_A");
+    const toolBWhileRunning = messages.find((m) => m.toolCall?.id === "toolu_B");
+    expect(toolA?.toolCall?.status).toBe("running");
+    expect(toolA?.toolCall?.durationMs).toBeUndefined();
+    expect(toolBWhileRunning?.toolCall?.status).toBe("running");
+    expect(resumeSpy).not.toHaveBeenCalled();
+
+    vi.setSystemTime(2_600);
+    releaseB({ content: [{ type: "text", text: "b" }] });
+    await flushMicrotasks();
+
+    messages = (session as unknown as { messages: AgentWidgetMessage[] })
+      .messages;
+    const completedToolA = messages.find((m) => m.toolCall?.id === "toolu_A");
+    const toolB = messages.find((m) => m.toolCall?.id === "toolu_B");
+    expect(completedToolA?.toolCall?.status).toBe("complete");
+    expect(completedToolA?.toolCall?.durationMs).toBe(800);
+    expect(toolB?.toolCall?.status).toBe("complete");
+    expect(toolB?.toolCall?.durationMs).toBe(1_600);
+    expect(resumeSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not mark batched WebMCP bubbles complete when the shared /resume fails", async () => {
+    const { session, client, resumeSpy } = makeSession();
+    (client.resumeFlow as ReturnType<typeof vi.fn>).mockImplementationOnce(
+      async () => {
+        throw new Error("resume failed");
+      },
+    );
+
+    feed(session, parallelAwait("toolu_A", "SHOE-001"));
+    feed(session, parallelAwait("toolu_B", "SHOE-007"));
+    endStream(session);
+    await flushMicrotasks();
+
+    const messages = (session as unknown as { messages: AgentWidgetMessage[] })
+      .messages;
+    const toolA = messages.find((m) => m.toolCall?.id === "toolu_A");
+    const toolB = messages.find((m) => m.toolCall?.id === "toolu_B");
+    expect(resumeSpy).toHaveBeenCalledTimes(1);
+    expect(toolA?.toolCall?.status).toBe("running");
+    expect(toolA?.toolCall?.result).toBeUndefined();
+    expect(toolA?.toolCall?.durationMs).toBeUndefined();
+    expect(toolB?.toolCall?.status).toBe("running");
+    expect(toolB?.toolCall?.result).toBeUndefined();
+    expect(toolB?.toolCall?.durationMs).toBeUndefined();
+  });
+
   it("dedupes a duplicate parallel await within the same batch", async () => {
     const { session, executeSpy, resumeSpy } = makeSession();
     feed(session, parallelAwait("toolu_A", "SHOE-001"));

package/src/utils/code-generators.ts

@@ -141,6 +141,16 @@ export type CodeGeneratorOptions = {
    * Only affects script formats (script-installer, script-manual, script-advanced).
    */
   windowKey?: string;
+
+  /**
+   * CSS selector for the mount target. When omitted, the widget mounts on
+   * `body` (the existing default). When provided, the generated snippet mounts
+   * into that element: ESM / React / manual / advanced formats emit it as the
+   * `target` argument to `initAgentWidget()`, and `script-installer` serializes
+   * it into `data-config` (the installer reads `config.target`).
+   * @default "body"
+   */
+  target?: string;
 };
 
 // Internal type for normalized hooks (always strings)
@@ -540,6 +550,15 @@ function appendSerializableObjectBlock(
   lines.push(`${indent}},`);
 }
 
+/**
+ * Resolve the mount-target selector for a single-quoted JS string context.
+ * Defaults to `body` and escapes backslashes / single quotes so an arbitrary
+ * selector can't break out of the emitted `target: '...'` literal.
+ */
+function emitTargetSelector(options?: CodeGeneratorOptions): string {
+  return (options?.target ?? "body").replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+
 export function generateCodeSnippet(
   config: any,
   format: CodeFormat = "esm",
@@ -580,7 +599,7 @@ function generateESMCode(config: any, options?: CodeGeneratorOptions): string {
     "import { initAgentWidget, markdownPostprocessor } from '@runtypelabs/persona';",
     "",
     "initAgentWidget({",
-    "  target: 'body',",
+    `  target: '${emitTargetSelector(options)}',`,
     "  config: {"
   ];
 
@@ -726,7 +745,7 @@ function generateReactComponentCode(config: any, options?: CodeGeneratorOptions)
     "    let handle: AgentWidgetInitHandle | null = null;",
     "",
     "    handle = initAgentWidget({",
-    "      target: 'body',",
+    `      target: '${emitTargetSelector(options)}',`,
     "      config: {"
   ];
 
@@ -990,7 +1009,7 @@ function generateReactAdvancedCode(config: any, options?: CodeGeneratorOptions):
     "    };",
     "",
     "    handle = initAgentWidget({",
-    "      target: 'body',",
+    `      target: '${emitTargetSelector(options)}',`,
     "      config: {"
   ];
 
@@ -1356,10 +1375,20 @@ function buildSerializableConfig(config: any): Record<string, any> {
 function generateScriptInstallerCode(config: any, options?: CodeGeneratorOptions): string {
   const serializableConfig = buildSerializableConfig(config);
 
-  // When windowKey is provided, nest the widget config under `config` so the
-  // install script's parsedConfig.config detection picks it up alongside windowKey.
-  const payload = options?.windowKey
-    ? { config: serializableConfig, windowKey: options.windowKey }
+  // `windowKey` and `target` are INSTALLER options, not widget-config fields.
+  // install.ts reads them from the top level of data-config: the nested-`config`
+  // branch hoists every sibling key (Object.assign(scriptConfig, parsed)), while
+  // a flat payload becomes the widget config wholesale and its siblings are
+  // ignored. So whenever either is set we emit the nested `{ config, ...}` form
+  // with the option as a SIBLING of `config` — nesting `target` inside the
+  // widget config would leave the widget mounted on `body`.
+  const needsWrapper = Boolean(options?.windowKey || options?.target);
+  const payload = needsWrapper
+    ? {
+        config: serializableConfig,
+        ...(options?.windowKey ? { windowKey: options.windowKey } : {}),
+        ...(options?.target ? { target: options.target } : {}),
+      }
     : serializableConfig;
 
   // Escape single quotes in JSON for HTML attribute
@@ -1383,7 +1412,7 @@ function generateScriptManualCode(config: any, options?: CodeGeneratorOptions):
     "<!-- Initialize widget -->",
     "<script>",
     "  var handle = window.AgentWidget.initAgentWidget({",
-    "    target: 'body',",
+    `    target: '${emitTargetSelector(options)}',`,
     ...(options?.windowKey ? [`    windowKey: '${options.windowKey}',`] : []),
     "    config: {"
   ];
@@ -1735,7 +1764,7 @@ function generateScriptAdvancedCode(config: any, options?: CodeGeneratorOptions)
     "",
     "    // Initialize widget",
     "    var handle = agentWidget.initAgentWidget({",
-    "      target: 'body',",
+    `      target: '${emitTargetSelector(options)}',`,
     "      useShadowDom: false,",
     ...(options?.windowKey ? [`      windowKey: '${options.windowKey}',`] : []),
     "      config: widgetConfig",