Composer: re-enable Stop when a cancel request itself fails

Author: TheGreatAxios

packages/chat-ui/src/chat-workspace.tsx

@@ -812,15 +812,19 @@ function ChatWorkspaceInner({
     [tenantId, activeWorkbenchId],
   );
 
-  // CL-7201: fire-and-forget, matching the reaction/pin handlers above —
-  // the composer's own `stopping` state is the user-visible feedback,
-  // and the timeline's cancelled-turn notice (not this response) is
-  // what actually clears the typing indicator once the turn settles.
+  // CL-7201: unlike the reaction/pin handlers above, this rethrows after
+  // toasting — the composer's own `onStop` awaits the returned promise
+  // and re-enables its Stop button on rejection, so a genuinely failed
+  // request (network, a denied grant) never leaves the button stuck
+  // disabled for the rest of the turn. The timeline's cancelled-turn
+  // notice, not this response, is what actually clears the typing
+  // indicator once (or if) the turn settles.
   const handleStopTurn = useCallback(() => {
-    if (activeWorkbenchId === null) return;
-    cancelWorkbenchTurn(tenantId, activeWorkbenchId).catch(() =>
-      toast(CHAT_STRINGS.turnCancelError),
-    );
+    if (activeWorkbenchId === null) return Promise.resolve();
+    return cancelWorkbenchTurn(tenantId, activeWorkbenchId).catch((err) => {
+      toast(CHAT_STRINGS.turnCancelError);
+      throw err;
+    });
   }, [tenantId, activeWorkbenchId]);
 
   const handlePinMessage = useCallback(

packages/chat-ui/src/composer.tsx

@@ -351,10 +351,16 @@ export const Composer = forwardRef<
      * typically the host's own `isPendingReply(streamingReply)`. Absent
      * or `false` renders no Stop affordance at all. */
     readonly running?: boolean;
-    /** Cancels the running turn — `POST .../turns/cancel`. Required
+    /**
+     * Cancels the running turn — `POST .../turns/cancel`. Required
      * whenever `running` can be `true`; the composer never guesses at
-     * how to stop a turn on its own. */
-    readonly onStop?: () => void;
+     * how to stop a turn on its own. May return a promise: a rejection
+     * re-enables the button immediately (the request itself failed —
+     * network, a denied grant — not merely a slow cancel, so there is
+     * no reason to make the person wait for `running` to change before
+     * they can try again).
+     */
+    readonly onStop?: () => void | Promise<unknown>;
   }
 >(function Composer(
   {
@@ -737,7 +743,13 @@ export const Composer = forwardRef<
   function handleStop() {
     if (stopping || onStop === undefined) return;
     setStopping(true);
-    onStop();
+    // CL-7201 (Critique finding): a rejected stop request is a FAILED
+    // cancel, not a slow one -- the `useEffect` above only re-enables
+    // once the host reports `running` has gone false, which never
+    // happens for a request that never reached the server. Without
+    // this catch the button stayed disabled for the rest of the turn's
+    // life with no way to retry.
+    Promise.resolve(onStop()).catch(() => setStopping(false));
   }
 
   return (