fix(cli): unstick streamingState after Esc-cancel + close leaked turn span (#145)

Symptom (also reported on the Langfuse trace, session 442ed5c7,
turn ba924d250d7c with 739s latency and zero LLM activity in the
middle): user presses Esc to cancel, then any subsequent input is
silently dropped — UI stays in the loading indicator forever.

Root cause:
  - cancelOngoingRequest aborts the AbortController and flips
    isResponding=false, but does not clear toolCalls. If a tool
    ignores its AbortSignal, it stays in 'executing' / 'scheduled' /
    etc., or finishes with responseSubmittedToGemini=false. Either
    way, streamingState computes 'Responding' (useGeminiStream.ts:
    424-437) and submitQuery's guard (1305-1314) silently drops the
    next user submission. The in-code comment at line 244-245 even
    flags this class of bug for a different cause.
  - cancelOngoingRequest never calls endTurnSpan, so the OTel turn
    span leaks. The recap + prompt-suggestion LLM calls that fire on
    streamingState=Idle then attach to the dead span — Langfuse
    reports the turn as 12 minutes long when the actual model work
    was 1.7 seconds.

Inheritance: upstream qwen-code has the identical cancelOngoingRequest
shape and the identical silent-return guard. gemini-cli upstream's
PR #21960 (closing #21096) addressed a different cancel-related bug
(retry-loop loading indicator showing stale "still on it" text), not
the stuck-toolCalls case. Issue #18525 there ("Agent Stuck between
Responses") is essentially the same symptom and is still open. So
this is inherited, not introduced — but the leaked turn span is
fork-only, since startTurnSpan/endTurnSpan are part of our agent
harness.

Fix:
- useReactToolScheduler exposes a new forceCancelStaleToolCalls()
  that flips responseSubmittedToGemini=true on terminal calls and
  synthesizes a 'cancelled' state for any non-terminal call (with a
  clear "User cancelled. Tool was force-cleared after the abort
  signal did not stop it within the grace window" message in the
  responseParts so downstream consumers don't choke).
- cancelOngoingRequest in useGeminiStream:
  * marks every current toolCall as submitted immediately (handles
    the common case where the tool finished but the flag wasn't
    flipped),
  * schedules a 3s setTimeout that calls forceCancelStaleToolCalls
    and surfaces a WARNING if anything had to be force-cleared so
    the user knows the underlying process may still be running,
  * calls endTurnSpan('ok') so the recap/suggestion LLM calls don't
    keep nesting under a dead turn span in Langfuse.
- submitQuery no longer silently drops submissions when streamingState
  is non-Idle. It logs a clear WARNING explaining what state we're
  in (Responding / WaitingForConfirmation / Backgrounded) and what
  the user should do (approve the tool, wait, or press Esc).

Tests: 3,767 cli tests + 5,337 core tests pass. Existing cancellation
tests in useGeminiStream.test.tsx (49 tests in that file) continue to
pass with the new flow.

Co-authored-by: Automaker <automaker@localhost>
Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: 3 people

packages/cli/src/ui/hooks/useGeminiStream.ts

@@ -38,6 +38,7 @@ import {
   ToolConfirmationOutcome,
   logApiCancel,
   ApiCancelEvent,
+  endTurnSpan,
   isSupportedImageMimeType,
   getUnsupportedImageFormatWarning,
   hasFileEdits,
@@ -262,13 +263,27 @@ export const useGeminiStream = (
     [],
   );
 
-  const [toolCalls, scheduleToolCalls, markToolsAsSubmitted] =
-    useReactToolScheduler(
-      stableOnComplete,
-      config,
-      getPreferredEditor,
-      onEditorClose,
-    );
+  const [
+    toolCalls,
+    scheduleToolCalls,
+    markToolsAsSubmitted,
+    forceCancelStaleToolCalls,
+  ] = useReactToolScheduler(
+    stableOnComplete,
+    config,
+    getPreferredEditor,
+    onEditorClose,
+  );
+
+  // Stable refs so cancelOngoingRequest can read the current toolCalls
+  // and call forceCancelStaleToolCalls without itself depending on those
+  // values (which would invalidate the callback every render).
+  const toolCallsRef = useRef(toolCalls);
+  toolCallsRef.current = toolCalls;
+  const markToolsAsSubmittedRef = useRef(markToolsAsSubmitted);
+  markToolsAsSubmittedRef.current = markToolsAsSubmitted;
+  const forceCancelStaleToolCallsRef = useRef(forceCancelStaleToolCalls);
+  forceCancelStaleToolCallsRef.current = forceCancelStaleToolCalls;
 
   const pendingToolCallGroupDisplay = useMemo(
     () =>
@@ -510,6 +525,40 @@ export const useGeminiStream = (
     onCancelSubmit();
     setIsResponding(false);
     setShellInputFocused(false);
+
+    // Close any leaked OTel turn span so the recap / prompt-suggestion
+    // LLM calls that fire on streamingState=Idle don't get nested under
+    // a still-open turn span (Langfuse otherwise reports the turn as
+    // running until the next prompt opens a new span).
+    endTurnSpan('ok');
+
+    // Immediately flip responseSubmittedToGemini=true on every current
+    // toolCall. Handles the common case where a tool finished but the
+    // submitted flag wasn't flipped (the in-code comment at the top of
+    // this hook documents the same class of bug for a different cause).
+    const currentCallIds = toolCallsRef.current.map((tc) => tc.request.callId);
+    if (currentCallIds.length > 0) {
+      markToolsAsSubmittedRef.current(currentCallIds);
+    }
+
+    // Schedule a grace-window force-clear for any tool that ignored the
+    // abort signal. Without this, a runaway subagent (or any tool that
+    // doesn't honor signal.aborted) leaves the toolCall in a non-terminal
+    // state, which keeps streamingState=Responding and silently drops
+    // every subsequent user submission via submitQuery's guard at line
+    // 1305. Three seconds is generous — well-behaved tools clean up in ms.
+    setTimeout(() => {
+      const cleared = forceCancelStaleToolCallsRef.current();
+      if (cleared > 0) {
+        addItem(
+          {
+            type: MessageType.WARNING,
+            text: `Force-cleared ${cleared} stuck tool call(s) after cancel grace window. The underlying process(es) may still be running in the background.`,
+          },
+          Date.now(),
+        );
+      }
+    }, 3000);
   }, [
     streamingState,
     addItem,
@@ -1310,6 +1359,31 @@ export const useGeminiStream = (
       ) {
         // Release the guard — we're not actually going to run
         if (generation !== null) queryGuardRef.current.end(generation);
+        // Surface the dropped submission so the user knows their input was
+        // not sent. Previously this was a silent `return`, which made
+        // protoCLI feel hung when a tool refused to honor cancel — the
+        // user types and gets nothing back forever. With the cancel
+        // handler's grace-window force-clear (~3s), this state is now
+        // self-resolving; the message just tells them to wait or retry.
+        const stateLabel =
+          streamingState === StreamingState.Responding
+            ? 'still responding'
+            : streamingState === StreamingState.WaitingForConfirmation
+              ? 'awaiting tool confirmation'
+              : 'backgrounded';
+        addItem(
+          {
+            type: MessageType.WARNING,
+            text: `Input not sent — previous turn is ${stateLabel}. ${
+              streamingState === StreamingState.WaitingForConfirmation
+                ? 'Approve or reject the pending tool call first.'
+                : streamingState === StreamingState.Backgrounded
+                  ? 'Wait for the backgrounded turn to finish or press Esc to cancel.'
+                  : 'Press Esc to cancel and try again (stuck tools auto-clear after 3s).'
+            }`,
+          },
+          Date.now(),
+        );
         return;
       }
 

packages/cli/src/ui/hooks/useReactToolScheduler.ts

@@ -24,7 +24,7 @@ import {
   CoreToolScheduler,
   createDebugLogger,
 } from '@qwen-code/qwen-code-core';
-import { useCallback, useState, useMemo } from 'react';
+import { useCallback, useState, useMemo, useRef } from 'react';
 import type {
   HistoryItemToolGroup,
   IndividualToolCallDisplay,
@@ -38,6 +38,16 @@ export type ScheduleFn = (
   signal: AbortSignal,
 ) => void;
 export type MarkToolsAsSubmittedFn = (callIds: string[]) => void;
+/**
+ * Forcibly transition any non-terminal tool calls to a synthetic
+ * `cancelled` state with `responseSubmittedToGemini=true`. Used by the
+ * cancel handler to unblock `streamingState` when a tool ignores its
+ * AbortSignal — the underlying process may keep running, but the UI
+ * stops being held hostage by it. Returns the number of calls that
+ * were force-cancelled (so callers can decide whether to surface a
+ * notice).
+ */
+export type ForceCancelStaleToolCallsFn = () => number;
 
 export type TrackedScheduledToolCall = ScheduledToolCall & {
   responseSubmittedToGemini?: boolean;
@@ -72,7 +82,12 @@ export function useReactToolScheduler(
   config: Config,
   getPreferredEditor: () => EditorType | undefined,
   onEditorClose: () => void,
-): [TrackedToolCall[], ScheduleFn, MarkToolsAsSubmittedFn] {
+): [
+  TrackedToolCall[],
+  ScheduleFn,
+  MarkToolsAsSubmittedFn,
+  ForceCancelStaleToolCallsFn,
+] {
   const [toolCallsForDisplay, setToolCallsForDisplay] = useState<
     TrackedToolCall[]
   >([]);
@@ -179,7 +194,76 @@ export function useReactToolScheduler(
     [],
   );
 
-  return [toolCallsForDisplay, schedule, markToolsAsSubmitted];
+  // Track how many calls were transitioned by the most recent
+  // forceCancelStaleToolCalls invocation. The setter callback runs inside
+  // setToolCallsForDisplay's reducer, so we need a side-channel ref to
+  // return a synchronous count to the caller.
+  const lastForceCancelledCountRef = useRef(0);
+
+  const forceCancelStaleToolCalls: ForceCancelStaleToolCallsFn =
+    useCallback(() => {
+      lastForceCancelledCountRef.current = 0;
+      setToolCallsForDisplay((prevCalls) => {
+        let changed = 0;
+        const next = prevCalls.map((tc): TrackedToolCall => {
+          // Already terminal: just guarantee the submitted flag so
+          // streamingState clears even if handleCompletedTools never ran.
+          if (
+            tc.status === 'success' ||
+            tc.status === 'error' ||
+            tc.status === 'cancelled'
+          ) {
+            if (tc.responseSubmittedToGemini) return tc;
+            changed++;
+            return { ...tc, responseSubmittedToGemini: true };
+          }
+
+          // Non-terminal: synthesize a cancelled response. The underlying
+          // process may still be running — the UI stops waiting on it.
+          changed++;
+          const cancelled: TrackedCancelledToolCall = {
+            request: tc.request,
+            tool: 'tool' in tc ? tc.tool : undefined!,
+            invocation: 'invocation' in tc ? tc.invocation : undefined!,
+            status: 'cancelled',
+            response: {
+              callId: tc.request.callId,
+              error: undefined,
+              errorType: undefined,
+              responseParts: [
+                {
+                  functionResponse: {
+                    id: tc.request.callId,
+                    name: tc.request.name,
+                    response: {
+                      error:
+                        'User cancelled. Tool was force-cleared after the abort signal did not stop it within the grace window; the underlying process may still be running.',
+                    },
+                  },
+                },
+              ],
+              resultDisplay:
+                'Force-cancelled (tool did not honor AbortSignal in time).',
+              contentLength: undefined,
+            },
+            durationMs: undefined,
+            outcome: tc.outcome,
+            responseSubmittedToGemini: true,
+          };
+          return cancelled;
+        });
+        lastForceCancelledCountRef.current = changed;
+        return changed > 0 ? next : prevCalls;
+      });
+      return lastForceCancelledCountRef.current;
+    }, []);
+
+  return [
+    toolCallsForDisplay,
+    schedule,
+    markToolsAsSubmitted,
+    forceCancelStaleToolCalls,
+  ];
 }
 
 /**