@runtypelabs/persona 4.25.0 → 4.26.1

package/src/session-actions-chunk.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi } from "vitest";
+
+// Simulate the IIFE/CDN path: the session-actions chunk is not provided up
+// front and its load is held open by the test.
+const chunk = vi.hoisted(() => {
+  let release: (mod: unknown) => void = () => {};
+  const resolveApproval = vi.fn(async () => {});
+  return {
+    resolveApproval,
+    promise: new Promise((resolve) => {
+      release = resolve;
+    }),
+    release: () =>
+      release({
+        resolveApproval,
+        resolveAskUserQuestion: vi.fn(async () => {}),
+        resolveWebMcpToolCall: vi.fn(async () => {}),
+        resolveWebMcpToolCallBatch: vi.fn(async () => {}),
+      }),
+  };
+});
+
+vi.mock("./session-actions-loader", () => ({
+  getSessionActionsSync: () => null,
+  loadSessionActions: () => chunk.promise,
+  setSessionActionsLoader: () => {},
+  provideSessionActions: () => {},
+}));
+
+import { AgentWidgetSession } from "./session";
+
+const approval = {
+  id: "approval-1",
+  status: "pending" as const,
+  agentId: "agent-1",
+  executionId: "exec-1",
+  toolName: "do_thing",
+  description: "Do the thing",
+  parameters: {},
+};
+
+describe("session actions waiting on the lazy chunk", () => {
+  it("drops a resolve whose turn was stopped while the chunk loaded", async () => {
+    const session = new AgentWidgetSession({ apiUrl: "http://localhost:8000" }, {
+      onMessagesChanged: () => {},
+      onStatusChanged: () => {},
+      onStreamingChanged: () => {},
+    });
+    const pending = session.resolveApproval(approval as never, "approved");
+    session.cancel();
+    chunk.release();
+    await pending;
+    expect(chunk.resolveApproval).not.toHaveBeenCalled();
+  });
+});

package/src/session-actions-eager.ts

@@ -0,0 +1,11 @@
+/**
+ * Eager registration of the session resolve paths for the bundled (ESM / CJS)
+ * builds and tests, so approvals and local-tool resumes never take the async
+ * chunk hop there. Like `client-stream-eager.ts`, this module must NOT be
+ * reachable from `index-global.ts`: the IIFE/CDN build fetches the
+ * `session-actions.js` chunk.
+ */
+import * as sessionActions from "./session-actions";
+import { provideSessionActions } from "./session-actions-loader";
+
+provideSessionActions(sessionActions);

package/src/session-actions-loader.ts

@@ -0,0 +1,37 @@
+import { createChunkLoader } from "./utils/chunk-loader";
+import type {
+  resolveApproval,
+  resolveAskUserQuestion,
+  resolveWebMcpToolCall,
+  resolveWebMcpToolCallBatch,
+} from "./session-actions";
+
+/**
+ * Loader indirection for the session's approval / ask-user-question / WebMCP
+ * resolve paths (`session-actions.ts`). The ESM/CJS fallback imports
+ * `./session-actions` directly (inlined by `--splitting false`); the IIFE/CDN
+ * build marks it external and registers a loader for the sibling
+ * `session-actions.js` chunk (see `index-global.ts`).
+ */
+export type SessionActionsModule = {
+  resolveApproval: typeof resolveApproval;
+  resolveAskUserQuestion: typeof resolveAskUserQuestion;
+  resolveWebMcpToolCall: typeof resolveWebMcpToolCall;
+  resolveWebMcpToolCallBatch: typeof resolveWebMcpToolCallBatch;
+};
+
+const { setLoader, load, provide, getSync } = createChunkLoader<SessionActionsModule>({
+  fallbackImport: () => import("./session-actions"),
+});
+
+/** Override how the chunk is fetched (the IIFE build registers a sibling-URL loader). */
+export const setSessionActionsLoader = setLoader;
+
+/** Load the resolve paths. Memoized; retries after rejection. */
+export const loadSessionActions = load;
+
+/** Eagerly supply the module (`session-actions-eager.ts`: npm builds and tests). */
+export const provideSessionActions = provide;
+
+/** Synchronous access once loaded/provided; null before that. */
+export const getSessionActionsSync = getSync;