@athenaintel/react 0.18.0 → 0.20.0

package/dist/packages/agent-runtime/src/client-tool-bridge.cjs

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const react = require("react");
+const clientTools = require("./client-tools.cjs");
+const CLIENT_TOOL_WRITE_DECLINED_MESSAGE = "The user declined this edit. Do not retry it; ask the user how to proceed.";
+function defaultMissingClientToolMessage(toolName) {
+  return `This surface has no tool named '${toolName}'.`;
+}
+function clientToolClaimKey(threadId, requestId) {
+  return `${threadId}:${requestId}`;
+}
+const CLIENT_TOOL_RESUME_RETRY_DELAYS_MS = [2e3, 5e3, 1e4, 15e3, 3e4];
+const MAX_CLIENT_TOOL_RESUME_ATTEMPTS = 25;
+function clientToolResumeRetryDelayMs(attemptNumber) {
+  const index = Math.min(
+    Math.max(attemptNumber - 1, 0),
+    CLIENT_TOOL_RESUME_RETRY_DELAYS_MS.length - 1
+  );
+  return CLIENT_TOOL_RESUME_RETRY_DELAYS_MS[index] ?? 3e4;
+}
+function jsonSafeClientToolResult(value) {
+  const serialized = JSON.stringify(value);
+  return serialized === void 0 ? null : JSON.parse(serialized);
+}
+function isPendingClientToolRequest(request) {
+  if (request.type !== "interrupt" || "response" in request) return false;
+  return clientTools.isClientToolInterrupt(request.payload);
+}
+async function executeClientToolBatch(options) {
+  const {
+    calls,
+    tools,
+    isLive,
+    confirmWrites,
+    writeDeclinedMessage = CLIENT_TOOL_WRITE_DECLINED_MESSAGE,
+    missingToolMessage = defaultMissingClientToolMessage,
+    onCallSettled,
+    onExecutionStart
+  } = options;
+  const registry = new Map(tools.map((tool) => [tool.name, tool]));
+  let writesDeclined = false;
+  const writeToolNames = calls.filter((call) => {
+    var _a;
+    return ((_a = registry.get(call.tool_name)) == null ? void 0 : _a.requiresWrite) === true;
+  }).map((call) => call.tool_name);
+  if (writeToolNames.length > 0 && confirmWrites) {
+    const decision = await confirmWrites({ writeToolNames });
+    if (decision === "abandoned" || !isLive()) {
+      return null;
+    }
+    writesDeclined = decision === "declined";
+  }
+  onExecutionStart == null ? void 0 : onExecutionStart();
+  const results = {};
+  for (const call of calls) {
+    if (!isLive()) return null;
+    const tool = registry.get(call.tool_name);
+    let envelope;
+    let status = "success";
+    let errorType;
+    if (!tool) {
+      envelope = clientTools.clientToolErrorEnvelope(missingToolMessage(call.tool_name));
+      status = "error";
+      errorType = "UnknownClientTool";
+    } else if (tool.requiresWrite === true && writesDeclined) {
+      envelope = clientTools.clientToolErrorEnvelope(writeDeclinedMessage);
+      status = "declined";
+    } else {
+      try {
+        envelope = clientTools.clientToolSuccessEnvelope(
+          jsonSafeClientToolResult(
+            await tool.run(clientTools.clientToolCallArgs(call), {
+              toolCallId: call.interrupt_id
+            })
+          )
+        );
+      } catch (error) {
+        envelope = clientTools.clientToolErrorEnvelope(error);
+        status = "error";
+        errorType = error instanceof Error ? error.name : typeof error;
+      }
+    }
+    results[call.interrupt_id] = envelope;
+    onCallSettled == null ? void 0 : onCallSettled({
+      toolName: call.tool_name,
+      status,
+      ...errorType !== void 0 ? { errorType } : {}
+    });
+  }
+  return isLive() ? results : null;
+}
+function useStatewireClientToolBridge(options) {
+  const { threadId, tracker, inputRequests, logLabel = "[AthenaSDK]" } = options;
+  const optionsRef = react.useRef(options);
+  optionsRef.current = options;
+  const pendingRequest = inputRequests == null ? void 0 : inputRequests.find(isPendingClientToolRequest);
+  const ownedClaimsRef = react.useRef(/* @__PURE__ */ new Set());
+  const startedClaimsRef = react.useRef(/* @__PURE__ */ new Set());
+  const resumeOwnerRef = react.useRef(Symbol("client-tool-resume-owner"));
+  const resumeClaimsRef = react.useRef(/* @__PURE__ */ new Set());
+  const resumeTimersRef = react.useRef(/* @__PURE__ */ new Map());
+  const activeRef = react.useRef(true);
+  const releaseClaim = react.useCallback(
+    (claim) => {
+      const owned = ownedClaimsRef.current.delete(claim);
+      startedClaimsRef.current.delete(claim);
+      if (owned) tracker.release(claim);
+    },
+    [tracker]
+  );
+  const stopResumeReplay = react.useCallback(
+    (claim) => {
+      const timerEntry = resumeTimersRef.current.get(claim);
+      if (timerEntry) clearTimeout(timerEntry.timer);
+      resumeTimersRef.current.delete(claim);
+      if (resumeClaimsRef.current.delete(claim)) {
+        tracker.releaseResumeReplay(claim, resumeOwnerRef.current);
+      }
+    },
+    [tracker]
+  );
+  react.useEffect(() => {
+    activeRef.current = true;
+    const ownedClaims = ownedClaimsRef.current;
+    const startedClaims = startedClaimsRef.current;
+    return () => {
+      activeRef.current = false;
+      for (const claim of Array.from(resumeClaimsRef.current)) {
+        stopResumeReplay(claim);
+      }
+      for (const claim of ownedClaims) {
+        if (startedClaims.has(claim)) continue;
+        ownedClaims.delete(claim);
+        tracker.release(claim);
+      }
+    };
+  }, [stopResumeReplay, tracker]);
+  const liveRequestIdsRef = react.useRef(/* @__PURE__ */ new Set());
+  liveRequestIdsRef.current = new Set((inputRequests ?? []).map((request) => request.id));
+  const startResumeReplay = react.useCallback(
+    (claim, requestId) => {
+      if (!activeRef.current || resumeClaimsRef.current.has(claim)) return;
+      if (!tracker.claimResumeReplay(claim, resumeOwnerRef.current)) return;
+      resumeClaimsRef.current.add(claim);
+      const dispatch = () => {
+        resumeTimersRef.current.delete(claim);
+        if (!activeRef.current) {
+          stopResumeReplay(claim);
+          return;
+        }
+        const attempt = tracker.takeResumeAttempt(claim, {
+          owner: resumeOwnerRef.current,
+          maxAttempts: MAX_CLIENT_TOOL_RESUME_ATTEMPTS
+        });
+        if (!attempt) {
+          stopResumeReplay(claim);
+          return;
+        }
+        try {
+          const settled = optionsRef.current.sendResume(requestId, attempt.value);
+          void Promise.resolve(settled).then(
+            () => {
+              tracker.settleResume(claim);
+              stopResumeReplay(claim);
+            },
+            (error) => {
+              console.error(`${logLabel} failed to resume client tool results:`, error);
+            }
+          );
+        } catch (error) {
+          console.error(`${logLabel} failed to resume client tool results:`, error);
+        }
+        if (attempt.attemptNumber >= MAX_CLIENT_TOOL_RESUME_ATTEMPTS || !activeRef.current || !resumeClaimsRef.current.has(claim)) {
+          stopResumeReplay(claim);
+          return;
+        }
+        const timer = setTimeout(dispatch, clientToolResumeRetryDelayMs(attempt.attemptNumber));
+        resumeTimersRef.current.set(claim, { requestId, timer });
+      };
+      dispatch();
+    },
+    [logLabel, stopResumeReplay, tracker]
+  );
+  const executeRequest = react.useCallback(
+    async (request) => {
+      const payload = request.payload;
+      if (!clientTools.isClientToolInterrupt(payload)) return;
+      const claim = clientToolClaimKey(threadId, request.id);
+      const {
+        tools,
+        confirmWrites,
+        writeDeclinedMessage,
+        missingToolMessage,
+        onCallSettled,
+        sendResume
+      } = optionsRef.current;
+      const results = await executeClientToolBatch({
+        calls: payload.context.requests,
+        tools,
+        // Live while the request still exists AND this surface may answer it:
+        // mounted, or already past the point of no return (handlers started —
+        // the detached execution must finish and settle, never re-execute).
+        // After unmount the request-id snapshot freezes at its last observed
+        // state, which keeps a started batch's own request visible to it.
+        isLive: () => liveRequestIdsRef.current.has(request.id) && (activeRef.current || startedClaimsRef.current.has(claim)),
+        onExecutionStart: () => {
+          startedClaimsRef.current.add(claim);
+        },
+        ...confirmWrites ? {
+          confirmWrites: ({ writeToolNames }) => confirmWrites({ requestId: request.id, writeToolNames })
+        } : {},
+        ...writeDeclinedMessage !== void 0 ? { writeDeclinedMessage } : {},
+        ...missingToolMessage ? { missingToolMessage } : {},
+        ...onCallSettled ? { onCallSettled } : {}
+      });
+      if (results === null) {
+        releaseClaim(claim);
+        return;
+      }
+      const resumeValue = clientTools.clientToolResultsResumeValue(results);
+      tracker.cacheResume(claim, resumeValue);
+      ownedClaimsRef.current.delete(claim);
+      startedClaimsRef.current.delete(claim);
+      if (!activeRef.current) {
+        if (tracker.claimResumeReplay(claim, resumeOwnerRef.current)) {
+          const attempt = tracker.takeResumeAttempt(claim, {
+            owner: resumeOwnerRef.current,
+            maxAttempts: MAX_CLIENT_TOOL_RESUME_ATTEMPTS
+          });
+          if (attempt) {
+            try {
+              void Promise.resolve(sendResume(request.id, attempt.value)).then(
+                () => tracker.settleResume(claim),
+                (error) => {
+                  console.error(`${logLabel} failed to resume client tool results:`, error);
+                }
+              );
+            } catch (error) {
+              console.error(`${logLabel} failed to resume client tool results:`, error);
+            }
+          }
+          tracker.releaseResumeReplay(claim, resumeOwnerRef.current);
+        }
+        return;
+      }
+      startResumeReplay(claim, request.id);
+    },
+    [logLabel, releaseClaim, startResumeReplay, threadId, tracker]
+  );
+  react.useEffect(() => {
+    if (!pendingRequest) return;
+    const claim = clientToolClaimKey(threadId, pendingRequest.id);
+    if (!tracker.claim(claim)) {
+      if (tracker.getCachedResume(claim)) {
+        startResumeReplay(claim, pendingRequest.id);
+      }
+      return;
+    }
+    ownedClaimsRef.current.add(claim);
+    void executeRequest(pendingRequest);
+  }, [executeRequest, pendingRequest, startResumeReplay, threadId, tracker]);
+}
+exports.CLIENT_TOOL_WRITE_DECLINED_MESSAGE = CLIENT_TOOL_WRITE_DECLINED_MESSAGE;
+exports.clientToolClaimKey = clientToolClaimKey;
+exports.defaultMissingClientToolMessage = defaultMissingClientToolMessage;
+exports.executeClientToolBatch = executeClientToolBatch;
+exports.isPendingClientToolRequest = isPendingClientToolRequest;
+exports.jsonSafeClientToolResult = jsonSafeClientToolResult;
+exports.useStatewireClientToolBridge = useStatewireClientToolBridge;
+//# sourceMappingURL=client-tool-bridge.cjs.map

package/dist/packages/agent-runtime/src/client-tool-bridge.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-tool-bridge.cjs","sources":["../../../../../agent-runtime/src/client-tool-bridge.ts"],"sourcesContent":["/**\n * The statewire client-tool bridge loop, shared by every surface that executes\n * frontend tool calls (Olympus, the React SDK, the Office add-in, mobile).\n *\n * Tools declared through `runConfig.custom.client_tools` have no backend\n * implementation: a call parks the run on an interrupt that arrives as a\n * statewire input request. The bridge claims the request (exactly-once per\n * ownership domain), runs the matching local handlers, and resumes the run\n * with per-call result envelopes — so a missing tool or a thrown handler still\n * frees the run with an error the model can act on instead of hanging it.\n *\n * Wire-adjacent correctness invariants this module owns, so they can never\n * drift apart per surface again:\n * - exactly-once claim per request, with un-claim on every path that did NOT\n *   run any handler (abandoned before execution, consent dismissed, unmount\n *   before the first handler) so a re-emitted request is executable instead\n *   of stranding the run;\n * - once a batch has STARTED executing handlers, its claim is never released\n *   by unmount: handlers cannot be cancelled, so releasing would let another\n *   mount re-claim the re-emitted request and re-execute side effects that\n *   already ran (double-executing a mutating tool). The completed wire-safe\n *   result is cached and may be replayed across reconnects/remounts instead;\n * - liveness checks between awaits (the run can be stopped or answered\n *   elsewhere while a handler runs) so a stale request is never resumed;\n * - per-call JSON wire-safety, so one unrepresentable handler result answers\n *   that one call with an error instead of failing the whole batch.\n *\n * Like `interrupts.ts`, this is parameterized rather than self-wiring: the\n * host component reads `useStatewireRuns().inputRequests` and\n * `useStatewireSendCommand()` itself (both mockable per surface) and passes\n * them in, together with its ownership tracker and write-consent policy.\n */\n\nimport type { StatewireThread } from '@assistant-ui/react-statewire';\nimport { useCallback, useEffect, useRef } from 'react';\nimport {\n  type ClientToolCallRequest,\n  type ClientToolRequestTracker,\n  type ClientToolResultEnvelope,\n  clientToolCallArgs,\n  clientToolErrorEnvelope,\n  clientToolResultsResumeValue,\n  clientToolSuccessEnvelope,\n  isClientToolInterrupt,\n} from './client-tools';\n\n/** A locally executable tool, normalized across the per-surface tool shapes. */\nexport interface ClientToolBridgeTool {\n  /** Snake_case tool id the model calls (e.g. `update_sheet_range`). */\n  name: string;\n  /** Mutating tools gate on the surface's write-consent flow (`confirmWrites`). */\n  requiresWrite?: boolean;\n  run: (\n    args: Record<string, unknown>,\n    context: { toolCallId: string },\n  ) => Promise<unknown>;\n}\n\n/**\n * Batch write-consent outcome. `proceed` runs the write calls, `declined`\n * answers them with the declined message while reads still run, `abandoned`\n * releases the claim without resuming (the request died, or the consent UI was\n * dismissed by the run moving on). Grant persistence (a thread set, a stored\n * preference) is the surface's own policy, applied inside its callback.\n */\nexport type ClientToolWriteConsentDecision = 'proceed' | 'declined' | 'abandoned';\n\nexport interface ClientToolCallSettledEvent {\n  toolName: string;\n  status: 'success' | 'error' | 'declined';\n  errorType?: string;\n}\n\n/** Default resume error for a write call the user declined. */\nexport const CLIENT_TOOL_WRITE_DECLINED_MESSAGE =\n  'The user declined this edit. Do not retry it; ask the user how to proceed.';\n\n/** Default resume error for a call naming a tool this surface does not have. */\nexport function defaultMissingClientToolMessage(toolName: string): string {\n  return `This surface has no tool named '${toolName}'.`;\n}\n\n/** Statewire request ids are unique per run, but a thread scope keeps a\n * process-wide claim unambiguous when two conversations are open at once. */\nexport function clientToolClaimKey(threadId: string, requestId: string): string {\n  return `${threadId}:${requestId}`;\n}\n\nconst CLIENT_TOOL_RESUME_RETRY_DELAYS_MS = [2_000, 5_000, 10_000, 15_000, 30_000];\nconst MAX_CLIENT_TOOL_RESUME_ATTEMPTS = 25;\n\nfunction clientToolResumeRetryDelayMs(attemptNumber: number): number {\n  const index = Math.min(\n    Math.max(attemptNumber - 1, 0),\n    CLIENT_TOOL_RESUME_RETRY_DELAYS_MS.length - 1,\n  );\n  return CLIENT_TOOL_RESUME_RETRY_DELAYS_MS[index] ?? 30_000;\n}\n\n/**\n * A wire-safe copy of a handler's return value: handlers can return values\n * JSON cannot represent (DOM nodes, host objects, bigints), which must never\n * reach the transport. Throws for an unrepresentable value so the caller can\n * answer that one call with an error instead of stranding the whole batch.\n */\nexport function jsonSafeClientToolResult(value: unknown): unknown {\n  const serialized = JSON.stringify(value);\n  return serialized === undefined ? null : JSON.parse(serialized);\n}\n\n/** A parked, unanswered client-tool input request. */\nexport function isPendingClientToolRequest(\n  request: StatewireThread.InputRequestState,\n): request is StatewireThread.CustomInputRequest {\n  if (request.type !== 'interrupt' || 'response' in request) return false;\n  return isClientToolInterrupt((request as { payload?: unknown }).payload);\n}\n\nexport interface ExecuteClientToolBatchOptions {\n  calls: readonly ClientToolCallRequest[];\n  tools: readonly ClientToolBridgeTool[];\n  /** Whether the parked request still exists and this surface may answer it.\n   * Checked before consent resolution, before every call, and before the\n   * results are handed back for resume. */\n  isLive: () => boolean;\n  /** Batch write gate; absent means writes run without consent (surfaces that\n   * only register read tools). Called once per batch, before any handler. */\n  confirmWrites?: (batch: {\n    writeToolNames: readonly string[];\n  }) => Promise<ClientToolWriteConsentDecision>;\n  writeDeclinedMessage?: string;\n  missingToolMessage?: (toolName: string) => string;\n  /** Per-call telemetry (the Office add-in's tool events). */\n  onCallSettled?: (event: ClientToolCallSettledEvent) => void;\n  /**\n   * Called once, after the write-consent gate resolves and immediately before\n   * the first handler runs — the point where side effects begin. There is no\n   * await between this callback and the first handler invocation, so a caller\n   * marking \"execution started\" here can never miss a handler that ran.\n   */\n  onExecutionStart?: () => void;\n}\n\n/**\n * Execute one batched client-tool park: consent, per-call execution with\n * wire-safe envelopes, liveness aborts. Returns the per-interrupt result map\n * to resume with, or `null` when the batch was abandoned (the request died,\n * consent was abandoned, or the surface went away) — the caller must release\n * its claim and must NOT resume.\n */\nexport async function executeClientToolBatch(\n  options: ExecuteClientToolBatchOptions,\n): Promise<Record<string, ClientToolResultEnvelope> | null> {\n  const {\n    calls,\n    tools,\n    isLive,\n    confirmWrites,\n    writeDeclinedMessage = CLIENT_TOOL_WRITE_DECLINED_MESSAGE,\n    missingToolMessage = defaultMissingClientToolMessage,\n    onCallSettled,\n    onExecutionStart,\n  } = options;\n  const registry = new Map(tools.map((tool) => [tool.name, tool]));\n\n  // One consent covers the whole batch (and whatever scope the surface's\n  // callback persists): writes are declined together while reads still run.\n  let writesDeclined = false;\n  const writeToolNames = calls\n    .filter((call) => registry.get(call.tool_name)?.requiresWrite === true)\n    .map((call) => call.tool_name);\n  if (writeToolNames.length > 0 && confirmWrites) {\n    const decision = await confirmWrites({ writeToolNames });\n    if (decision === 'abandoned' || !isLive()) {\n      // The run was stopped (or answered elsewhere) while consent was\n      // pending: abort before any handler mutates the user's asset.\n      return null;\n    }\n    writesDeclined = decision === 'declined';\n  }\n\n  onExecutionStart?.();\n\n  const results: Record<string, ClientToolResultEnvelope> = {};\n  for (const call of calls) {\n    if (!isLive()) return null;\n    const tool = registry.get(call.tool_name);\n    let envelope: ClientToolResultEnvelope;\n    let status: ClientToolCallSettledEvent['status'] = 'success';\n    let errorType: string | undefined;\n    if (!tool) {\n      envelope = clientToolErrorEnvelope(missingToolMessage(call.tool_name));\n      status = 'error';\n      errorType = 'UnknownClientTool';\n    } else if (tool.requiresWrite === true && writesDeclined) {\n      envelope = clientToolErrorEnvelope(writeDeclinedMessage);\n      status = 'declined';\n    } else {\n      try {\n        envelope = clientToolSuccessEnvelope(\n          jsonSafeClientToolResult(\n            await tool.run(clientToolCallArgs(call), {\n              toolCallId: call.interrupt_id,\n            }),\n          ),\n        );\n      } catch (error) {\n        envelope = clientToolErrorEnvelope(error);\n        status = 'error';\n        errorType = error instanceof Error ? error.name : typeof error;\n      }\n    }\n    results[call.interrupt_id] = envelope;\n    onCallSettled?.({\n      toolName: call.tool_name,\n      status,\n      ...(errorType !== undefined ? { errorType } : {}),\n    });\n  }\n\n  // Abandoned mid-flight: resuming a dead request would error, and a\n  // re-emitted one must be executable again.\n  return isLive() ? results : null;\n}\n\nexport interface UseStatewireClientToolBridgeOptions {\n  threadId: string;\n  tools: readonly ClientToolBridgeTool[];\n  /**\n   * Ownership domain for parked-request claims. Pass a module-scoped tracker\n   * to make ownership process-wide across every mount of the surface (two\n   * mounted surfaces of one conversation execute each request exactly once),\n   * or a per-mount tracker to scope ownership to one mounted bridge.\n   */\n  tracker: ClientToolRequestTracker;\n  /** The surface's `useStatewireRuns().inputRequests` read. */\n  inputRequests: readonly StatewireThread.InputRequestState[] | undefined;\n  /** Dispatch the `run/input` resume on the surface's transport. The value is\n   * already wire-safe (per-call JSON round-trip inside the batch engine). */\n  /** Dispatch the answer and settle only once the Statewire host accepts or\n   * rejects the command. The bridge deliberately keeps replaying while this\n   * promise is pending: `run/input` removes the request optimistically before\n   * the server has accepted the answer. */\n  sendResume: (\n    requestId: string,\n    value: Record<string, unknown>,\n  ) => PromiseLike<unknown>;\n  /** Batch write gate, with the parked request's id so the surface can close\n   * its consent UI the instant that request disappears. */\n  confirmWrites?: (batch: {\n    requestId: string;\n    writeToolNames: readonly string[];\n  }) => Promise<ClientToolWriteConsentDecision>;\n  writeDeclinedMessage?: string;\n  missingToolMessage?: (toolName: string) => string;\n  onCallSettled?: (event: ClientToolCallSettledEvent) => void;\n  /** Log prefix for resume-dispatch failures. */\n  logLabel?: string;\n}\n\n/**\n * The claim lifecycle around {@link executeClientToolBatch}: claim the pending\n * request once per ownership domain, execute, resume — releasing the claim on\n * every path that ran no handler, so re-emitted requests recover.\n *\n * Unmount splits by whether side effects began:\n * - a claim whose batch has NOT started executing (claimed this tick, or\n *   parked on write consent) is released, so another mount — or a remount —\n *   can execute the re-emitted request instead of stranding the parked run;\n * - a claim whose batch HAS started stays held: handlers cannot be cancelled,\n *   so releasing would let a sibling mount re-claim and re-execute a mutation\n *   whose side effects already ran. The detached execution caches its result\n *   and attempts one resume through its captured transport; a later mount can\n *   replay the same result without repeating the side effect.\n */\nexport function useStatewireClientToolBridge(\n  options: UseStatewireClientToolBridgeOptions,\n): void {\n  const { threadId, tracker, inputRequests, logLabel = '[AthenaSDK]' } = options;\n  const optionsRef = useRef(options);\n  optionsRef.current = options;\n\n  const pendingRequest = inputRequests?.find(isPendingClientToolRequest);\n\n  // Claims this bridge holds but has not resumed, split by whether their\n  // batch has begun running handlers. The ref Set instances are stable (only\n  // their contents mutate), so the unmount cleanup sees every claim.\n  const ownedClaimsRef = useRef<Set<string>>(new Set());\n  const startedClaimsRef = useRef<Set<string>>(new Set());\n  const resumeOwnerRef = useRef(Symbol('client-tool-resume-owner'));\n  const resumeClaimsRef = useRef<Set<string>>(new Set());\n  const resumeTimersRef = useRef<\n    Map<string, { requestId: string; timer: ReturnType<typeof setTimeout> }>\n  >(new Map());\n  const activeRef = useRef(true);\n  const releaseClaim = useCallback(\n    (claim: string) => {\n      // Release the shared tracker entry only while THIS mount still owns it.\n      // A detached batch can settle after the unmount cleanup already released\n      // (and disowned) its claim; by then the tracker entry may belong to\n      // another mount that claimed, executed, and resumed — releasing it here\n      // would let a stale re-emission of the same request execute again.\n      const owned = ownedClaimsRef.current.delete(claim);\n      startedClaimsRef.current.delete(claim);\n      if (owned) tracker.release(claim);\n    },\n    [tracker],\n  );\n  const stopResumeReplay = useCallback(\n    (claim: string) => {\n      const timerEntry = resumeTimersRef.current.get(claim);\n      if (timerEntry) clearTimeout(timerEntry.timer);\n      resumeTimersRef.current.delete(claim);\n      if (resumeClaimsRef.current.delete(claim)) {\n        tracker.releaseResumeReplay(claim, resumeOwnerRef.current);\n      }\n    },\n    [tracker],\n  );\n  useEffect(() => {\n    activeRef.current = true;\n    const ownedClaims = ownedClaimsRef.current;\n    const startedClaims = startedClaimsRef.current;\n    return () => {\n      activeRef.current = false;\n      for (const claim of Array.from(resumeClaimsRef.current)) {\n        stopResumeReplay(claim);\n      }\n      for (const claim of ownedClaims) {\n        // Started batches keep their claim — their detached execution settles\n        // it (resume, or release on a failed dispatch). Releasing here would\n        // double-execute the side effects that already ran.\n        if (startedClaims.has(claim)) continue;\n        ownedClaims.delete(claim);\n        tracker.release(claim);\n      }\n    };\n  }, [stopResumeReplay, tracker]);\n\n  // Handlers (and consent) are async, so the run can be stopped or the request\n  // answered elsewhere while we await. The live ids let us abandon an\n  // unfinished local execution when its request is no longer present. Once a\n  // result is cached, only command settlement may stop its replay: Statewire\n  // removes submitted requests optimistically before the host accepts them.\n  const liveRequestIdsRef = useRef<ReadonlySet<string>>(new Set());\n  liveRequestIdsRef.current = new Set((inputRequests ?? []).map((request) => request.id));\n\n  const startResumeReplay = useCallback(\n    (claim: string, requestId: string) => {\n      if (!activeRef.current || resumeClaimsRef.current.has(claim)) return;\n      if (!tracker.claimResumeReplay(claim, resumeOwnerRef.current)) return;\n      resumeClaimsRef.current.add(claim);\n\n      const dispatch = (): void => {\n        resumeTimersRef.current.delete(claim);\n        if (!activeRef.current) {\n          stopResumeReplay(claim);\n          return;\n        }\n        const attempt = tracker.takeResumeAttempt(claim, {\n          owner: resumeOwnerRef.current,\n          maxAttempts: MAX_CLIENT_TOOL_RESUME_ATTEMPTS,\n        });\n        if (!attempt) {\n          stopResumeReplay(claim);\n          return;\n        }\n\n        try {\n          const settled = optionsRef.current.sendResume(requestId, attempt.value);\n          // A fulfilled command result is the authoritative acknowledgement:\n          // the host accepted and applied the answer. The local input request\n          // disappearing is NOT an acknowledgement because the Statewire\n          // reducer does that optimistically as soon as the command is\n          // submitted.\n          void Promise.resolve(settled).then(\n            () => {\n              // Keep the execution claim, but discard the cached result once\n              // the host accepts it. A stale pending-request render can no\n              // longer replay the command or re-execute the local mutation.\n              tracker.settleResume(claim);\n              stopResumeReplay(claim);\n            },\n            (error) => {\n              // A rejected attempt may have raced another still-pending\n              // replay. Keep the bounded loop alive; any accepted sibling\n              // stops it, while the global attempt cap prevents storms.\n              console.error(`${logLabel} failed to resume client tool results:`, error);\n            },\n          );\n        } catch (error) {\n          // Keep the cached result and retry it. Re-executing a mutating local\n          // handler would be unsafe; replaying its id-stamped result is safe.\n          console.error(`${logLabel} failed to resume client tool results:`, error);\n        }\n\n        if (\n          attempt.attemptNumber >= MAX_CLIENT_TOOL_RESUME_ATTEMPTS ||\n          !activeRef.current ||\n          !resumeClaimsRef.current.has(claim)\n        ) {\n          stopResumeReplay(claim);\n          return;\n        }\n        const timer = setTimeout(dispatch, clientToolResumeRetryDelayMs(attempt.attemptNumber));\n        resumeTimersRef.current.set(claim, { requestId, timer });\n      };\n\n      dispatch();\n    },\n    [logLabel, stopResumeReplay, tracker],\n  );\n\n  const executeRequest = useCallback(\n    async (request: StatewireThread.CustomInputRequest) => {\n      const payload = request.payload;\n      if (!isClientToolInterrupt(payload)) return;\n      const claim = clientToolClaimKey(threadId, request.id);\n      const {\n        tools,\n        confirmWrites,\n        writeDeclinedMessage,\n        missingToolMessage,\n        onCallSettled,\n        sendResume,\n      } = optionsRef.current;\n\n      const results = await executeClientToolBatch({\n        calls: payload.context.requests,\n        tools,\n        // Live while the request still exists AND this surface may answer it:\n        // mounted, or already past the point of no return (handlers started —\n        // the detached execution must finish and settle, never re-execute).\n        // After unmount the request-id snapshot freezes at its last observed\n        // state, which keeps a started batch's own request visible to it.\n        isLive: () =>\n          liveRequestIdsRef.current.has(request.id) &&\n          (activeRef.current || startedClaimsRef.current.has(claim)),\n        onExecutionStart: () => {\n          startedClaimsRef.current.add(claim);\n        },\n        ...(confirmWrites\n          ? {\n              confirmWrites: ({ writeToolNames }: { writeToolNames: readonly string[] }) =>\n                confirmWrites({ requestId: request.id, writeToolNames }),\n            }\n          : {}),\n        ...(writeDeclinedMessage !== undefined ? { writeDeclinedMessage } : {}),\n        ...(missingToolMessage ? { missingToolMessage } : {}),\n        ...(onCallSettled ? { onCallSettled } : {}),\n      });\n      if (results === null) {\n        releaseClaim(claim);\n        return;\n      }\n\n      const resumeValue = clientToolResultsResumeValue(results);\n      tracker.cacheResume(claim, resumeValue);\n      // Execution is complete, but the exactly-once claim remains. A pending\n      // re-emission must replay this cached value, never run the handlers again.\n      ownedClaimsRef.current.delete(claim);\n      startedClaimsRef.current.delete(claim);\n\n      if (!activeRef.current) {\n        // The handler crossed an unmount. Preserve the pre-existing best-effort\n        // settle through its captured transport, but leave the cached result\n        // available for a later mount if this dispatch is lost.\n        if (tracker.claimResumeReplay(claim, resumeOwnerRef.current)) {\n          const attempt = tracker.takeResumeAttempt(claim, {\n            owner: resumeOwnerRef.current,\n            maxAttempts: MAX_CLIENT_TOOL_RESUME_ATTEMPTS,\n          });\n          if (attempt) {\n            try {\n              void Promise.resolve(sendResume(request.id, attempt.value)).then(\n                () => tracker.settleResume(claim),\n                (error) => {\n                  console.error(`${logLabel} failed to resume client tool results:`, error);\n                },\n              );\n            } catch (error) {\n              console.error(`${logLabel} failed to resume client tool results:`, error);\n            }\n          }\n          // Ownership only fences this best-effort dispatch; a future mount\n          // may claim and replay the cached value if it did not settle.\n          tracker.releaseResumeReplay(claim, resumeOwnerRef.current);\n        }\n        return;\n      }\n\n      startResumeReplay(claim, request.id);\n    },\n    [logLabel, releaseClaim, startResumeReplay, threadId, tracker],\n  );\n\n  useEffect(() => {\n    if (!pendingRequest) return;\n    const claim = clientToolClaimKey(threadId, pendingRequest.id);\n    if (!tracker.claim(claim)) {\n      // The local handler already ran. This is the reconnect/remount path:\n      // replay its cached answer instead of double-executing the side effect.\n      if (tracker.getCachedResume(claim)) {\n        startResumeReplay(claim, pendingRequest.id);\n      }\n      return;\n    }\n    ownedClaimsRef.current.add(claim);\n    void executeRequest(pendingRequest);\n  }, [executeRequest, pendingRequest, startResumeReplay, threadId, tracker]);\n}\n"],"names":["isClientToolInterrupt","clientToolErrorEnvelope","clientToolSuccessEnvelope","clientToolCallArgs","useRef","useCallback","useEffect","clientToolResultsResumeValue"],"mappings":"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"}

package/dist/packages/agent-runtime/src/client-tool-bridge.js

@@ -0,0 +1,270 @@
+import { useRef, useCallback, useEffect } from "react";
+import { isClientToolInterrupt, clientToolErrorEnvelope, clientToolSuccessEnvelope, clientToolCallArgs, clientToolResultsResumeValue } from "./client-tools.js";
+const CLIENT_TOOL_WRITE_DECLINED_MESSAGE = "The user declined this edit. Do not retry it; ask the user how to proceed.";
+function defaultMissingClientToolMessage(toolName) {
+  return `This surface has no tool named '${toolName}'.`;
+}
+function clientToolClaimKey(threadId, requestId) {
+  return `${threadId}:${requestId}`;
+}
+const CLIENT_TOOL_RESUME_RETRY_DELAYS_MS = [2e3, 5e3, 1e4, 15e3, 3e4];
+const MAX_CLIENT_TOOL_RESUME_ATTEMPTS = 25;
+function clientToolResumeRetryDelayMs(attemptNumber) {
+  const index = Math.min(
+    Math.max(attemptNumber - 1, 0),
+    CLIENT_TOOL_RESUME_RETRY_DELAYS_MS.length - 1
+  );
+  return CLIENT_TOOL_RESUME_RETRY_DELAYS_MS[index] ?? 3e4;
+}
+function jsonSafeClientToolResult(value) {
+  const serialized = JSON.stringify(value);
+  return serialized === void 0 ? null : JSON.parse(serialized);
+}
+function isPendingClientToolRequest(request) {
+  if (request.type !== "interrupt" || "response" in request) return false;
+  return isClientToolInterrupt(request.payload);
+}
+async function executeClientToolBatch(options) {
+  const {
+    calls,
+    tools,
+    isLive,
+    confirmWrites,
+    writeDeclinedMessage = CLIENT_TOOL_WRITE_DECLINED_MESSAGE,
+    missingToolMessage = defaultMissingClientToolMessage,
+    onCallSettled,
+    onExecutionStart
+  } = options;
+  const registry = new Map(tools.map((tool) => [tool.name, tool]));
+  let writesDeclined = false;
+  const writeToolNames = calls.filter((call) => {
+    var _a;
+    return ((_a = registry.get(call.tool_name)) == null ? void 0 : _a.requiresWrite) === true;
+  }).map((call) => call.tool_name);
+  if (writeToolNames.length > 0 && confirmWrites) {
+    const decision = await confirmWrites({ writeToolNames });
+    if (decision === "abandoned" || !isLive()) {
+      return null;
+    }
+    writesDeclined = decision === "declined";
+  }
+  onExecutionStart == null ? void 0 : onExecutionStart();
+  const results = {};
+  for (const call of calls) {
+    if (!isLive()) return null;
+    const tool = registry.get(call.tool_name);
+    let envelope;
+    let status = "success";
+    let errorType;
+    if (!tool) {
+      envelope = clientToolErrorEnvelope(missingToolMessage(call.tool_name));
+      status = "error";
+      errorType = "UnknownClientTool";
+    } else if (tool.requiresWrite === true && writesDeclined) {
+      envelope = clientToolErrorEnvelope(writeDeclinedMessage);
+      status = "declined";
+    } else {
+      try {
+        envelope = clientToolSuccessEnvelope(
+          jsonSafeClientToolResult(
+            await tool.run(clientToolCallArgs(call), {
+              toolCallId: call.interrupt_id
+            })
+          )
+        );
+      } catch (error) {
+        envelope = clientToolErrorEnvelope(error);
+        status = "error";
+        errorType = error instanceof Error ? error.name : typeof error;
+      }
+    }
+    results[call.interrupt_id] = envelope;
+    onCallSettled == null ? void 0 : onCallSettled({
+      toolName: call.tool_name,
+      status,
+      ...errorType !== void 0 ? { errorType } : {}
+    });
+  }
+  return isLive() ? results : null;
+}
+function useStatewireClientToolBridge(options) {
+  const { threadId, tracker, inputRequests, logLabel = "[AthenaSDK]" } = options;
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const pendingRequest = inputRequests == null ? void 0 : inputRequests.find(isPendingClientToolRequest);
+  const ownedClaimsRef = useRef(/* @__PURE__ */ new Set());
+  const startedClaimsRef = useRef(/* @__PURE__ */ new Set());
+  const resumeOwnerRef = useRef(Symbol("client-tool-resume-owner"));
+  const resumeClaimsRef = useRef(/* @__PURE__ */ new Set());
+  const resumeTimersRef = useRef(/* @__PURE__ */ new Map());
+  const activeRef = useRef(true);
+  const releaseClaim = useCallback(
+    (claim) => {
+      const owned = ownedClaimsRef.current.delete(claim);
+      startedClaimsRef.current.delete(claim);
+      if (owned) tracker.release(claim);
+    },
+    [tracker]
+  );
+  const stopResumeReplay = useCallback(
+    (claim) => {
+      const timerEntry = resumeTimersRef.current.get(claim);
+      if (timerEntry) clearTimeout(timerEntry.timer);
+      resumeTimersRef.current.delete(claim);
+      if (resumeClaimsRef.current.delete(claim)) {
+        tracker.releaseResumeReplay(claim, resumeOwnerRef.current);
+      }
+    },
+    [tracker]
+  );
+  useEffect(() => {
+    activeRef.current = true;
+    const ownedClaims = ownedClaimsRef.current;
+    const startedClaims = startedClaimsRef.current;
+    return () => {
+      activeRef.current = false;
+      for (const claim of Array.from(resumeClaimsRef.current)) {
+        stopResumeReplay(claim);
+      }
+      for (const claim of ownedClaims) {
+        if (startedClaims.has(claim)) continue;
+        ownedClaims.delete(claim);
+        tracker.release(claim);
+      }
+    };
+  }, [stopResumeReplay, tracker]);
+  const liveRequestIdsRef = useRef(/* @__PURE__ */ new Set());
+  liveRequestIdsRef.current = new Set((inputRequests ?? []).map((request) => request.id));
+  const startResumeReplay = useCallback(
+    (claim, requestId) => {
+      if (!activeRef.current || resumeClaimsRef.current.has(claim)) return;
+      if (!tracker.claimResumeReplay(claim, resumeOwnerRef.current)) return;
+      resumeClaimsRef.current.add(claim);
+      const dispatch = () => {
+        resumeTimersRef.current.delete(claim);
+        if (!activeRef.current) {
+          stopResumeReplay(claim);
+          return;
+        }
+        const attempt = tracker.takeResumeAttempt(claim, {
+          owner: resumeOwnerRef.current,
+          maxAttempts: MAX_CLIENT_TOOL_RESUME_ATTEMPTS
+        });
+        if (!attempt) {
+          stopResumeReplay(claim);
+          return;
+        }
+        try {
+          const settled = optionsRef.current.sendResume(requestId, attempt.value);
+          void Promise.resolve(settled).then(
+            () => {
+              tracker.settleResume(claim);
+              stopResumeReplay(claim);
+            },
+            (error) => {
+              console.error(`${logLabel} failed to resume client tool results:`, error);
+            }
+          );
+        } catch (error) {
+          console.error(`${logLabel} failed to resume client tool results:`, error);
+        }
+        if (attempt.attemptNumber >= MAX_CLIENT_TOOL_RESUME_ATTEMPTS || !activeRef.current || !resumeClaimsRef.current.has(claim)) {
+          stopResumeReplay(claim);
+          return;
+        }
+        const timer = setTimeout(dispatch, clientToolResumeRetryDelayMs(attempt.attemptNumber));
+        resumeTimersRef.current.set(claim, { requestId, timer });
+      };
+      dispatch();
+    },
+    [logLabel, stopResumeReplay, tracker]
+  );
+  const executeRequest = useCallback(
+    async (request) => {
+      const payload = request.payload;
+      if (!isClientToolInterrupt(payload)) return;
+      const claim = clientToolClaimKey(threadId, request.id);
+      const {
+        tools,
+        confirmWrites,
+        writeDeclinedMessage,
+        missingToolMessage,
+        onCallSettled,
+        sendResume
+      } = optionsRef.current;
+      const results = await executeClientToolBatch({
+        calls: payload.context.requests,
+        tools,
+        // Live while the request still exists AND this surface may answer it:
+        // mounted, or already past the point of no return (handlers started —
+        // the detached execution must finish and settle, never re-execute).
+        // After unmount the request-id snapshot freezes at its last observed
+        // state, which keeps a started batch's own request visible to it.
+        isLive: () => liveRequestIdsRef.current.has(request.id) && (activeRef.current || startedClaimsRef.current.has(claim)),
+        onExecutionStart: () => {
+          startedClaimsRef.current.add(claim);
+        },
+        ...confirmWrites ? {
+          confirmWrites: ({ writeToolNames }) => confirmWrites({ requestId: request.id, writeToolNames })
+        } : {},
+        ...writeDeclinedMessage !== void 0 ? { writeDeclinedMessage } : {},
+        ...missingToolMessage ? { missingToolMessage } : {},
+        ...onCallSettled ? { onCallSettled } : {}
+      });
+      if (results === null) {
+        releaseClaim(claim);
+        return;
+      }
+      const resumeValue = clientToolResultsResumeValue(results);
+      tracker.cacheResume(claim, resumeValue);
+      ownedClaimsRef.current.delete(claim);
+      startedClaimsRef.current.delete(claim);
+      if (!activeRef.current) {
+        if (tracker.claimResumeReplay(claim, resumeOwnerRef.current)) {
+          const attempt = tracker.takeResumeAttempt(claim, {
+            owner: resumeOwnerRef.current,
+            maxAttempts: MAX_CLIENT_TOOL_RESUME_ATTEMPTS
+          });
+          if (attempt) {
+            try {
+              void Promise.resolve(sendResume(request.id, attempt.value)).then(
+                () => tracker.settleResume(claim),
+                (error) => {
+                  console.error(`${logLabel} failed to resume client tool results:`, error);
+                }
+              );
+            } catch (error) {
+              console.error(`${logLabel} failed to resume client tool results:`, error);
+            }
+          }
+          tracker.releaseResumeReplay(claim, resumeOwnerRef.current);
+        }
+        return;
+      }
+      startResumeReplay(claim, request.id);
+    },
+    [logLabel, releaseClaim, startResumeReplay, threadId, tracker]
+  );
+  useEffect(() => {
+    if (!pendingRequest) return;
+    const claim = clientToolClaimKey(threadId, pendingRequest.id);
+    if (!tracker.claim(claim)) {
+      if (tracker.getCachedResume(claim)) {
+        startResumeReplay(claim, pendingRequest.id);
+      }
+      return;
+    }
+    ownedClaimsRef.current.add(claim);
+    void executeRequest(pendingRequest);
+  }, [executeRequest, pendingRequest, startResumeReplay, threadId, tracker]);
+}
+export {
+  CLIENT_TOOL_WRITE_DECLINED_MESSAGE,
+  clientToolClaimKey,
+  defaultMissingClientToolMessage,
+  executeClientToolBatch,
+  isPendingClientToolRequest,
+  jsonSafeClientToolResult,
+  useStatewireClientToolBridge
+};
+//# sourceMappingURL=client-tool-bridge.js.map