@athenaintel/react 0.41.2 → 0.42.1

package/dist/chat/use-statewire-approval-request.cjs

@@ -131,5 +131,41 @@ function useStatewireApprovalRequest(options = {}) {
     replayQueuedLanes
   };
 }
+const NO_WAITING_TOOL_CALL_IDS = /* @__PURE__ */ new Set();
+const NOTHING_WAITS = {
+  toolCallIds: NO_WAITING_TOOL_CALL_IDS,
+  runParked: false
+};
+const TOOL_CALL_ID_SEPARATOR = "\n";
+function toolCallIdSet(key) {
+  return key === "" ? NO_WAITING_TOOL_CALL_IDS : new Set(key.split(TOOL_CALL_ID_SEPARATOR));
+}
+function useStatewireApprovalWait() {
+  const { requestId, actionRequests, liveActionRequests, queuedLaneDecisions } = useStatewireApprovalRequest();
+  const runParked = requestId !== void 0;
+  const ids = interrupts.toolCallIdsAwaitingApproval({
+    actionRequests: runParked ? actionRequests : liveActionRequests,
+    queuedLaneDecisions
+  });
+  const key = [...ids].sort().join(TOOL_CALL_ID_SEPARATOR);
+  return react.useMemo(
+    () => key === "" && !runParked ? NOTHING_WAITS : { toolCallIds: toolCallIdSet(key), runParked },
+    [key, runParked]
+  );
+}
+const StatewireApprovalWaitContext = react.createContext(NOTHING_WAITS);
+function StatewireApprovalWaitProvider({ children }) {
+  return react.createElement(
+    StatewireApprovalWaitContext.Provider,
+    { value: useStatewireApprovalWait() },
+    children
+  );
+}
+function useApprovalWaitInScope() {
+  return react.useContext(StatewireApprovalWaitContext);
+}
+exports.StatewireApprovalWaitProvider = StatewireApprovalWaitProvider;
+exports.useApprovalWaitInScope = useApprovalWaitInScope;
 exports.useStatewireApprovalRequest = useStatewireApprovalRequest;
+exports.useStatewireApprovalWait = useStatewireApprovalWait;
 //# sourceMappingURL=use-statewire-approval-request.cjs.map

package/dist/chat/use-statewire-approval-request.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-statewire-approval-request.cjs","sources":["../../src/chat/use-statewire-approval-request.ts"],"sourcesContent":["import type { StatewireThread } from '@assistant-ui/react-statewire';\nimport {\n  useStatewireRuns,\n  useStatewireSendCommand,\n  useStatewireState,\n} from '@assistant-ui/react-statewire';\nimport {\n  type AbandonedInputRequest,\n  asHitlApproval,\n  findAbandonedInterrupt,\n  HITL_PENDING_RESUME_GRACE_MS,\n  type HitlApprovalPayload,\n  interruptMirrorPayload,\n  isApprovalCardInterrupt,\n  laneInterruptIds,\n  type PendingActionRequest,\n  pendingActionRequests,\n  readAbandonedInputRequests,\n  readInterruptMirror,\n  readQueuedLaneDecisions,\n  useApprovalResumeLock,\n} from '@athenaintel/agent-runtime';\nimport { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react';\nimport { useAthenaRunLive } from './use-athena-run-live';\n\ndeclare module '@assistant-ui/core' {\n  namespace Assistant {\n    interface Commands {\n      /**\n       * Decide per-dispatch subagent lanes while the parent run is still\n       * streaming (`DeepAgentThread.run_lane_input`). Keys are the lanes'\n       * langgraph interrupt ids; the host matches them against the lanes its\n       * mirrored interrupt currently parks, answers at once when the run is\n       * already parked, and otherwise holds them until it parks — stale or\n       * unknown ids are ignored, never carried to a later interrupt.\n       */\n      runLaneInput: {\n        readonly type: 'run/lane-input';\n        readonly laneDecisions: Readonly<Record<string, StatewireThread.InputResponse>>;\n      };\n      /**\n       * Re-send the lane decisions the host still holds queued as their\n       * approver's resume of the parked request (`DeepAgentThread.run_lane_replay`).\n       * The host resumes under the meta the approver's `run/lane-input`\n       * recorded and refuses any other caller — every attached client reads\n       * the same queue, and only the one that queued it may turn it into a\n       * resume. Carries no decisions: the host replays what it recorded.\n       */\n      runLaneReplay: {\n        readonly type: 'run/lane-replay';\n        readonly requestId: string;\n      };\n    }\n  }\n}\n\nconst NO_QUEUED_LANE_DECISIONS: Readonly<Record<string, unknown>> = Object.freeze({});\nconst NO_ACTION_REQUESTS: PendingActionRequest[] = [];\n\n/**\n * Lane ids of the parked requests this client resumed, keyed by request id\n * and shared by every hook instance on the page (approval card,\n * waiting-on-you banner, host editors) so all of them treat a lingering\n * mirror the same way. Request ids are unique per parked interrupt, so an\n * instance only ever consults the record of the request it saw parked: two\n * chats mounted side by side cannot suppress or clear each other's. A record\n * is retired once the host drops that request's mirror (the resume run\n * started), the surface sees a different request park, or it unmounts.\n */\nconst answeredRequests = new Map<string, readonly string[]>();\nconst answeredListeners = new Set<() => void>();\nlet answeredVersion = 0;\nfunction notifyAnswered(): void {\n  answeredVersion += 1;\n  for (const listener of answeredListeners) listener();\n}\nfunction recordAnswered(requestId: string, laneIds: readonly string[]): void {\n  answeredRequests.set(requestId, laneIds);\n  notifyAnswered();\n}\nfunction forgetAnswered(requestId: string): void {\n  if (answeredRequests.delete(requestId)) notifyAnswered();\n}\nfunction subscribeAnswered(listener: () => void): () => void {\n  answeredListeners.add(listener);\n  return () => {\n    answeredListeners.delete(listener);\n  };\n}\nconst readAnsweredVersion = (): number => answeredVersion;\n\n/**\n * The lanes a resume of the parked request settles: every lane of the request\n * (a resume answers the whole park — lanes already queued through\n * `run/lane-input` ride along) plus any lane named in the `lane_decisions` map.\n */\nfunction answeredLaneIds(value: unknown, actionRequests: readonly PendingActionRequest[]): string[] {\n  const ids = laneInterruptIds(actionRequests) ?? [];\n  if (typeof value === 'object' && value !== null && 'lane_decisions' in value) {\n    const lanes = (value as { lane_decisions: unknown }).lane_decisions;\n    if (typeof lanes === 'object' && lanes !== null) {\n      for (const id of Object.keys(lanes)) if (!ids.includes(id)) ids.push(id);\n    }\n  }\n  return ids;\n}\n\n/**\n * Whether the host's mirror still shows an interrupt this client already\n * answered. After `run/input` the host drops the parked request at once but\n * keeps `__interrupt__` until the resume run starts and clears it (seconds on\n * a cold checkpoint); without this check the card would re-offer the SAME\n * approval from the mirror, buttons live, and then fold it away again.\n */\nfunction mirrorAlreadyAnswered(\n  answeredLanes: readonly string[] | undefined,\n  liveActionRequests: readonly PendingActionRequest[],\n): boolean {\n  if (answeredLanes === undefined) return false;\n  const ids = laneInterruptIds(liveActionRequests);\n  if (ids === null) return false;\n  return ids.every((id) => answeredLanes.includes(id));\n}\n\n/** Selects which pending interrupt an approval surface answers. */\nexport type StatewireInterruptPredicate = (\n  request: StatewireThread.InputRequestState,\n) => request is StatewireThread.CustomInputRequest;\n\nexport interface UseStatewireApprovalRequestOptions {\n  /**\n   * Which pending interrupt to answer. Defaults to `isApprovalCardInterrupt`\n   * (client-tool parks excluded — the client-tool bridge owns those, and a\n   * generic resume would corrupt the parked tool call).\n   */\n  interruptPredicate?: StatewireInterruptPredicate;\n  /**\n   * How long a sent decision keeps the actions locked when no resume run ever\n   * starts. Defaults to {@link HITL_PENDING_RESUME_GRACE_MS}.\n   */\n  pendingResumeGraceMs?: number;\n  /**\n   * The host refused the `run/input` (or the transport lost it): the\n   * optimistic fold rolls back, the request is on screen again with its\n   * actions re-enabled, and this is the surface's one chance to say why.\n   */\n  onResumeRejected?: (error: unknown, requestId: string) => void;\n  /** See {@link UseApprovalResumeLockOptions.onResumeRetry}. */\n  onResumeRetry?: (error: unknown, requestId: string, attempt: number) => void;\n}\n\nexport interface StatewireApprovalRequest<TValue> {\n  /** The pending interrupt this surface answers, if any. */\n  request: StatewireThread.CustomInputRequest | undefined;\n  requestId: string | undefined;\n  /** The payload narrowed to the Athena HITL approval shape, or `null`. */\n  hitl: HitlApprovalPayload | null;\n  /** Every gated call the approval covers, in decision order (empty for non-HITL parks). */\n  actionRequests: PendingActionRequest[];\n  /** An interrupt a non-resume dispatch dropped — the \"approval was cancelled\" notice. */\n  abandonedInterrupt: AbandonedInputRequest | undefined;\n  /**\n   * The mirrored interrupt's HITL payload while the run is still live and no\n   * input request is answerable: per-dispatch `task` lanes parked on their\n   * gates while sibling lanes stream. `null` once the run parks (the same\n   * lanes are then `hitl` / `actionRequests`) and when nothing is parked.\n   */\n  liveHitl: HitlApprovalPayload | null;\n  /** Every gated call `liveHitl` covers (empty when it is `null`). */\n  liveActionRequests: PendingActionRequest[];\n  /**\n   * The decisions the host already holds from a `run/lane-input`, keyed by\n   * langgraph interrupt id, to be answered when the run parks — a queued lane\n   * reads as decided on every attached client, not just the one that sent it.\n   */\n  queuedLaneDecisions: Readonly<Record<string, unknown>>;\n  /** True after a resume until the request identity changes (or recovery fires). */\n  pending: boolean;\n  /**\n   * Answer the request with `{ type: 'run/input', requestId, response: { type: 'resume', value } }`.\n   * Returns the dispatch promise (settles when the host accepts, rejects when\n   * it refuses), or `undefined` when the lock dropped the send.\n   */\n  resume: (value: TValue) => Promise<unknown> | undefined;\n  /**\n   * Decide per-dispatch lanes by langgraph interrupt id. With a pending\n   * request this is the native `lane_decisions` resume through the lock;\n   * without one (the run is still streaming siblings) it is `run/lane-input`,\n   * which the host queues and answers on the park. Returns the dispatch\n   * promise, or `undefined` when the lock dropped a resume.\n   */\n  sendLaneDecisions: (\n    lanes: Readonly<Record<string, StatewireThread.InputResponse>>,\n  ) => Promise<unknown> | undefined;\n  /**\n   * Ask the host to resume the parked `requestId` with the lane decisions it\n   * still holds queued, as their approver (`run/lane-replay`). For the card\n   * that queued them, after the host's own answerer has stayed silent past\n   * its budget; the host refuses every other caller. Settles when the host\n   * accepts, rejects when it refuses.\n   */\n  replayQueuedLanes: (requestId: string) => Promise<unknown>;\n}\n\n/**\n * The headless half of every statewire approval surface: selects the pending\n * interrupt from the runs projection, narrows its payload, reads the\n * host-published abandoned interrupts, and wires the shared optimistic resume\n * lock to the thread's `run/input` command. `StatewireApprovalCard` renders\n * over it; hosts with their own decision UI (per-lane subagent cards) build\n * on it directly so the selection and lock semantics cannot drift.\n *\n * Requires a statewire aui scope (throws outside one, like every\n * `useStatewire*` hook) — gate the mount with `hasStatewireThreadExtras`.\n */\nexport function useStatewireApprovalRequest<\n  TValue extends StatewireThread.InputResponse = Record<string, string>,\n>(options: UseStatewireApprovalRequestOptions = {}): StatewireApprovalRequest<TValue> {\n  const {\n    interruptPredicate = isApprovalCardInterrupt,\n    pendingResumeGraceMs = HITL_PENDING_RESUME_GRACE_MS,\n    onResumeRejected,\n    onResumeRetry,\n  } = options;\n  const sendCommand = useStatewireSendCommand();\n  // The runs projection is memoized by the lib, so this derivation is\n  // reference-stable between state updates.\n  const request = useStatewireRuns().inputRequests?.find(interruptPredicate);\n  const requestId = request?.id;\n\n  // The host publishes the interrupts a non-resume dispatch dropped. Select\n  // the raw array reference (pre-stream-safe) and derive inline; a `.find`\n  // selector would return a fresh object every update.\n  const abandoned = useStatewireState(readAbandonedInputRequests);\n  const abandonedInterrupt = findAbandonedInterrupt(abandoned);\n\n  const hitl = asHitlApproval(request?.payload);\n  const actionRequests = useMemo(() => pendingActionRequests(hitl), [hitl]);\n\n  const isRunning = useAthenaRunLive();\n  // The host mirrors the interrupt into state as soon as a lane parks — while\n  // the run manager still reports `running` (siblings streaming) and has no\n  // request to answer. Raw reference selectors; derive inline.\n  const mirror = useStatewireState(readInterruptMirror);\n  const mirrorHitl =\n    request === undefined && isRunning ? asHitlApproval(interruptMirrorPayload(mirror)) : null;\n  const mirrorActionRequests = useMemo(() => pendingActionRequests(mirrorHitl), [mirrorHitl]);\n\n  // The request this surface last saw parked: the only record it may read\n  // or retire (the mirror it watches is the one that request's resume clears).\n  const lastRequestIdRef = useRef<string>(undefined);\n  if (requestId !== undefined) lastRequestIdRef.current = requestId;\n  useSyncExternalStore(subscribeAnswered, readAnsweredVersion, readAnsweredVersion);\n  const answeredLanes =\n    lastRequestIdRef.current === undefined ? undefined : answeredRequests.get(lastRequestIdRef.current);\n  const mirrorCleared = interruptMirrorPayload(mirror) === undefined;\n  useEffect(() => {\n    if (requestId === undefined) return;\n    return () => {\n      // A different request parks next (or this one unparks for good): the\n      // record of this one is stale once it is not the one on screen.\n      if (lastRequestIdRef.current !== requestId) forgetAnswered(requestId);\n    };\n  }, [requestId]);\n  useEffect(() => {\n    if (mirrorCleared && lastRequestIdRef.current !== undefined) forgetAnswered(lastRequestIdRef.current);\n  }, [mirrorCleared]);\n  useEffect(\n    () => () => {\n      if (lastRequestIdRef.current !== undefined) forgetAnswered(lastRequestIdRef.current);\n    },\n    [],\n  );\n  const liveHitl = mirrorAlreadyAnswered(answeredLanes, mirrorActionRequests) ? null : mirrorHitl;\n  const liveActionRequests = liveHitl === mirrorHitl ? mirrorActionRequests : NO_ACTION_REQUESTS;\n  const queuedLaneDecisions =\n    useStatewireState(readQueuedLaneDecisions) ?? NO_QUEUED_LANE_DECISIONS;\n\n  const { pending, resume: resumeLocked } = useApprovalResumeLock<TValue>({\n    requestId,\n    isRunning,\n    pendingResumeGraceMs,\n    onResumeRejected,\n    onResumeRetry,\n    // The dispatch promise is handed to the lock: a refusal releases it and\n    // reaches `onResumeRejected`.\n    sendResume: (id, value) =>\n      sendCommand({\n        type: 'run/input',\n        requestId: id,\n        response: { type: 'resume', value },\n      }),\n  });\n\n  const resume = useCallback(\n    (value: TValue) => {\n      if (requestId !== undefined) {\n        recordAnswered(requestId, answeredLaneIds(value, actionRequests));\n      }\n      return resumeLocked(value);\n    },\n    [requestId, actionRequests, resumeLocked],\n  );\n\n  const sendLaneDecisions = useCallback(\n    (lanes: Readonly<Record<string, StatewireThread.InputResponse>>) =>\n      requestId !== undefined\n        ? resume({ lane_decisions: lanes } as unknown as TValue)\n        : sendCommand({ type: 'run/lane-input', laneDecisions: lanes }),\n    [requestId, resume, sendCommand],\n  );\n\n  const replayQueuedLanes = useCallback(\n    (id: string) => sendCommand({ type: 'run/lane-replay', requestId: id }),\n    [sendCommand],\n  );\n\n  return {\n    request,\n    requestId,\n    hitl,\n    actionRequests,\n    liveHitl,\n    liveActionRequests,\n    queuedLaneDecisions,\n    abandonedInterrupt,\n    pending,\n    resume,\n    sendLaneDecisions,\n    replayQueuedLanes,\n  };\n}\n"],"names":["laneInterruptIds","isApprovalCardInterrupt","HITL_PENDING_RESUME_GRACE_MS","useStatewireSendCommand","useStatewireRuns","useStatewireState","readAbandonedInputRequests","findAbandonedInterrupt","asHitlApproval","useMemo","pendingActionRequests","useAthenaRunLive","readInterruptMirror","interruptMirrorPayload","useRef","useSyncExternalStore","useEffect","readQueuedLaneDecisions","useApprovalResumeLock","useCallback"],"mappings":"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"}
+{"version":3,"file":"use-statewire-approval-request.cjs","sources":["../../src/chat/use-statewire-approval-request.ts"],"sourcesContent":["import type { StatewireThread } from '@assistant-ui/react-statewire';\nimport {\n  useStatewireRuns,\n  useStatewireSendCommand,\n  useStatewireState,\n} from '@assistant-ui/react-statewire';\nimport {\n  type AbandonedInputRequest,\n  asHitlApproval,\n  findAbandonedInterrupt,\n  HITL_PENDING_RESUME_GRACE_MS,\n  type HitlApprovalPayload,\n  interruptMirrorPayload,\n  isApprovalCardInterrupt,\n  laneInterruptIds,\n  type PendingActionRequest,\n  pendingActionRequests,\n  readAbandonedInputRequests,\n  readInterruptMirror,\n  readQueuedLaneDecisions,\n  toolCallIdsAwaitingApproval,\n  useApprovalResumeLock,\n} from '@athenaintel/agent-runtime';\nimport {\n  createContext,\n  createElement,\n  type ReactNode,\n  useCallback,\n  useContext,\n  useEffect,\n  useMemo,\n  useRef,\n  useSyncExternalStore,\n} from 'react';\nimport { useAthenaRunLive } from './use-athena-run-live';\n\ndeclare module '@assistant-ui/core' {\n  namespace Assistant {\n    interface Commands {\n      /**\n       * Decide per-dispatch subagent lanes while the parent run is still\n       * streaming (`DeepAgentThread.run_lane_input`). Keys are the lanes'\n       * langgraph interrupt ids; the host matches them against the lanes its\n       * mirrored interrupt currently parks, answers at once when the run is\n       * already parked, and otherwise holds them until it parks — stale or\n       * unknown ids are ignored, never carried to a later interrupt.\n       */\n      runLaneInput: {\n        readonly type: 'run/lane-input';\n        readonly laneDecisions: Readonly<Record<string, StatewireThread.InputResponse>>;\n      };\n      /**\n       * Re-send the lane decisions the host still holds queued as their\n       * approver's resume of the parked request (`DeepAgentThread.run_lane_replay`).\n       * The host resumes under the meta the approver's `run/lane-input`\n       * recorded and refuses any other caller — every attached client reads\n       * the same queue, and only the one that queued it may turn it into a\n       * resume. Carries no decisions: the host replays what it recorded.\n       */\n      runLaneReplay: {\n        readonly type: 'run/lane-replay';\n        readonly requestId: string;\n      };\n    }\n  }\n}\n\nconst NO_QUEUED_LANE_DECISIONS: Readonly<Record<string, unknown>> = Object.freeze({});\nconst NO_ACTION_REQUESTS: PendingActionRequest[] = [];\n\n/**\n * Lane ids of the parked requests this client resumed, keyed by request id\n * and shared by every hook instance on the page (approval card,\n * waiting-on-you banner, host editors) so all of them treat a lingering\n * mirror the same way. Request ids are unique per parked interrupt, so an\n * instance only ever consults the record of the request it saw parked: two\n * chats mounted side by side cannot suppress or clear each other's. A record\n * is retired once the host drops that request's mirror (the resume run\n * started), the surface sees a different request park, or it unmounts.\n */\nconst answeredRequests = new Map<string, readonly string[]>();\nconst answeredListeners = new Set<() => void>();\nlet answeredVersion = 0;\nfunction notifyAnswered(): void {\n  answeredVersion += 1;\n  for (const listener of answeredListeners) listener();\n}\nfunction recordAnswered(requestId: string, laneIds: readonly string[]): void {\n  answeredRequests.set(requestId, laneIds);\n  notifyAnswered();\n}\nfunction forgetAnswered(requestId: string): void {\n  if (answeredRequests.delete(requestId)) notifyAnswered();\n}\nfunction subscribeAnswered(listener: () => void): () => void {\n  answeredListeners.add(listener);\n  return () => {\n    answeredListeners.delete(listener);\n  };\n}\nconst readAnsweredVersion = (): number => answeredVersion;\n\n/**\n * The lanes a resume of the parked request settles: every lane of the request\n * (a resume answers the whole park — lanes already queued through\n * `run/lane-input` ride along) plus any lane named in the `lane_decisions` map.\n */\nfunction answeredLaneIds(value: unknown, actionRequests: readonly PendingActionRequest[]): string[] {\n  const ids = laneInterruptIds(actionRequests) ?? [];\n  if (typeof value === 'object' && value !== null && 'lane_decisions' in value) {\n    const lanes = (value as { lane_decisions: unknown }).lane_decisions;\n    if (typeof lanes === 'object' && lanes !== null) {\n      for (const id of Object.keys(lanes)) if (!ids.includes(id)) ids.push(id);\n    }\n  }\n  return ids;\n}\n\n/**\n * Whether the host's mirror still shows an interrupt this client already\n * answered. After `run/input` the host drops the parked request at once but\n * keeps `__interrupt__` until the resume run starts and clears it (seconds on\n * a cold checkpoint); without this check the card would re-offer the SAME\n * approval from the mirror, buttons live, and then fold it away again.\n */\nfunction mirrorAlreadyAnswered(\n  answeredLanes: readonly string[] | undefined,\n  liveActionRequests: readonly PendingActionRequest[],\n): boolean {\n  if (answeredLanes === undefined) return false;\n  const ids = laneInterruptIds(liveActionRequests);\n  if (ids === null) return false;\n  return ids.every((id) => answeredLanes.includes(id));\n}\n\n/** Selects which pending interrupt an approval surface answers. */\nexport type StatewireInterruptPredicate = (\n  request: StatewireThread.InputRequestState,\n) => request is StatewireThread.CustomInputRequest;\n\nexport interface UseStatewireApprovalRequestOptions {\n  /**\n   * Which pending interrupt to answer. Defaults to `isApprovalCardInterrupt`\n   * (client-tool parks excluded — the client-tool bridge owns those, and a\n   * generic resume would corrupt the parked tool call).\n   */\n  interruptPredicate?: StatewireInterruptPredicate;\n  /**\n   * How long a sent decision keeps the actions locked when no resume run ever\n   * starts. Defaults to {@link HITL_PENDING_RESUME_GRACE_MS}.\n   */\n  pendingResumeGraceMs?: number;\n  /**\n   * The host refused the `run/input` (or the transport lost it): the\n   * optimistic fold rolls back, the request is on screen again with its\n   * actions re-enabled, and this is the surface's one chance to say why.\n   */\n  onResumeRejected?: (error: unknown, requestId: string) => void;\n  /** See {@link UseApprovalResumeLockOptions.onResumeRetry}. */\n  onResumeRetry?: (error: unknown, requestId: string, attempt: number) => void;\n}\n\nexport interface StatewireApprovalRequest<TValue> {\n  /** The pending interrupt this surface answers, if any. */\n  request: StatewireThread.CustomInputRequest | undefined;\n  requestId: string | undefined;\n  /** The payload narrowed to the Athena HITL approval shape, or `null`. */\n  hitl: HitlApprovalPayload | null;\n  /** Every gated call the approval covers, in decision order (empty for non-HITL parks). */\n  actionRequests: PendingActionRequest[];\n  /** An interrupt a non-resume dispatch dropped — the \"approval was cancelled\" notice. */\n  abandonedInterrupt: AbandonedInputRequest | undefined;\n  /**\n   * The mirrored interrupt's HITL payload while the run is still live and no\n   * input request is answerable: per-dispatch `task` lanes parked on their\n   * gates while sibling lanes stream. `null` once the run parks (the same\n   * lanes are then `hitl` / `actionRequests`) and when nothing is parked.\n   */\n  liveHitl: HitlApprovalPayload | null;\n  /** Every gated call `liveHitl` covers (empty when it is `null`). */\n  liveActionRequests: PendingActionRequest[];\n  /**\n   * The decisions the host already holds from a `run/lane-input`, keyed by\n   * langgraph interrupt id, to be answered when the run parks — a queued lane\n   * reads as decided on every attached client, not just the one that sent it.\n   */\n  queuedLaneDecisions: Readonly<Record<string, unknown>>;\n  /** True after a resume until the request identity changes (or recovery fires). */\n  pending: boolean;\n  /**\n   * Answer the request with `{ type: 'run/input', requestId, response: { type: 'resume', value } }`.\n   * Returns the dispatch promise (settles when the host accepts, rejects when\n   * it refuses), or `undefined` when the lock dropped the send.\n   */\n  resume: (value: TValue) => Promise<unknown> | undefined;\n  /**\n   * Decide per-dispatch lanes by langgraph interrupt id. With a pending\n   * request this is the native `lane_decisions` resume through the lock;\n   * without one (the run is still streaming siblings) it is `run/lane-input`,\n   * which the host queues and answers on the park. Returns the dispatch\n   * promise, or `undefined` when the lock dropped a resume.\n   */\n  sendLaneDecisions: (\n    lanes: Readonly<Record<string, StatewireThread.InputResponse>>,\n  ) => Promise<unknown> | undefined;\n  /**\n   * Ask the host to resume the parked `requestId` with the lane decisions it\n   * still holds queued, as their approver (`run/lane-replay`). For the card\n   * that queued them, after the host's own answerer has stayed silent past\n   * its budget; the host refuses every other caller. Settles when the host\n   * accepts, rejects when it refuses.\n   */\n  replayQueuedLanes: (requestId: string) => Promise<unknown>;\n}\n\n/**\n * The headless half of every statewire approval surface: selects the pending\n * interrupt from the runs projection, narrows its payload, reads the\n * host-published abandoned interrupts, and wires the shared optimistic resume\n * lock to the thread's `run/input` command. `StatewireApprovalCard` renders\n * over it; hosts with their own decision UI (per-lane subagent cards) build\n * on it directly so the selection and lock semantics cannot drift.\n *\n * Requires a statewire aui scope (throws outside one, like every\n * `useStatewire*` hook) — gate the mount with `hasStatewireThreadExtras`.\n */\nexport function useStatewireApprovalRequest<\n  TValue extends StatewireThread.InputResponse = Record<string, string>,\n>(options: UseStatewireApprovalRequestOptions = {}): StatewireApprovalRequest<TValue> {\n  const {\n    interruptPredicate = isApprovalCardInterrupt,\n    pendingResumeGraceMs = HITL_PENDING_RESUME_GRACE_MS,\n    onResumeRejected,\n    onResumeRetry,\n  } = options;\n  const sendCommand = useStatewireSendCommand();\n  // The runs projection is memoized by the lib, so this derivation is\n  // reference-stable between state updates.\n  const request = useStatewireRuns().inputRequests?.find(interruptPredicate);\n  const requestId = request?.id;\n\n  // The host publishes the interrupts a non-resume dispatch dropped. Select\n  // the raw array reference (pre-stream-safe) and derive inline; a `.find`\n  // selector would return a fresh object every update.\n  const abandoned = useStatewireState(readAbandonedInputRequests);\n  const abandonedInterrupt = findAbandonedInterrupt(abandoned);\n\n  const hitl = asHitlApproval(request?.payload);\n  const actionRequests = useMemo(() => pendingActionRequests(hitl), [hitl]);\n\n  const isRunning = useAthenaRunLive();\n  // The host mirrors the interrupt into state as soon as a lane parks — while\n  // the run manager still reports `running` (siblings streaming) and has no\n  // request to answer. Raw reference selectors; derive inline.\n  const mirror = useStatewireState(readInterruptMirror);\n  const mirrorHitl =\n    request === undefined && isRunning ? asHitlApproval(interruptMirrorPayload(mirror)) : null;\n  const mirrorActionRequests = useMemo(() => pendingActionRequests(mirrorHitl), [mirrorHitl]);\n\n  // The request this surface last saw parked: the only record it may read\n  // or retire (the mirror it watches is the one that request's resume clears).\n  const lastRequestIdRef = useRef<string>(undefined);\n  if (requestId !== undefined) lastRequestIdRef.current = requestId;\n  useSyncExternalStore(subscribeAnswered, readAnsweredVersion, readAnsweredVersion);\n  const answeredLanes =\n    lastRequestIdRef.current === undefined ? undefined : answeredRequests.get(lastRequestIdRef.current);\n  const mirrorCleared = interruptMirrorPayload(mirror) === undefined;\n  useEffect(() => {\n    if (requestId === undefined) return;\n    return () => {\n      // A different request parks next (or this one unparks for good): the\n      // record of this one is stale once it is not the one on screen.\n      if (lastRequestIdRef.current !== requestId) forgetAnswered(requestId);\n    };\n  }, [requestId]);\n  useEffect(() => {\n    if (mirrorCleared && lastRequestIdRef.current !== undefined) forgetAnswered(lastRequestIdRef.current);\n  }, [mirrorCleared]);\n  useEffect(\n    () => () => {\n      if (lastRequestIdRef.current !== undefined) forgetAnswered(lastRequestIdRef.current);\n    },\n    [],\n  );\n  const liveHitl = mirrorAlreadyAnswered(answeredLanes, mirrorActionRequests) ? null : mirrorHitl;\n  const liveActionRequests = liveHitl === mirrorHitl ? mirrorActionRequests : NO_ACTION_REQUESTS;\n  const queuedLaneDecisions =\n    useStatewireState(readQueuedLaneDecisions) ?? NO_QUEUED_LANE_DECISIONS;\n\n  const { pending, resume: resumeLocked } = useApprovalResumeLock<TValue>({\n    requestId,\n    isRunning,\n    pendingResumeGraceMs,\n    onResumeRejected,\n    onResumeRetry,\n    // The dispatch promise is handed to the lock: a refusal releases it and\n    // reaches `onResumeRejected`.\n    sendResume: (id, value) =>\n      sendCommand({\n        type: 'run/input',\n        requestId: id,\n        response: { type: 'resume', value },\n      }),\n  });\n\n  const resume = useCallback(\n    (value: TValue) => {\n      if (requestId !== undefined) {\n        recordAnswered(requestId, answeredLaneIds(value, actionRequests));\n      }\n      return resumeLocked(value);\n    },\n    [requestId, actionRequests, resumeLocked],\n  );\n\n  const sendLaneDecisions = useCallback(\n    (lanes: Readonly<Record<string, StatewireThread.InputResponse>>) =>\n      requestId !== undefined\n        ? resume({ lane_decisions: lanes } as unknown as TValue)\n        : sendCommand({ type: 'run/lane-input', laneDecisions: lanes }),\n    [requestId, resume, sendCommand],\n  );\n\n  const replayQueuedLanes = useCallback(\n    (id: string) => sendCommand({ type: 'run/lane-replay', requestId: id }),\n    [sendCommand],\n  );\n\n  return {\n    request,\n    requestId,\n    hitl,\n    actionRequests,\n    liveHitl,\n    liveActionRequests,\n    queuedLaneDecisions,\n    abandonedInterrupt,\n    pending,\n    resume,\n    sendLaneDecisions,\n    replayQueuedLanes,\n  };\n}\n\n/**\n * What the run waits on a person's approval for: the one read every surface\n * that shows a parked step makes (the SDK chat's turns and subagent cards,\n * Olympus's lane cards and step lists), so they all agree with the approval\n * card. The join from an approval to the calls, lanes and steps it gates is\n * agent-runtime's (`toolCallIdsAwaitingApproval`, `subagentAwaitingApproval`,\n * `useTurnToolCallsAwaitingApproval`). Read-only: nothing here sends a command.\n */\nexport interface StatewireApprovalWait {\n  /**\n   * The gated calls still waiting on a decision, by `tool_call_id`: a step\n   * holding one waits for approval, and so does a subagent lane whose own\n   * dispatch, or a call it made, is one. Keeps its identity while its ids are\n   * unchanged.\n   */\n  toolCallIds: ReadonlySet<string>;\n  /**\n   * The run is parked on a request a person answers (an approval, a\n   * question): nothing runs until someone answers it, so no step's silence is\n   * a stall.\n   */\n  runParked: boolean;\n}\n\nconst NO_WAITING_TOOL_CALL_IDS: ReadonlySet<string> = new Set();\n\n/** Nothing waits on a person. */\nconst NOTHING_WAITS: StatewireApprovalWait = {\n  toolCallIds: NO_WAITING_TOOL_CALL_IDS,\n  runParked: false,\n};\n\n/** Joins call ids into one selector value; an id never holds it. */\nconst TOOL_CALL_ID_SEPARATOR = '\\n';\n\nfunction toolCallIdSet(key: string): ReadonlySet<string> {\n  return key === '' ? NO_WAITING_TOOL_CALL_IDS : new Set(key.split(TOOL_CALL_ID_SEPARATOR));\n}\n\n/**\n * The run's approval wait: the gated calls of the approval on screen (the\n * parked request's, else the host's mirror of a lane parked while its\n * siblings still stream) that nobody has answered, less the lanes whose\n * decision the host already holds (`queuedLaneDecisions`: a lane decided live\n * waits for the run to park, not for anyone), and whether the run is parked.\n * It clears the moment the approval is answered.\n *\n * Requires a statewire aui scope (throws outside one), like\n * {@link useStatewireApprovalRequest}.\n */\nexport function useStatewireApprovalWait(): StatewireApprovalWait {\n  const { requestId, actionRequests, liveActionRequests, queuedLaneDecisions } =\n    useStatewireApprovalRequest();\n  const runParked = requestId !== undefined;\n  const ids = toolCallIdsAwaitingApproval({\n    actionRequests: runParked ? actionRequests : liveActionRequests,\n    queuedLaneDecisions,\n  });\n  // A fresh set per state update: key it, so a reader re-renders only when the ids change.\n  const key = [...ids].sort().join(TOOL_CALL_ID_SEPARATOR);\n  return useMemo(\n    () => (key === '' && !runParked ? NOTHING_WAITS : { toolCallIds: toolCallIdSet(key), runParked }),\n    [key, runParked],\n  );\n}\n\nconst StatewireApprovalWaitContext = createContext<StatewireApprovalWait>(NOTHING_WAITS);\n\n/**\n * Reads the run's approval wait once for everything below it: `AthenaChat`'s\n * turns and subagent cards. Needs a statewire aui scope.\n */\nexport function StatewireApprovalWaitProvider({ children }: { children?: ReactNode }) {\n  return createElement(\n    StatewireApprovalWaitContext.Provider,\n    { value: useStatewireApprovalWait() },\n    children,\n  );\n}\n\n/**\n * The nearest {@link StatewireApprovalWaitProvider}'s wait. Without one (a\n * host's own thread), nothing waits, as before the SDK read it.\n */\nexport function useApprovalWaitInScope(): StatewireApprovalWait {\n  return useContext(StatewireApprovalWaitContext);\n}\n"],"names":["laneInterruptIds","isApprovalCardInterrupt","HITL_PENDING_RESUME_GRACE_MS","useStatewireSendCommand","useStatewireRuns","useStatewireState","readAbandonedInputRequests","findAbandonedInterrupt","asHitlApproval","useMemo","pendingActionRequests","useAthenaRunLive","readInterruptMirror","interruptMirrorPayload","useRef","useSyncExternalStore","useEffect","readQueuedLaneDecisions","useApprovalResumeLock","useCallback","toolCallIdsAwaitingApproval","createContext","createElement","useContext"],"mappings":"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"}

package/dist/chat/use-statewire-approval-request.d.ts

@@ -1,5 +1,6 @@
 import type { StatewireThread } from '@assistant-ui/react-statewire';
-import { type AbandonedInputRequest, type HitlApprovalPayload, type PendingActionRequest } from '@athenaintel/agent-runtime';
+import { type AbandonedInputRequest, type HitlApprovalPayload, type PendingActionRequest } from '../agent-runtime/src/index';
+import { type ReactNode } from 'react';
 declare module '@assistant-ui/core' {
     namespace Assistant {
         interface Commands {
@@ -115,3 +116,50 @@ export interface StatewireApprovalRequest<TValue> {
  * `useStatewire*` hook) — gate the mount with `hasStatewireThreadExtras`.
  */
 export declare function useStatewireApprovalRequest<TValue extends StatewireThread.InputResponse = Record<string, string>>(options?: UseStatewireApprovalRequestOptions): StatewireApprovalRequest<TValue>;
+/**
+ * What the run waits on a person's approval for: the one read every surface
+ * that shows a parked step makes (the SDK chat's turns and subagent cards,
+ * Olympus's lane cards and step lists), so they all agree with the approval
+ * card. The join from an approval to the calls, lanes and steps it gates is
+ * agent-runtime's (`toolCallIdsAwaitingApproval`, `subagentAwaitingApproval`,
+ * `useTurnToolCallsAwaitingApproval`). Read-only: nothing here sends a command.
+ */
+export interface StatewireApprovalWait {
+    /**
+     * The gated calls still waiting on a decision, by `tool_call_id`: a step
+     * holding one waits for approval, and so does a subagent lane whose own
+     * dispatch, or a call it made, is one. Keeps its identity while its ids are
+     * unchanged.
+     */
+    toolCallIds: ReadonlySet<string>;
+    /**
+     * The run is parked on a request a person answers (an approval, a
+     * question): nothing runs until someone answers it, so no step's silence is
+     * a stall.
+     */
+    runParked: boolean;
+}
+/**
+ * The run's approval wait: the gated calls of the approval on screen (the
+ * parked request's, else the host's mirror of a lane parked while its
+ * siblings still stream) that nobody has answered, less the lanes whose
+ * decision the host already holds (`queuedLaneDecisions`: a lane decided live
+ * waits for the run to park, not for anyone), and whether the run is parked.
+ * It clears the moment the approval is answered.
+ *
+ * Requires a statewire aui scope (throws outside one), like
+ * {@link useStatewireApprovalRequest}.
+ */
+export declare function useStatewireApprovalWait(): StatewireApprovalWait;
+/**
+ * Reads the run's approval wait once for everything below it: `AthenaChat`'s
+ * turns and subagent cards. Needs a statewire aui scope.
+ */
+export declare function StatewireApprovalWaitProvider({ children }: {
+    children?: ReactNode;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<StatewireApprovalWait>>;
+/**
+ * The nearest {@link StatewireApprovalWaitProvider}'s wait. Without one (a
+ * host's own thread), nothing waits, as before the SDK read it.
+ */
+export declare function useApprovalWaitInScope(): StatewireApprovalWait;

package/dist/chat/use-statewire-approval-request.js

@@ -1,7 +1,7 @@
 import { useStatewireSendCommand, useStatewireRuns, useStatewireState } from "@assistant-ui/react-statewire";
-import { useMemo, useRef, useSyncExternalStore, useEffect, useCallback } from "react";
+import { useMemo, useRef, useSyncExternalStore, useEffect, useCallback, useContext, createElement, createContext } from "react";
 import { useAthenaRunLive } from "./use-athena-run-live.js";
-import { isApprovalCardInterrupt, HITL_PENDING_RESUME_GRACE_MS, readAbandonedInputRequests, findAbandonedInterrupt, asHitlApproval, pendingActionRequests, readInterruptMirror, interruptMirrorPayload, readQueuedLaneDecisions, useApprovalResumeLock, laneInterruptIds } from "../agent-runtime/src/interrupts.js";
+import { isApprovalCardInterrupt, HITL_PENDING_RESUME_GRACE_MS, readAbandonedInputRequests, findAbandonedInterrupt, asHitlApproval, pendingActionRequests, readInterruptMirror, interruptMirrorPayload, readQueuedLaneDecisions, useApprovalResumeLock, toolCallIdsAwaitingApproval, laneInterruptIds } from "../agent-runtime/src/interrupts.js";
 const NO_QUEUED_LANE_DECISIONS = Object.freeze({});
 const NO_ACTION_REQUESTS = [];
 const answeredRequests = /* @__PURE__ */ new Map();
@@ -129,7 +129,43 @@ function useStatewireApprovalRequest(options = {}) {
     replayQueuedLanes
   };
 }
+const NO_WAITING_TOOL_CALL_IDS = /* @__PURE__ */ new Set();
+const NOTHING_WAITS = {
+  toolCallIds: NO_WAITING_TOOL_CALL_IDS,
+  runParked: false
+};
+const TOOL_CALL_ID_SEPARATOR = "\n";
+function toolCallIdSet(key) {
+  return key === "" ? NO_WAITING_TOOL_CALL_IDS : new Set(key.split(TOOL_CALL_ID_SEPARATOR));
+}
+function useStatewireApprovalWait() {
+  const { requestId, actionRequests, liveActionRequests, queuedLaneDecisions } = useStatewireApprovalRequest();
+  const runParked = requestId !== void 0;
+  const ids = toolCallIdsAwaitingApproval({
+    actionRequests: runParked ? actionRequests : liveActionRequests,
+    queuedLaneDecisions
+  });
+  const key = [...ids].sort().join(TOOL_CALL_ID_SEPARATOR);
+  return useMemo(
+    () => key === "" && !runParked ? NOTHING_WAITS : { toolCallIds: toolCallIdSet(key), runParked },
+    [key, runParked]
+  );
+}
+const StatewireApprovalWaitContext = createContext(NOTHING_WAITS);
+function StatewireApprovalWaitProvider({ children }) {
+  return createElement(
+    StatewireApprovalWaitContext.Provider,
+    { value: useStatewireApprovalWait() },
+    children
+  );
+}
+function useApprovalWaitInScope() {
+  return useContext(StatewireApprovalWaitContext);
+}
 export {
-  useStatewireApprovalRequest
+  StatewireApprovalWaitProvider,
+  useApprovalWaitInScope,
+  useStatewireApprovalRequest,
+  useStatewireApprovalWait
 };
 //# sourceMappingURL=use-statewire-approval-request.js.map

package/dist/chat/use-statewire-approval-request.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-statewire-approval-request.js","sources":["../../src/chat/use-statewire-approval-request.ts"],"sourcesContent":["import type { StatewireThread } from '@assistant-ui/react-statewire';\nimport {\n  useStatewireRuns,\n  useStatewireSendCommand,\n  useStatewireState,\n} from '@assistant-ui/react-statewire';\nimport {\n  type AbandonedInputRequest,\n  asHitlApproval,\n  findAbandonedInterrupt,\n  HITL_PENDING_RESUME_GRACE_MS,\n  type HitlApprovalPayload,\n  interruptMirrorPayload,\n  isApprovalCardInterrupt,\n  laneInterruptIds,\n  type PendingActionRequest,\n  pendingActionRequests,\n  readAbandonedInputRequests,\n  readInterruptMirror,\n  readQueuedLaneDecisions,\n  useApprovalResumeLock,\n} from '@athenaintel/agent-runtime';\nimport { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react';\nimport { useAthenaRunLive } from './use-athena-run-live';\n\ndeclare module '@assistant-ui/core' {\n  namespace Assistant {\n    interface Commands {\n      /**\n       * Decide per-dispatch subagent lanes while the parent run is still\n       * streaming (`DeepAgentThread.run_lane_input`). Keys are the lanes'\n       * langgraph interrupt ids; the host matches them against the lanes its\n       * mirrored interrupt currently parks, answers at once when the run is\n       * already parked, and otherwise holds them until it parks — stale or\n       * unknown ids are ignored, never carried to a later interrupt.\n       */\n      runLaneInput: {\n        readonly type: 'run/lane-input';\n        readonly laneDecisions: Readonly<Record<string, StatewireThread.InputResponse>>;\n      };\n      /**\n       * Re-send the lane decisions the host still holds queued as their\n       * approver's resume of the parked request (`DeepAgentThread.run_lane_replay`).\n       * The host resumes under the meta the approver's `run/lane-input`\n       * recorded and refuses any other caller — every attached client reads\n       * the same queue, and only the one that queued it may turn it into a\n       * resume. Carries no decisions: the host replays what it recorded.\n       */\n      runLaneReplay: {\n        readonly type: 'run/lane-replay';\n        readonly requestId: string;\n      };\n    }\n  }\n}\n\nconst NO_QUEUED_LANE_DECISIONS: Readonly<Record<string, unknown>> = Object.freeze({});\nconst NO_ACTION_REQUESTS: PendingActionRequest[] = [];\n\n/**\n * Lane ids of the parked requests this client resumed, keyed by request id\n * and shared by every hook instance on the page (approval card,\n * waiting-on-you banner, host editors) so all of them treat a lingering\n * mirror the same way. Request ids are unique per parked interrupt, so an\n * instance only ever consults the record of the request it saw parked: two\n * chats mounted side by side cannot suppress or clear each other's. A record\n * is retired once the host drops that request's mirror (the resume run\n * started), the surface sees a different request park, or it unmounts.\n */\nconst answeredRequests = new Map<string, readonly string[]>();\nconst answeredListeners = new Set<() => void>();\nlet answeredVersion = 0;\nfunction notifyAnswered(): void {\n  answeredVersion += 1;\n  for (const listener of answeredListeners) listener();\n}\nfunction recordAnswered(requestId: string, laneIds: readonly string[]): void {\n  answeredRequests.set(requestId, laneIds);\n  notifyAnswered();\n}\nfunction forgetAnswered(requestId: string): void {\n  if (answeredRequests.delete(requestId)) notifyAnswered();\n}\nfunction subscribeAnswered(listener: () => void): () => void {\n  answeredListeners.add(listener);\n  return () => {\n    answeredListeners.delete(listener);\n  };\n}\nconst readAnsweredVersion = (): number => answeredVersion;\n\n/**\n * The lanes a resume of the parked request settles: every lane of the request\n * (a resume answers the whole park — lanes already queued through\n * `run/lane-input` ride along) plus any lane named in the `lane_decisions` map.\n */\nfunction answeredLaneIds(value: unknown, actionRequests: readonly PendingActionRequest[]): string[] {\n  const ids = laneInterruptIds(actionRequests) ?? [];\n  if (typeof value === 'object' && value !== null && 'lane_decisions' in value) {\n    const lanes = (value as { lane_decisions: unknown }).lane_decisions;\n    if (typeof lanes === 'object' && lanes !== null) {\n      for (const id of Object.keys(lanes)) if (!ids.includes(id)) ids.push(id);\n    }\n  }\n  return ids;\n}\n\n/**\n * Whether the host's mirror still shows an interrupt this client already\n * answered. After `run/input` the host drops the parked request at once but\n * keeps `__interrupt__` until the resume run starts and clears it (seconds on\n * a cold checkpoint); without this check the card would re-offer the SAME\n * approval from the mirror, buttons live, and then fold it away again.\n */\nfunction mirrorAlreadyAnswered(\n  answeredLanes: readonly string[] | undefined,\n  liveActionRequests: readonly PendingActionRequest[],\n): boolean {\n  if (answeredLanes === undefined) return false;\n  const ids = laneInterruptIds(liveActionRequests);\n  if (ids === null) return false;\n  return ids.every((id) => answeredLanes.includes(id));\n}\n\n/** Selects which pending interrupt an approval surface answers. */\nexport type StatewireInterruptPredicate = (\n  request: StatewireThread.InputRequestState,\n) => request is StatewireThread.CustomInputRequest;\n\nexport interface UseStatewireApprovalRequestOptions {\n  /**\n   * Which pending interrupt to answer. Defaults to `isApprovalCardInterrupt`\n   * (client-tool parks excluded — the client-tool bridge owns those, and a\n   * generic resume would corrupt the parked tool call).\n   */\n  interruptPredicate?: StatewireInterruptPredicate;\n  /**\n   * How long a sent decision keeps the actions locked when no resume run ever\n   * starts. Defaults to {@link HITL_PENDING_RESUME_GRACE_MS}.\n   */\n  pendingResumeGraceMs?: number;\n  /**\n   * The host refused the `run/input` (or the transport lost it): the\n   * optimistic fold rolls back, the request is on screen again with its\n   * actions re-enabled, and this is the surface's one chance to say why.\n   */\n  onResumeRejected?: (error: unknown, requestId: string) => void;\n  /** See {@link UseApprovalResumeLockOptions.onResumeRetry}. */\n  onResumeRetry?: (error: unknown, requestId: string, attempt: number) => void;\n}\n\nexport interface StatewireApprovalRequest<TValue> {\n  /** The pending interrupt this surface answers, if any. */\n  request: StatewireThread.CustomInputRequest | undefined;\n  requestId: string | undefined;\n  /** The payload narrowed to the Athena HITL approval shape, or `null`. */\n  hitl: HitlApprovalPayload | null;\n  /** Every gated call the approval covers, in decision order (empty for non-HITL parks). */\n  actionRequests: PendingActionRequest[];\n  /** An interrupt a non-resume dispatch dropped — the \"approval was cancelled\" notice. */\n  abandonedInterrupt: AbandonedInputRequest | undefined;\n  /**\n   * The mirrored interrupt's HITL payload while the run is still live and no\n   * input request is answerable: per-dispatch `task` lanes parked on their\n   * gates while sibling lanes stream. `null` once the run parks (the same\n   * lanes are then `hitl` / `actionRequests`) and when nothing is parked.\n   */\n  liveHitl: HitlApprovalPayload | null;\n  /** Every gated call `liveHitl` covers (empty when it is `null`). */\n  liveActionRequests: PendingActionRequest[];\n  /**\n   * The decisions the host already holds from a `run/lane-input`, keyed by\n   * langgraph interrupt id, to be answered when the run parks — a queued lane\n   * reads as decided on every attached client, not just the one that sent it.\n   */\n  queuedLaneDecisions: Readonly<Record<string, unknown>>;\n  /** True after a resume until the request identity changes (or recovery fires). */\n  pending: boolean;\n  /**\n   * Answer the request with `{ type: 'run/input', requestId, response: { type: 'resume', value } }`.\n   * Returns the dispatch promise (settles when the host accepts, rejects when\n   * it refuses), or `undefined` when the lock dropped the send.\n   */\n  resume: (value: TValue) => Promise<unknown> | undefined;\n  /**\n   * Decide per-dispatch lanes by langgraph interrupt id. With a pending\n   * request this is the native `lane_decisions` resume through the lock;\n   * without one (the run is still streaming siblings) it is `run/lane-input`,\n   * which the host queues and answers on the park. Returns the dispatch\n   * promise, or `undefined` when the lock dropped a resume.\n   */\n  sendLaneDecisions: (\n    lanes: Readonly<Record<string, StatewireThread.InputResponse>>,\n  ) => Promise<unknown> | undefined;\n  /**\n   * Ask the host to resume the parked `requestId` with the lane decisions it\n   * still holds queued, as their approver (`run/lane-replay`). For the card\n   * that queued them, after the host's own answerer has stayed silent past\n   * its budget; the host refuses every other caller. Settles when the host\n   * accepts, rejects when it refuses.\n   */\n  replayQueuedLanes: (requestId: string) => Promise<unknown>;\n}\n\n/**\n * The headless half of every statewire approval surface: selects the pending\n * interrupt from the runs projection, narrows its payload, reads the\n * host-published abandoned interrupts, and wires the shared optimistic resume\n * lock to the thread's `run/input` command. `StatewireApprovalCard` renders\n * over it; hosts with their own decision UI (per-lane subagent cards) build\n * on it directly so the selection and lock semantics cannot drift.\n *\n * Requires a statewire aui scope (throws outside one, like every\n * `useStatewire*` hook) — gate the mount with `hasStatewireThreadExtras`.\n */\nexport function useStatewireApprovalRequest<\n  TValue extends StatewireThread.InputResponse = Record<string, string>,\n>(options: UseStatewireApprovalRequestOptions = {}): StatewireApprovalRequest<TValue> {\n  const {\n    interruptPredicate = isApprovalCardInterrupt,\n    pendingResumeGraceMs = HITL_PENDING_RESUME_GRACE_MS,\n    onResumeRejected,\n    onResumeRetry,\n  } = options;\n  const sendCommand = useStatewireSendCommand();\n  // The runs projection is memoized by the lib, so this derivation is\n  // reference-stable between state updates.\n  const request = useStatewireRuns().inputRequests?.find(interruptPredicate);\n  const requestId = request?.id;\n\n  // The host publishes the interrupts a non-resume dispatch dropped. Select\n  // the raw array reference (pre-stream-safe) and derive inline; a `.find`\n  // selector would return a fresh object every update.\n  const abandoned = useStatewireState(readAbandonedInputRequests);\n  const abandonedInterrupt = findAbandonedInterrupt(abandoned);\n\n  const hitl = asHitlApproval(request?.payload);\n  const actionRequests = useMemo(() => pendingActionRequests(hitl), [hitl]);\n\n  const isRunning = useAthenaRunLive();\n  // The host mirrors the interrupt into state as soon as a lane parks — while\n  // the run manager still reports `running` (siblings streaming) and has no\n  // request to answer. Raw reference selectors; derive inline.\n  const mirror = useStatewireState(readInterruptMirror);\n  const mirrorHitl =\n    request === undefined && isRunning ? asHitlApproval(interruptMirrorPayload(mirror)) : null;\n  const mirrorActionRequests = useMemo(() => pendingActionRequests(mirrorHitl), [mirrorHitl]);\n\n  // The request this surface last saw parked: the only record it may read\n  // or retire (the mirror it watches is the one that request's resume clears).\n  const lastRequestIdRef = useRef<string>(undefined);\n  if (requestId !== undefined) lastRequestIdRef.current = requestId;\n  useSyncExternalStore(subscribeAnswered, readAnsweredVersion, readAnsweredVersion);\n  const answeredLanes =\n    lastRequestIdRef.current === undefined ? undefined : answeredRequests.get(lastRequestIdRef.current);\n  const mirrorCleared = interruptMirrorPayload(mirror) === undefined;\n  useEffect(() => {\n    if (requestId === undefined) return;\n    return () => {\n      // A different request parks next (or this one unparks for good): the\n      // record of this one is stale once it is not the one on screen.\n      if (lastRequestIdRef.current !== requestId) forgetAnswered(requestId);\n    };\n  }, [requestId]);\n  useEffect(() => {\n    if (mirrorCleared && lastRequestIdRef.current !== undefined) forgetAnswered(lastRequestIdRef.current);\n  }, [mirrorCleared]);\n  useEffect(\n    () => () => {\n      if (lastRequestIdRef.current !== undefined) forgetAnswered(lastRequestIdRef.current);\n    },\n    [],\n  );\n  const liveHitl = mirrorAlreadyAnswered(answeredLanes, mirrorActionRequests) ? null : mirrorHitl;\n  const liveActionRequests = liveHitl === mirrorHitl ? mirrorActionRequests : NO_ACTION_REQUESTS;\n  const queuedLaneDecisions =\n    useStatewireState(readQueuedLaneDecisions) ?? NO_QUEUED_LANE_DECISIONS;\n\n  const { pending, resume: resumeLocked } = useApprovalResumeLock<TValue>({\n    requestId,\n    isRunning,\n    pendingResumeGraceMs,\n    onResumeRejected,\n    onResumeRetry,\n    // The dispatch promise is handed to the lock: a refusal releases it and\n    // reaches `onResumeRejected`.\n    sendResume: (id, value) =>\n      sendCommand({\n        type: 'run/input',\n        requestId: id,\n        response: { type: 'resume', value },\n      }),\n  });\n\n  const resume = useCallback(\n    (value: TValue) => {\n      if (requestId !== undefined) {\n        recordAnswered(requestId, answeredLaneIds(value, actionRequests));\n      }\n      return resumeLocked(value);\n    },\n    [requestId, actionRequests, resumeLocked],\n  );\n\n  const sendLaneDecisions = useCallback(\n    (lanes: Readonly<Record<string, StatewireThread.InputResponse>>) =>\n      requestId !== undefined\n        ? resume({ lane_decisions: lanes } as unknown as TValue)\n        : sendCommand({ type: 'run/lane-input', laneDecisions: lanes }),\n    [requestId, resume, sendCommand],\n  );\n\n  const replayQueuedLanes = useCallback(\n    (id: string) => sendCommand({ type: 'run/lane-replay', requestId: id }),\n    [sendCommand],\n  );\n\n  return {\n    request,\n    requestId,\n    hitl,\n    actionRequests,\n    liveHitl,\n    liveActionRequests,\n    queuedLaneDecisions,\n    abandonedInterrupt,\n    pending,\n    resume,\n    sendLaneDecisions,\n    replayQueuedLanes,\n  };\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"use-statewire-approval-request.js","sources":["../../src/chat/use-statewire-approval-request.ts"],"sourcesContent":["import type { StatewireThread } from '@assistant-ui/react-statewire';\nimport {\n  useStatewireRuns,\n  useStatewireSendCommand,\n  useStatewireState,\n} from '@assistant-ui/react-statewire';\nimport {\n  type AbandonedInputRequest,\n  asHitlApproval,\n  findAbandonedInterrupt,\n  HITL_PENDING_RESUME_GRACE_MS,\n  type HitlApprovalPayload,\n  interruptMirrorPayload,\n  isApprovalCardInterrupt,\n  laneInterruptIds,\n  type PendingActionRequest,\n  pendingActionRequests,\n  readAbandonedInputRequests,\n  readInterruptMirror,\n  readQueuedLaneDecisions,\n  toolCallIdsAwaitingApproval,\n  useApprovalResumeLock,\n} from '@athenaintel/agent-runtime';\nimport {\n  createContext,\n  createElement,\n  type ReactNode,\n  useCallback,\n  useContext,\n  useEffect,\n  useMemo,\n  useRef,\n  useSyncExternalStore,\n} from 'react';\nimport { useAthenaRunLive } from './use-athena-run-live';\n\ndeclare module '@assistant-ui/core' {\n  namespace Assistant {\n    interface Commands {\n      /**\n       * Decide per-dispatch subagent lanes while the parent run is still\n       * streaming (`DeepAgentThread.run_lane_input`). Keys are the lanes'\n       * langgraph interrupt ids; the host matches them against the lanes its\n       * mirrored interrupt currently parks, answers at once when the run is\n       * already parked, and otherwise holds them until it parks — stale or\n       * unknown ids are ignored, never carried to a later interrupt.\n       */\n      runLaneInput: {\n        readonly type: 'run/lane-input';\n        readonly laneDecisions: Readonly<Record<string, StatewireThread.InputResponse>>;\n      };\n      /**\n       * Re-send the lane decisions the host still holds queued as their\n       * approver's resume of the parked request (`DeepAgentThread.run_lane_replay`).\n       * The host resumes under the meta the approver's `run/lane-input`\n       * recorded and refuses any other caller — every attached client reads\n       * the same queue, and only the one that queued it may turn it into a\n       * resume. Carries no decisions: the host replays what it recorded.\n       */\n      runLaneReplay: {\n        readonly type: 'run/lane-replay';\n        readonly requestId: string;\n      };\n    }\n  }\n}\n\nconst NO_QUEUED_LANE_DECISIONS: Readonly<Record<string, unknown>> = Object.freeze({});\nconst NO_ACTION_REQUESTS: PendingActionRequest[] = [];\n\n/**\n * Lane ids of the parked requests this client resumed, keyed by request id\n * and shared by every hook instance on the page (approval card,\n * waiting-on-you banner, host editors) so all of them treat a lingering\n * mirror the same way. Request ids are unique per parked interrupt, so an\n * instance only ever consults the record of the request it saw parked: two\n * chats mounted side by side cannot suppress or clear each other's. A record\n * is retired once the host drops that request's mirror (the resume run\n * started), the surface sees a different request park, or it unmounts.\n */\nconst answeredRequests = new Map<string, readonly string[]>();\nconst answeredListeners = new Set<() => void>();\nlet answeredVersion = 0;\nfunction notifyAnswered(): void {\n  answeredVersion += 1;\n  for (const listener of answeredListeners) listener();\n}\nfunction recordAnswered(requestId: string, laneIds: readonly string[]): void {\n  answeredRequests.set(requestId, laneIds);\n  notifyAnswered();\n}\nfunction forgetAnswered(requestId: string): void {\n  if (answeredRequests.delete(requestId)) notifyAnswered();\n}\nfunction subscribeAnswered(listener: () => void): () => void {\n  answeredListeners.add(listener);\n  return () => {\n    answeredListeners.delete(listener);\n  };\n}\nconst readAnsweredVersion = (): number => answeredVersion;\n\n/**\n * The lanes a resume of the parked request settles: every lane of the request\n * (a resume answers the whole park — lanes already queued through\n * `run/lane-input` ride along) plus any lane named in the `lane_decisions` map.\n */\nfunction answeredLaneIds(value: unknown, actionRequests: readonly PendingActionRequest[]): string[] {\n  const ids = laneInterruptIds(actionRequests) ?? [];\n  if (typeof value === 'object' && value !== null && 'lane_decisions' in value) {\n    const lanes = (value as { lane_decisions: unknown }).lane_decisions;\n    if (typeof lanes === 'object' && lanes !== null) {\n      for (const id of Object.keys(lanes)) if (!ids.includes(id)) ids.push(id);\n    }\n  }\n  return ids;\n}\n\n/**\n * Whether the host's mirror still shows an interrupt this client already\n * answered. After `run/input` the host drops the parked request at once but\n * keeps `__interrupt__` until the resume run starts and clears it (seconds on\n * a cold checkpoint); without this check the card would re-offer the SAME\n * approval from the mirror, buttons live, and then fold it away again.\n */\nfunction mirrorAlreadyAnswered(\n  answeredLanes: readonly string[] | undefined,\n  liveActionRequests: readonly PendingActionRequest[],\n): boolean {\n  if (answeredLanes === undefined) return false;\n  const ids = laneInterruptIds(liveActionRequests);\n  if (ids === null) return false;\n  return ids.every((id) => answeredLanes.includes(id));\n}\n\n/** Selects which pending interrupt an approval surface answers. */\nexport type StatewireInterruptPredicate = (\n  request: StatewireThread.InputRequestState,\n) => request is StatewireThread.CustomInputRequest;\n\nexport interface UseStatewireApprovalRequestOptions {\n  /**\n   * Which pending interrupt to answer. Defaults to `isApprovalCardInterrupt`\n   * (client-tool parks excluded — the client-tool bridge owns those, and a\n   * generic resume would corrupt the parked tool call).\n   */\n  interruptPredicate?: StatewireInterruptPredicate;\n  /**\n   * How long a sent decision keeps the actions locked when no resume run ever\n   * starts. Defaults to {@link HITL_PENDING_RESUME_GRACE_MS}.\n   */\n  pendingResumeGraceMs?: number;\n  /**\n   * The host refused the `run/input` (or the transport lost it): the\n   * optimistic fold rolls back, the request is on screen again with its\n   * actions re-enabled, and this is the surface's one chance to say why.\n   */\n  onResumeRejected?: (error: unknown, requestId: string) => void;\n  /** See {@link UseApprovalResumeLockOptions.onResumeRetry}. */\n  onResumeRetry?: (error: unknown, requestId: string, attempt: number) => void;\n}\n\nexport interface StatewireApprovalRequest<TValue> {\n  /** The pending interrupt this surface answers, if any. */\n  request: StatewireThread.CustomInputRequest | undefined;\n  requestId: string | undefined;\n  /** The payload narrowed to the Athena HITL approval shape, or `null`. */\n  hitl: HitlApprovalPayload | null;\n  /** Every gated call the approval covers, in decision order (empty for non-HITL parks). */\n  actionRequests: PendingActionRequest[];\n  /** An interrupt a non-resume dispatch dropped — the \"approval was cancelled\" notice. */\n  abandonedInterrupt: AbandonedInputRequest | undefined;\n  /**\n   * The mirrored interrupt's HITL payload while the run is still live and no\n   * input request is answerable: per-dispatch `task` lanes parked on their\n   * gates while sibling lanes stream. `null` once the run parks (the same\n   * lanes are then `hitl` / `actionRequests`) and when nothing is parked.\n   */\n  liveHitl: HitlApprovalPayload | null;\n  /** Every gated call `liveHitl` covers (empty when it is `null`). */\n  liveActionRequests: PendingActionRequest[];\n  /**\n   * The decisions the host already holds from a `run/lane-input`, keyed by\n   * langgraph interrupt id, to be answered when the run parks — a queued lane\n   * reads as decided on every attached client, not just the one that sent it.\n   */\n  queuedLaneDecisions: Readonly<Record<string, unknown>>;\n  /** True after a resume until the request identity changes (or recovery fires). */\n  pending: boolean;\n  /**\n   * Answer the request with `{ type: 'run/input', requestId, response: { type: 'resume', value } }`.\n   * Returns the dispatch promise (settles when the host accepts, rejects when\n   * it refuses), or `undefined` when the lock dropped the send.\n   */\n  resume: (value: TValue) => Promise<unknown> | undefined;\n  /**\n   * Decide per-dispatch lanes by langgraph interrupt id. With a pending\n   * request this is the native `lane_decisions` resume through the lock;\n   * without one (the run is still streaming siblings) it is `run/lane-input`,\n   * which the host queues and answers on the park. Returns the dispatch\n   * promise, or `undefined` when the lock dropped a resume.\n   */\n  sendLaneDecisions: (\n    lanes: Readonly<Record<string, StatewireThread.InputResponse>>,\n  ) => Promise<unknown> | undefined;\n  /**\n   * Ask the host to resume the parked `requestId` with the lane decisions it\n   * still holds queued, as their approver (`run/lane-replay`). For the card\n   * that queued them, after the host's own answerer has stayed silent past\n   * its budget; the host refuses every other caller. Settles when the host\n   * accepts, rejects when it refuses.\n   */\n  replayQueuedLanes: (requestId: string) => Promise<unknown>;\n}\n\n/**\n * The headless half of every statewire approval surface: selects the pending\n * interrupt from the runs projection, narrows its payload, reads the\n * host-published abandoned interrupts, and wires the shared optimistic resume\n * lock to the thread's `run/input` command. `StatewireApprovalCard` renders\n * over it; hosts with their own decision UI (per-lane subagent cards) build\n * on it directly so the selection and lock semantics cannot drift.\n *\n * Requires a statewire aui scope (throws outside one, like every\n * `useStatewire*` hook) — gate the mount with `hasStatewireThreadExtras`.\n */\nexport function useStatewireApprovalRequest<\n  TValue extends StatewireThread.InputResponse = Record<string, string>,\n>(options: UseStatewireApprovalRequestOptions = {}): StatewireApprovalRequest<TValue> {\n  const {\n    interruptPredicate = isApprovalCardInterrupt,\n    pendingResumeGraceMs = HITL_PENDING_RESUME_GRACE_MS,\n    onResumeRejected,\n    onResumeRetry,\n  } = options;\n  const sendCommand = useStatewireSendCommand();\n  // The runs projection is memoized by the lib, so this derivation is\n  // reference-stable between state updates.\n  const request = useStatewireRuns().inputRequests?.find(interruptPredicate);\n  const requestId = request?.id;\n\n  // The host publishes the interrupts a non-resume dispatch dropped. Select\n  // the raw array reference (pre-stream-safe) and derive inline; a `.find`\n  // selector would return a fresh object every update.\n  const abandoned = useStatewireState(readAbandonedInputRequests);\n  const abandonedInterrupt = findAbandonedInterrupt(abandoned);\n\n  const hitl = asHitlApproval(request?.payload);\n  const actionRequests = useMemo(() => pendingActionRequests(hitl), [hitl]);\n\n  const isRunning = useAthenaRunLive();\n  // The host mirrors the interrupt into state as soon as a lane parks — while\n  // the run manager still reports `running` (siblings streaming) and has no\n  // request to answer. Raw reference selectors; derive inline.\n  const mirror = useStatewireState(readInterruptMirror);\n  const mirrorHitl =\n    request === undefined && isRunning ? asHitlApproval(interruptMirrorPayload(mirror)) : null;\n  const mirrorActionRequests = useMemo(() => pendingActionRequests(mirrorHitl), [mirrorHitl]);\n\n  // The request this surface last saw parked: the only record it may read\n  // or retire (the mirror it watches is the one that request's resume clears).\n  const lastRequestIdRef = useRef<string>(undefined);\n  if (requestId !== undefined) lastRequestIdRef.current = requestId;\n  useSyncExternalStore(subscribeAnswered, readAnsweredVersion, readAnsweredVersion);\n  const answeredLanes =\n    lastRequestIdRef.current === undefined ? undefined : answeredRequests.get(lastRequestIdRef.current);\n  const mirrorCleared = interruptMirrorPayload(mirror) === undefined;\n  useEffect(() => {\n    if (requestId === undefined) return;\n    return () => {\n      // A different request parks next (or this one unparks for good): the\n      // record of this one is stale once it is not the one on screen.\n      if (lastRequestIdRef.current !== requestId) forgetAnswered(requestId);\n    };\n  }, [requestId]);\n  useEffect(() => {\n    if (mirrorCleared && lastRequestIdRef.current !== undefined) forgetAnswered(lastRequestIdRef.current);\n  }, [mirrorCleared]);\n  useEffect(\n    () => () => {\n      if (lastRequestIdRef.current !== undefined) forgetAnswered(lastRequestIdRef.current);\n    },\n    [],\n  );\n  const liveHitl = mirrorAlreadyAnswered(answeredLanes, mirrorActionRequests) ? null : mirrorHitl;\n  const liveActionRequests = liveHitl === mirrorHitl ? mirrorActionRequests : NO_ACTION_REQUESTS;\n  const queuedLaneDecisions =\n    useStatewireState(readQueuedLaneDecisions) ?? NO_QUEUED_LANE_DECISIONS;\n\n  const { pending, resume: resumeLocked } = useApprovalResumeLock<TValue>({\n    requestId,\n    isRunning,\n    pendingResumeGraceMs,\n    onResumeRejected,\n    onResumeRetry,\n    // The dispatch promise is handed to the lock: a refusal releases it and\n    // reaches `onResumeRejected`.\n    sendResume: (id, value) =>\n      sendCommand({\n        type: 'run/input',\n        requestId: id,\n        response: { type: 'resume', value },\n      }),\n  });\n\n  const resume = useCallback(\n    (value: TValue) => {\n      if (requestId !== undefined) {\n        recordAnswered(requestId, answeredLaneIds(value, actionRequests));\n      }\n      return resumeLocked(value);\n    },\n    [requestId, actionRequests, resumeLocked],\n  );\n\n  const sendLaneDecisions = useCallback(\n    (lanes: Readonly<Record<string, StatewireThread.InputResponse>>) =>\n      requestId !== undefined\n        ? resume({ lane_decisions: lanes } as unknown as TValue)\n        : sendCommand({ type: 'run/lane-input', laneDecisions: lanes }),\n    [requestId, resume, sendCommand],\n  );\n\n  const replayQueuedLanes = useCallback(\n    (id: string) => sendCommand({ type: 'run/lane-replay', requestId: id }),\n    [sendCommand],\n  );\n\n  return {\n    request,\n    requestId,\n    hitl,\n    actionRequests,\n    liveHitl,\n    liveActionRequests,\n    queuedLaneDecisions,\n    abandonedInterrupt,\n    pending,\n    resume,\n    sendLaneDecisions,\n    replayQueuedLanes,\n  };\n}\n\n/**\n * What the run waits on a person's approval for: the one read every surface\n * that shows a parked step makes (the SDK chat's turns and subagent cards,\n * Olympus's lane cards and step lists), so they all agree with the approval\n * card. The join from an approval to the calls, lanes and steps it gates is\n * agent-runtime's (`toolCallIdsAwaitingApproval`, `subagentAwaitingApproval`,\n * `useTurnToolCallsAwaitingApproval`). Read-only: nothing here sends a command.\n */\nexport interface StatewireApprovalWait {\n  /**\n   * The gated calls still waiting on a decision, by `tool_call_id`: a step\n   * holding one waits for approval, and so does a subagent lane whose own\n   * dispatch, or a call it made, is one. Keeps its identity while its ids are\n   * unchanged.\n   */\n  toolCallIds: ReadonlySet<string>;\n  /**\n   * The run is parked on a request a person answers (an approval, a\n   * question): nothing runs until someone answers it, so no step's silence is\n   * a stall.\n   */\n  runParked: boolean;\n}\n\nconst NO_WAITING_TOOL_CALL_IDS: ReadonlySet<string> = new Set();\n\n/** Nothing waits on a person. */\nconst NOTHING_WAITS: StatewireApprovalWait = {\n  toolCallIds: NO_WAITING_TOOL_CALL_IDS,\n  runParked: false,\n};\n\n/** Joins call ids into one selector value; an id never holds it. */\nconst TOOL_CALL_ID_SEPARATOR = '\\n';\n\nfunction toolCallIdSet(key: string): ReadonlySet<string> {\n  return key === '' ? NO_WAITING_TOOL_CALL_IDS : new Set(key.split(TOOL_CALL_ID_SEPARATOR));\n}\n\n/**\n * The run's approval wait: the gated calls of the approval on screen (the\n * parked request's, else the host's mirror of a lane parked while its\n * siblings still stream) that nobody has answered, less the lanes whose\n * decision the host already holds (`queuedLaneDecisions`: a lane decided live\n * waits for the run to park, not for anyone), and whether the run is parked.\n * It clears the moment the approval is answered.\n *\n * Requires a statewire aui scope (throws outside one), like\n * {@link useStatewireApprovalRequest}.\n */\nexport function useStatewireApprovalWait(): StatewireApprovalWait {\n  const { requestId, actionRequests, liveActionRequests, queuedLaneDecisions } =\n    useStatewireApprovalRequest();\n  const runParked = requestId !== undefined;\n  const ids = toolCallIdsAwaitingApproval({\n    actionRequests: runParked ? actionRequests : liveActionRequests,\n    queuedLaneDecisions,\n  });\n  // A fresh set per state update: key it, so a reader re-renders only when the ids change.\n  const key = [...ids].sort().join(TOOL_CALL_ID_SEPARATOR);\n  return useMemo(\n    () => (key === '' && !runParked ? NOTHING_WAITS : { toolCallIds: toolCallIdSet(key), runParked }),\n    [key, runParked],\n  );\n}\n\nconst StatewireApprovalWaitContext = createContext<StatewireApprovalWait>(NOTHING_WAITS);\n\n/**\n * Reads the run's approval wait once for everything below it: `AthenaChat`'s\n * turns and subagent cards. Needs a statewire aui scope.\n */\nexport function StatewireApprovalWaitProvider({ children }: { children?: ReactNode }) {\n  return createElement(\n    StatewireApprovalWaitContext.Provider,\n    { value: useStatewireApprovalWait() },\n    children,\n  );\n}\n\n/**\n * The nearest {@link StatewireApprovalWaitProvider}'s wait. Without one (a\n * host's own thread), nothing waits, as before the SDK read it.\n */\nexport function useApprovalWaitInScope(): StatewireApprovalWait {\n  return useContext(StatewireApprovalWaitContext);\n}\n"],"names":[],"mappings":"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"}

package/dist/chat-ui/composer/tiptap-composer.cjs

@@ -9,6 +9,7 @@ const Placeholder = require("@tiptap/extension-placeholder");
 const core = require("@tiptap/core");
 const react$1 = require("@assistant-ui/react");
 const composerHandoff = require("../../composer/composer-handoff.cjs");
+const statewireSessionLane = require("../../runtime/statewire-session-lane.cjs");
 const lucideReact = require("lucide-react");
 const chatTextSchema = require("../rich-text/chat-text-schema.cjs");
 const mentionSuggestions_extension = require("../mentions/suggestions/mention-suggestions.extension.cjs");
@@ -19,6 +20,8 @@ const state = require("@tiptap/pm/state");
 const composerMessage = require("./composer-message.cjs");
 const pendingAttachmentUploads = require("./pending-attachment-uploads.cjs");
 const runInputRulesOnEnter = require("./run-input-rules-on-enter.cjs");
+const useDeepAgentChatOutbox = require("../../agent-runtime/src/use-deep-agent-chat-outbox.cjs");
+const composerMarkdown = require("../../agent-runtime/src/composer-markdown.cjs");
 const athenaAssetDrag = require("../../agent-runtime/src/athena-asset-drag.cjs");
 const assetAttachment = require("../../agent-runtime/src/asset-attachment.cjs");
 const cnfast = require("cnfast");
@@ -89,6 +92,34 @@ function appendPlainText(editor, text) {
   editor.chain().setTextSelection(end.from).insertContent({ type: "text", text: needsSpace ? ` ${words}` : words }).run();
   return true;
 }
+function assetMentionIds(editor) {
+  const ids = /* @__PURE__ */ new Set();
+  editor.state.doc.descendants((node) => {
+    if (node.type.name === "mention" && node.attrs.type === "asset" && typeof node.attrs.id === "string") {
+      ids.add(node.attrs.id);
+    }
+  });
+  return ids;
+}
+const OFFLINE_EXTRAS_MESSAGE = "Athena can't be reached. A message with an attachment or a quote can't wait to be sent — remove it to send the text when Athena is back.";
+const WAITING_EXTRAS_MESSAGE = "Messages you wrote while Athena couldn't be reached haven't gone yet. A message with an attachment or a quote can't wait behind them — send it once they've gone.";
+function chatOutboxRead(outbox) {
+  if (outbox.getSnapshot().loaded) return Promise.resolve();
+  return new Promise((resolve) => {
+    let stop = () => void 0;
+    const timer = setTimeout(() => {
+      stop();
+      resolve();
+    }, CHAT_OUTBOX_READ_WAIT_MS);
+    stop = outbox.subscribe(() => {
+      if (!outbox.getSnapshot().loaded) return;
+      clearTimeout(timer);
+      stop();
+      resolve();
+    });
+  });
+}
+const CHAT_OUTBOX_READ_WAIT_MS = 2e3;
 const NO_WEBPAGES = [];
 function revokeImagePreview(src) {
   if (typeof URL.revokeObjectURL === "function") URL.revokeObjectURL(src);
@@ -152,6 +183,7 @@ const TiptapComposer = react.forwardRef(
     placeholder = "Message Athena... (type @ to mention)",
     threadId,
     disabled = false,
+    sendBlocked = false,
     appearance = "default",
     webpages = NO_WEBPAGES,
     tools,
@@ -163,9 +195,14 @@ const TiptapComposer = react.forwardRef(
     fileIntake,
     waitForHostUploads,
     interceptSubmit,
+    hasPendingExtras,
+    holdPendingExtras,
     onSubmitted
   }, outerRef) => {
     const aui = react$1.useAui();
+    const outbox = useDeepAgentChatOutbox.useDeepAgentChatOutboxContext();
+    const outboxRef = react.useRef(outbox);
+    outboxRef.current = outbox;
     const composerInput = react$1.unstable_useComposerInput();
     const handoff = composerHandoff.useComposerHandoffStore();
     const applyingRuntimeTextRef = react.useRef(false);
@@ -174,6 +211,11 @@ const TiptapComposer = react.forwardRef(
     const listRef = react.useRef(null);
     const pendingUploadsRef = react.useRef(new pendingAttachmentUploads.PendingAttachmentUploads());
     const submitInFlightRef = react.useRef(false);
+    const sendBlockedRef = react.useRef(sendBlocked);
+    sendBlockedRef.current = sendBlocked;
+    const sessionLane = statewireSessionLane.useStatewireSessionLane();
+    const sessionLaneRef = react.useRef(sessionLane);
+    sessionLaneRef.current = sessionLane;
     const imagePreviewsRef = react.useRef([]);
     const [imagePreviews, setImagePreviews] = react.useState([]);
     const replaceImagePreviews = react.useCallback((next) => {
@@ -232,19 +274,69 @@ const TiptapComposer = react.forwardRef(
     });
     const editorRef = react.useRef(null);
     const handleSubmit = react.useCallback(async () => {
-      var _a;
-      if (disabled) return;
+      var _a, _b;
+      if (disabled || sendBlockedRef.current) return;
       if (submitInFlightRef.current) return;
       submitInFlightRef.current = true;
       try {
         await pendingUploadsRef.current.waitForIdle();
         await (waitForHostUploads == null ? void 0 : waitForHostUploads());
+        const lane = sessionLaneRef.current;
+        if (lane == null ? void 0 : lane.isPending()) await lane.whenKnown();
+        if (sendBlockedRef.current) return;
         const ed = editorRef.current;
         if (!ed) return;
         const { text, draftMarkdown } = composerMessage.captureComposerSend(ed);
+        const waitingOutbox = outboxRef.current;
+        const runtimeAttachments = (((_a = aui.composer.getState().attachments) == null ? void 0 : _a.length) ?? 0) > 0;
+        const hostExtras = Boolean(hasPendingExtras == null ? void 0 : hasPendingExtras());
+        const cannotWait = runtimeAttachments || hostExtras && !holdPendingExtras;
+        if (waitingOutbox && cannotWait) await chatOutboxRead(waitingOutbox);
+        if (waitingOutbox == null ? void 0 : waitingOutbox.shouldHold()) {
+          if (cannotWait) {
+            onAttachmentError == null ? void 0 : onAttachmentError(
+              waitingOutbox.getSnapshot().rows.length > 0 ? WAITING_EXTRAS_MESSAGE : OFFLINE_EXTRAS_MESSAGE
+            );
+            return;
+          }
+          if (!text && !(hostExtras && holdPendingExtras)) return;
+          const attachments = composerHandoff.takeRestoredAttachments({
+            store: handoff,
+            threadId,
+            assetIdsInDraft: assetMentionIds(ed)
+          });
+          if (hostExtras && holdPendingExtras) {
+            if (!holdPendingExtras({
+              outbox: waitingOutbox,
+              send: { text, draftMarkdown },
+              attachments
+            })) {
+              return;
+            }
+          } else {
+            waitingOutbox.hold({
+              text,
+              composerMarkdown: draftMarkdown,
+              metadata: composerMarkdown.withDeepAgentComposerMarkdown({
+                metadata: void 0,
+                text,
+                markdown: draftMarkdown
+              }),
+              ...attachments.length > 0 && { attachments }
+            });
+          }
+          ed.commands.clearContent(false);
+          lastEmittedMarkdownRef.current = "";
+          composerInput.setText("");
+          clearImagePreviews();
+          onDraftStateChange == null ? void 0 : onDraftStateChange(false);
+          onSubmitted == null ? void 0 : onSubmitted();
+          return;
+        }
         if (interceptSubmit) {
-          const hasAttachments = (((_a = aui.composer.getState().attachments) == null ? void 0 : _a.length) ?? 0) > 0;
+          const hasAttachments = (((_b = aui.composer.getState().attachments) == null ? void 0 : _b.length) ?? 0) > 0;
           if (!hasAttachments && await interceptSubmit(text, draftMarkdown)) {
+            composerHandoff.takeRestoredAttachments({ store: handoff, threadId, assetIdsInDraft: /* @__PURE__ */ new Set() });
             ed.commands.clearContent(false);
             clearImagePreviews();
             onDraftStateChange == null ? void 0 : onDraftStateChange(false);
@@ -255,6 +347,7 @@ const TiptapComposer = react.forwardRef(
         if (!text) return;
         if (!composerInput.canSend) return;
         composerMessage.prepareComposerSend({ threadId, text, draftMarkdown });
+        composerHandoff.takeRestoredAttachments({ store: handoff, threadId, assetIdsInDraft: /* @__PURE__ */ new Set() });
         composerInput.setText(text);
         composerInput.send({ steer: false });
         ed.commands.clearContent(false);
@@ -268,7 +361,11 @@ const TiptapComposer = react.forwardRef(
       clearImagePreviews,
       composerInput,
       disabled,
+      handoff,
+      hasPendingExtras,
+      holdPendingExtras,
       interceptSubmit,
+      onAttachmentError,
       onDraftStateChange,
       onSubmitted,
       threadId,
@@ -670,6 +767,8 @@ const TiptapComposer = react.forwardRef(
   }
 );
 TiptapComposer.displayName = "TiptapComposer";
+exports.OFFLINE_EXTRAS_MESSAGE = OFFLINE_EXTRAS_MESSAGE;
 exports.TiptapComposer = TiptapComposer;
+exports.WAITING_EXTRAS_MESSAGE = WAITING_EXTRAS_MESSAGE;
 exports.serializeDraft = serializeDraft;
 //# sourceMappingURL=tiptap-composer.cjs.map