@truefoundry/assistant-ui-runtime 0.1.6 → 0.1.7

package/dist/index.js

@@ -10,7 +10,7 @@ import {
   isTfyMcpToolInfo,
   isTfySystemToolInfo,
   isTfyToolInfo
-} from "./chunk-Q2SHKMLM.js";
+} from "./chunk-SQDOTGP2.js";
 
 // src/useTrueFoundryAgentRuntime.ts
 import {
@@ -2386,7 +2386,7 @@ function repositoryItemsFromMessages(messages) {
   return items;
 }
 
-// src/private/draftSessionBridge.ts
+// src/draft/draftSessionBridge.ts
 var DRAFT_SESSION_LAST_UPDATED_AT_HEADER = "x-tfy-session-last-updated-at";
 function createDraftSessionBridge(server) {
   return {
@@ -2409,7 +2409,7 @@ function createDraftSessionBridge(server) {
   };
 }
 
-// src/private/agentSpec.ts
+// src/draft/agentSpec.ts
 function mergeAgentSpec(base, update) {
   const { model: modelUpdate, ...rest } = update;
   const next = {
@@ -2437,7 +2437,7 @@ function sessionListStartTimestamp() {
   return start.toISOString();
 }
 
-// src/private/truefoundryDraftThreadListAdapter.ts
+// src/draft/truefoundryDraftThreadListAdapter.ts
 var THREAD_LIST_PAGE_SIZE = 20;
 function createTrueFoundryDraftThreadListAdapter(options) {
   const { server, defaultAgentSpec, getAgentSpec } = options;
@@ -2502,6 +2502,7 @@ var trueFoundryExtras = createRuntimeExtras(
 var EMPTY_DRAFT_EXTRAS = {
   agentSpec: null,
   draftSessionId: void 0,
+  isSpecLoading: false,
   isSpecSyncing: false,
   specError: null,
   updateAgentSpec: () => {
@@ -2597,7 +2598,7 @@ function resolveTrueFoundryAgentRuntimeOptions(options) {
   };
 }
 
-// src/private/useDraftAgentSpec.ts
+// src/draft/useDraftAgentSpec.ts
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 var SPEC_SYNC_DEBOUNCE_MS = 400;
 function useDraftAgentSpec({
@@ -2609,6 +2610,7 @@ function useDraftAgentSpec({
 }) {
   const enabled = draftBridge != null;
   const [agentSpec, setAgentSpec] = useState(defaultAgentSpec);
+  const [isSpecLoading, setIsSpecLoading] = useState(false);
   const [isSpecSyncing, setIsSpecSyncing] = useState(false);
   const [specError, setSpecError] = useState(null);
   const agentSpecRef = useRef(agentSpec);
@@ -2649,12 +2651,14 @@ function useDraftAgentSpec({
       setAgentSpec(defaultAgentSpec);
       localDirtyRef.current = false;
       setSpecError(null);
+      setIsSpecLoading(false);
       return;
     }
     if (loadedDraftIdRef.current === draftSessionId) {
       return;
     }
     let cancelled = false;
+    setIsSpecLoading(true);
     void (async () => {
       try {
         const loaded = await draftBridge.getDraftAgentSpec(draftSessionId);
@@ -2666,19 +2670,23 @@ function useDraftAgentSpec({
           scheduleSpecSyncRef.current?.(draftSessionId, agentSpecRef.current);
           localDirtyRef.current = false;
           setSpecError(null);
+          setIsSpecLoading(false);
           return;
         }
         setAgentSpec(loaded);
         setSpecError(null);
+        setIsSpecLoading(false);
       } catch (error) {
         if (!cancelled) {
           onError?.(error);
           setSpecError(error);
+          setIsSpecLoading(false);
         }
       }
     })();
     return () => {
       cancelled = true;
+      setIsSpecLoading(false);
     };
   }, [defaultAgentSpec, draftBridge, draftSessionId, enabled, onError]);
   const flushSpecSync = useCallback(
@@ -2781,6 +2789,7 @@ function useDraftAgentSpec({
     () => ({
       agentSpec: enabled ? agentSpec : null,
       draftSessionId: enabled ? draftSessionId : void 0,
+      isSpecLoading: enabled ? isSpecLoading : false,
       isSpecSyncing: enabled ? isSpecSyncing : false,
       specError: enabled ? specError : null,
       updateAgentSpec,
@@ -2790,6 +2799,7 @@ function useDraftAgentSpec({
       agentSpec,
       draftSessionId,
       enabled,
+      isSpecLoading,
       isSpecSyncing,
       specError,
       takeTurnHeaderTimestamp,
@@ -3058,6 +3068,7 @@ function useTrueFoundryAgentMessages({
   server,
   sessionId,
   isMain,
+  isInitialSession,
   listEventsConcurrency,
   onError,
   initializeSession,
@@ -3066,7 +3077,9 @@ function useTrueFoundryAgentMessages({
 }) {
   const [snapshot, setSnapshot] = useState2(createEmptySessionSnapshot);
   const [isRunning, setIsRunning] = useState2(false);
-  const [isLoading, setIsLoading] = useState2(false);
+  const [isLoading, setIsLoading] = useState2(
+    sessionId != null && (isMain !== false || isInitialSession === true)
+  );
   const [isLoadingOlderHistory, setIsLoadingOlderHistory] = useState2(false);
   const [loadRetryTrigger, setLoadRetryTrigger] = useState2(0);
   const snapshotRef = useRef2(snapshot);
@@ -3087,6 +3100,8 @@ function useTrueFoundryAgentMessages({
   const loadGenerationRef = useRef2(0);
   const streamGenerationRef = useRef2(0);
   const lazilyCreatedSessionIdRef = useRef2(void 0);
+  const initialLoadStartedForRef = useRef2(void 0);
+  const skipInitialPromotionLoadForRef = useRef2(void 0);
   const projectOptions = useMemo2(
     () => ({
       getCreatedAt: (messageId, fallback) => {
@@ -3197,12 +3212,24 @@ function useTrueFoundryAgentMessages({
     [onError]
   );
   const load = useCallback2(async () => {
+    void loadRetryTrigger;
     if (sessionId == null) {
       createdAtByMessageIdRef.current = /* @__PURE__ */ new Map();
       setSnapshot(createEmptySessionSnapshot());
       return;
     }
-    if (isMain === false) return;
+    const isEarlyInitialLoad = isMain === false && isInitialSession === true && initialLoadStartedForRef.current !== sessionId;
+    if (isMain === false) {
+      if (!isEarlyInitialLoad) return;
+      initialLoadStartedForRef.current = sessionId;
+      skipInitialPromotionLoadForRef.current = sessionId;
+    } else if (isMain === true && skipInitialPromotionLoadForRef.current === sessionId) {
+      skipInitialPromotionLoadForRef.current = void 0;
+      return;
+    }
+    if (isInitialSession === true) {
+      initialLoadStartedForRef.current = sessionId;
+    }
     if (lazilyCreatedSessionIdRef.current != null && sessionId !== lazilyCreatedSessionIdRef.current) {
       lazilyCreatedSessionIdRef.current = void 0;
     }
@@ -3211,6 +3238,7 @@ function useTrueFoundryAgentMessages({
     }
     const generation = ++loadGenerationRef.current;
     ++streamGenerationRef.current;
+    setIsRunning(false);
     abortControllerRef.current?.abort();
     loadOlderInflightRef.current = null;
     createdAtByMessageIdRef.current = /* @__PURE__ */ new Map();
@@ -3257,6 +3285,10 @@ function useTrueFoundryAgentMessages({
       }
     } catch (error) {
       if (generation === loadGenerationRef.current) {
+        if (isEarlyInitialLoad) {
+          initialLoadStartedForRef.current = void 0;
+          skipInitialPromotionLoadForRef.current = void 0;
+        }
         onErrorRef.current?.(error);
       }
       throw error;
@@ -3265,134 +3297,178 @@ function useTrueFoundryAgentMessages({
         setIsLoading(false);
       }
     }
-  }, [server, runStream, sessionId, loadRetryTrigger, isMain]);
+  }, [
+    server,
+    runStream,
+    sessionId,
+    loadRetryTrigger,
+    isMain,
+    isInitialSession
+  ]);
   useEffect2(() => {
     void load().catch(() => void 0);
   }, [load]);
   const sendTurn = useCallback2(
     async (options) => {
-      let activeSessionId = sessionId;
-      if (activeSessionId == null) {
-        if (initializeSessionRef.current == null) {
-          throw new Error("Cannot send a turn without an active session.");
+      let gatewayTurnAccepted = false;
+      let pendingUserWasSet = false;
+      let runStreamStarted = false;
+      let pendingUserTurnId;
+      try {
+        let activeSessionId = sessionId;
+        if (activeSessionId == null) {
+          if (initializeSessionRef.current == null) {
+            throw new Error("Cannot send a turn without an active session.");
+          }
+          const { remoteId } = await initializeSessionRef.current();
+          activeSessionId = remoteId;
+          lazilyCreatedSessionIdRef.current = remoteId;
         }
-        const { remoteId } = await initializeSessionRef.current();
-        activeSessionId = remoteId;
-        lazilyCreatedSessionIdRef.current = remoteId;
-      }
-      const conversationSessionId = await resolveActiveSessionId(
-        activeSessionId,
-        resolveConversationSessionIdRef.current
-      );
-      const turnHeaders = await getTurnHeadersRef.current?.();
-      const streamHeaders = turnHeaders != null ? { headers: turnHeaders } : {};
-      const isContinuation = "inputs" in options || "resumeMcpAuth" in options && options.resumeMcpAuth === true;
-      const continuationTurnId = snapshotRef.current.activeStream?.turnId;
-      const turnId = isContinuation && continuationTurnId != null ? continuationTurnId : generateId();
-      const isFirstTurnInSession = "userMessage" in options && options.previousTurnId === void 0 && snapshotRef.current.turns.length === 0 && snapshotRef.current.pendingUser == null && snapshotRef.current.activeStream == null;
-      const turnIdRef = { current: turnId };
-      if ("inputs" in options) {
-        applyUserToolResponsesToFold(
-          snapshotRef.current.fold,
-          options.inputs
-        );
-      }
-      const branchBase = "userMessage" in options ? options.branchFromSnapshot : void 0;
-      let groupRootBaseline;
-      if (branchBase != null && "userMessage" in options) {
-        const rootBucket = branchBase.fold.threads.get(ROOT_THREAD_ID);
-        groupRootBaseline = [...rootBucket?.modelMessageIds ?? []];
-        const nextSnapshot = replaceSessionSnapshot(branchBase, {
-          pendingUser: {
-            turnId,
-            content: options.userMessage,
-            createdAt: /* @__PURE__ */ new Date()
-          },
-          activeStream: void 0,
-          groupRootBaseline
-        });
-        snapshotRef.current = nextSnapshot;
-        setSnapshot(nextSnapshot);
-      } else {
-        setSnapshot(
-          (prev) => commitActiveStream(
-            prev,
-            "inputs" in options ? options.inputs : void 0
-          )
+        const conversationSessionId = await resolveActiveSessionId(
+          activeSessionId,
+          resolveConversationSessionIdRef.current
         );
-        if ("userMessage" in options) {
-          const rootBucket = snapshotRef.current.fold.threads.get(ROOT_THREAD_ID);
+        const turnHeaders = await getTurnHeadersRef.current?.();
+        const streamHeaders = turnHeaders != null ? { headers: turnHeaders } : {};
+        const isContinuation = "inputs" in options || "resumeMcpAuth" in options && options.resumeMcpAuth === true;
+        const continuationTurnId = snapshotRef.current.activeStream?.turnId;
+        const turnId = isContinuation && continuationTurnId != null ? continuationTurnId : generateId();
+        const isFirstTurnInSession = "userMessage" in options && options.previousTurnId === void 0 && snapshotRef.current.turns.length === 0 && snapshotRef.current.pendingUser == null && snapshotRef.current.activeStream == null;
+        const turnIdRef = { current: turnId };
+        if ("inputs" in options) {
+          applyUserToolResponsesToFold(
+            snapshotRef.current.fold,
+            options.inputs
+          );
+        }
+        const branchBase = "userMessage" in options ? options.branchFromSnapshot : void 0;
+        let groupRootBaseline;
+        if (branchBase != null && "userMessage" in options) {
+          const rootBucket = branchBase.fold.threads.get(ROOT_THREAD_ID);
           groupRootBaseline = [...rootBucket?.modelMessageIds ?? []];
-          setSnapshot((prev) => {
-            const next = replaceSessionSnapshot(prev, {
-              pendingUser: {
-                turnId,
-                content: options.userMessage,
-                createdAt: /* @__PURE__ */ new Date()
-              },
-              activeStream: void 0,
-              groupRootBaseline
-            });
-            snapshotRef.current = next;
-            return next;
+          const nextSnapshot = replaceSessionSnapshot(branchBase, {
+            pendingUser: {
+              turnId,
+              content: options.userMessage,
+              createdAt: /* @__PURE__ */ new Date()
+            },
+            activeStream: void 0,
+            groupRootBaseline
           });
+          snapshotRef.current = nextSnapshot;
+          setSnapshot(nextSnapshot);
+          pendingUserWasSet = true;
+          pendingUserTurnId = turnId;
         } else {
-          groupRootBaseline = snapshotRef.current.groupRootBaseline ?? computeGroupRootBaseline(snapshotRef.current.turns);
-        }
-      }
-      await runStream(
-        (signal) => {
-          if ("inputs" in options) {
-            return streamTurnContent(
-              server,
-              conversationSessionId,
-              snapshotRef.current.fold,
-              { inputs: options.inputs, ...streamHeaders },
-              signal,
-              groupRootBaseline
-            );
+          setSnapshot(
+            (prev) => commitActiveStream(
+              prev,
+              "inputs" in options ? options.inputs : void 0
+            )
+          );
+          if ("userMessage" in options) {
+            const rootBucket = snapshotRef.current.fold.threads.get(ROOT_THREAD_ID);
+            groupRootBaseline = [...rootBucket?.modelMessageIds ?? []];
+            setSnapshot((prev) => {
+              const next = replaceSessionSnapshot(prev, {
+                pendingUser: {
+                  turnId,
+                  content: options.userMessage,
+                  createdAt: /* @__PURE__ */ new Date()
+                },
+                activeStream: void 0,
+                groupRootBaseline
+              });
+              snapshotRef.current = next;
+              return next;
+            });
+            pendingUserWasSet = true;
+            pendingUserTurnId = turnId;
+          } else {
+            groupRootBaseline = snapshotRef.current.groupRootBaseline ?? computeGroupRootBaseline(snapshotRef.current.turns);
           }
-          if ("resumeMcpAuth" in options) {
+        }
+        runStreamStarted = true;
+        await runStream(
+          (signal) => {
+            if ("inputs" in options) {
+              return streamTurnContent(
+                server,
+                conversationSessionId,
+                snapshotRef.current.fold,
+                { inputs: options.inputs, ...streamHeaders },
+                signal,
+                groupRootBaseline
+              );
+            }
+            if ("resumeMcpAuth" in options) {
+              return streamTurnContent(
+                server,
+                conversationSessionId,
+                snapshotRef.current.fold,
+                { resumeMcpAuth: true, ...streamHeaders },
+                signal,
+                groupRootBaseline
+              );
+            }
             return streamTurnContent(
               server,
               conversationSessionId,
               snapshotRef.current.fold,
-              { resumeMcpAuth: true, ...streamHeaders },
+              {
+                userMessage: options.userMessage,
+                ...options.previousTurnId !== void 0 ? { previousTurnId: options.previousTurnId ?? "none" } : isFirstTurnInSession ? { previousTurnId: "none" } : {},
+                ...streamHeaders
+              },
               signal,
-              groupRootBaseline
+              groupRootBaseline,
+              // Rename the optimistic local ID to the gateway turn ID
+              // so that edit/retry can resolve the turn via the gateway.
+              (gatewayTurnId) => {
+                const oldId = turnIdRef.current;
+                gatewayTurnAccepted = true;
+                if (gatewayTurnId === oldId) return;
+                turnIdRef.current = gatewayTurnId;
+                const renamePendingUser = (prev) => {
+                  if (prev.pendingUser?.turnId !== oldId) return prev;
+                  return replaceSessionSnapshot(prev, {
+                    pendingUser: { ...prev.pendingUser, turnId: gatewayTurnId }
+                  });
+                };
+                snapshotRef.current = renamePendingUser(snapshotRef.current);
+                setSnapshot(renamePendingUser);
+              }
             );
+          },
+          turnIdRef,
+          isContinuation
+        );
+      } catch (error) {
+        if ("userMessage" in options && !gatewayTurnAccepted) {
+          const branchRollbackSnapshot = options.branchRollbackSnapshot;
+          const canRestoreBranch = branchRollbackSnapshot != null && (snapshotRef.current === options.branchFromSnapshot || snapshotRef.current.pendingUser?.turnId === pendingUserTurnId);
+          if (canRestoreBranch) {
+            snapshotRef.current = branchRollbackSnapshot;
+            setSnapshot(branchRollbackSnapshot);
+          } else if (pendingUserWasSet) {
+            const clearPendingUser = (previous) => {
+              if (previous.pendingUser?.turnId !== pendingUserTurnId) {
+                return previous;
+              }
+              return replaceSessionSnapshot(previous, {
+                pendingUser: void 0
+              });
+            };
+            snapshotRef.current = clearPendingUser(snapshotRef.current);
+            setSnapshot(clearPendingUser);
           }
-          return streamTurnContent(
-            server,
-            conversationSessionId,
-            snapshotRef.current.fold,
-            {
-              userMessage: options.userMessage,
-              ...options.previousTurnId !== void 0 ? { previousTurnId: options.previousTurnId ?? "none" } : isFirstTurnInSession ? { previousTurnId: "none" } : {},
-              ...streamHeaders
-            },
-            signal,
-            groupRootBaseline,
-            // Rename the optimistic local ID to the gateway turn ID
-            // so that edit/retry can resolve the turn via the gateway.
-            (gatewayTurnId) => {
-              const oldId = turnIdRef.current;
-              if (gatewayTurnId === oldId) return;
-              turnIdRef.current = gatewayTurnId;
-              const renamePendingUser = (prev) => {
-                if (prev.pendingUser?.turnId !== oldId) return prev;
-                return replaceSessionSnapshot(prev, {
-                  pendingUser: { ...prev.pendingUser, turnId: gatewayTurnId }
-                });
-              };
-              snapshotRef.current = renamePendingUser(snapshotRef.current);
-              setSnapshot(renamePendingUser);
-            }
-          );
-        },
-        turnIdRef,
-        isContinuation
-      );
+          options.onPreTurnFailure?.();
+        }
+        if (!runStreamStarted) {
+          onErrorRef.current?.(error);
+        }
+        throw error;
+      }
     },
     [server, runStream, sessionId]
   );
@@ -3422,7 +3498,7 @@ function useTrueFoundryAgentMessages({
       }
       const inputs = collectRequiredActionInputs(paused);
       if (inputs.length > 0) {
-        void sendTurn({ inputs }).catch((error) => onErrorRef.current?.(error));
+        void sendTurn({ inputs }).catch(() => void 0);
       }
     },
     [projectOptions, sendTurn]
@@ -3483,35 +3559,44 @@ function useTrueFoundryAgentMessages({
   }, [runStream, server]);
   const branchFromTurn = useCallback2(
     async (turnId, userMessage) => {
-      let activeSessionId = sessionId;
-      if (activeSessionId == null) {
-        throw new Error("Cannot branch from a turn without an active session.");
+      let committed;
+      let previousTurnId;
+      let rewound;
+      try {
+        let activeSessionId = sessionId;
+        if (activeSessionId == null) {
+          throw new Error("Cannot branch from a turn without an active session.");
+        }
+        committed = commitActiveStream(snapshotRef.current);
+        setSnapshot(committed);
+        await cancel();
+        const conversationSessionId = await resolveActiveSessionId(
+          activeSessionId,
+          resolveConversationSessionIdRef.current
+        );
+        previousTurnId = await resolveGatewayBranchPreviousTurnIdForTurn(
+          server,
+          conversationSessionId,
+          turnId
+        );
+        rewound = await buildSnapshotBeforeTurn(
+          server,
+          conversationSessionId,
+          turnId,
+          listEventsConcurrency
+        );
+        createdAtByMessageIdRef.current = /* @__PURE__ */ new Map();
+        snapshotRef.current = rewound;
+        setSnapshot(rewound);
+      } catch (error) {
+        onErrorRef.current?.(error);
+        throw error;
       }
-      const committed = commitActiveStream(snapshotRef.current);
-      setSnapshot(committed);
-      await cancel();
-      const conversationSessionId = await resolveActiveSessionId(
-        activeSessionId,
-        resolveConversationSessionIdRef.current
-      );
-      const previousTurnId = await resolveGatewayBranchPreviousTurnIdForTurn(
-        server,
-        conversationSessionId,
-        turnId
-      );
-      const rewound = await buildSnapshotBeforeTurn(
-        server,
-        conversationSessionId,
-        turnId,
-        listEventsConcurrency
-      );
-      createdAtByMessageIdRef.current = /* @__PURE__ */ new Map();
-      snapshotRef.current = rewound;
-      setSnapshot(rewound);
       await sendTurn({
         userMessage,
         previousTurnId,
-        branchFromSnapshot: rewound
+        branchFromSnapshot: rewound,
+        branchRollbackSnapshot: committed
       });
     },
     [
@@ -3527,7 +3612,9 @@ function useTrueFoundryAgentMessages({
       const committed = commitActiveStream(snapshotRef.current);
       const originalInput = resolveTurnInput(committed, turnId);
       if (originalInput == null) {
-        throw new Error(`Turn ${turnId} not found in session snapshot`);
+        const error = new Error(`Turn ${turnId} not found in session snapshot`);
+        onErrorRef.current?.(error);
+        throw error;
       }
       const userMessage = extractTurnUserMessageContent(originalInput);
       await branchFromTurn(turnId, userMessage);
@@ -3539,7 +3626,9 @@ function useTrueFoundryAgentMessages({
       const committed = commitActiveStream(snapshotRef.current);
       const originalInput = resolveTurnInput(committed, turnId);
       if (originalInput == null) {
-        throw new Error(`Turn ${turnId} not found in session snapshot`);
+        const error = new Error(`Turn ${turnId} not found in session snapshot`);
+        onErrorRef.current?.(error);
+        throw error;
       }
       const userMessage = buildEditedUserMessageContent(
         editedText,
@@ -3638,6 +3727,7 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
   const isMain = useAuiState(
     (state) => state.threads.mainThreadId === state.threadListItem.id
   );
+  const isInitialSession = sessionId != null && sessionId === options.initialSessionId;
   const draftSpec = useDraftAgentSpec({
     draftSessionId,
     draftBridge: draftBridgeRef.current,
@@ -3683,6 +3773,7 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
     server,
     sessionId,
     isMain,
+    isInitialSession,
     listEventsConcurrency,
     onError,
     initializeSession,
@@ -3708,20 +3799,16 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
   const downloadSandboxFile = useCallback3(
     async (path) => {
       if (server.downloadSandboxFile == null) {
-        const error = new Error(
+        throw new Error(
           "Downloading a sandbox file requires AgentChatServer.downloadSandboxFile."
         );
-        onError?.(error);
-        throw error;
       }
       if (sandboxId == null) {
-        const error = new Error("No sandbox is available yet for this session.");
-        onError?.(error);
-        throw error;
+        throw new Error("No sandbox is available yet for this session.");
       }
       return await server.downloadSandboxFile(sandboxId, { path });
     },
-    [server, sandboxId, onError]
+    [server, sandboxId]
   );
   const draftExtras = useMemo3(() => {
     if (agent.mode !== "draft") {
@@ -3730,6 +3817,7 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
     return {
       agentSpec: draftSpec.agentSpec,
       draftSessionId: draftSpec.draftSessionId,
+      isSpecLoading: draftSpec.isSpecLoading,
       isSpecSyncing: draftSpec.isSpecSyncing,
       specError: draftSpec.specError,
       updateAgentSpec: draftSpec.updateAgentSpec
@@ -3750,9 +3838,8 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
       resumeMcpAuth,
       downloadSandboxFile,
       cancel,
-      resetFromTurn: (turnId) => resetFromTurn(turnId).catch((error) => {
-        onError?.(error);
-      }),
+      // resetFromTurn/branchFromTurn/sendTurn already report via onError.
+      resetFromTurn: (turnId) => resetFromTurn(turnId).catch(() => void 0),
       reload: retryLoad,
       hasOlderHistory,
       isLoadingOlderHistory,
@@ -3777,7 +3864,19 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
         await sendTurn({ resumeMcpAuth: true });
         return;
       }
-      await sendTurn({ userMessage: buildUserMessageContent(message) });
+      const userMessage = buildUserMessageContent(message);
+      await sendTurn({
+        userMessage,
+        // The composer clears before onNew runs. Restore its text only when
+        // the turn failed before turn.created registered it in the backend.
+        onPreTurnFailure: () => {
+          const text = userMessageContentToText(userMessage);
+          const composer = aui.thread().composer();
+          if (text && !composer.getState().text.trim()) {
+            composer.setText(text);
+          }
+        }
+      });
     },
     onCancel: async () => {
       await cancel();
@@ -3795,12 +3894,7 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
       }
       const turnId = parseTurnIdFromMessageId(sourceId);
       const editedText = extractEditedText(message);
-      try {
-        await editFromTurn(turnId, editedText);
-      } catch (error) {
-        onError?.(error);
-        throw error;
-      }
+      await editFromTurn(turnId, editedText);
     }
   });
 }