@athenaintel/react 0.41.3 → 0.42.1

package/dist/agent-runtime/src/withdrawn-turns.d.ts

@@ -0,0 +1,97 @@
+/**
+ * User turns this client took back before the run answered them.
+ *
+ * A user stop before any assistant output retracts the turn server-side — the
+ * host drops it from the wire and hands its text back through the stop verdict
+ * (see `run/stop` → `retracted`). That verdict is a network round trip away;
+ * the client that asked for it already knows the outcome, so it withdraws the
+ * turn locally the moment it stops: the converter omits the message (and the
+ * "thinking" placeholder it would otherwise earn) until the wire agrees, and
+ * the host restores the text to its composer at once. The seam is
+ * subscribable so the thread re-converts when a withdrawal opens or closes,
+ * the same way a fetched tool output re-runs the converter.
+ */
+export interface DeepAgentWithdrawnTurns {
+    /** Whether the transcript should omit the user message `messageId`. */
+    isWithdrawn(messageId: string): boolean;
+    subscribe(listener: () => void): () => void;
+}
+/** The user turn a stop right now would take back, read off a raw statewire state. */
+export interface DeepAgentWithdrawableTurn {
+    messageId: string;
+    text: string;
+    /** The composer markdown the turn was sent from (see `composer-markdown.ts`), when it carries one. */
+    composerMarkdown: string | null;
+    runId: string;
+    epoch: number | undefined;
+    /** The turn is the transcript's only visible message: taking it back empties the chat. */
+    first: boolean;
+}
+/**
+ * The turn an immediate user stop retracts, or `null` when the stop would be
+ * an ordinary one. Mirrors the host's own predicate from the client's side:
+ * the run is live and the transcript's last visible message is the user's —
+ * nothing has answered it yet. A run whose latest visible message is the
+ * assistant's (any output, a notice) keeps its turn; so does a run the wire
+ * does not show as running.
+ */
+export declare function readDeepAgentWithdrawableTurn(state: unknown): DeepAgentWithdrawableTurn | null;
+/** A send the transport failed, as the thread retains it in its failed lane. */
+export interface DeepAgentFailedSend {
+    /** The failed message's id — the lane keeps entries by identity. */
+    id: string;
+    /** The message's text parts joined the way the library hands them back to the composer. */
+    text: string;
+}
+/**
+ * The sends the thread retains in its failed lane (`runs.failed`, read
+ * structurally off the thread extras). A withdrawn turn never lands there —
+ * its send was accepted — so the lane tells a failed send's text apart from a
+ * stop verdict's echo of the same words. Absent extras or lane read as empty.
+ */
+export declare function readDeepAgentFailedSends(extras: unknown): DeepAgentFailedSend[];
+/**
+ * Whether `text`, just handed to the composer, is a failed send's rather than
+ * a stop verdict's echo: some failed-lane entry carries that text and is new
+ * since `seen` last recorded the lane. Every entry now in the lane is recorded
+ * as seen — a failure the composer has already been handed back (or that
+ * predates a withdrawal, see the caller) cannot be the one returning this
+ * text, however many times the same words come back later.
+ */
+export declare function claimDeepAgentFailedSendText({ extras, text, seen, }: {
+    extras: unknown;
+    text: string;
+    seen: Set<string>;
+}): boolean;
+/**
+ * The wire's answer to a withdrawal: `retracted` once the turn is gone from
+ * the wire altogether — dropped from the transcript and held in no lane —
+ * with the run at rest (or the host's retraction named); `kept` once the wire
+ * shows it stayed — the run answered it, or rested with it durably in place
+ * and no retraction named, so the stop was an ordinary one — and `pending`
+ * while neither has happened (or before any snapshot).
+ *
+ * The stop lifecycle passes through snapshots that look like neither: the
+ * run's status leaves `running` (`stopping`, or the mount's `ready` before the
+ * host admits the dispatch) while the turn is still materialized from the
+ * `dispatching` lane, and the host hands a retracted turn back through the
+ * queue lane for the stopping client to pop. A turn the host still holds in a
+ * lane is not durably kept, and a turn missing from a run that is still live
+ * is not durably gone — both stay `pending`. A live run that is not the one
+ * the turn was withdrawn from (`withdrawnFrom`: a newer send's epoch) says
+ * nothing about it, so a turn missing under it is gone. `retractionNamed` is
+ * the host's own verdict for this run (`retractedRun`), which lands ahead of
+ * the drop.
+ */
+export type DeepAgentWithdrawnTurnVerdict = 'pending' | 'retracted' | 'kept';
+/** The run a turn was withdrawn from, as the withdrawal recorded it. */
+export interface DeepAgentWithdrawnFromRun {
+    runId: string;
+    epoch: number | undefined;
+}
+export declare function readDeepAgentWithdrawnTurnVerdict({ state, messageId, retractionNamed, withdrawnFrom, }: {
+    state: unknown;
+    messageId: string;
+    retractionNamed: boolean;
+    withdrawnFrom?: DeepAgentWithdrawnFromRun;
+}): DeepAgentWithdrawnTurnVerdict;

package/dist/chat/AthenaChat.cjs

@@ -14,9 +14,12 @@ const wakeMarker = require("../chat-ui/messages/wake-marker.cjs");
 const toolFallback = require("../tools/tool-fallback.cjs");
 const appendDocumentToolUi = require("../tools/append-document-tool-ui.cjs");
 const readAssetToolUi = require("../tools/read-asset-tool-ui.cjs");
+const inlineTools = require("../tools/inline-tools.cjs");
+const subagentTaskToolUi = require("../tools/subagent-task-tool-ui.cjs");
 const toolUis = require("../tools/tool-uis.cjs");
 const SuperGroupingCard = require("./super-grouping/SuperGroupingCard.cjs");
 const SuperGroupingTranscript = require("./super-grouping/SuperGroupingTranscript.cjs");
+const useStatewireApprovalRequest = require("./use-statewire-approval-request.cjs");
 const NestedPtcMessages = require("../tools/NestedPtcMessages.cjs");
 const tooltipIconButton = require("./tooltip-icon-button.cjs");
 const button = require("../ui/button.cjs");
@@ -44,6 +47,7 @@ const athenaChatWelcome = require("./athena-chat-welcome.cjs");
 const athenaComposerControls = require("./athena-composer-controls.cjs");
 const composerKeyboardHint = require("./composer-keyboard-hint.cjs");
 const usePrefersReducedMotion = require("../lib/use-prefers-reduced-motion.cjs");
+const statewireSessionLane = require("../runtime/statewire-session-lane.cjs");
 const AthenaAuthContext = require("../auth/AthenaAuthContext.cjs");
 const react = require("@assistant-ui/react");
 const lucideReact = require("lucide-react");
@@ -66,9 +70,13 @@ const index = require("../toolkits/index.cjs");
 const runActivity = require("./run-activity.cjs");
 const messageTime = require("./message-time.cjs");
 const threadScrollToBottom = require("./thread-scroll-to-bottom.cjs");
+const toolNames = require("../agent-runtime/src/tool-names.cjs");
+const subagents = require("../agent-runtime/src/subagents.cjs");
 const githubWakeEvent = require("../agent-runtime/src/github-wake-event.cjs");
 const subscriptionWakeEvent = require("../agent-runtime/src/subscription-wake-event.cjs");
 const threadStatus = require("../agent-runtime/src/thread-status.cjs");
+const useDeepAgentChatOutbox = require("../agent-runtime/src/use-deep-agent-chat-outbox.cjs");
+const chatOutbox = require("../agent-runtime/src/chat-outbox.cjs");
 const cnfast = require("cnfast");
 const DEFAULT_COMPOSER_PLACEHOLDER = "Type @ to tag an asset";
 function QuotePostMessageBridge() {
@@ -251,7 +259,7 @@ const AthenaChat = ({
     }),
     [AssistantMessageComponent, UserMessageComponent]
   );
-  return /* @__PURE__ */ jsxRuntime.jsx(AthenaChatDefaultComponentsContext.Provider, { value: defaultComponentsContextValue, children: /* @__PURE__ */ jsxRuntime.jsx(AthenaChatErrorBoundary.AthenaChatErrorBoundary, { children: /* @__PURE__ */ jsxRuntime.jsx(toolFallback.ToolFallbackAppearanceProvider, { appearance: "thread", children: /* @__PURE__ */ jsxRuntime.jsx(apiClient.MentionAuthCtx.Provider, { value: mentionAuth, children: /* @__PURE__ */ jsxRuntime.jsx(
+  return /* @__PURE__ */ jsxRuntime.jsx(AthenaChatDefaultComponentsContext.Provider, { value: defaultComponentsContextValue, children: /* @__PURE__ */ jsxRuntime.jsx(AthenaChatErrorBoundary.AthenaChatErrorBoundary, { children: /* @__PURE__ */ jsxRuntime.jsx(useStatewireApprovalRequest.StatewireApprovalWaitProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(toolFallback.ToolFallbackAppearanceProvider, { appearance: "thread", children: /* @__PURE__ */ jsxRuntime.jsx(apiClient.MentionAuthCtx.Provider, { value: mentionAuth, children: /* @__PURE__ */ jsxRuntime.jsx(
     chatThreadShell.ChatThreadShell,
     {
       overlay: /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
@@ -299,7 +307,7 @@ const AthenaChat = ({
         ] }) })
       ] })
     }
-  ) }) }) }, statewireThreadId ?? void 0) });
+  ) }) }) }) }, statewireThreadId ?? void 0) });
 };
 const THREAD_VIEWPORT_ATTR = "data-aui-thread-viewport";
 const useScrollToTop = () => {
@@ -355,11 +363,22 @@ const AthenaChatComposer = ({ tools, slots, dictation, welcomeSuggestionCount })
   const aui = react.useAui();
   const threadId = threadIdContext.useAthenaStatewireThreadId();
   const { appUrl } = AthenaContext.useAthenaConfig();
-  const { attachments, clearAttachments, isUploading } = AttachmentContext.useAttachments();
+  const { attachments, clearAttachments, isUploading, notice: attachNotice, setNotice: setAttachNotice } = AttachmentContext.useAttachments();
   const { quote, clearQuote } = QuoteContext.useQuote();
   const { attachFiles } = useAttachFiles.useAttachFiles();
+  const sessionLane = statewireSessionLane.useStatewireSessionLane();
   const composerRef = react$1.useRef(null);
   const [hasText, setHasText] = react$1.useState(false);
+  const [composerNotice, setComposerNotice] = react$1.useState(null);
+  const onDraftStateChange = react$1.useCallback(
+    (next) => {
+      setHasText(next);
+      setComposerNotice(null);
+      setAttachNotice(null);
+    },
+    [setAttachNotice]
+  );
+  const notice = composerNotice ?? attachNotice;
   const isRunning = react.useAuiState((state) => {
     var _a;
     return ((_a = state.optional.thread) == null ? void 0 : _a.isRunning) ?? false;
@@ -454,6 +473,31 @@ const AthenaChatComposer = ({ tools, slots, dictation, welcomeSuggestionCount })
     (text, draftMarkdown) => attachmentsRef.current.length > 0 || quoteRef.current !== null ? sendComposed({ text, draftMarkdown }) : false,
     [sendComposed]
   );
+  const hasPendingExtras = react$1.useCallback(
+    () => attachmentsRef.current.length > 0 || quoteRef.current !== null,
+    []
+  );
+  const holdPendingExtras = react$1.useCallback(
+    ({
+      outbox,
+      send,
+      attachments: attachments2
+    }) => {
+      const held = buildComposedMessage.holdComposedSend({
+        outbox,
+        attachments: attachmentsRef.current,
+        carried: attachments2,
+        quote: quoteRef.current,
+        send,
+        appUrl
+      });
+      if (!held) return false;
+      clearAttachments();
+      clearQuote();
+      return true;
+    },
+    [appUrl, clearAttachments, clearQuote]
+  );
   const fileIntake = react$1.useMemo(
     () => ({
       onPaste: (files) => {
@@ -470,6 +514,7 @@ const AthenaChatComposer = ({ tools, slots, dictation, welcomeSuggestionCount })
     const { text: spoken, error } = await dictationCtl.stop();
     appendSpokenText(spoken);
     if (error) return;
+    if (sessionLane == null ? void 0 : sessionLane.isPending()) await sessionLane.whenKnown();
     const send = ((_b = (_a = composerRef.current) == null ? void 0 : _a.captureSend) == null ? void 0 : _b.call(_a)) ?? {
       text: aui.composer.getState().text ?? "",
       draftMarkdown: aui.composer.getState().text ?? ""
@@ -497,7 +542,7 @@ const AthenaChatComposer = ({ tools, slots, dictation, welcomeSuggestionCount })
     composerMessage.prepareComposerSend({ threadId, ...send });
     aui.composer.setText(send.text);
     aui.composer.send({ steer: false });
-  }, [appendSpokenText, aui, dictationCtl, isRunning, sendComposed, slots, threadId]);
+  }, [appendSpokenText, aui, dictationCtl, isRunning, sendComposed, sessionLane, slots, threadId]);
   return /* @__PURE__ */ jsxRuntime.jsx(ComposerDropZone.ComposerDropZone, { onDragActiveChange: setDragActive, children: /* @__PURE__ */ jsxRuntime.jsx(
     "div",
     {
@@ -524,13 +569,17 @@ const AthenaChatComposer = ({ tools, slots, dictation, welcomeSuggestionCount })
                 placeholder: (runLive ? slots == null ? void 0 : slots.runningPlaceholder : void 0) ?? (slots == null ? void 0 : slots.placeholder) ?? DEFAULT_COMPOSER_PLACEHOLDER,
                 tools,
                 rootCategories,
-                onDraftStateChange: setHasText,
+                onDraftStateChange,
                 waitForHostUploads,
                 interceptSubmit,
+                hasPendingExtras,
+                holdPendingExtras,
+                onAttachmentError: setComposerNotice,
                 fileIntake,
                 onSubmitted: keyboardHint.onSubmitted
               }
             ) }),
+            notice && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "aui-composer-notice px-1.5 pb-1 text-destructive text-xs", role: "alert", children: notice }),
             recording && /* @__PURE__ */ jsxRuntime.jsx(
               DictationStrip.DictationStrip,
               {
@@ -842,6 +891,7 @@ const AthenaReasoningPart = ({
   );
 };
 const noToolGrouping = () => null;
+const isInlineToolOrSubagent = (toolName) => toolName === toolNames.TASK_TOOL_NAME || inlineTools.isSdkInlineTool(toolName);
 const AthenaAssistantMessage = ({
   toolUIs,
   AvatarComponent,
@@ -859,6 +909,8 @@ const AthenaAssistantMessage = ({
     }
     return wrappedToolUIs;
   }, [toolUIs]);
+  const isInlineTool = toolUIs[toolNames.TASK_TOOL_NAME] === subagentTaskToolUi.SubagentTaskToolUI ? isInlineToolOrSubagent : inlineTools.isSdkInlineTool;
+  const waitingToolCallIds = subagents.useTurnToolCallsAwaitingApproval(useStatewireApprovalRequest.useApprovalWaitInScope().toolCallIds);
   const nestedPtcComponents = react$1.useMemo(
     () => ({
       Text: TextComponent,
@@ -896,6 +948,8 @@ const AthenaAssistantMessage = ({
                     toolUIs: toolUIsWithNestedMessages,
                     TextComponent,
                     ReasoningComponent: effectiveReasoningComponent,
+                    isInlineTool,
+                    waitingToolCallIds,
                     renderRunningMeta: renderGroupedRunningMeta
                   }
                 ),
@@ -953,7 +1007,20 @@ const EditMessageButton = () => {
   const allowEdit = react.useAuiState((s) => s.thread.capabilities.edit);
   const isRunning = useAthenaRunLive.useAthenaRunLive();
   const readOnly = messageActionsConfig.useMessageActionsReadOnly();
+  const reachable = useDeepAgentChatOutbox.useChatOutboxReachable(useDeepAgentChatOutbox.useDeepAgentChatOutboxContext());
   if (!allowEdit || isRunning || readOnly) return null;
+  if (!reachable) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      tooltipIconButton.TooltipIconButton,
+      {
+        tooltip: chatOutbox.CHAT_EDIT_UNREACHABLE_LABEL,
+        "aria-disabled": true,
+        "data-testid": "chat-message-edit-unreachable",
+        className: "cursor-not-allowed opacity-50",
+        children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.PencilIcon, {})
+      }
+    );
+  }
   return /* @__PURE__ */ jsxRuntime.jsx(react.ActionBarPrimitive.Edit, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(tooltipIconButton.TooltipIconButton, { tooltip: "Edit", children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.PencilIcon, {}) }) });
 };
 const AthenaUserActionBar = () => {