@athenaintel/react 0.57.1 → 0.59.0

package/dist/chat/typed-interrupts/typed-interrupt-notice.cjs

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const typedInterrupts = require("../../agent-runtime/src/typed-interrupts.cjs");
+const typedInterruptKinds = require("../../agent-runtime/src/typed-interrupt-kinds.cjs");
+const lucideReact = require("lucide-react");
+const require$$0 = require("react");
+const button = require("../../ui/button.cjs");
+const interrupts = require("../../agent-runtime/src/interrupts.cjs");
+function TypedInterruptNotice({
+  interrupt,
+  displayMessage,
+  variant,
+  readOnlyNotice = "Waiting for someone with edit access to respond.",
+  disabled = false,
+  resume,
+  cancel
+}) {
+  const decline = () => {
+    if (interrupt.type === typedInterrupts.TypedInterruptType.HITL) {
+      resume == null ? void 0 : resume(typedInterruptKinds.typedApprovalResume({ action: "reject", reason: interrupts.HITL_REJECT_REASON }));
+      return;
+    }
+    cancel == null ? void 0 : cancel();
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      "data-testid": `typed-interrupt-${variant}`,
+      className: "w-full rounded-2xl border border-amber-300 bg-amber-50 px-4 py-3 text-amber-900",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-start gap-3", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.TriangleAlertIcon, { className: "mt-0.5 size-4 shrink-0" }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "min-w-0 flex-1", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("p", { className: "font-semibold text-sm", children: variant === "read-only" ? "Input required" : "This request could not be displayed" }),
+            /* @__PURE__ */ jsxRuntime.jsx("p", { className: "pt-1 text-amber-800 text-sm leading-snug", children: displayMessage || interrupt.message })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-wrap items-center gap-2 pt-3", children: variant === "read-only" ? /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-amber-800 text-sm", children: readOnlyNotice }) : /* @__PURE__ */ jsxRuntime.jsxs(button.Button, { size: "sm", variant: "outline", disabled, onClick: decline, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.XIcon, {}),
+          "Cancel request"
+        ] }) })
+      ]
+    }
+  );
+}
+class TypedInterruptErrorBoundary extends require$$0.Component {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "state", { hasError: false, resetKey: this.props.resetKey });
+  }
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  static getDerivedStateFromProps(props, state) {
+    return props.resetKey === state.resetKey ? null : { hasError: false, resetKey: props.resetKey };
+  }
+  componentDidCatch(error, info) {
+    console.error("[athena] a typed interrupt card failed to render", error, info.componentStack);
+  }
+  render() {
+    return this.state.hasError ? this.props.fallback : this.props.children;
+  }
+}
+exports.TypedInterruptErrorBoundary = TypedInterruptErrorBoundary;
+exports.TypedInterruptNotice = TypedInterruptNotice;
+//# sourceMappingURL=typed-interrupt-notice.cjs.map

package/dist/chat/typed-interrupts/typed-interrupt-notice.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-interrupt-notice.cjs","sources":["../../../src/chat/typed-interrupts/typed-interrupt-notice.tsx"],"sourcesContent":["import { HITL_REJECT_REASON } from '@athenaintel/agent-runtime';\nimport { type TypedInterruptPayload, TypedInterruptType } from '@athenaintel/agent-runtime/typed-interrupts';\nimport { typedApprovalResume } from '@athenaintel/agent-runtime/typed-interrupt-kinds';\nimport { TriangleAlertIcon, XIcon } from 'lucide-react';\nimport { Component, type ErrorInfo, type ReactNode } from 'react';\nimport { Button } from '../../ui/button';\nimport type { TypedInterruptAnswer } from './typed-interrupt-types';\n\nexport interface TypedInterruptNoticeProps {\n  interrupt: TypedInterruptPayload;\n  /** The park's message as the engine shows it (its timeout suffix gone once the timer stopped). */\n  displayMessage: string;\n  /**\n   * `read-only`: a viewer without edit rights sees the park's message and who\n   * answers it. `render-failed`: the card threw; the message and the one\n   * honest answer, a cancel.\n   */\n  variant: 'read-only' | 'render-failed';\n  readOnlyNotice?: ReactNode;\n  disabled?: boolean;\n  resume?: (value: TypedInterruptAnswer) => void;\n  cancel?: () => void;\n}\n\n/**\n * What the typed slot shows when a card cannot (Olympus's\n * `TypedInterruptNotice`): never a generic answer, which a typed raiser's\n * resume model would refuse. The only answer every raiser reads as a clean\n * decline is a cancel (`FormCancelledError`), and for a tool-raised approval,\n * whose model takes only approve or reject, a reject.\n */\nexport function TypedInterruptNotice({\n  interrupt,\n  displayMessage,\n  variant,\n  readOnlyNotice = 'Waiting for someone with edit access to respond.',\n  disabled = false,\n  resume,\n  cancel,\n}: TypedInterruptNoticeProps) {\n  const decline = () => {\n    if (interrupt.type === TypedInterruptType.HITL) {\n      resume?.(typedApprovalResume({ action: 'reject', reason: HITL_REJECT_REASON }));\n      return;\n    }\n    cancel?.();\n  };\n  return (\n    <div\n      data-testid={`typed-interrupt-${variant}`}\n      className=\"w-full rounded-2xl border border-amber-300 bg-amber-50 px-4 py-3 text-amber-900\"\n    >\n      <div className=\"flex items-start gap-3\">\n        <TriangleAlertIcon className=\"mt-0.5 size-4 shrink-0\" />\n        <div className=\"min-w-0 flex-1\">\n          <p className=\"font-semibold text-sm\">\n            {variant === 'read-only' ? 'Input required' : 'This request could not be displayed'}\n          </p>\n          <p className=\"pt-1 text-amber-800 text-sm leading-snug\">{displayMessage || interrupt.message}</p>\n        </div>\n      </div>\n      <div className=\"flex flex-wrap items-center gap-2 pt-3\">\n        {variant === 'read-only' ? (\n          <p className=\"text-amber-800 text-sm\">{readOnlyNotice}</p>\n        ) : (\n          <Button size=\"sm\" variant=\"outline\" disabled={disabled} onClick={decline}>\n            <XIcon />\n            Cancel request\n          </Button>\n        )}\n      </div>\n    </div>\n  );\n}\n\ninterface TypedInterruptErrorBoundaryProps {\n  /** A change here (a new park) clears a caught error so the next card renders. */\n  resetKey: string | undefined;\n  fallback: ReactNode;\n  children: ReactNode;\n}\n\ninterface TypedInterruptErrorBoundaryState {\n  hasError: boolean;\n  resetKey: string | undefined;\n}\n\n/** A card that throws never takes the chat with it: the fallback stands in until the next park. */\nexport class TypedInterruptErrorBoundary extends Component<\n  TypedInterruptErrorBoundaryProps,\n  TypedInterruptErrorBoundaryState\n> {\n  state: TypedInterruptErrorBoundaryState = { hasError: false, resetKey: this.props.resetKey };\n\n  static getDerivedStateFromError(): Partial<TypedInterruptErrorBoundaryState> {\n    return { hasError: true };\n  }\n\n  static getDerivedStateFromProps(\n    props: TypedInterruptErrorBoundaryProps,\n    state: TypedInterruptErrorBoundaryState,\n  ): Partial<TypedInterruptErrorBoundaryState> | null {\n    return props.resetKey === state.resetKey ? null : { hasError: false, resetKey: props.resetKey };\n  }\n\n  componentDidCatch(error: unknown, info: ErrorInfo): void {\n    console.error('[athena] a typed interrupt card failed to render', error, info.componentStack);\n  }\n\n  render(): ReactNode {\n    return this.state.hasError ? this.props.fallback : this.props.children;\n  }\n}\n"],"names":["TypedInterruptType","typedApprovalResume","HITL_REJECT_REASON","jsxs","jsx","TriangleAlertIcon","Button","XIcon","Component"],"mappings":";;;;;;;;;;;;AA+BO,SAAS,qBAAqB;AAAA,EACnC;AAAA,EACA;AAAA,EACA;AAAA,EACA,iBAAiB;AAAA,EACjB,WAAW;AAAA,EACX;AAAA,EACA;AACF,GAA8B;AAC5B,QAAM,UAAU,MAAM;AACpB,QAAI,UAAU,SAASA,gBAAAA,mBAAmB,MAAM;AAC9C,uCAASC,oBAAAA,oBAAoB,EAAE,QAAQ,UAAU,QAAQC,WAAAA,mBAAA,CAAoB;AAC7E;AAAA,IACF;AACA;AAAA,EACF;AACA,SACEC,2BAAAA;AAAAA,IAAC;AAAA,IAAA;AAAA,MACC,eAAa,mBAAmB,OAAO;AAAA,MACvC,WAAU;AAAA,MAEV,UAAA;AAAA,QAAAA,2BAAAA,KAAC,OAAA,EAAI,WAAU,0BACb,UAAA;AAAA,UAAAC,2BAAAA,IAACC,YAAAA,mBAAA,EAAkB,WAAU,yBAAA,CAAyB;AAAA,UACtDF,2BAAAA,KAAC,OAAA,EAAI,WAAU,kBACb,UAAA;AAAA,YAAAC,+BAAC,OAAE,WAAU,yBACV,UAAA,YAAY,cAAc,mBAAmB,uCAChD;AAAA,2CACC,KAAA,EAAE,WAAU,4CAA4C,UAAA,kBAAkB,UAAU,QAAA,CAAQ;AAAA,UAAA,EAAA,CAC/F;AAAA,QAAA,GACF;AAAA,QACAA,2BAAAA,IAAC,SAAI,WAAU,0CACZ,sBAAY,cACXA,2BAAAA,IAAC,OAAE,WAAU,0BAA0B,0BAAe,IAEtDD,2BAAAA,KAACG,OAAAA,UAAO,MAAK,MAAK,SAAQ,WAAU,UAAoB,SAAS,SAC/D,UAAA;AAAA,UAAAF,2BAAAA,IAACG,YAAAA,OAAA,EAAM;AAAA,UAAE;AAAA,QAAA,EAAA,CAEX,EAAA,CAEJ;AAAA,MAAA;AAAA,IAAA;AAAA,EAAA;AAGN;AAeO,MAAM,oCAAoCC,WAAAA,UAG/C;AAAA,EAHK;AAAA;AAIL,iCAA0C,EAAE,UAAU,OAAO,UAAU,KAAK,MAAM,SAAA;AAAA;AAAA,EAElF,OAAO,2BAAsE;AAC3E,WAAO,EAAE,UAAU,KAAA;AAAA,EACrB;AAAA,EAEA,OAAO,yBACL,OACA,OACkD;AAClD,WAAO,MAAM,aAAa,MAAM,WAAW,OAAO,EAAE,UAAU,OAAO,UAAU,MAAM,SAAA;AAAA,EACvF;AAAA,EAEA,kBAAkB,OAAgB,MAAuB;AACvD,YAAQ,MAAM,oDAAoD,OAAO,KAAK,cAAc;AAAA,EAC9F;AAAA,EAEA,SAAoB;AAClB,WAAO,KAAK,MAAM,WAAW,KAAK,MAAM,WAAW,KAAK,MAAM;AAAA,EAChE;AACF;;;"}

package/dist/chat/typed-interrupts/typed-interrupt-notice.d.ts

@@ -0,0 +1,45 @@
+import { type TypedInterruptPayload } from '../../agent-runtime/src/typed-interrupts';
+import { Component, type ErrorInfo, type ReactNode } from 'react';
+import type { TypedInterruptAnswer } from './typed-interrupt-types';
+export interface TypedInterruptNoticeProps {
+    interrupt: TypedInterruptPayload;
+    /** The park's message as the engine shows it (its timeout suffix gone once the timer stopped). */
+    displayMessage: string;
+    /**
+     * `read-only`: a viewer without edit rights sees the park's message and who
+     * answers it. `render-failed`: the card threw; the message and the one
+     * honest answer, a cancel.
+     */
+    variant: 'read-only' | 'render-failed';
+    readOnlyNotice?: ReactNode;
+    disabled?: boolean;
+    resume?: (value: TypedInterruptAnswer) => void;
+    cancel?: () => void;
+}
+/**
+ * What the typed slot shows when a card cannot (Olympus's
+ * `TypedInterruptNotice`): never a generic answer, which a typed raiser's
+ * resume model would refuse. The only answer every raiser reads as a clean
+ * decline is a cancel (`FormCancelledError`), and for a tool-raised approval,
+ * whose model takes only approve or reject, a reject.
+ */
+export declare function TypedInterruptNotice({ interrupt, displayMessage, variant, readOnlyNotice, disabled, resume, cancel, }: TypedInterruptNoticeProps): import("react").JSX.Element;
+interface TypedInterruptErrorBoundaryProps {
+    /** A change here (a new park) clears a caught error so the next card renders. */
+    resetKey: string | undefined;
+    fallback: ReactNode;
+    children: ReactNode;
+}
+interface TypedInterruptErrorBoundaryState {
+    hasError: boolean;
+    resetKey: string | undefined;
+}
+/** A card that throws never takes the chat with it: the fallback stands in until the next park. */
+export declare class TypedInterruptErrorBoundary extends Component<TypedInterruptErrorBoundaryProps, TypedInterruptErrorBoundaryState> {
+    state: TypedInterruptErrorBoundaryState;
+    static getDerivedStateFromError(): Partial<TypedInterruptErrorBoundaryState>;
+    static getDerivedStateFromProps(props: TypedInterruptErrorBoundaryProps, state: TypedInterruptErrorBoundaryState): Partial<TypedInterruptErrorBoundaryState> | null;
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    render(): ReactNode;
+}
+export {};

package/dist/chat/typed-interrupts/typed-interrupt-notice.js

@@ -0,0 +1,70 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { jsxs, jsx } from "react/jsx-runtime";
+import { TypedInterruptType } from "../../agent-runtime/src/typed-interrupts.js";
+import { typedApprovalResume } from "../../agent-runtime/src/typed-interrupt-kinds.js";
+import { TriangleAlertIcon, XIcon } from "lucide-react";
+import { Component } from "react";
+import { Button } from "../../ui/button.js";
+import { HITL_REJECT_REASON } from "../../agent-runtime/src/interrupts.js";
+function TypedInterruptNotice({
+  interrupt,
+  displayMessage,
+  variant,
+  readOnlyNotice = "Waiting for someone with edit access to respond.",
+  disabled = false,
+  resume,
+  cancel
+}) {
+  const decline = () => {
+    if (interrupt.type === TypedInterruptType.HITL) {
+      resume == null ? void 0 : resume(typedApprovalResume({ action: "reject", reason: HITL_REJECT_REASON }));
+      return;
+    }
+    cancel == null ? void 0 : cancel();
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-testid": `typed-interrupt-${variant}`,
+      className: "w-full rounded-2xl border border-amber-300 bg-amber-50 px-4 py-3 text-amber-900",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-start gap-3", children: [
+          /* @__PURE__ */ jsx(TriangleAlertIcon, { className: "mt-0.5 size-4 shrink-0" }),
+          /* @__PURE__ */ jsxs("div", { className: "min-w-0 flex-1", children: [
+            /* @__PURE__ */ jsx("p", { className: "font-semibold text-sm", children: variant === "read-only" ? "Input required" : "This request could not be displayed" }),
+            /* @__PURE__ */ jsx("p", { className: "pt-1 text-amber-800 text-sm leading-snug", children: displayMessage || interrupt.message })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "flex flex-wrap items-center gap-2 pt-3", children: variant === "read-only" ? /* @__PURE__ */ jsx("p", { className: "text-amber-800 text-sm", children: readOnlyNotice }) : /* @__PURE__ */ jsxs(Button, { size: "sm", variant: "outline", disabled, onClick: decline, children: [
+          /* @__PURE__ */ jsx(XIcon, {}),
+          "Cancel request"
+        ] }) })
+      ]
+    }
+  );
+}
+class TypedInterruptErrorBoundary extends Component {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "state", { hasError: false, resetKey: this.props.resetKey });
+  }
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  static getDerivedStateFromProps(props, state) {
+    return props.resetKey === state.resetKey ? null : { hasError: false, resetKey: props.resetKey };
+  }
+  componentDidCatch(error, info) {
+    console.error("[athena] a typed interrupt card failed to render", error, info.componentStack);
+  }
+  render() {
+    return this.state.hasError ? this.props.fallback : this.props.children;
+  }
+}
+export {
+  TypedInterruptErrorBoundary,
+  TypedInterruptNotice
+};
+//# sourceMappingURL=typed-interrupt-notice.js.map

package/dist/chat/typed-interrupts/typed-interrupt-notice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-interrupt-notice.js","sources":["../../../src/chat/typed-interrupts/typed-interrupt-notice.tsx"],"sourcesContent":["import { HITL_REJECT_REASON } from '@athenaintel/agent-runtime';\nimport { type TypedInterruptPayload, TypedInterruptType } from '@athenaintel/agent-runtime/typed-interrupts';\nimport { typedApprovalResume } from '@athenaintel/agent-runtime/typed-interrupt-kinds';\nimport { TriangleAlertIcon, XIcon } from 'lucide-react';\nimport { Component, type ErrorInfo, type ReactNode } from 'react';\nimport { Button } from '../../ui/button';\nimport type { TypedInterruptAnswer } from './typed-interrupt-types';\n\nexport interface TypedInterruptNoticeProps {\n  interrupt: TypedInterruptPayload;\n  /** The park's message as the engine shows it (its timeout suffix gone once the timer stopped). */\n  displayMessage: string;\n  /**\n   * `read-only`: a viewer without edit rights sees the park's message and who\n   * answers it. `render-failed`: the card threw; the message and the one\n   * honest answer, a cancel.\n   */\n  variant: 'read-only' | 'render-failed';\n  readOnlyNotice?: ReactNode;\n  disabled?: boolean;\n  resume?: (value: TypedInterruptAnswer) => void;\n  cancel?: () => void;\n}\n\n/**\n * What the typed slot shows when a card cannot (Olympus's\n * `TypedInterruptNotice`): never a generic answer, which a typed raiser's\n * resume model would refuse. The only answer every raiser reads as a clean\n * decline is a cancel (`FormCancelledError`), and for a tool-raised approval,\n * whose model takes only approve or reject, a reject.\n */\nexport function TypedInterruptNotice({\n  interrupt,\n  displayMessage,\n  variant,\n  readOnlyNotice = 'Waiting for someone with edit access to respond.',\n  disabled = false,\n  resume,\n  cancel,\n}: TypedInterruptNoticeProps) {\n  const decline = () => {\n    if (interrupt.type === TypedInterruptType.HITL) {\n      resume?.(typedApprovalResume({ action: 'reject', reason: HITL_REJECT_REASON }));\n      return;\n    }\n    cancel?.();\n  };\n  return (\n    <div\n      data-testid={`typed-interrupt-${variant}`}\n      className=\"w-full rounded-2xl border border-amber-300 bg-amber-50 px-4 py-3 text-amber-900\"\n    >\n      <div className=\"flex items-start gap-3\">\n        <TriangleAlertIcon className=\"mt-0.5 size-4 shrink-0\" />\n        <div className=\"min-w-0 flex-1\">\n          <p className=\"font-semibold text-sm\">\n            {variant === 'read-only' ? 'Input required' : 'This request could not be displayed'}\n          </p>\n          <p className=\"pt-1 text-amber-800 text-sm leading-snug\">{displayMessage || interrupt.message}</p>\n        </div>\n      </div>\n      <div className=\"flex flex-wrap items-center gap-2 pt-3\">\n        {variant === 'read-only' ? (\n          <p className=\"text-amber-800 text-sm\">{readOnlyNotice}</p>\n        ) : (\n          <Button size=\"sm\" variant=\"outline\" disabled={disabled} onClick={decline}>\n            <XIcon />\n            Cancel request\n          </Button>\n        )}\n      </div>\n    </div>\n  );\n}\n\ninterface TypedInterruptErrorBoundaryProps {\n  /** A change here (a new park) clears a caught error so the next card renders. */\n  resetKey: string | undefined;\n  fallback: ReactNode;\n  children: ReactNode;\n}\n\ninterface TypedInterruptErrorBoundaryState {\n  hasError: boolean;\n  resetKey: string | undefined;\n}\n\n/** A card that throws never takes the chat with it: the fallback stands in until the next park. */\nexport class TypedInterruptErrorBoundary extends Component<\n  TypedInterruptErrorBoundaryProps,\n  TypedInterruptErrorBoundaryState\n> {\n  state: TypedInterruptErrorBoundaryState = { hasError: false, resetKey: this.props.resetKey };\n\n  static getDerivedStateFromError(): Partial<TypedInterruptErrorBoundaryState> {\n    return { hasError: true };\n  }\n\n  static getDerivedStateFromProps(\n    props: TypedInterruptErrorBoundaryProps,\n    state: TypedInterruptErrorBoundaryState,\n  ): Partial<TypedInterruptErrorBoundaryState> | null {\n    return props.resetKey === state.resetKey ? null : { hasError: false, resetKey: props.resetKey };\n  }\n\n  componentDidCatch(error: unknown, info: ErrorInfo): void {\n    console.error('[athena] a typed interrupt card failed to render', error, info.componentStack);\n  }\n\n  render(): ReactNode {\n    return this.state.hasError ? this.props.fallback : this.props.children;\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;AA+BO,SAAS,qBAAqB;AAAA,EACnC;AAAA,EACA;AAAA,EACA;AAAA,EACA,iBAAiB;AAAA,EACjB,WAAW;AAAA,EACX;AAAA,EACA;AACF,GAA8B;AAC5B,QAAM,UAAU,MAAM;AACpB,QAAI,UAAU,SAAS,mBAAmB,MAAM;AAC9C,uCAAS,oBAAoB,EAAE,QAAQ,UAAU,QAAQ,mBAAA,CAAoB;AAC7E;AAAA,IACF;AACA;AAAA,EACF;AACA,SACE;AAAA,IAAC;AAAA,IAAA;AAAA,MACC,eAAa,mBAAmB,OAAO;AAAA,MACvC,WAAU;AAAA,MAEV,UAAA;AAAA,QAAA,qBAAC,OAAA,EAAI,WAAU,0BACb,UAAA;AAAA,UAAA,oBAAC,mBAAA,EAAkB,WAAU,yBAAA,CAAyB;AAAA,UACtD,qBAAC,OAAA,EAAI,WAAU,kBACb,UAAA;AAAA,YAAA,oBAAC,OAAE,WAAU,yBACV,UAAA,YAAY,cAAc,mBAAmB,uCAChD;AAAA,gCACC,KAAA,EAAE,WAAU,4CAA4C,UAAA,kBAAkB,UAAU,QAAA,CAAQ;AAAA,UAAA,EAAA,CAC/F;AAAA,QAAA,GACF;AAAA,QACA,oBAAC,SAAI,WAAU,0CACZ,sBAAY,cACX,oBAAC,OAAE,WAAU,0BAA0B,0BAAe,IAEtD,qBAAC,UAAO,MAAK,MAAK,SAAQ,WAAU,UAAoB,SAAS,SAC/D,UAAA;AAAA,UAAA,oBAAC,OAAA,EAAM;AAAA,UAAE;AAAA,QAAA,EAAA,CAEX,EAAA,CAEJ;AAAA,MAAA;AAAA,IAAA;AAAA,EAAA;AAGN;AAeO,MAAM,oCAAoC,UAG/C;AAAA,EAHK;AAAA;AAIL,iCAA0C,EAAE,UAAU,OAAO,UAAU,KAAK,MAAM,SAAA;AAAA;AAAA,EAElF,OAAO,2BAAsE;AAC3E,WAAO,EAAE,UAAU,KAAA;AAAA,EACrB;AAAA,EAEA,OAAO,yBACL,OACA,OACkD;AAClD,WAAO,MAAM,aAAa,MAAM,WAAW,OAAO,EAAE,UAAU,OAAO,UAAU,MAAM,SAAA;AAAA,EACvF;AAAA,EAEA,kBAAkB,OAAgB,MAAuB;AACvD,YAAQ,MAAM,oDAAoD,OAAO,KAAK,cAAc;AAAA,EAC9F;AAAA,EAEA,SAAoB;AAClB,WAAO,KAAK,MAAM,WAAW,KAAK,MAAM,WAAW,KAAK,MAAM;AAAA,EAChE;AACF;"}

package/dist/chat/typed-interrupts/typed-interrupt-panel.cjs

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const require$$0 = require("react");
+const typedInterruptBody = require("./typed-interrupt-body.cjs");
+const typedInterruptNotice = require("./typed-interrupt-notice.cjs");
+const useStatewireTypedInterrupt = require("./use-statewire-typed-interrupt.cjs");
+const cnfast = require("cnfast");
+const TypedInterruptPanel = ({
+  classNames,
+  readOnly = false,
+  readOnlyNotice,
+  isHandledElsewhere,
+  confirmDecision,
+  onResumeRejected,
+  pendingResumeGraceMs
+}) => {
+  const engine = useStatewireTypedInterrupt.useStatewireTypedInterrupt({ confirmDecision, onResumeRejected, pendingResumeGraceMs });
+  const { interrupt, request, requestId } = engine;
+  const handledRef = require$$0.useRef({
+    requestId: void 0,
+    handled: false
+  });
+  let handledElsewhere = false;
+  if (request) {
+    handledElsewhere = (isHandledElsewhere == null ? void 0 : isHandledElsewhere({ request, hitl: null, actionRequests: [] })) ?? false;
+    handledRef.current = { requestId, handled: handledElsewhere };
+  } else if (requestId !== void 0 && handledRef.current.requestId === requestId) {
+    handledElsewhere = handledRef.current.handled;
+  }
+  if (!interrupt || engine.isHiddenByRunning || handledElsewhere) return null;
+  const notice = (variant) => /* @__PURE__ */ jsxRuntime.jsx(
+    typedInterruptNotice.TypedInterruptNotice,
+    {
+      interrupt,
+      displayMessage: engine.displayMessage,
+      variant,
+      readOnlyNotice,
+      disabled: engine.isLoading || engine.isConversationStreaming,
+      resume: engine.resume,
+      cancel: engine.cancel
+    }
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "section",
+    {
+      "aria-label": "Input required",
+      "data-testid": "typed-interrupt-card",
+      "data-interrupt-source": interrupt.source,
+      className: cnfast.cn("aui-approval-card aui-typed-interrupt-card flex w-full flex-col gap-2", classNames == null ? void 0 : classNames.root),
+      children: [
+        readOnly ? notice("read-only") : /* @__PURE__ */ jsxRuntime.jsx(typedInterruptNotice.TypedInterruptErrorBoundary, { resetKey: requestId, fallback: notice("render-failed"), children: /* @__PURE__ */ jsxRuntime.jsx(
+          typedInterruptBody.TypedInterruptBody,
+          {
+            interrupt,
+            resume: engine.resume,
+            cancel: engine.cancel,
+            engine
+          },
+          requestId
+        ) }),
+        engine.failure && !readOnly ? /* @__PURE__ */ jsxRuntime.jsx(
+          "p",
+          {
+            role: "alert",
+            "data-testid": "typed-interrupt-error",
+            className: "rounded-md border border-destructive/30 bg-destructive/5 px-3 py-2 text-destructive text-sm",
+            children: engine.failure
+          }
+        ) : null
+      ]
+    }
+  );
+};
+exports.TypedInterruptPanel = TypedInterruptPanel;
+//# sourceMappingURL=typed-interrupt-panel.cjs.map

package/dist/chat/typed-interrupts/typed-interrupt-panel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-interrupt-panel.cjs","sources":["../../../src/chat/typed-interrupts/typed-interrupt-panel.tsx"],"sourcesContent":["import { type FC, useRef } from 'react';\nimport { cn } from '../../lib/utils';\nimport type { StatewireTypedInterruptCardProps } from './StatewireTypedInterruptCard';\nimport { TypedInterruptBody } from './typed-interrupt-body';\nimport { TypedInterruptErrorBoundary, TypedInterruptNotice } from './typed-interrupt-notice';\nimport { useStatewireTypedInterrupt } from './use-statewire-typed-interrupt';\n\n/**\n * What `StatewireTypedInterruptCard` loads on the first typed park: the engine\n * (`useStatewireTypedInterrupt`), the card for the park's kind\n * (`typed-interrupt-body.tsx`), the viewer's notice and the render-failure\n * fallback, and the host's reason when it refuses an answer.\n *\n * Mount only inside a statewire aui scope.\n */\nexport const TypedInterruptPanel: FC<StatewireTypedInterruptCardProps> = ({\n  classNames,\n  readOnly = false,\n  readOnlyNotice,\n  isHandledElsewhere,\n  confirmDecision,\n  onResumeRejected,\n  pendingResumeGraceMs,\n}) => {\n  const engine = useStatewireTypedInterrupt({ confirmDecision, onResumeRejected, pendingResumeGraceMs });\n  const { interrupt, request, requestId } = engine;\n\n  // Whether another surface answers this park: asked while it is live, and\n  // kept while its answer is held (the request folds away until the verdict).\n  const handledRef = useRef<{ requestId: string | undefined; handled: boolean }>({\n    requestId: undefined,\n    handled: false,\n  });\n  let handledElsewhere = false;\n  if (request) {\n    handledElsewhere = isHandledElsewhere?.({ request, hitl: null, actionRequests: [] }) ?? false;\n    handledRef.current = { requestId, handled: handledElsewhere };\n  } else if (requestId !== undefined && handledRef.current.requestId === requestId) {\n    handledElsewhere = handledRef.current.handled;\n  }\n\n  if (!interrupt || engine.isHiddenByRunning || handledElsewhere) return null;\n\n  const notice = (variant: 'read-only' | 'render-failed') => (\n    <TypedInterruptNotice\n      interrupt={interrupt}\n      displayMessage={engine.displayMessage}\n      variant={variant}\n      readOnlyNotice={readOnlyNotice}\n      disabled={engine.isLoading || engine.isConversationStreaming}\n      resume={engine.resume}\n      cancel={engine.cancel}\n    />\n  );\n\n  return (\n    <section\n      aria-label=\"Input required\"\n      data-testid=\"typed-interrupt-card\"\n      data-interrupt-source={interrupt.source}\n      // The approval card's class: the waiting-on-you banner scrolls to it.\n      className={cn('aui-approval-card aui-typed-interrupt-card flex w-full flex-col gap-2', classNames?.root)}\n    >\n      {readOnly ? (\n        notice('read-only')\n      ) : (\n        <TypedInterruptErrorBoundary resetKey={requestId} fallback={notice('render-failed')}>\n          {/* One card per park: the next one (two file requests parked together)\n              never inherits what the person did in this one. */}\n          <TypedInterruptBody\n            key={requestId}\n            interrupt={interrupt}\n            resume={engine.resume}\n            cancel={engine.cancel}\n            engine={engine}\n          />\n        </TypedInterruptErrorBoundary>\n      )}\n      {engine.failure && !readOnly ? (\n        <p\n          role=\"alert\"\n          data-testid=\"typed-interrupt-error\"\n          className=\"rounded-md border border-destructive/30 bg-destructive/5 px-3 py-2 text-destructive text-sm\"\n        >\n          {engine.failure}\n        </p>\n      ) : null}\n    </section>\n  );\n};\n"],"names":["useStatewireTypedInterrupt","useRef","jsx","TypedInterruptNotice","jsxs","cn","TypedInterruptErrorBoundary","TypedInterruptBody"],"mappings":";;;;;;;;AAeO,MAAM,sBAA4D,CAAC;AAAA,EACxE;AAAA,EACA,WAAW;AAAA,EACX;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAAM;AACJ,QAAM,SAASA,2BAAAA,2BAA2B,EAAE,iBAAiB,kBAAkB,sBAAsB;AACrG,QAAM,EAAE,WAAW,SAAS,UAAA,IAAc;AAI1C,QAAM,aAAaC,WAAAA,OAA4D;AAAA,IAC7E,WAAW;AAAA,IACX,SAAS;AAAA,EAAA,CACV;AACD,MAAI,mBAAmB;AACvB,MAAI,SAAS;AACX,wBAAmB,yDAAqB,EAAE,SAAS,MAAM,MAAM,gBAAgB,GAAC,OAAQ;AACxF,eAAW,UAAU,EAAE,WAAW,SAAS,iBAAA;AAAA,EAC7C,WAAW,cAAc,UAAa,WAAW,QAAQ,cAAc,WAAW;AAChF,uBAAmB,WAAW,QAAQ;AAAA,EACxC;AAEA,MAAI,CAAC,aAAa,OAAO,qBAAqB,iBAAkB,QAAO;AAEvE,QAAM,SAAS,CAAC,YACdC,2BAAAA;AAAAA,IAACC,qBAAAA;AAAAA,IAAA;AAAA,MACC;AAAA,MACA,gBAAgB,OAAO;AAAA,MACvB;AAAA,MACA;AAAA,MACA,UAAU,OAAO,aAAa,OAAO;AAAA,MACrC,QAAQ,OAAO;AAAA,MACf,QAAQ,OAAO;AAAA,IAAA;AAAA,EAAA;AAInB,SACEC,2BAAAA;AAAAA,IAAC;AAAA,IAAA;AAAA,MACC,cAAW;AAAA,MACX,eAAY;AAAA,MACZ,yBAAuB,UAAU;AAAA,MAEjC,WAAWC,OAAAA,GAAG,yEAAyE,yCAAY,IAAI;AAAA,MAEtG,UAAA;AAAA,QAAA,WACC,OAAO,WAAW,IAElBH,2BAAAA,IAACI,qBAAAA,6BAAA,EAA4B,UAAU,WAAW,UAAU,OAAO,eAAe,GAGhF,UAAAJ,2BAAAA;AAAAA,UAACK,mBAAAA;AAAAA,UAAA;AAAA,YAEC;AAAA,YACA,QAAQ,OAAO;AAAA,YACf,QAAQ,OAAO;AAAA,YACf;AAAA,UAAA;AAAA,UAJK;AAAA,QAAA,GAMT;AAAA,QAED,OAAO,WAAW,CAAC,WAClBL,2BAAAA;AAAAA,UAAC;AAAA,UAAA;AAAA,YACC,MAAK;AAAA,YACL,eAAY;AAAA,YACZ,WAAU;AAAA,YAET,UAAA,OAAO;AAAA,UAAA;AAAA,QAAA,IAER;AAAA,MAAA;AAAA,IAAA;AAAA,EAAA;AAGV;;"}

package/dist/chat/typed-interrupts/typed-interrupt-panel.d.ts

@@ -0,0 +1,11 @@
+import { type FC } from 'react';
+import type { StatewireTypedInterruptCardProps } from './StatewireTypedInterruptCard';
+/**
+ * What `StatewireTypedInterruptCard` loads on the first typed park: the engine
+ * (`useStatewireTypedInterrupt`), the card for the park's kind
+ * (`typed-interrupt-body.tsx`), the viewer's notice and the render-failure
+ * fallback, and the host's reason when it refuses an answer.
+ *
+ * Mount only inside a statewire aui scope.
+ */
+export declare const TypedInterruptPanel: FC<StatewireTypedInterruptCardProps>;

package/dist/chat/typed-interrupts/typed-interrupt-panel.js

@@ -0,0 +1,76 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useRef } from "react";
+import { TypedInterruptBody } from "./typed-interrupt-body.js";
+import { TypedInterruptErrorBoundary, TypedInterruptNotice } from "./typed-interrupt-notice.js";
+import { useStatewireTypedInterrupt } from "./use-statewire-typed-interrupt.js";
+import { cn } from "cnfast";
+const TypedInterruptPanel = ({
+  classNames,
+  readOnly = false,
+  readOnlyNotice,
+  isHandledElsewhere,
+  confirmDecision,
+  onResumeRejected,
+  pendingResumeGraceMs
+}) => {
+  const engine = useStatewireTypedInterrupt({ confirmDecision, onResumeRejected, pendingResumeGraceMs });
+  const { interrupt, request, requestId } = engine;
+  const handledRef = useRef({
+    requestId: void 0,
+    handled: false
+  });
+  let handledElsewhere = false;
+  if (request) {
+    handledElsewhere = (isHandledElsewhere == null ? void 0 : isHandledElsewhere({ request, hitl: null, actionRequests: [] })) ?? false;
+    handledRef.current = { requestId, handled: handledElsewhere };
+  } else if (requestId !== void 0 && handledRef.current.requestId === requestId) {
+    handledElsewhere = handledRef.current.handled;
+  }
+  if (!interrupt || engine.isHiddenByRunning || handledElsewhere) return null;
+  const notice = (variant) => /* @__PURE__ */ jsx(
+    TypedInterruptNotice,
+    {
+      interrupt,
+      displayMessage: engine.displayMessage,
+      variant,
+      readOnlyNotice,
+      disabled: engine.isLoading || engine.isConversationStreaming,
+      resume: engine.resume,
+      cancel: engine.cancel
+    }
+  );
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      "aria-label": "Input required",
+      "data-testid": "typed-interrupt-card",
+      "data-interrupt-source": interrupt.source,
+      className: cn("aui-approval-card aui-typed-interrupt-card flex w-full flex-col gap-2", classNames == null ? void 0 : classNames.root),
+      children: [
+        readOnly ? notice("read-only") : /* @__PURE__ */ jsx(TypedInterruptErrorBoundary, { resetKey: requestId, fallback: notice("render-failed"), children: /* @__PURE__ */ jsx(
+          TypedInterruptBody,
+          {
+            interrupt,
+            resume: engine.resume,
+            cancel: engine.cancel,
+            engine
+          },
+          requestId
+        ) }),
+        engine.failure && !readOnly ? /* @__PURE__ */ jsx(
+          "p",
+          {
+            role: "alert",
+            "data-testid": "typed-interrupt-error",
+            className: "rounded-md border border-destructive/30 bg-destructive/5 px-3 py-2 text-destructive text-sm",
+            children: engine.failure
+          }
+        ) : null
+      ]
+    }
+  );
+};
+export {
+  TypedInterruptPanel
+};
+//# sourceMappingURL=typed-interrupt-panel.js.map

package/dist/chat/typed-interrupts/typed-interrupt-panel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-interrupt-panel.js","sources":["../../../src/chat/typed-interrupts/typed-interrupt-panel.tsx"],"sourcesContent":["import { type FC, useRef } from 'react';\nimport { cn } from '../../lib/utils';\nimport type { StatewireTypedInterruptCardProps } from './StatewireTypedInterruptCard';\nimport { TypedInterruptBody } from './typed-interrupt-body';\nimport { TypedInterruptErrorBoundary, TypedInterruptNotice } from './typed-interrupt-notice';\nimport { useStatewireTypedInterrupt } from './use-statewire-typed-interrupt';\n\n/**\n * What `StatewireTypedInterruptCard` loads on the first typed park: the engine\n * (`useStatewireTypedInterrupt`), the card for the park's kind\n * (`typed-interrupt-body.tsx`), the viewer's notice and the render-failure\n * fallback, and the host's reason when it refuses an answer.\n *\n * Mount only inside a statewire aui scope.\n */\nexport const TypedInterruptPanel: FC<StatewireTypedInterruptCardProps> = ({\n  classNames,\n  readOnly = false,\n  readOnlyNotice,\n  isHandledElsewhere,\n  confirmDecision,\n  onResumeRejected,\n  pendingResumeGraceMs,\n}) => {\n  const engine = useStatewireTypedInterrupt({ confirmDecision, onResumeRejected, pendingResumeGraceMs });\n  const { interrupt, request, requestId } = engine;\n\n  // Whether another surface answers this park: asked while it is live, and\n  // kept while its answer is held (the request folds away until the verdict).\n  const handledRef = useRef<{ requestId: string | undefined; handled: boolean }>({\n    requestId: undefined,\n    handled: false,\n  });\n  let handledElsewhere = false;\n  if (request) {\n    handledElsewhere = isHandledElsewhere?.({ request, hitl: null, actionRequests: [] }) ?? false;\n    handledRef.current = { requestId, handled: handledElsewhere };\n  } else if (requestId !== undefined && handledRef.current.requestId === requestId) {\n    handledElsewhere = handledRef.current.handled;\n  }\n\n  if (!interrupt || engine.isHiddenByRunning || handledElsewhere) return null;\n\n  const notice = (variant: 'read-only' | 'render-failed') => (\n    <TypedInterruptNotice\n      interrupt={interrupt}\n      displayMessage={engine.displayMessage}\n      variant={variant}\n      readOnlyNotice={readOnlyNotice}\n      disabled={engine.isLoading || engine.isConversationStreaming}\n      resume={engine.resume}\n      cancel={engine.cancel}\n    />\n  );\n\n  return (\n    <section\n      aria-label=\"Input required\"\n      data-testid=\"typed-interrupt-card\"\n      data-interrupt-source={interrupt.source}\n      // The approval card's class: the waiting-on-you banner scrolls to it.\n      className={cn('aui-approval-card aui-typed-interrupt-card flex w-full flex-col gap-2', classNames?.root)}\n    >\n      {readOnly ? (\n        notice('read-only')\n      ) : (\n        <TypedInterruptErrorBoundary resetKey={requestId} fallback={notice('render-failed')}>\n          {/* One card per park: the next one (two file requests parked together)\n              never inherits what the person did in this one. */}\n          <TypedInterruptBody\n            key={requestId}\n            interrupt={interrupt}\n            resume={engine.resume}\n            cancel={engine.cancel}\n            engine={engine}\n          />\n        </TypedInterruptErrorBoundary>\n      )}\n      {engine.failure && !readOnly ? (\n        <p\n          role=\"alert\"\n          data-testid=\"typed-interrupt-error\"\n          className=\"rounded-md border border-destructive/30 bg-destructive/5 px-3 py-2 text-destructive text-sm\"\n        >\n          {engine.failure}\n        </p>\n      ) : null}\n    </section>\n  );\n};\n"],"names":[],"mappings":";;;;;;AAeO,MAAM,sBAA4D,CAAC;AAAA,EACxE;AAAA,EACA,WAAW;AAAA,EACX;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAAM;AACJ,QAAM,SAAS,2BAA2B,EAAE,iBAAiB,kBAAkB,sBAAsB;AACrG,QAAM,EAAE,WAAW,SAAS,UAAA,IAAc;AAI1C,QAAM,aAAa,OAA4D;AAAA,IAC7E,WAAW;AAAA,IACX,SAAS;AAAA,EAAA,CACV;AACD,MAAI,mBAAmB;AACvB,MAAI,SAAS;AACX,wBAAmB,yDAAqB,EAAE,SAAS,MAAM,MAAM,gBAAgB,GAAC,OAAQ;AACxF,eAAW,UAAU,EAAE,WAAW,SAAS,iBAAA;AAAA,EAC7C,WAAW,cAAc,UAAa,WAAW,QAAQ,cAAc,WAAW;AAChF,uBAAmB,WAAW,QAAQ;AAAA,EACxC;AAEA,MAAI,CAAC,aAAa,OAAO,qBAAqB,iBAAkB,QAAO;AAEvE,QAAM,SAAS,CAAC,YACd;AAAA,IAAC;AAAA,IAAA;AAAA,MACC;AAAA,MACA,gBAAgB,OAAO;AAAA,MACvB;AAAA,MACA;AAAA,MACA,UAAU,OAAO,aAAa,OAAO;AAAA,MACrC,QAAQ,OAAO;AAAA,MACf,QAAQ,OAAO;AAAA,IAAA;AAAA,EAAA;AAInB,SACE;AAAA,IAAC;AAAA,IAAA;AAAA,MACC,cAAW;AAAA,MACX,eAAY;AAAA,MACZ,yBAAuB,UAAU;AAAA,MAEjC,WAAW,GAAG,yEAAyE,yCAAY,IAAI;AAAA,MAEtG,UAAA;AAAA,QAAA,WACC,OAAO,WAAW,IAElB,oBAAC,6BAAA,EAA4B,UAAU,WAAW,UAAU,OAAO,eAAe,GAGhF,UAAA;AAAA,UAAC;AAAA,UAAA;AAAA,YAEC;AAAA,YACA,QAAQ,OAAO;AAAA,YACf,QAAQ,OAAO;AAAA,YACf;AAAA,UAAA;AAAA,UAJK;AAAA,QAAA,GAMT;AAAA,QAED,OAAO,WAAW,CAAC,WAClB;AAAA,UAAC;AAAA,UAAA;AAAA,YACC,MAAK;AAAA,YACL,eAAY;AAAA,YACZ,WAAU;AAAA,YAET,UAAA,OAAO;AAAA,UAAA;AAAA,QAAA,IAER;AAAA,MAAA;AAAA,IAAA;AAAA,EAAA;AAGV;"}

package/dist/chat/typed-interrupts/typed-interrupt-types.d.ts

@@ -0,0 +1,46 @@
+import type { TypedInterruptPayload } from '../../agent-runtime/src/typed-interrupts';
+/**
+ * The engine state a typed card renders from (`useStatewireTypedInterrupt`'s
+ * read side). The same fields as Olympus's `TypedInterruptEngineSlice`, so a
+ * host with an engine of its own can hand these cards its slice.
+ */
+export interface TypedInterruptEngineSlice {
+    /** The pending request's id: unique per park, the key for anything per park. */
+    requestId: string | undefined;
+    /** An answer is in flight, or its passkey check is open. */
+    isLoading: boolean;
+    /** The thread is running: the agent moved on, or is processing the answer. */
+    isConversationStreaming: boolean;
+    /** The backend's timer answers this park at a deadline (display only: the timer is the backend's). */
+    hasTimeout: boolean;
+    timeoutSeconds: number | null;
+    timeoutRemaining: number | null;
+    isTimedOut: boolean;
+    isTimeoutCancelled: boolean;
+    /**
+     * Whether `cancelTimeout` can stop the timer (agora keeps it per
+     * conversation, which the host must name). `false` keeps the countdown and
+     * hides Stop timer; absent reads as `true`.
+     */
+    canCancelTimeout?: boolean;
+    /** Stop the timer for good (kept server-side), giving the person all the time they need. */
+    cancelTimeout: () => void | Promise<void>;
+    /** The park's message, without its timeout suffix once the timer is stopped. */
+    displayMessage: string;
+    /** The conversation the park belongs to, when the host names it (drafts and the timer need it). */
+    currentThreadId: string | null;
+}
+/** The value a card answers with: its kind's resume shape (the engine stamps the park on it). */
+export type TypedInterruptAnswer = Readonly<Record<string, unknown>>;
+/**
+ * What every typed card receives: the parked payload, the two ways to answer
+ * it, and the engine slice it renders from. Cards are pure renderers over
+ * these; the engine owns the request, the lock and the passkey check.
+ */
+export interface TypedInterruptCardProps {
+    interrupt: TypedInterruptPayload;
+    resume: (value: TypedInterruptAnswer) => void;
+    /** `{ action: 'cancel' }`: the raiser ends the interrupted operation. */
+    cancel: () => void;
+    engine: TypedInterruptEngineSlice;
+}

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const reactQuery = require("@tanstack/react-query");
+const require$$0 = require("react");
+const useAthenaRestQuery = require("../../lib/use-athena-rest-query.cjs");
+const typedInterruptGraphql = require("./typed-interrupt-graphql.cjs");
+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 = useAthenaRestQuery.useAthenaQueryClient();
+  const { data, isFetching } = reactQuery.useQuery(
+    {
+      queryKey: draftQueryKey(conversation, interruptId),
+      queryFn: ({ signal }) => conversation ? typedInterruptGraphql.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 = useAthenaRestQuery.useAthenaQueryClient();
+  const [status, setStatus] = require$$0.useState("idle");
+  const { mutate } = reactQuery.useMutation(
+    {
+      mutationKey: ["athena-sdk", "interrupt-draft-save"],
+      mutationFn: (variables) => typedInterruptGraphql.saveInterruptDraft(variables.conversation, variables.interruptId, variables.answers),
+      retry: false
+    },
+    queryClient
+  );
+  const latest = require$$0.useRef({ conversation, interruptId, payload });
+  latest.current = { conversation, interruptId, payload };
+  const timerRef = require$$0.useRef(null);
+  const save = require$$0.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 = require$$0.useCallback(() => {
+    if (timerRef.current === null) return;
+    clearTimeout(timerRef.current);
+    save();
+  }, [save]);
+  require$$0.useEffect(() => {
+    setStatus("idle");
+    return () => {
+      if (timerRef.current !== null) clearTimeout(timerRef.current);
+      timerRef.current = null;
+    };
+  }, [interruptId]);
+  require$$0.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]);
+  require$$0.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 };
+}
+exports.useInterruptDraft = useInterruptDraft;
+exports.useInterruptDraftSave = useInterruptDraftSave;
+//# sourceMappingURL=use-interrupt-draft.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-interrupt-draft.cjs","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":["useAthenaQueryClient","useQuery","readInterruptDraft","useState","useMutation","saveInterruptDraft","useRef","useCallback","useEffect"],"mappings":"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"}

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

@@ -0,0 +1,29 @@
+import { type TypedInterruptConversation } from './typed-interrupt-graphql';
+export type DraftSaveStatus = 'idle' | 'saving' | 'saved' | 'error';
+/**
+ * The draft agora holds for `interruptId` (`null` without one), read again
+ * each time a card mounts: another app may have saved answers since. Loading
+ * while that read is in flight, so a card restores the latest draft, not a
+ * cached one; a read the network holds (offline) does not keep it waiting.
+ */
+export declare function useInterruptDraft({ conversation, interruptId, }: {
+    conversation: TypedInterruptConversation | null;
+    interruptId: string;
+}): {
+    draft: unknown;
+    isLoading: boolean;
+};
+/**
+ * Saves `payload` under `interruptId` two seconds after it last changed while
+ * `enabled`; `flush` saves a pending change at once. A pending save never
+ * lands under the next park's key, and none outlives the card.
+ */
+export declare function useInterruptDraftSave({ conversation, interruptId, payload, enabled, }: {
+    conversation: TypedInterruptConversation | null;
+    interruptId: string;
+    payload: unknown;
+    enabled: boolean;
+}): {
+    flush: () => void;
+    status: DraftSaveStatus;
+};