@athenaintel/react 0.57.2 → 0.59.0

package/dist/chat/typed-interrupts/use-interrupt-draft.js

@@ -0,0 +1,106 @@
+import { useQuery, useMutation } from "@tanstack/react-query";
+import { useState, useRef, useCallback, useEffect } from "react";
+import { useAthenaQueryClient } from "../../lib/use-athena-rest-query.js";
+import { readInterruptDraft, saveInterruptDraft } from "./typed-interrupt-graphql.js";
+const DRAFT_SAVE_DEBOUNCE_MS = 2e3;
+function draftQueryKey(conversation, interruptId) {
+  return [
+    "athena-sdk",
+    "interrupt-draft",
+    (conversation == null ? void 0 : conversation.auth.backendUrl) ?? "",
+    (conversation == null ? void 0 : conversation.principal) ?? "",
+    (conversation == null ? void 0 : conversation.threadId) ?? "",
+    interruptId
+  ];
+}
+function useInterruptDraft({
+  conversation,
+  interruptId
+}) {
+  const queryClient = useAthenaQueryClient();
+  const { data, isFetching } = useQuery(
+    {
+      queryKey: draftQueryKey(conversation, interruptId),
+      queryFn: ({ signal }) => conversation ? readInterruptDraft(conversation, interruptId, signal) : null,
+      enabled: conversation !== null,
+      staleTime: 0,
+      refetchOnMount: "always",
+      retry: false,
+      refetchOnWindowFocus: false
+    },
+    queryClient
+  );
+  return { draft: conversation ? data : null, isLoading: conversation !== null && isFetching };
+}
+function useInterruptDraftSave({
+  conversation,
+  interruptId,
+  payload,
+  enabled
+}) {
+  const queryClient = useAthenaQueryClient();
+  const [status, setStatus] = useState("idle");
+  const { mutate } = useMutation(
+    {
+      mutationKey: ["athena-sdk", "interrupt-draft-save"],
+      mutationFn: (variables) => saveInterruptDraft(variables.conversation, variables.interruptId, variables.answers),
+      retry: false
+    },
+    queryClient
+  );
+  const latest = useRef({ conversation, interruptId, payload });
+  latest.current = { conversation, interruptId, payload };
+  const timerRef = useRef(null);
+  const save = useCallback(() => {
+    timerRef.current = null;
+    const { conversation: target, interruptId: key, payload: answers } = latest.current;
+    if (!target) return;
+    mutate(
+      { conversation: target, interruptId: key, answers },
+      {
+        onSuccess: () => {
+          setStatus("saved");
+          queryClient.setQueryData(draftQueryKey(target, key), answers);
+        },
+        onError: () => setStatus("error")
+      }
+    );
+  }, [mutate, queryClient]);
+  const flush = useCallback(() => {
+    if (timerRef.current === null) return;
+    clearTimeout(timerRef.current);
+    save();
+  }, [save]);
+  useEffect(() => {
+    setStatus("idle");
+    return () => {
+      if (timerRef.current !== null) clearTimeout(timerRef.current);
+      timerRef.current = null;
+    };
+  }, [interruptId]);
+  useEffect(() => {
+    if (!enabled || !conversation) return;
+    setStatus("saving");
+    if (timerRef.current !== null) clearTimeout(timerRef.current);
+    timerRef.current = setTimeout(save, DRAFT_SAVE_DEBOUNCE_MS);
+  }, [enabled, conversation, payload, save]);
+  useEffect(() => {
+    if (!enabled) return void 0;
+    const onBlur = () => flush();
+    const onVisibility = () => {
+      if (document.visibilityState === "hidden") flush();
+    };
+    window.addEventListener("blur", onBlur);
+    document.addEventListener("visibilitychange", onVisibility);
+    return () => {
+      window.removeEventListener("blur", onBlur);
+      document.removeEventListener("visibilitychange", onVisibility);
+    };
+  }, [enabled, flush]);
+  return { flush, status };
+}
+export {
+  useInterruptDraft,
+  useInterruptDraftSave
+};
+//# sourceMappingURL=use-interrupt-draft.js.map

package/dist/chat/typed-interrupts/use-interrupt-draft.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-interrupt-draft.js","sources":["../../../src/chat/typed-interrupts/use-interrupt-draft.ts"],"sourcesContent":["/**\n * A questionnaire's draft, kept on agora as Olympus keeps it: read once when\n * the card mounts, so answers typed on another surface (or before a reload)\n * come back, and saved two seconds after each change, at once when the window\n * loses focus or hides. agora's timer worker reads a draft's presence as \"the\n * person is answering\" and holds the timeout while it exists; its content is\n * never a resume value. Saves are best-effort: a failed one only shows on the\n * card's indicator.\n */\nimport { useMutation, useQuery } from '@tanstack/react-query';\nimport { useCallback, useEffect, useRef, useState } from 'react';\nimport { useAthenaQueryClient } from '../../lib/use-athena-rest-query';\nimport {\n  readInterruptDraft,\n  saveInterruptDraft,\n  type TypedInterruptConversation,\n} from './typed-interrupt-graphql';\n\nconst DRAFT_SAVE_DEBOUNCE_MS = 2000;\n\nexport type DraftSaveStatus = 'idle' | 'saving' | 'saved' | 'error';\n\nfunction draftQueryKey(conversation: TypedInterruptConversation | null, interruptId: string) {\n  return [\n    'athena-sdk',\n    'interrupt-draft',\n    conversation?.auth.backendUrl ?? '',\n    conversation?.principal ?? '',\n    conversation?.threadId ?? '',\n    interruptId,\n  ] as const;\n}\n\n/**\n * The draft agora holds for `interruptId` (`null` without one), read again\n * each time a card mounts: another app may have saved answers since. Loading\n * while that read is in flight, so a card restores the latest draft, not a\n * cached one; a read the network holds (offline) does not keep it waiting.\n */\nexport function useInterruptDraft({\n  conversation,\n  interruptId,\n}: {\n  conversation: TypedInterruptConversation | null;\n  interruptId: string;\n}): { draft: unknown; isLoading: boolean } {\n  const queryClient = useAthenaQueryClient();\n  const { data, isFetching } = useQuery(\n    {\n      queryKey: draftQueryKey(conversation, interruptId),\n      queryFn: ({ signal }) =>\n        conversation ? readInterruptDraft(conversation, interruptId, signal) : null,\n      enabled: conversation !== null,\n      staleTime: 0,\n      refetchOnMount: 'always',\n      retry: false,\n      refetchOnWindowFocus: false,\n    },\n    queryClient,\n  );\n  return { draft: conversation ? data : null, isLoading: conversation !== null && isFetching };\n}\n\n/**\n * Saves `payload` under `interruptId` two seconds after it last changed while\n * `enabled`; `flush` saves a pending change at once. A pending save never\n * lands under the next park's key, and none outlives the card.\n */\nexport function useInterruptDraftSave({\n  conversation,\n  interruptId,\n  payload,\n  enabled,\n}: {\n  conversation: TypedInterruptConversation | null;\n  interruptId: string;\n  payload: unknown;\n  enabled: boolean;\n}): { flush: () => void; status: DraftSaveStatus } {\n  const queryClient = useAthenaQueryClient();\n  const [status, setStatus] = useState<DraftSaveStatus>('idle');\n  const { mutate } = useMutation(\n    {\n      mutationKey: ['athena-sdk', 'interrupt-draft-save'],\n      mutationFn: (variables: { conversation: TypedInterruptConversation; interruptId: string; answers: unknown }) =>\n        saveInterruptDraft(variables.conversation, variables.interruptId, variables.answers),\n      retry: false,\n    },\n    queryClient,\n  );\n  const latest = useRef({ conversation, interruptId, payload });\n  latest.current = { conversation, interruptId, payload };\n  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n\n  const save = useCallback(() => {\n    timerRef.current = null;\n    const { conversation: target, interruptId: key, payload: answers } = latest.current;\n    if (!target) return;\n    mutate(\n      { conversation: target, interruptId: key, answers },\n      {\n        onSuccess: () => {\n          setStatus('saved');\n          // A card mounted again for this park restores what was saved last.\n          queryClient.setQueryData(draftQueryKey(target, key), answers);\n        },\n        onError: () => setStatus('error'),\n      },\n    );\n  }, [mutate, queryClient]);\n\n  const flush = useCallback(() => {\n    if (timerRef.current === null) return;\n    clearTimeout(timerRef.current);\n    save();\n  }, [save]);\n\n  // Another park: what was pending belonged to the last one.\n  useEffect(() => {\n    setStatus('idle');\n    return () => {\n      if (timerRef.current !== null) clearTimeout(timerRef.current);\n      timerRef.current = null;\n    };\n  }, [interruptId]);\n\n  useEffect(() => {\n    if (!enabled || !conversation) return;\n    setStatus('saving');\n    if (timerRef.current !== null) clearTimeout(timerRef.current);\n    timerRef.current = setTimeout(save, DRAFT_SAVE_DEBOUNCE_MS);\n  }, [enabled, conversation, payload, save]);\n\n  useEffect(() => {\n    if (!enabled) return undefined;\n    const onBlur = () => flush();\n    const onVisibility = () => {\n      if (document.visibilityState === 'hidden') flush();\n    };\n    window.addEventListener('blur', onBlur);\n    document.addEventListener('visibilitychange', onVisibility);\n    return () => {\n      window.removeEventListener('blur', onBlur);\n      document.removeEventListener('visibilitychange', onVisibility);\n    };\n  }, [enabled, flush]);\n\n  return { flush, status };\n}\n"],"names":[],"mappings":"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"}

package/dist/chat/typed-interrupts/use-statewire-typed-interrupt.cjs

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const react = require("@assistant-ui/react");
+const typedInterrupts = require("../../agent-runtime/src/typed-interrupts.cjs");
+const typedInterruptKinds = require("../../agent-runtime/src/typed-interrupt-kinds.cjs");
+const reactQuery = require("@tanstack/react-query");
+const require$$0 = require("react");
+const useAthenaRestQuery = require("../../lib/use-athena-rest-query.cjs");
+const useStatewireApprovalRequest = require("../use-statewire-approval-request.cjs");
+const typedInterruptGraphql = require("./typed-interrupt-graphql.cjs");
+const interrupts = require("../../agent-runtime/src/interrupts.cjs");
+const errors = require("../../agent-runtime/src/errors.cjs");
+const TYPED_INTERRUPT_ANSWER_FAILED_MESSAGE = "Your answer could not be sent. Please try again.";
+const TIMEOUT_STATUS_DELAY_MS = 500;
+const CANCEL_TIMEOUT_RETRIES = 2;
+const CANCEL_TIMEOUT_INITIAL_DELAY_MS = 500;
+function refusalMessage(error) {
+  if (errors.isConversationArchivedRejection(error)) return errors.CONVERSATION_ARCHIVED_MESSAGE;
+  return errors.statewireRejectionDetailMessage(error) ?? TYPED_INTERRUPT_ANSWER_FAILED_MESSAGE;
+}
+function useStatewireTypedInterrupt(options = {}) {
+  const { confirmDecision, onResumeRejected, pendingResumeGraceMs } = options;
+  const isConversationStreaming = react.useAuiState((state) => state.thread.isRunning);
+  const conversation = typedInterruptGraphql.useTypedInterruptConversation();
+  const queryClient = useAthenaRestQuery.useAthenaQueryClient();
+  const [held, setHeld] = require$$0.useState(null);
+  const lastHeldRef = require$$0.useRef(null);
+  const [failure, setFailure] = require$$0.useState(null);
+  const onResumeRejectedRef = require$$0.useRef(onResumeRejected);
+  onResumeRejectedRef.current = onResumeRejected;
+  const confirmDecisionRef = require$$0.useRef(confirmDecision);
+  confirmDecisionRef.current = confirmDecision;
+  const {
+    request,
+    requestId: liveRequestId,
+    pending,
+    resume: sendResume
+  } = useStatewireApprovalRequest.useStatewireApprovalRequest({
+    interruptPredicate: typedInterrupts.isTypedInterruptRequest,
+    pendingResumeGraceMs: pendingResumeGraceMs ?? interrupts.HITL_PENDING_RESUME_GRACE_MS,
+    // The host refused the answer (or the transport lost it): the fold has
+    // rolled back and the request is on screen again; say why on the card.
+    onResumeRejected: (error, refusedRequestId) => {
+      var _a;
+      setHeld(null);
+      if (errors.statewireTransportOutcome(error) === "unmount") return;
+      setFailure({ requestId: refusedRequestId, message: refusalMessage(error) });
+      (_a = onResumeRejectedRef.current) == null ? void 0 : _a.call(onResumeRejectedRef, error, refusedRequestId);
+    },
+    // The socket dropped with the answer in flight and the lock re-sends it:
+    // a fresh hold keeps the card through the re-send.
+    onResumeRetry: (_error, retriedRequestId) => {
+      const last = lastHeldRef.current;
+      if (last && last.requestId === retriedRequestId) setHeld({ ...last });
+    }
+  });
+  const liveInterrupt = require$$0.useMemo(
+    () => request ? typedInterrupts.parseTypedInterruptPayload(request.payload) : null,
+    [request]
+  );
+  require$$0.useEffect(() => {
+    if (held && liveRequestId !== void 0) setHeld(null);
+  }, [held, liveRequestId]);
+  const graceMs = pendingResumeGraceMs ?? interrupts.HITL_PENDING_RESUME_GRACE_MS;
+  require$$0.useEffect(() => {
+    if (!held) return void 0;
+    const timer = setTimeout(() => setHeld(null), graceMs);
+    return () => clearTimeout(timer);
+  }, [held, graceMs]);
+  const holding = held !== null && liveInterrupt === null;
+  const interrupt = holding ? held.interrupt : liveInterrupt;
+  const requestId = holding ? held.requestId : liveRequestId;
+  const [confirming, setConfirming] = require$$0.useState(false);
+  const currentRequestIdRef = require$$0.useRef(liveRequestId);
+  currentRequestIdRef.current = liveRequestId;
+  const isLoading = pending || holding || confirming;
+  const instanceKey = interrupt ? requestId ?? null : null;
+  const [timeoutRemaining, setTimeoutRemaining] = require$$0.useState(null);
+  const [isTimedOut, setIsTimedOut] = require$$0.useState(false);
+  const [cancelledInstance, setCancelledInstance] = require$$0.useState(null);
+  const isTimeoutCancelled = instanceKey !== null && cancelledInstance === instanceKey;
+  const timed = interrupt !== null && typedInterruptKinds.hasInterruptTimeout(interrupt);
+  const timeoutSeconds = (interrupt == null ? void 0 : interrupt.timeout_seconds) ?? null;
+  const timeoutAt = (interrupt == null ? void 0 : interrupt.timeout_at) ?? null;
+  require$$0.useEffect(() => {
+    if (!interrupt || !timed || isTimeoutCancelled) {
+      setTimeoutRemaining(null);
+      setIsTimedOut(false);
+      return void 0;
+    }
+    const tick = () => {
+      const remaining = typedInterruptKinds.interruptTimeoutRemaining(interrupt);
+      setTimeoutRemaining(remaining);
+      setIsTimedOut(remaining !== null && remaining <= 0);
+    };
+    tick();
+    const interval = setInterval(tick, 1e3);
+    return () => clearInterval(interval);
+  }, [interrupt, timed, isTimeoutCancelled]);
+  const [statusReady, setStatusReady] = require$$0.useState(false);
+  require$$0.useEffect(() => {
+    setStatusReady(false);
+    if (!timed || !timeoutAt) return void 0;
+    const timer = setTimeout(() => setStatusReady(true), TIMEOUT_STATUS_DELAY_MS);
+    return () => clearTimeout(timer);
+  }, [timed, timeoutAt]);
+  const source = (interrupt == null ? void 0 : interrupt.source) ?? null;
+  const statusEnabled = timed && statusReady && !isTimeoutCancelled && conversation !== null && source !== null;
+  const { data: cancelledBefore } = reactQuery.useQuery(
+    {
+      queryKey: [
+        "athena-sdk",
+        "interrupt-timeout-status",
+        (conversation == null ? void 0 : conversation.auth.backendUrl) ?? "",
+        (conversation == null ? void 0 : conversation.principal) ?? "",
+        (conversation == null ? void 0 : conversation.threadId) ?? "",
+        source ?? "",
+        timeoutAt ?? ""
+      ],
+      queryFn: ({ signal }) => {
+        if (!conversation || !source) return false;
+        return typedInterruptGraphql.readInterruptTimeoutCancelled(conversation, source, signal);
+      },
+      enabled: statusEnabled,
+      staleTime: Number.POSITIVE_INFINITY,
+      retry: false,
+      refetchOnWindowFocus: false
+    },
+    queryClient
+  );
+  require$$0.useEffect(() => {
+    if (cancelledBefore === true && instanceKey !== null) setCancelledInstance(instanceKey);
+  }, [cancelledBefore, instanceKey]);
+  const { mutate: sendCancelTimeout } = reactQuery.useMutation(
+    {
+      mutationKey: ["athena-sdk", "interrupt-timeout-cancel"],
+      mutationFn: ({ interruptId }) => {
+        if (!conversation) return Promise.reject(new Error("no conversation to stop the timer of"));
+        return typedInterruptGraphql.cancelInterruptTimeout(conversation, interruptId);
+      },
+      // The backend's timer answers at the deadline unless this lands: a
+      // blip must not let it fire while the person is answering.
+      retry: CANCEL_TIMEOUT_RETRIES,
+      retryDelay: (attempt) => {
+        const base = CANCEL_TIMEOUT_INITIAL_DELAY_MS * 2 ** attempt;
+        return base + Math.random() * base * 0.3;
+      }
+    },
+    queryClient
+  );
+  const canCancelTimeout = timed && conversation !== null;
+  const cancelRequestedRef = require$$0.useRef(null);
+  const cancelTimeout = require$$0.useCallback(() => {
+    if (!interrupt || !canCancelTimeout || isTimeoutCancelled || instanceKey === null) return;
+    if (cancelRequestedRef.current === instanceKey) return;
+    const instance = instanceKey;
+    cancelRequestedRef.current = instance;
+    setCancelledInstance(instance);
+    sendCancelTimeout(
+      { interruptId: interrupt.source },
+      {
+        // agora did not stop it after the retries: the countdown is true
+        // again, and Stop timer may ask once more.
+        onError: () => {
+          if (cancelRequestedRef.current === instance) cancelRequestedRef.current = null;
+          setCancelledInstance((current) => current === instance ? null : current);
+        }
+      }
+    );
+  }, [interrupt, canCancelTimeout, isTimeoutCancelled, instanceKey, sendCancelTimeout]);
+  const sendAnswer = require$$0.useCallback(
+    (kind, value) => {
+      if (!interrupt || requestId === void 0) return;
+      setFailure(null);
+      const answer = typedInterruptKinds.stampTypedInterruptAnswer({ payload: interrupt, value });
+      const park = { interrupt, requestId };
+      const deliver = (decisionCheck) => {
+        const dispatched = sendResume(answer, decisionCheck ? { decisionCheck } : void 0);
+        if (!dispatched) return;
+        lastHeldRef.current = park;
+        setHeld(park);
+        dispatched.then(
+          () => setHeld(null),
+          () => setHeld(null)
+        );
+      };
+      const confirm = confirmDecisionRef.current;
+      if (confirm === void 0 || kind !== "resume" || !typedInterruptKinds.isTypedApprovalInterrupt(interrupt) || !typedInterruptKinds.typedAnswerLetsSomethingRun(answer)) {
+        deliver();
+        return;
+      }
+      setConfirming(true);
+      confirm({ kind: "input", requestId, value: answer }).catch(() => void 0).then((token) => {
+        setConfirming(false);
+        if (currentRequestIdRef.current !== requestId) return;
+        deliver(token);
+      });
+    },
+    [interrupt, requestId, sendResume]
+  );
+  const resume = require$$0.useCallback((value) => sendAnswer("resume", value), [sendAnswer]);
+  const cancel = require$$0.useCallback(() => sendAnswer("cancel", typedInterruptKinds.typedInterruptCancel()), [sendAnswer]);
+  const message = interrupt == null ? void 0 : interrupt.message;
+  const displayMessage = require$$0.useMemo(() => {
+    if (!message) return "";
+    return isTimeoutCancelled ? typedInterruptKinds.stripInterruptTimeoutText(message) : message;
+  }, [message, isTimeoutCancelled]);
+  return {
+    interrupt,
+    request,
+    requestId,
+    resume,
+    cancel,
+    failure: failure !== null && failure.requestId === requestId ? failure.message : null,
+    isLoading,
+    isConversationStreaming,
+    isHiddenByRunning: isConversationStreaming && !isLoading,
+    hasTimeout: timed,
+    timeoutSeconds,
+    timeoutRemaining,
+    isTimedOut,
+    isTimeoutCancelled,
+    canCancelTimeout,
+    cancelTimeout,
+    displayMessage,
+    currentThreadId: (conversation == null ? void 0 : conversation.threadId) ?? null
+  };
+}
+exports.TYPED_INTERRUPT_ANSWER_FAILED_MESSAGE = TYPED_INTERRUPT_ANSWER_FAILED_MESSAGE;
+exports.useStatewireTypedInterrupt = useStatewireTypedInterrupt;
+//# sourceMappingURL=use-statewire-typed-interrupt.cjs.map

package/dist/chat/typed-interrupts/use-statewire-typed-interrupt.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-statewire-typed-interrupt.cjs","sources":["../../../src/chat/typed-interrupts/use-statewire-typed-interrupt.ts"],"sourcesContent":["/**\n * The typed-interrupt engine: everything a typed card renders from, and the\n * two ways it answers. The port of Olympus's `useLangGraphInterrupt` onto the\n * SDK, on the same request machine the approval card runs\n * (`useStatewireApprovalRequest`: selection, the optimistic resume lock and\n * its recovery), with ONE predicate, `isTypedInterruptRequest`, so the request\n * a card renders for is the request its answer is sent under.\n *\n * On top of the lock it adds what the cards need:\n *\n * - the parsed payload, held while the host decides an answer, so the card\n *   keeps what the person typed (react-statewire folds `run/input` away the\n *   instant it is applied, before any verdict, and a refusal brings the same\n *   request back);\n * - the stamps the raiser's stale-resume check reads (`__interrupt_id__`,\n *   `__interrupt_instance_id__`) on every answer;\n * - the passkey decision check (identity 0b.9) on an answer that approves a\n *   typed approval (`isTypedApprovalInterrupt`), through the host's\n *   `confirmDecision`, as the approval card runs it; a question's answer, a\n *   reject and a cancel never ask;\n * - the host's reason when it refuses an answer (agora holds an approving\n *   answer to a signed-in person: `person_decision_required` names where to\n *   answer instead), for the card to show;\n * - the timed-interrupt countdown (display only: the backend's timer answers),\n *   whether the person already stopped it, and stopping it.\n *\n * Requires a statewire aui scope (the SDK's statewire hooks throw outside\n * one): `StatewireTypedInterruptCard` mounts it under `StatewireApprovalCard`'s\n * extras gate.\n */\n\nimport { useAuiState } from '@assistant-ui/react';\nimport type { StatewireThread } from '@assistant-ui/react-statewire';\nimport {\n  CONVERSATION_ARCHIVED_MESSAGE,\n  HITL_PENDING_RESUME_GRACE_MS,\n  isConversationArchivedRejection,\n  statewireRejectionDetailMessage,\n  statewireTransportOutcome,\n} from '@athenaintel/agent-runtime';\nimport {\n  isTypedInterruptRequest,\n  parseTypedInterruptPayload,\n  type TypedInterruptPayload,\n} from '@athenaintel/agent-runtime/typed-interrupts';\nimport {\n  hasInterruptTimeout,\n  interruptTimeoutRemaining,\n  isTypedApprovalInterrupt,\n  stampTypedInterruptAnswer,\n  stripInterruptTimeoutText,\n  typedAnswerLetsSomethingRun,\n  typedInterruptCancel,\n} from '@athenaintel/agent-runtime/typed-interrupt-kinds';\nimport { useMutation, useQuery } from '@tanstack/react-query';\nimport type { ReadonlyJSONObject } from 'assistant-stream/utils';\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react';\nimport { useAthenaQueryClient } from '../../lib/use-athena-rest-query';\nimport type { StatewireDecisionConfirmer } from '../StatewireApprovalCard';\nimport { useStatewireApprovalRequest } from '../use-statewire-approval-request';\nimport {\n  cancelInterruptTimeout,\n  readInterruptTimeoutCancelled,\n  useTypedInterruptConversation,\n} from './typed-interrupt-graphql';\nimport type { TypedInterruptAnswer, TypedInterruptEngineSlice } from './typed-interrupt-types';\n\n/** What a card says when the host refused an answer without saying why. */\nexport const TYPED_INTERRUPT_ANSWER_FAILED_MESSAGE = 'Your answer could not be sent. Please try again.';\n\n/** The backend registers a park's timer just before it parks: ask about it a moment later. */\nconst TIMEOUT_STATUS_DELAY_MS = 500;\nconst CANCEL_TIMEOUT_RETRIES = 2;\nconst CANCEL_TIMEOUT_INITIAL_DELAY_MS = 500;\n\nexport interface UseStatewireTypedInterruptOptions {\n  /**\n   * The host's passkey decision check (identity 0b.9), as `StatewireApprovalCard`\n   * takes it: an answer that approves a typed approval is handed to it first\n   * and sent with the token it resolves.\n   */\n  confirmDecision?: StatewireDecisionConfirmer;\n  /** The host refused an answer (or the transport lost it); the card is back with its controls. */\n  onResumeRejected?: (error: unknown, requestId: string) => void;\n  /** How long a sent answer keeps the card locked when no resume run ever starts. */\n  pendingResumeGraceMs?: number;\n}\n\nexport interface StatewireTypedInterrupt extends TypedInterruptEngineSlice {\n  /** The parked typed interrupt (held while the host decides an answer), or `null`. */\n  interrupt: TypedInterruptPayload | null;\n  /** The live request (absent while an answer is held). */\n  request: StatewireThread.CustomInputRequest | undefined;\n  /**\n   * The thread moved on without this park: running, and no answer of this\n   * card's own in flight. The card stands down while it holds.\n   */\n  isHiddenByRunning: boolean;\n  /** Why the host refused this park's last answer, until the next one is sent. */\n  failure: string | null;\n  /** Answer the park with its kind's resume value. */\n  resume: (value: TypedInterruptAnswer) => void;\n  /** Answer the park with `{ action: 'cancel' }`. */\n  cancel: () => void;\n}\n\ninterface HeldPark {\n  interrupt: TypedInterruptPayload;\n  requestId: string;\n}\n\nfunction refusalMessage(error: unknown): string {\n  if (isConversationArchivedRejection(error)) return CONVERSATION_ARCHIVED_MESSAGE;\n  return statewireRejectionDetailMessage(error) ?? TYPED_INTERRUPT_ANSWER_FAILED_MESSAGE;\n}\n\nexport function useStatewireTypedInterrupt(\n  options: UseStatewireTypedInterruptOptions = {},\n): StatewireTypedInterrupt {\n  const { confirmDecision, onResumeRejected, pendingResumeGraceMs } = options;\n  const isConversationStreaming = useAuiState((state) => state.thread.isRunning);\n  const conversation = useTypedInterruptConversation();\n  const queryClient = useAthenaQueryClient();\n\n  const [held, setHeld] = useState<HeldPark | null>(null);\n  const lastHeldRef = useRef<HeldPark | null>(null);\n  const [failure, setFailure] = useState<{ requestId: string; message: string } | null>(null);\n  const onResumeRejectedRef = useRef(onResumeRejected);\n  onResumeRejectedRef.current = onResumeRejected;\n  const confirmDecisionRef = useRef(confirmDecision);\n  confirmDecisionRef.current = confirmDecision;\n\n  const {\n    request,\n    requestId: liveRequestId,\n    pending,\n    resume: sendResume,\n  } = useStatewireApprovalRequest<ReadonlyJSONObject>({\n    interruptPredicate: isTypedInterruptRequest,\n    pendingResumeGraceMs: pendingResumeGraceMs ?? HITL_PENDING_RESUME_GRACE_MS,\n    // The host refused the answer (or the transport lost it): the fold has\n    // rolled back and the request is on screen again; say why on the card.\n    onResumeRejected: (error, refusedRequestId) => {\n      setHeld(null);\n      // The surface itself went away mid-flight: nobody to tell.\n      if (statewireTransportOutcome(error) === 'unmount') return;\n      setFailure({ requestId: refusedRequestId, message: refusalMessage(error) });\n      onResumeRejectedRef.current?.(error, refusedRequestId);\n    },\n    // The socket dropped with the answer in flight and the lock re-sends it:\n    // a fresh hold keeps the card through the re-send.\n    onResumeRetry: (_error, retriedRequestId) => {\n      const last = lastHeldRef.current;\n      if (last && last.requestId === retriedRequestId) setHeld({ ...last });\n    },\n  });\n\n  // The predicate parsed the payload already; parse again for its value.\n  const liveInterrupt = useMemo(\n    () => (request ? parseTypedInterruptPayload(request.payload) : null),\n    [request],\n  );\n\n  // A hold ends with the host's verdict (below), when a park is live again\n  // (the refused one, under its id, or a new one), or after the grace window.\n  useEffect(() => {\n    if (held && liveRequestId !== undefined) setHeld(null);\n  }, [held, liveRequestId]);\n  const graceMs = pendingResumeGraceMs ?? HITL_PENDING_RESUME_GRACE_MS;\n  useEffect(() => {\n    if (!held) return undefined;\n    const timer = setTimeout(() => setHeld(null), graceMs);\n    return () => clearTimeout(timer);\n  }, [held, graceMs]);\n  const holding = held !== null && liveInterrupt === null;\n  const interrupt = holding ? held.interrupt : liveInterrupt;\n  const requestId = holding ? held.requestId : liveRequestId;\n\n  // A passkey check is open for an answer sent from here.\n  const [confirming, setConfirming] = useState(false);\n  // The park on screen now, read once a check settles: an answer confirmed for\n  // a park that is gone is never sent to whatever parked next.\n  const currentRequestIdRef = useRef(liveRequestId);\n  currentRequestIdRef.current = liveRequestId;\n  const isLoading = pending || holding || confirming;\n\n  // ── The timer (display only; the backend's timer answers at the deadline) ──\n  // Everything below is per park instance: the request id, never the source,\n  // which repeats (every toolkit selection is `toolkit_selection`).\n  const instanceKey = interrupt ? (requestId ?? null) : null;\n  const [timeoutRemaining, setTimeoutRemaining] = useState<number | null>(null);\n  const [isTimedOut, setIsTimedOut] = useState(false);\n  const [cancelledInstance, setCancelledInstance] = useState<string | null>(null);\n  const isTimeoutCancelled = instanceKey !== null && cancelledInstance === instanceKey;\n  const timed = interrupt !== null && hasInterruptTimeout(interrupt);\n  const timeoutSeconds = interrupt?.timeout_seconds ?? null;\n  const timeoutAt = interrupt?.timeout_at ?? null;\n\n  useEffect(() => {\n    if (!interrupt || !timed || isTimeoutCancelled) {\n      setTimeoutRemaining(null);\n      setIsTimedOut(false);\n      return undefined;\n    }\n    const tick = () => {\n      const remaining = interruptTimeoutRemaining(interrupt);\n      setTimeoutRemaining(remaining);\n      setIsTimedOut(remaining !== null && remaining <= 0);\n    };\n    tick();\n    const interval = setInterval(tick, 1000);\n    return () => clearInterval(interval);\n  }, [interrupt, timed, isTimeoutCancelled]);\n\n  // Whether the person stopped this park's timer before (another app, a\n  // reload): asked once per instance, a moment after it parks.\n  const [statusReady, setStatusReady] = useState(false);\n  useEffect(() => {\n    setStatusReady(false);\n    if (!timed || !timeoutAt) return undefined;\n    const timer = setTimeout(() => setStatusReady(true), TIMEOUT_STATUS_DELAY_MS);\n    return () => clearTimeout(timer);\n  }, [timed, timeoutAt]);\n  const source = interrupt?.source ?? null;\n  const statusEnabled =\n    timed && statusReady && !isTimeoutCancelled && conversation !== null && source !== null;\n  const { data: cancelledBefore } = useQuery(\n    {\n      queryKey: [\n        'athena-sdk',\n        'interrupt-timeout-status',\n        conversation?.auth.backendUrl ?? '',\n        conversation?.principal ?? '',\n        conversation?.threadId ?? '',\n        source ?? '',\n        timeoutAt ?? '',\n      ],\n      queryFn: ({ signal }) => {\n        if (!conversation || !source) return false;\n        return readInterruptTimeoutCancelled(conversation, source, signal);\n      },\n      enabled: statusEnabled,\n      staleTime: Number.POSITIVE_INFINITY,\n      retry: false,\n      refetchOnWindowFocus: false,\n    },\n    queryClient,\n  );\n  useEffect(() => {\n    if (cancelledBefore === true && instanceKey !== null) setCancelledInstance(instanceKey);\n  }, [cancelledBefore, instanceKey]);\n\n  const { mutate: sendCancelTimeout } = useMutation(\n    {\n      mutationKey: ['athena-sdk', 'interrupt-timeout-cancel'],\n      mutationFn: ({ interruptId }: { interruptId: string }) => {\n        if (!conversation) return Promise.reject(new Error('no conversation to stop the timer of'));\n        return cancelInterruptTimeout(conversation, interruptId);\n      },\n      // The backend's timer answers at the deadline unless this lands: a\n      // blip must not let it fire while the person is answering.\n      retry: CANCEL_TIMEOUT_RETRIES,\n      retryDelay: (attempt) => {\n        const base = CANCEL_TIMEOUT_INITIAL_DELAY_MS * 2 ** attempt;\n        return base + Math.random() * base * 0.3;\n      },\n    },\n    queryClient,\n  );\n\n  // Only agora can stop its timer: without the conversation (a host that\n  // names no thread) the countdown stays, and nothing offers to stop it.\n  const canCancelTimeout = timed && conversation !== null;\n  // One request per park: a press on Stop timer is also the card's first\n  // interaction, and both ask in the same tick, before a render says so.\n  const cancelRequestedRef = useRef<string | null>(null);\n  const cancelTimeout = useCallback(() => {\n    if (!interrupt || !canCancelTimeout || isTimeoutCancelled || instanceKey === null) return;\n    if (cancelRequestedRef.current === instanceKey) return;\n    const instance = instanceKey;\n    cancelRequestedRef.current = instance;\n    setCancelledInstance(instance);\n    sendCancelTimeout(\n      { interruptId: interrupt.source },\n      {\n        // agora did not stop it after the retries: the countdown is true\n        // again, and Stop timer may ask once more.\n        onError: () => {\n          if (cancelRequestedRef.current === instance) cancelRequestedRef.current = null;\n          setCancelledInstance((current) => (current === instance ? null : current));\n        },\n      },\n    );\n  }, [interrupt, canCancelTimeout, isTimeoutCancelled, instanceKey, sendCancelTimeout]);\n\n  // ── Answers ──\n  const sendAnswer = useCallback(\n    (kind: 'resume' | 'cancel', value: TypedInterruptAnswer) => {\n      if (!interrupt || requestId === undefined) return;\n      setFailure(null);\n      const answer = stampTypedInterruptAnswer({ payload: interrupt, value }) as ReadonlyJSONObject;\n      const park: HeldPark = { interrupt, requestId };\n      const deliver = (decisionCheck?: string) => {\n        const dispatched = sendResume(answer, decisionCheck ? { decisionCheck } : undefined);\n        if (!dispatched) return;\n        lastHeldRef.current = park;\n        setHeld(park);\n        // Accepted or refused, the verdict ends the hold (a refusal also\n        // brings the request back through the live selection).\n        dispatched.then(\n          () => setHeld(null),\n          () => setHeld(null),\n        );\n      };\n      const confirm = confirmDecisionRef.current;\n      if (\n        confirm === undefined ||\n        kind !== 'resume' ||\n        !isTypedApprovalInterrupt(interrupt) ||\n        !typedAnswerLetsSomethingRun(answer)\n      ) {\n        deliver();\n        return;\n      }\n      // Identity 0b.9: approving is confirmed with the person's passkey first,\n      // as the approval card does; a check that gave no token sends the\n      // answer without one, and agora decides.\n      setConfirming(true);\n      confirm({ kind: 'input', requestId, value: answer })\n        .catch(() => undefined)\n        .then((token) => {\n          setConfirming(false);\n          if (currentRequestIdRef.current !== requestId) return;\n          deliver(token);\n        });\n    },\n    [interrupt, requestId, sendResume],\n  );\n\n  const resume = useCallback((value: TypedInterruptAnswer) => sendAnswer('resume', value), [sendAnswer]);\n  const cancel = useCallback(() => sendAnswer('cancel', typedInterruptCancel()), [sendAnswer]);\n\n  const message = interrupt?.message;\n  const displayMessage = useMemo(() => {\n    if (!message) return '';\n    return isTimeoutCancelled ? stripInterruptTimeoutText(message) : message;\n  }, [message, isTimeoutCancelled]);\n\n  return {\n    interrupt,\n    request,\n    requestId,\n    resume,\n    cancel,\n    failure: failure !== null && failure.requestId === requestId ? failure.message : null,\n    isLoading,\n    isConversationStreaming,\n    isHiddenByRunning: isConversationStreaming && !isLoading,\n    hasTimeout: timed,\n    timeoutSeconds,\n    timeoutRemaining,\n    isTimedOut,\n    isTimeoutCancelled,\n    canCancelTimeout,\n    cancelTimeout,\n    displayMessage,\n    currentThreadId: conversation?.threadId ?? null,\n  };\n}\n"],"names":["isConversationArchivedRejection","CONVERSATION_ARCHIVED_MESSAGE","statewireRejectionDetailMessage","useAuiState","useTypedInterruptConversation","useAthenaQueryClient","useState","useRef","useStatewireApprovalRequest","isTypedInterruptRequest","HITL_PENDING_RESUME_GRACE_MS","statewireTransportOutcome","useMemo","parseTypedInterruptPayload","useEffect","hasInterruptTimeout","interruptTimeoutRemaining","useQuery","readInterruptTimeoutCancelled","useMutation","cancelInterruptTimeout","useCallback","stampTypedInterruptAnswer","isTypedApprovalInterrupt","typedAnswerLetsSomethingRun","typedInterruptCancel","stripInterruptTimeoutText"],"mappings":"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"}

package/dist/chat/typed-interrupts/use-statewire-typed-interrupt.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The typed-interrupt engine: everything a typed card renders from, and the
+ * two ways it answers. The port of Olympus's `useLangGraphInterrupt` onto the
+ * SDK, on the same request machine the approval card runs
+ * (`useStatewireApprovalRequest`: selection, the optimistic resume lock and
+ * its recovery), with ONE predicate, `isTypedInterruptRequest`, so the request
+ * a card renders for is the request its answer is sent under.
+ *
+ * On top of the lock it adds what the cards need:
+ *
+ * - the parsed payload, held while the host decides an answer, so the card
+ *   keeps what the person typed (react-statewire folds `run/input` away the
+ *   instant it is applied, before any verdict, and a refusal brings the same
+ *   request back);
+ * - the stamps the raiser's stale-resume check reads (`__interrupt_id__`,
+ *   `__interrupt_instance_id__`) on every answer;
+ * - the passkey decision check (identity 0b.9) on an answer that approves a
+ *   typed approval (`isTypedApprovalInterrupt`), through the host's
+ *   `confirmDecision`, as the approval card runs it; a question's answer, a
+ *   reject and a cancel never ask;
+ * - the host's reason when it refuses an answer (agora holds an approving
+ *   answer to a signed-in person: `person_decision_required` names where to
+ *   answer instead), for the card to show;
+ * - the timed-interrupt countdown (display only: the backend's timer answers),
+ *   whether the person already stopped it, and stopping it.
+ *
+ * Requires a statewire aui scope (the SDK's statewire hooks throw outside
+ * one): `StatewireTypedInterruptCard` mounts it under `StatewireApprovalCard`'s
+ * extras gate.
+ */
+import type { StatewireThread } from '@assistant-ui/react-statewire';
+import { type TypedInterruptPayload } from '../../agent-runtime/src/typed-interrupts';
+import type { StatewireDecisionConfirmer } from '../StatewireApprovalCard';
+import type { TypedInterruptAnswer, TypedInterruptEngineSlice } from './typed-interrupt-types';
+/** What a card says when the host refused an answer without saying why. */
+export declare const TYPED_INTERRUPT_ANSWER_FAILED_MESSAGE = "Your answer could not be sent. Please try again.";
+export interface UseStatewireTypedInterruptOptions {
+    /**
+     * The host's passkey decision check (identity 0b.9), as `StatewireApprovalCard`
+     * takes it: an answer that approves a typed approval is handed to it first
+     * and sent with the token it resolves.
+     */
+    confirmDecision?: StatewireDecisionConfirmer;
+    /** The host refused an answer (or the transport lost it); the card is back with its controls. */
+    onResumeRejected?: (error: unknown, requestId: string) => void;
+    /** How long a sent answer keeps the card locked when no resume run ever starts. */
+    pendingResumeGraceMs?: number;
+}
+export interface StatewireTypedInterrupt extends TypedInterruptEngineSlice {
+    /** The parked typed interrupt (held while the host decides an answer), or `null`. */
+    interrupt: TypedInterruptPayload | null;
+    /** The live request (absent while an answer is held). */
+    request: StatewireThread.CustomInputRequest | undefined;
+    /**
+     * The thread moved on without this park: running, and no answer of this
+     * card's own in flight. The card stands down while it holds.
+     */
+    isHiddenByRunning: boolean;
+    /** Why the host refused this park's last answer, until the next one is sent. */
+    failure: string | null;
+    /** Answer the park with its kind's resume value. */
+    resume: (value: TypedInterruptAnswer) => void;
+    /** Answer the park with `{ action: 'cancel' }`. */
+    cancel: () => void;
+}
+export declare function useStatewireTypedInterrupt(options?: UseStatewireTypedInterruptOptions): StatewireTypedInterrupt;