@runtypelabs/persona 4.25.0 → 4.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/persona",
-  "version": "4.25.0",
+  "version": "4.26.0",
   "description": "Themeable, pluggable streaming agent widget for websites, in plain JS with support for voice input and reasoning / tool output.",
   "type": "module",
   "main": "dist/index.cjs",
@@ -149,6 +149,7 @@
     "fake-indexeddb": "^6.2.5",
     "rimraf": "^5.0.5",
     "size-limit": "^12.1.0",
+    "terser": "^5.49.0",
     "tsup": "^8.0.1",
     "typescript": "^5.4.5",
     "vitest": "^4.0.9"
@@ -180,10 +181,15 @@
     "access": "public"
   },
   "scripts": {
-    "build": "rimraf dist && pnpm run build:styles && pnpm run build:markdown-parsers && pnpm run build:client && pnpm run build:installer && pnpm run build:launcher && pnpm run build:webmcp-polyfill && pnpm run build:context-mentions && pnpm run build:context-mentions-inline && pnpm run build:history-view && pnpm run build:event-stream-view && pnpm run build:runtype-tts && pnpm run build:theme-ref && pnpm run build:codegen && pnpm run build:theme-editor && pnpm run build:theme-editor-preview && pnpm run build:testing && pnpm run build:smart-dom-reader && pnpm run build:voice-worklet-player && pnpm run build:plugin-kit && pnpm run build:animations && pnpm run build:animations-extra && pnpm run build:approval-ui && pnpm run build:session-reconnect && pnpm run build:webmcp-runtime && pnpm run build:icons-extra && pnpm run build:artifacts-ui && pnpm run build:voice-runtime && pnpm run build:forms-ui && pnpm run check:dist-vite8 && pnpm run check:size",
+    "build": "rimraf dist && pnpm run build:styles && pnpm run build:markdown-parsers && pnpm run build:client-stream && pnpm run build:client-history && pnpm run build:ui-extras && pnpm run build:session-actions && pnpm run build:history-shell && pnpm run build:client && pnpm run build:installer && pnpm run build:launcher && pnpm run build:webmcp-polyfill && pnpm run build:context-mentions && pnpm run build:context-mentions-inline && pnpm run build:history-view && pnpm run build:event-stream-view && pnpm run build:runtype-tts && pnpm run build:theme-ref && pnpm run build:codegen && pnpm run build:theme-editor && pnpm run build:theme-editor-preview && pnpm run build:testing && pnpm run build:smart-dom-reader && pnpm run build:voice-worklet-player && pnpm run build:plugin-kit && pnpm run build:animations && pnpm run build:animations-extra && pnpm run build:approval-ui && pnpm run build:session-reconnect && pnpm run build:webmcp-runtime && pnpm run build:icons-extra && pnpm run build:artifacts-ui && pnpm run build:voice-runtime && pnpm run build:forms-ui && pnpm run check:dist-vite8 && pnpm run check:size",
     "check:size": "node scripts/check-size.mjs",
     "check:dist-vite8": "node scripts/check-dist-no-in-for-init.mjs",
     "build:markdown-parsers": "tsup --config tsup.markdown-parsers.config.ts",
+    "build:client-stream": "tsup --config tsup.client-stream.config.ts",
+    "build:client-history": "tsup --config tsup.client-history.config.ts",
+    "build:ui-extras": "tsup --config tsup.ui-extras.config.ts",
+    "build:session-actions": "tsup --config tsup.session-actions.config.ts",
+    "build:history-shell": "tsup --config tsup.history-shell.config.ts",
     "build:plugin-kit": "tsup src/plugin-kit.ts --format esm,cjs --minify --dts --out-dir dist --no-splitting",
     "build:theme-editor": "tsup src/theme-editor.ts --format esm,cjs --minify --dts --out-dir dist --no-splitting",
     "build:theme-editor-preview": "tsup src/theme-editor-preview.ts --format esm,cjs --minify --dts --out-dir dist",
@@ -202,14 +208,14 @@
     "build:theme-ref": "tsup src/theme-reference.ts --format esm,cjs --minify --dts",
     "build:codegen": "tsup src/codegen.ts --format esm,cjs --minify --dts",
     "build:styles": "node scripts/build-styles.mjs",
-    "build:client": "tsup src/index.ts --format esm,cjs --minify --sourcemap --splitting false --dts --loader \".css=text\" --external @runtypelabs/persona/context-mentions --external @runtypelabs/persona/context-mentions-inline --external @runtypelabs/persona/history-view --external @runtypelabs/persona/event-stream-view --external @runtypelabs/persona/animations-extra --external @runtypelabs/persona/approval-ui --external @runtypelabs/persona/session-reconnect --external @runtypelabs/persona/webmcp-runtime --external @runtypelabs/persona/icons-extra --external @runtypelabs/persona/artifacts-ui --external @runtypelabs/persona/voice-runtime --external @runtypelabs/persona/forms-ui && tsup --config tsup.global.config.ts && node -e \"const fs=require('fs');for(const ext of ['.global.js','.global.js.map']){const from='dist/index-global'+ext;if(fs.existsSync(from))fs.renameSync(from,'dist/index'+ext);}\"",
+    "build:client": "tsup src/index.ts --format esm,cjs --minify --sourcemap --splitting false --dts --loader \".css=text\" --external @runtypelabs/persona/context-mentions --external @runtypelabs/persona/context-mentions-inline --external @runtypelabs/persona/history-view --external @runtypelabs/persona/event-stream-view --external @runtypelabs/persona/animations-extra --external @runtypelabs/persona/approval-ui --external @runtypelabs/persona/session-reconnect --external @runtypelabs/persona/webmcp-runtime --external @runtypelabs/persona/icons-extra --external @runtypelabs/persona/artifacts-ui --external @runtypelabs/persona/voice-runtime --external @runtypelabs/persona/forms-ui && tsup --config tsup.global.config.ts && node -e \"const fs=require('fs');for(const ext of ['.global.js','.global.js.map']){const from='dist/index-global'+ext;if(fs.existsSync(from))fs.renameSync(from,'dist/index'+ext);}\" && node scripts/terser-global.mjs dist/index.global.js",
     "build:webmcp-polyfill": "tsup --config tsup.webmcp-polyfill.config.ts",
     "build:context-mentions": "tsup --config tsup.context-mentions.config.ts",
     "build:context-mentions-inline": "tsup --config tsup.context-mentions-inline.config.ts",
     "build:history-view": "tsup --config tsup.history-view.config.ts",
     "build:runtype-tts": "tsup --config tsup.runtype-tts.config.ts",
-    "build:installer": "tsup src/install.ts --format iife --global-name SiteAgentInstaller --out-dir dist --minify --sourcemap --no-splitting",
-    "build:launcher": "tsup --config tsup.launcher.config.ts && node -e \"const fs=require('fs');for(const ext of ['.global.js','.global.js.map']){const from='dist/launcher-global'+ext;if(fs.existsSync(from))fs.renameSync(from,'dist/launcher'+ext);}\"",
+    "build:installer": "tsup src/install.ts --format iife --global-name SiteAgentInstaller --out-dir dist --minify --sourcemap --no-splitting && node scripts/terser-global.mjs dist/install.global.js",
+    "build:launcher": "tsup --config tsup.launcher.config.ts && node -e \"const fs=require('fs');for(const ext of ['.global.js','.global.js.map']){const from='dist/launcher-global'+ext;if(fs.existsSync(from))fs.renameSync(from,'dist/launcher'+ext);}\" && node scripts/terser-global.mjs dist/launcher.global.js",
     "lint": "eslint . --ext .ts",
     "typecheck": "pnpm run check:runtype-types && tsc --noEmit",
     "test": "vitest",

package/src/approval-paused-tool-settle.test.ts

@@ -0,0 +1,221 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { AgentWidgetClient } from "./client";
+import { AgentWidgetSession } from "./session";
+import type { AgentWidgetMessage } from "./types";
+
+// An approval resume re-runs the agent, which re-issues the gated call under a
+// NEW toolCallId, so no terminal tool frame ever arrives for the paused one.
+// The session settles the paused bubble from the server's approval_complete.
+
+const originalFetch = global.fetch;
+afterEach(() => {
+  global.fetch = originalFetch;
+  vi.restoreAllMocks();
+});
+
+const sse = (events: Array<Record<string, unknown>>) =>
+  new Response(events.map((e) => `data: ${JSON.stringify(e)}\n\n`).join(""), {
+    headers: { "Content-Type": "text/event-stream" },
+  });
+
+const liveSession = (client: AgentWidgetClient) => {
+  (client as unknown as { clientSession: { sessionId: string; expiresAt: Date } }).clientSession = {
+    sessionId: "cs_123",
+    expiresAt: new Date(Date.now() + 60_000),
+  };
+};
+
+const pausedTool = (status: "running" | "complete" = "running"): AgentWidgetMessage => ({
+  id: "tool-toolu_paused",
+  role: "assistant",
+  content: "",
+  createdAt: new Date(Date.now() - 2_000).toISOString(),
+  streaming: status === "running",
+  variant: "tool",
+  toolCall: {
+    id: "toolu_paused",
+    name: "place_pickup_order",
+    status,
+    args: { item: "latte" },
+    startedAt: Date.now() - 2_000,
+  },
+});
+
+const pendingApproval = (toolCallId?: string): AgentWidgetMessage => ({
+  id: "approval-appr_1",
+  role: "assistant",
+  content: "",
+  createdAt: new Date(Date.now() - 1_000).toISOString(),
+  variant: "approval",
+  approval: {
+    id: "appr_1",
+    status: "pending",
+    agentId: "agent_abc",
+    executionId: "exec_abc",
+    toolName: "place_pickup_order",
+    description: "Place the order",
+    ...(toolCallId ? { toolCallId } : {}),
+  },
+});
+
+const setup = (initialMessages: AgentWidgetMessage[]) => {
+  let messages: AgentWidgetMessage[] = [];
+  const session = new AgentWidgetSession(
+    { clientToken: "ct_live_demo", apiUrl: "https://api.runtype.com", initialMessages },
+    {
+      onMessagesChanged: (m) => { messages = m; },
+      onStatusChanged: () => {},
+      onStreamingChanged: () => {},
+      onError: () => {},
+    }
+  );
+  liveSession((session as unknown as { client: AgentWidgetClient }).client);
+  const approval = initialMessages.find((m) => m.variant === "approval")!.approval!;
+  return {
+    resolve: (decision: "approved" | "denied") => session.resolveApproval(approval, decision),
+    tool: (id = "toolu_paused") => messages.find((m) => m.toolCall?.id === id),
+  };
+};
+
+const resumeStream = (decision: "approved" | "denied" | "timeout", rerun = true) =>
+  sse([
+    { type: "approval_complete", executionId: "exec_abc", approvalId: "appr_1", decision },
+    ...(rerun
+      ? [
+          { type: "tool_start", toolCallId: "toolu_rerun", toolName: "place_pickup_order", toolType: "custom" },
+          {
+            type: "tool_complete",
+            toolCallId: "toolu_rerun",
+            toolName: "place_pickup_order",
+            success: decision === "approved",
+            result: decision === "approved" ? { orderId: "ord_1" } : undefined,
+          },
+        ]
+      : []),
+    { type: "execution_complete", kind: "agent", success: true },
+  ]);
+
+describe("approval_start records the paused toolCallId", () => {
+  it("carries toolCallId onto the approval message", async () => {
+    const client = new AgentWidgetClient({ clientToken: "ct_live_demo", apiUrl: "https://api.runtype.com" });
+    const emitted: AgentWidgetMessage[] = [];
+    await client.processStream(
+      sse([
+        {
+          type: "approval_start",
+          executionId: "exec_abc",
+          approvalId: "appr_1",
+          toolCallId: "toolu_paused",
+          toolName: "place_pickup_order",
+          parameters: { item: "latte" },
+        },
+      ]).body!,
+      (event) => {
+        if (event.type === "message") emitted.push(event.message);
+      }
+    );
+    const approvalMessage = emitted.find((m) => m.variant === "approval");
+    expect(approvalMessage?.approval?.toolCallId).toBe("toolu_paused");
+  });
+});
+
+describe("AgentWidgetSession settles the approval-paused tool bubble", () => {
+  it("marks an approved call superseded and leaves the result on the re-run", async () => {
+    global.fetch = vi.fn().mockResolvedValue(resumeStream("approved"));
+    const { resolve, tool } = setup([pausedTool(), pendingApproval("toolu_paused")]);
+    await resolve("approved");
+
+    expect(tool()?.toolCall).toMatchObject({
+      status: "complete",
+      approvalStatus: "approved",
+      superseded: true,
+    });
+    expect(tool()?.toolCall?.success).toBeUndefined();
+    expect(tool()?.streaming).toBe(false);
+    expect(tool("toolu_rerun")?.toolCall).toMatchObject({
+      status: "complete",
+      result: { orderId: "ord_1" },
+    });
+  });
+
+  it("settles a denied call as failed with a Denied error", async () => {
+    global.fetch = vi.fn().mockResolvedValue(resumeStream("denied", false));
+    const { resolve, tool } = setup([pausedTool(), pendingApproval("toolu_paused")]);
+    await resolve("denied");
+
+    expect(tool()?.toolCall).toMatchObject({
+      status: "complete",
+      approvalStatus: "denied",
+      success: false,
+      error: "Denied",
+    });
+    expect(tool()?.toolCall?.superseded).toBeUndefined();
+  });
+
+  it("settles a timed-out call as failed", async () => {
+    global.fetch = vi.fn().mockResolvedValue(resumeStream("timeout", false));
+    const { resolve, tool } = setup([pausedTool(), pendingApproval("toolu_paused")]);
+    await resolve("denied");
+
+    expect(tool()?.toolCall).toMatchObject({
+      status: "complete",
+      approvalStatus: "timeout",
+      success: false,
+      error: "Approval timed out",
+    });
+  });
+
+  it("leaves the bubble running when the server refuses the decision", async () => {
+    global.fetch = vi.fn().mockResolvedValue(Response.json({ error: "Failed to process approval" }, { status: 500 }));
+    const { resolve, tool } = setup([pausedTool(), pendingApproval("toolu_paused")]);
+    await resolve("approved").catch(() => {});
+
+    expect(tool()?.toolCall?.status).toBe("running");
+    expect(tool()?.toolCall?.approvalStatus).toBeUndefined();
+  });
+
+  it("settles the call as timed out when the server reports the pause gone", async () => {
+    global.fetch = vi.fn().mockResolvedValue(
+      Response.json({ code: "APPROVAL_ALREADY_RESOLVED", message: "Already resolved" }, { status: 409 })
+    );
+    const { resolve, tool } = setup([pausedTool(), pendingApproval("toolu_paused")]);
+    await resolve("approved").catch(() => {});
+
+    expect(tool()?.toolCall).toMatchObject({
+      status: "complete",
+      approvalStatus: "timeout",
+      success: false,
+      error: "Approval timed out",
+    });
+  });
+
+  it("does not touch a tool call that already completed", async () => {
+    global.fetch = vi.fn().mockResolvedValue(resumeStream("denied", false));
+    const { resolve, tool } = setup([pausedTool("complete"), pendingApproval("toolu_paused")]);
+    await resolve("denied");
+
+    expect(tool()?.toolCall?.success).toBeUndefined();
+    expect(tool()?.toolCall?.approvalStatus).toBeUndefined();
+  });
+
+  it("does nothing for an approval without a toolCallId", async () => {
+    global.fetch = vi.fn().mockResolvedValue(resumeStream("denied", false));
+    const { resolve, tool } = setup([pausedTool(), pendingApproval()]);
+    await resolve("denied");
+
+    expect(tool()?.toolCall?.status).toBe("running");
+  });
+
+  it("settles a denied call when the accepted denial has no stream body", async () => {
+    global.fetch = vi.fn().mockResolvedValue(new Response(null, { status: 200 }));
+    const { resolve, tool } = setup([pausedTool(), pendingApproval("toolu_paused")]);
+    await resolve("denied");
+
+    expect(tool()?.toolCall).toMatchObject({
+      status: "complete",
+      approvalStatus: "denied",
+      success: false,
+      error: "Denied",
+    });
+  });
+});

package/src/client-approve.test.ts

@@ -0,0 +1,311 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { AgentWidgetClient } from "./client";
+import { AgentWidgetSession } from "./session";
+import type { AgentWidgetMessage } from "./types";
+
+// runtypelabs/core#9518: client-token embeds answer `approver: 'end-user'`
+// gates through the session-authenticated `/v1/client/approve`.
+
+const originalFetch = global.fetch;
+afterEach(() => {
+  global.fetch = originalFetch;
+  vi.restoreAllMocks();
+});
+
+const approval = { agentId: "agent_abc", executionId: "exec_abc", approvalId: "appr_1" };
+
+const liveSession = (client: AgentWidgetClient) => {
+  // A live session so initSession() short-circuits instead of fetching /init.
+  (client as unknown as { clientSession: { sessionId: string; expiresAt: Date } }).clientSession = {
+    sessionId: "cs_123",
+    expiresAt: new Date(Date.now() + 60_000),
+  };
+};
+
+const sse = (events: Array<Record<string, unknown>>) =>
+  new Response(events.map((e) => `data: ${JSON.stringify(e)}\n\n`).join(""), {
+    headers: { "Content-Type": "text/event-stream" },
+  });
+
+type Call = { url: string; body: Record<string, unknown>; headers: Record<string, string> };
+
+const mockFetch = (...responses: Response[]) => {
+  const calls: Call[] = [];
+  global.fetch = vi.fn().mockImplementation(async (url: string, init: RequestInit) => {
+    calls.push({
+      url,
+      body: JSON.parse(init.body as string),
+      headers: init.headers as Record<string, string>,
+    });
+    return responses.shift() ?? sse([]);
+  });
+  return calls;
+};
+
+const tokenClient = () => {
+  const client = new AgentWidgetClient({ clientToken: "ct_live_demo", apiUrl: "https://api.runtype.com" });
+  liveSession(client);
+  return client;
+};
+
+describe("AgentWidgetClient.resolveApproval", () => {
+  it("posts a client-token decision to /v1/client/approve with the session and no Bearer key", async () => {
+    const calls = mockFetch(sse([]));
+    await tokenClient().resolveApproval(approval, "approved");
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0].url).toBe("https://api.runtype.com/v1/client/approve");
+    expect(calls[0].body).toEqual({
+      sessionId: "cs_123",
+      executionId: "exec_abc",
+      approvalId: "appr_1",
+      decision: "approved",
+      streamResponse: true,
+    });
+    expect(calls[0].headers.Authorization).toBeUndefined();
+  });
+
+  it("sends a denial the same way", async () => {
+    const calls = mockFetch(sse([]));
+    await tokenClient().resolveApproval(approval, "denied");
+
+    expect(calls[0].url).toBe("https://api.runtype.com/v1/client/approve");
+    expect(calls[0].body.decision).toBe("denied");
+  });
+
+  it("falls back to the owner route when the core predates /v1/client/approve", async () => {
+    const calls = mockFetch(
+      Response.json({ error: "Not Found", message: "The requested resource was not found" }, { status: 404 }),
+      sse([])
+    );
+    const response = await tokenClient().resolveApproval(approval, "approved");
+
+    expect(calls.map((c) => c.url)).toEqual([
+      "https://api.runtype.com/v1/client/approve",
+      "https://api.runtype.com/v1/agents/agent_abc/approve",
+    ]);
+    expect(calls[1].body.sessionId).toBeUndefined();
+    expect(response.ok).toBe(true);
+  });
+
+  it("returns an unknown or expired pause 404 without falling back", async () => {
+    const calls = mockFetch(
+      Response.json({ error: "No paused execution found for this executionId" }, { status: 404 })
+    );
+    const response = await tokenClient().resolveApproval(approval, "approved");
+
+    expect(calls).toHaveLength(1);
+    expect(response.status).toBe(404);
+  });
+
+  it("keeps proxy mode on the owner route with the host headers", async () => {
+    const calls = mockFetch(sse([]));
+    const client = new AgentWidgetClient({
+      apiUrl: "https://api.runtype.com/v1/dispatch",
+      headers: { Authorization: "Bearer host" },
+    });
+    await client.resolveApproval(approval, "approved");
+
+    expect(calls[0].url).toBe("https://api.runtype.com/v1/agents/agent_abc/approve");
+    expect(calls[0].body).toEqual({
+      executionId: "exec_abc",
+      approvalId: "appr_1",
+      decision: "approved",
+      streamResponse: true,
+    });
+    expect(calls[0].headers.Authorization).toBe("Bearer host");
+  });
+});
+
+describe("AgentWidgetSession.resolveApproval in client-token mode", () => {
+  const setup = () => {
+    let messages: AgentWidgetMessage[] = [];
+    const errors: Error[] = [];
+    const pending: AgentWidgetMessage = {
+      id: "approval-appr_1",
+      role: "assistant",
+      content: "",
+      createdAt: new Date().toISOString(),
+      variant: "approval",
+      approval: {
+        id: "appr_1",
+        status: "pending",
+        agentId: "agent_abc",
+        executionId: "exec_abc",
+        toolName: "place_pickup_order",
+        description: "Place the order",
+      },
+    };
+    const session = new AgentWidgetSession(
+      { clientToken: "ct_live_demo", apiUrl: "https://api.runtype.com", initialMessages: [pending] },
+      {
+        onMessagesChanged: (m) => { messages = m; },
+        onStatusChanged: () => {},
+        onStreamingChanged: () => {},
+        onError: (e) => errors.push(e),
+      }
+    );
+    liveSession((session as unknown as { client: AgentWidgetClient }).client);
+    return {
+      session,
+      errors,
+      approve: (decision: "approved" | "denied" = "approved") =>
+        session.resolveApproval(pending.approval!, decision),
+      bubble: () => messages.find((m) => m.id === "approval-appr_1"),
+      last: () => messages.at(-1),
+      all: () => messages,
+    };
+  };
+
+  it("streams the approved continuation into the conversation", async () => {
+    mockFetch(
+      sse([
+        { type: "approval_complete", executionId: "exec_abc", approvalId: "appr_1", decision: "approved" },
+        { type: "text_start", id: "t1" },
+        { type: "text_delta", id: "t1", delta: "Order placed." },
+        { type: "text_complete", id: "t1" },
+        { type: "execution_complete", kind: "agent", success: true },
+      ])
+    );
+    const { session, errors, approve, bubble, last } = setup();
+    await approve();
+
+    expect(bubble()?.approval?.status).toBe("approved");
+    expect(last()?.content).toBe("Order placed.");
+    expect(session.isStreaming()).toBe(false);
+    expect(errors).toEqual([]);
+  });
+
+  it.each([
+    [
+      403,
+      {
+        error: "This approval needs the business owner, not the chat visitor",
+        code: "APPROVAL_APPROVER_NOT_END_USER",
+      },
+      "This approval needs the business owner, not the chat visitor",
+      "pending",
+    ],
+    [
+      409,
+      {
+        error: "Approval already resolved",
+        message: "This approval was already denied; that decision is the one in force.",
+        code: "APPROVAL_ALREADY_RESOLVED",
+      },
+      "This approval was already denied; that decision is the one in force.",
+      "timeout",
+    ],
+    [
+      404,
+      { error: "No paused execution found for this executionId" },
+      "No paused execution found for this executionId",
+      "timeout",
+    ],
+    [404, { error: "Agent not found" }, "Agent not found", "pending"],
+    [500, { error: "Failed to process approval" }, "Failed to process approval", "pending"],
+  ])("surfaces a %i refusal without claiming the decision applied", async (status, body, text, badge) => {
+    mockFetch(Response.json(body, { status }));
+    const { session, errors, approve, bubble, last } = setup();
+    await approve();
+
+    expect(bubble()?.approval?.status).toBe(badge);
+    expect(last()).toMatchObject({ id: "approval-error-appr_1", content: text });
+    expect(session.isStreaming()).toBe(false);
+    expect(errors.map((e) => e.message)).toEqual([text]);
+    // A refused request settles too: its token must not outlive it.
+    expect((session as unknown as { approvalTokens: Map<string, object> }).approvalTokens.size).toBe(0);
+  });
+
+  it("clears the failure notice when a retry succeeds", async () => {
+    mockFetch(
+      Response.json({ error: "Failed to process approval" }, { status: 500 }),
+      sse([{ type: "approval_complete", executionId: "exec_abc", approvalId: "appr_1", decision: "approved" }])
+    );
+    const { approve, bubble, all } = setup();
+    await approve();
+    expect(bubble()?.approval?.status).toBe("pending");
+    await approve();
+
+    expect(bubble()?.approval?.status).toBe("approved");
+    expect(all().some((m) => m.id === "approval-error-appr_1")).toBe(false);
+  });
+
+  it("does not overwrite a card a newer resolution already settled", async () => {
+    let failFirst!: (r: Response) => void;
+    global.fetch = vi
+      .fn()
+      .mockImplementationOnce(() => new Promise<Response>((res) => { failFirst = res; }))
+      .mockImplementationOnce(async () =>
+        sse([{ type: "approval_complete", executionId: "exec_abc", approvalId: "appr_1", decision: "approved" }])
+      );
+    const { approve, bubble, all } = setup();
+    const first = approve();
+    await new Promise((r) => setTimeout(r, 0));
+    await new Promise((r) => setTimeout(r, 2));
+    await approve();
+    failFirst(Response.json({ error: "Failed to process approval" }, { status: 500 }));
+    await first;
+
+    expect(bubble()?.approval?.status).toBe("approved");
+    expect(all().some((m) => m.id === "approval-error-appr_1")).toBe(false);
+  });
+
+  it("does not let an older failure reopen a card a newer decision settled in the same millisecond", async () => {
+    // Both decisions (and the newer one's approval_complete) stamp the same
+    // Date.now(), so only a per-request token tells the older failure apart.
+    vi.spyOn(Date, "now").mockReturnValue(Date.now());
+    let failFirst!: (r: Response) => void;
+    global.fetch = vi
+      .fn()
+      .mockImplementationOnce(() => new Promise<Response>((res) => { failFirst = res; }))
+      .mockImplementationOnce(async () =>
+        sse([{ type: "approval_complete", executionId: "exec_abc", approvalId: "appr_1", decision: "denied" }])
+      );
+    const { session, approve, bubble, all } = setup();
+    const first = approve("approved");
+    await new Promise((r) => setTimeout(r, 0));
+    await approve("denied");
+    expect(bubble()?.approval?.status).toBe("denied");
+    failFirst(Response.json({ error: "Failed to process approval" }, { status: 500 }));
+    await first;
+
+    expect(bubble()?.approval?.status).toBe("denied");
+    expect(all().some((m) => m.id === "approval-error-appr_1")).toBe(false);
+    // Both requests settled: no token outlives them.
+    expect((session as unknown as { approvalTokens: Map<string, object> }).approvalTokens.size).toBe(0);
+    vi.restoreAllMocks();
+  });
+
+  it("does not let an older success clear a newer request's failure notice", async () => {
+    let succeedFirst!: (r: Response) => void;
+    global.fetch = vi
+      .fn()
+      .mockImplementationOnce(() => new Promise<Response>((res) => { succeedFirst = res; }))
+      .mockResolvedValueOnce(Response.json({ error: "Failed to process approval" }, { status: 500 }));
+    const { approve, all } = setup();
+    const first = approve();
+    await new Promise((r) => setTimeout(r, 0));
+    await new Promise((r) => setTimeout(r, 2));
+    await approve();
+    expect(all().some((m) => m.id === "approval-error-appr_1")).toBe(true);
+    succeedFirst(
+      sse([{ type: "approval_complete", executionId: "exec_abc", approvalId: "appr_1", decision: "approved" }])
+    );
+    await first;
+
+    expect(all().some((m) => m.id === "approval-error-appr_1")).toBe(true);
+  });
+
+  it("keeps the failure notice when a retry rejects without a response", async () => {
+    global.fetch = vi
+      .fn()
+      .mockResolvedValueOnce(Response.json({ error: "Failed to process approval" }, { status: 500 }))
+      .mockRejectedValueOnce(new TypeError("Failed to fetch"));
+    const { approve, all } = setup();
+    await approve();
+    await approve();
+
+    expect(all().find((m) => m.id === "approval-error-appr_1")?.content).toBe("Failed to process approval");
+  });
+});

package/src/client-history-eager.ts

@@ -0,0 +1,9 @@
+/**
+ * Eager history-REST registration for the bundled (ESM / CJS) builds and
+ * tests. Like `markdown-parsers-eager.ts`, this module must NOT be reachable
+ * from `index-global.ts`: the IIFE/CDN build fetches `client-history.js`.
+ */
+import * as clientHistory from "./client-history";
+import { provideClientHistory } from "./client-history-loader";
+
+provideClientHistory(clientHistory);

package/src/client-history-loader.ts

@@ -0,0 +1,23 @@
+import { createChunkLoader } from "./utils/chunk-loader";
+
+/**
+ * Loader indirection for the visitor-history REST functions
+ * (`client-history.ts`). The ESM/CJS fallback imports `./client-history`
+ * directly (inlined by `--splitting false`); the IIFE/CDN build marks it
+ * external and registers a loader for the sibling `client-history.js` chunk
+ * (see `index-global.ts`).
+ */
+export type ClientHistoryModule = typeof import("./client-history");
+
+const { setLoader, load, provide } = createChunkLoader<ClientHistoryModule>({
+  fallbackImport: () => import("./client-history"),
+});
+
+/** Override how the chunk is fetched (the IIFE build registers a sibling-URL loader). */
+export const setClientHistoryLoader = setLoader;
+
+/** Load the history REST functions. Memoized; retries after rejection. */
+export const loadClientHistory = load;
+
+/** Eagerly supply the module (`client-history-eager.ts`: npm builds and tests). */
+export const provideClientHistory = provide;