@vybestack/llxprt-code 0.10.0 → 0.11.0-nightly.260728.ffaa8d5d7

package/src/ui/hooks/agentStream/useAgentEventStream.ts

@@ -27,7 +27,7 @@ import type {
   AgentInput,
 } from '@vybestack/llxprt-code-agents';
 import type {
-  AnsiOutput,
+  LiveOutputUpdate,
   CompletedToolCall,
   EditorType,
   ToolCall,
@@ -69,15 +69,13 @@ export interface UseAgentEventStreamArgs {
   clearPendingHistoryItem: () => void;
   /** Refreshes in-memory data after a successful save_memory. */
   performMemoryRefresh: () => Promise<void>;
-  /** Invoked when the pause tool succeeds. */
-  onTodoPause?: () => void;
   /**
    * Marks the given tool callIds as cleared from the React display state.
    */
   markToolsAsDisplayCleared?: (callIds: string[]) => void;
   /** Display callbacks for tool-call display state. */
   onToolCallsUpdate?: (toolCalls: ToolCall[]) => void;
-  outputUpdateHandler?: (callId: string, chunk: string | AnsiOutput) => void;
+  outputUpdateHandler?: (callId: string, update: LiveOutputUpdate) => void;
   getPreferredEditor?: () => EditorType | undefined;
   onEditorOpen?: () => void;
   onEditorClose?: () => void;
@@ -96,10 +94,10 @@ export interface UseAgentEventStreamReturn {
 }
 
 /**
- * Processes a tools_complete callback: adds the tool-group display item,
- * refreshes memory if a save_memory succeeded, and fires onTodoPause if a
- * pause-task tool succeeded. The Agent's loop has ALREADY recorded the completed
- * calls into chat history — do NOT call recordCompletedToolCalls here.
+ * Processes a tools_complete callback: adds the tool-group display item and
+ * refreshes memory if a save_memory succeeded. The Agent's loop has ALREADY
+ * recorded the completed calls into chat history — do NOT call
+ * recordCompletedToolCalls here.
  */
 function handleToolsComplete(
   completed: readonly CompletedToolCall[],
@@ -118,13 +116,6 @@ function handleToolsComplete(
     userMessageTimestamp,
   );
   const { primaryTools, externalTools } = classifyCompletedTools(completedArr);
-  if (
-    primaryTools.some(
-      (tc) => tc.request.name === 'todo_pause' && tc.status === 'success',
-    )
-  ) {
-    args.onTodoPause?.();
-  }
   const memoryRef = { current: processedMemoryTools };
   processMemoryToolResults(primaryTools, memoryRef, args.performMemoryRefresh);
 
@@ -161,8 +152,8 @@ export function useAgentEventStream(
     agent.tools.setDisplayCallbacks({
       onToolCallsUpdate: (toolCalls) =>
         latestArgs.current.onToolCallsUpdate?.(toolCalls),
-      outputUpdateHandler: (callId, chunk) =>
-        latestArgs.current.outputUpdateHandler?.(callId, chunk),
+      outputUpdateHandler: (callId, update) =>
+        latestArgs.current.outputUpdateHandler?.(callId, update),
       onAllToolCallsComplete: (completed) => {
         const userMessageTimestamp =
           currentTurnTimestampRef.current ?? Date.now();

package/src/ui/hooks/agentStream/useAgentStream.ts

@@ -53,7 +53,6 @@ export const useAgentStream = (
   setShellInputFocused: (value: boolean) => void,
   terminalWidth?: number,
   terminalHeight?: number,
-  onTodoPause?: () => void,
   onEditorOpen: () => void = () => {},
   recordingIntegration?: RecordingIntegration,
   runtimeMessageBus?: MessageBus,
@@ -74,7 +73,6 @@ export const useAgentStream = (
     setShellInputFocused,
     terminalWidth,
     terminalHeight,
-    onTodoPause,
     onEditorOpen,
     recordingIntegration,
     runtimeMessageBus,
@@ -114,6 +112,7 @@ function useAgentStreamReturn(
   return {
     streamingState: orchestration.streamingState,
     submitQuery: orchestration.submitQuery,
+    sanitizeContent: orchestration.st.sanitizeContent,
     initError: orchestration.st.initError,
     pendingHistoryItems,
     thought: orchestration.st.thought,
@@ -121,6 +120,7 @@ function useAgentStreamReturn(
     cancelOngoingRequest: orchestration.cancelOngoingRequest,
     activeShellPtyId: orchestration.activeShellPtyId,
     lastOutputTime: getLastOutputTime(orchestration),
+    queuedSubmissions: orchestration.queuedSubmissions,
   };
 }
 

package/src/ui/hooks/agentStream/useAgentStreamLifecycle.ts

@@ -29,7 +29,6 @@ import { mapToDisplay as mapTrackedToolCallsToDisplay } from '../toolMapping.js'
 import { classifyCompletedTools } from './toolCompletionHandler.js';
 import { useKeypress, type Key } from '../useKeypress.js';
 import { type UseHistoryManagerReturn } from '../useHistoryManager.js';
-import { type QueuedSubmission } from './types.js';
 import type { StreamRuntime } from '../../cliUiRuntime.js';
 
 export function useStreamingState(
@@ -220,7 +219,7 @@ export function useCancellation(
   >,
   onCancelSubmit: (shouldRestorePrompt?: boolean) => void,
   setIsResponding: React.Dispatch<React.SetStateAction<boolean>>,
-  queuedSubmissionsRef: React.MutableRefObject<QueuedSubmission[]>,
+  setShellInputFocused: (value: boolean) => void,
   cancelRunningAsyncTasks: () => void = () => {},
 ) {
   const cancelOngoingRequest = useCallback(() => {
@@ -233,14 +232,14 @@ export function useCancellation(
     if (turnCancelledRef.current) return;
     turnCancelledRef.current = true;
     abortControllerRef.current?.abort();
-    if (abortControllerRef.current) cancelAllToolCalls();
+    cancelAllToolCalls();
     cancelRunningAsyncTasks();
     if (pendingHistoryItemRef.current) flushPendingHistoryItem(Date.now());
     addItem({ type: MessageType.INFO, text: 'Request cancelled.' }, Date.now());
     setPendingHistoryItem(null);
     onCancelSubmit();
     setIsResponding(false);
-    queuedSubmissionsRef.current = [];
+    setShellInputFocused(false);
   }, [
     streamingState,
     turnCancelledRef,
@@ -253,7 +252,7 @@ export function useCancellation(
     setPendingHistoryItem,
     onCancelSubmit,
     setIsResponding,
-    queuedSubmissionsRef,
+    setShellInputFocused,
   ]);
   const cancelOngoingRequestRef = useRef(cancelOngoingRequest);
   cancelOngoingRequestRef.current = cancelOngoingRequest;

package/src/ui/hooks/agentStream/useAgentStreamOrchestration.ts

@@ -7,7 +7,7 @@
 import { useCallback, useMemo, useRef } from 'react';
 import {
   type EditorType,
-  type AnsiOutput,
+  type LiveOutputUpdate,
   type MessageBus,
   type RecordingIntegration,
   type ToolCall,
@@ -34,6 +34,7 @@ import {
   useStreamingState,
   useToolSchedulerSetup,
 } from './useAgentStreamLifecycle.js';
+import type { QueuedSubmission } from './types.js';
 import type { StreamRuntime } from '../../cliUiRuntime.js';
 
 export interface AgentStreamOrchestrationDeps {
@@ -54,7 +55,6 @@ export interface AgentStreamOrchestrationDeps {
   setShellInputFocused: (value: boolean) => void;
   terminalWidth?: number;
   terminalHeight?: number;
-  onTodoPause?: () => void;
   onEditorOpen: () => void;
   recordingIntegration?: RecordingIntegration;
   runtimeMessageBus?: MessageBus;
@@ -71,6 +71,7 @@ export interface AgentStreamOrchestrationResult {
   interactiveRuntimeReady: boolean;
   cancelOngoingRequest: () => void;
   activeShellPtyId: number | null;
+  queuedSubmissions: readonly QueuedSubmission[];
 }
 
 interface ToolSchedulerState {
@@ -83,7 +84,7 @@ interface ToolSchedulerState {
   interactiveRuntimeReady: boolean;
   /** Bound display-state updaters for the AgenticLoop's displayCallbacks. */
   replaceToolCalls: (calls: ToolCall[]) => void;
-  updateToolOutput: (callId: string, chunk: string | AnsiOutput) => void;
+  updateToolOutput: (callId: string, update: LiveOutputUpdate) => void;
 }
 
 export function useAgentStreamOrchestration(
@@ -123,7 +124,7 @@ export function useAgentStreamOrchestration(
     st.setPendingHistoryItem,
     args.onCancelSubmit,
     st.setIsResponding,
-    st.queuedSubmissionsRef,
+    args.setShellInputFocused,
     cancelRunningAsyncTasks,
   );
   // Refs to break the circular dependency between useSubmitQuery (which
@@ -264,7 +265,6 @@ function useEventStreamForAgent(
     flushPendingHistoryItem: st.flushPendingHistoryItem,
     clearPendingHistoryItem: () => st.setPendingHistoryItem(null),
     performMemoryRefresh: args.performMemoryRefresh,
-    onTodoPause: args.onTodoPause,
     markToolsAsDisplayCleared: scheduler.markToolsAsDisplayCleared,
     onToolCallsUpdate: scheduler.replaceToolCalls,
     outputUpdateHandler: scheduler.updateToolOutput,
@@ -304,6 +304,7 @@ function buildResult(
     interactiveRuntimeReady: scheduler.interactiveRuntimeReady,
     cancelOngoingRequest,
     activeShellPtyId: shell.activeShellPtyId,
+    queuedSubmissions: st.queuedSubmissions,
   };
 }
 
@@ -341,6 +342,12 @@ function buildSubmitQueryDeps({
     thinkingBlocksRef: st.thinkingBlocksRef,
     turnCancelledRef: st.turnCancelledRef,
     queuedSubmissionsRef: st.queuedSubmissionsRef,
+    enqueueSubmission: st.enqueueSubmission,
+    requeueSubmission: st.requeueSubmission,
+    dequeueSubmission: st.dequeueSubmission,
+    clearSubmissions: st.clearSubmissions,
+    tryReserveDrain: st.tryReserveDrain,
+    releaseDrain: st.releaseDrain,
     setPendingHistoryItem: st.setPendingHistoryItem,
     setIsResponding: st.setIsResponding,
     setInitError: st.setInitError,

package/src/ui/hooks/agentStream/useQueuedSubmissions.ts

@@ -0,0 +1,99 @@
+/**
+ * @license
+ * Copyright 2025 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useCallback, useRef } from 'react';
+import { useStateAndRef } from '../useStateAndRef.js';
+import type { QueuedSubmission } from './types.js';
+
+/**
+ * State-backed queued-submissions store with serialized drain ownership.
+ *
+ * Provides:
+ * - `queuedSubmissions` (reactive state for rendering)
+ * - `queuedSubmissionsRef` (stable ref for callback access)
+ * - `enqueueSubmission` (immutable append — updates both ref and state)
+ * - `requeueSubmission` (immutable front insertion for retry)
+ * - `dequeueSubmission` (FIFO shift — updates both ref and state)
+ * - `clearSubmissions` (clear — updates both ref and state)
+ *
+ * All mutations go through `setStateInternal` from useStateAndRef, which
+ * synchronously updates the ref AND schedules a React state update. This
+ * eliminates stale-closure/race conditions between the ref reads in
+ * scheduleNextQueuedSubmission/submitQuery and the reactive state that
+ * drives the QueuedMessagesPanel.
+ *
+ * Serialized draining: `tryReserveDrain` / `releaseDrain` provide a canonical
+ * ownership token that ensures exactly one drain attempt is in-flight at any
+ * time, preventing the double-drain race between the idle-effect trigger and
+ * the runSubmitQueryCore finally-block trigger (issue #2296).
+ */
+export function useQueuedSubmissions() {
+  const [queuedSubmissions, queuedSubmissionsRef, setQueuedSubmissions] =
+    useStateAndRef<QueuedSubmission[]>([]);
+
+  // Canonical drain owner: true while a scheduleNextQueuedSubmission call has
+  // dequeued an item but the resulting submitQuery hasn't had a chance to set
+  // isResponding(true) yet. Prevents concurrent triggers from each dequeuing
+  // a separate item.
+  const drainInFlightRef = useRef(false);
+  const nextQueueIdRef = useRef(0);
+
+  const enqueueSubmission = useCallback(
+    (submission: QueuedSubmission): void => {
+      const queueId = nextQueueIdRef.current;
+      nextQueueIdRef.current = queueId + 1;
+      setQueuedSubmissions((prev) => [...prev, { ...submission, queueId }]);
+    },
+    [setQueuedSubmissions],
+  );
+
+  const requeueSubmission = useCallback(
+    (submission: QueuedSubmission): void => {
+      setQueuedSubmissions((prev) => [submission, ...prev]);
+    },
+    [setQueuedSubmissions],
+  );
+
+  const dequeueSubmission = useCallback((): QueuedSubmission | undefined => {
+    if (queuedSubmissionsRef.current.length === 0) {
+      return undefined;
+    }
+    const [first, ...rest] = queuedSubmissionsRef.current;
+    setQueuedSubmissions(rest);
+    return first;
+  }, [queuedSubmissionsRef, setQueuedSubmissions]);
+
+  const clearSubmissions = useCallback((): void => {
+    setQueuedSubmissions([]);
+  }, [setQueuedSubmissions]);
+
+  const tryReserveDrain = useCallback((): boolean => {
+    if (drainInFlightRef.current) {
+      return false;
+    }
+    drainInFlightRef.current = true;
+    return true;
+  }, []);
+
+  const releaseDrain = useCallback((): void => {
+    drainInFlightRef.current = false;
+  }, []);
+
+  return {
+    queuedSubmissions,
+    queuedSubmissionsRef,
+    enqueueSubmission,
+    requeueSubmission,
+    dequeueSubmission,
+    clearSubmissions,
+    tryReserveDrain,
+    releaseDrain,
+  };
+}
+
+export type UseQueuedSubmissionsReturn = ReturnType<
+  typeof useQueuedSubmissions
+>;

package/src/ui/hooks/agentStream/useStreamEventHandlers.ts

@@ -141,13 +141,7 @@ interface StreamEventHandlerDeps {
   pendingHistoryItemRef: React.MutableRefObject<HistoryItemWithoutId | null>;
   thinkingBlocksRef: React.MutableRefObject<ThinkingBlock[]>;
   turnCancelledRef: React.MutableRefObject<boolean>;
-  queuedSubmissionsRef: React.MutableRefObject<
-    Array<{
-      query: AgentRequestInput;
-      options?: { isContinuation: boolean };
-      promptId?: string;
-    }>
-  >;
+  clearSubmissions: () => void;
   setPendingHistoryItem: React.Dispatch<
     React.SetStateAction<HistoryItemWithoutId | null>
   >;
@@ -249,7 +243,6 @@ function useUserCancelledHandler(deps: StreamEventHandlerDeps) {
     addItem,
     flushPendingHistoryItem,
     pendingHistoryItemRef,
-    queuedSubmissionsRef,
     setIsResponding,
     setPendingHistoryItem,
     setThought,
@@ -282,14 +275,12 @@ function useUserCancelledHandler(deps: StreamEventHandlerDeps) {
         userMessageTimestamp,
       );
       setIsResponding(false);
-      queuedSubmissionsRef.current = [];
       setThought(null);
     },
     [
       addItem,
       flushPendingHistoryItem,
       pendingHistoryItemRef,
-      queuedSubmissionsRef,
       setIsResponding,
       setPendingHistoryItem,
       setThought,
@@ -304,7 +295,7 @@ function useErrorEventHandler(deps: StreamEventHandlerDeps) {
     runtime,
     flushPendingHistoryItem,
     pendingHistoryItemRef,
-    queuedSubmissionsRef,
+    clearSubmissions,
     setPendingHistoryItem,
     setThought,
   } = deps;
@@ -334,7 +325,7 @@ function useErrorEventHandler(deps: StreamEventHandlerDeps) {
         },
         userMessageTimestamp,
       );
-      if (options?.clearQueue ?? true) queuedSubmissionsRef.current = [];
+      if (options?.clearQueue ?? true) clearSubmissions();
       setThought(null);
     },
     [
@@ -342,7 +333,7 @@ function useErrorEventHandler(deps: StreamEventHandlerDeps) {
       runtime,
       flushPendingHistoryItem,
       pendingHistoryItemRef,
-      queuedSubmissionsRef,
+      clearSubmissions,
       setPendingHistoryItem,
       setThought,
     ],

package/src/ui/hooks/agentStream/useStreamState.ts

@@ -26,7 +26,9 @@ import { type HistoryItemWithoutId, MessageType } from '../../types.js';
 import { useStateAndRef } from '../useStateAndRef.js';
 import { useLogger } from '../useLogger.js';
 import { type QueuedSubmission } from './types.js';
+import { useQueuedSubmissions } from './useQueuedSubmissions.js';
 import type { StreamRuntime } from '../../cliUiRuntime.js';
+import type { SubmissionExecutor } from './useSubmitQuery.js';
 
 export interface UseStreamStateReturn {
   initError: string | null;
@@ -49,14 +51,14 @@ export interface UseStreamStateReturn {
   lastAgentActivityTime: number;
   setLastAgentActivityTime: React.Dispatch<React.SetStateAction<number>>;
   queuedSubmissionsRef: React.MutableRefObject<QueuedSubmission[]>;
-  submitQueryRef: React.MutableRefObject<
-    | ((
-        query: unknown,
-        options?: { isContinuation: boolean },
-        prompt_id?: string,
-      ) => Promise<void>)
-    | null
-  >;
+  queuedSubmissions: readonly QueuedSubmission[];
+  enqueueSubmission: (submission: QueuedSubmission) => void;
+  requeueSubmission: (submission: QueuedSubmission) => void;
+  dequeueSubmission: () => QueuedSubmission | undefined;
+  clearSubmissions: () => void;
+  tryReserveDrain: () => boolean;
+  releaseDrain: () => void;
+  submitQueryRef: React.MutableRefObject<SubmissionExecutor | null>;
   sanitizeContent: (text: string) => {
     text: string;
     blocked: boolean;
@@ -187,10 +189,7 @@ function useFlushPendingHistoryItem(
   );
 }
 
-export function useStreamState(
-  addItem: (item: HistoryItemWithoutId, timestamp: number) => number,
-  runtime: StreamRuntime,
-): UseStreamStateReturn {
+function useBasicStreamState() {
   const [initError, setInitError] = useState<string | null>(null);
   const abortControllerRef = useRef<AbortController | null>(null);
   const abortActiveStream = useCallback((reason?: unknown) => {
@@ -205,36 +204,19 @@ export function useStreamState(
   const [pendingHistoryItem, pendingHistoryItemRef, setPendingHistoryItem] =
     useStateAndRef<HistoryItemWithoutId | null>(null);
   const [lastAgentActivityTime, setLastAgentActivityTime] = useState<number>(0);
-  const queuedSubmissionsRef = useRef<QueuedSubmission[]>([]);
-  const submitQueryRef = useRef<
-    | ((
-        query: unknown,
-        options?: { isContinuation: boolean },
-        prompt_id?: string,
-      ) => Promise<void>)
-    | null
-  >(null);
-  const storage = runtime.storage;
+  const {
+    queuedSubmissions,
+    queuedSubmissionsRef,
+    enqueueSubmission,
+    requeueSubmission,
+    dequeueSubmission,
+    clearSubmissions,
+    tryReserveDrain,
+    releaseDrain,
+  } = useQueuedSubmissions();
+  const submitQueryRef = useRef<SubmissionExecutor | null>(null);
   const thinkingBlocksRef = useRef<ThinkingBlock[]>([]);
 
-  const emojiFilter = useEmojiFilter(runtime);
-  const sanitizeContent = useSanitizeContent(emojiFilter);
-  const flushPendingHistoryItem = useFlushPendingHistoryItem(
-    addItem,
-    pendingHistoryItemRef,
-    sanitizeContent,
-    setPendingHistoryItem,
-    thinkingBlocksRef,
-  );
-  const logger = useLogger(storage);
-  const gitService = useMemo(() => {
-    const projectRoot = runtime.session.getProjectRoot();
-    if (projectRoot.length === 0) {
-      return undefined;
-    }
-    return new GitService(projectRoot, storage);
-  }, [runtime, storage]);
-
   return {
     initError,
     setInitError,
@@ -253,12 +235,49 @@ export function useStreamState(
     setPendingHistoryItem,
     lastAgentActivityTime,
     setLastAgentActivityTime,
+    queuedSubmissions,
     queuedSubmissionsRef,
+    enqueueSubmission,
+    requeueSubmission,
+    dequeueSubmission,
+    clearSubmissions,
+    tryReserveDrain,
+    releaseDrain,
     submitQueryRef,
+    thinkingBlocksRef,
+  };
+}
+
+export function useStreamState(
+  addItem: (item: HistoryItemWithoutId, timestamp: number) => number,
+  runtime: StreamRuntime,
+): UseStreamStateReturn {
+  const basic = useBasicStreamState();
+  const storage = runtime.storage;
+
+  const emojiFilter = useEmojiFilter(runtime);
+  const sanitizeContent = useSanitizeContent(emojiFilter);
+  const flushPendingHistoryItem = useFlushPendingHistoryItem(
+    addItem,
+    basic.pendingHistoryItemRef,
+    sanitizeContent,
+    basic.setPendingHistoryItem,
+    basic.thinkingBlocksRef,
+  );
+  const logger = useLogger(storage);
+  const gitService = useMemo(() => {
+    const projectRoot = runtime.session.getProjectRoot();
+    if (projectRoot.length === 0) {
+      return undefined;
+    }
+    return new GitService(projectRoot, storage);
+  }, [runtime, storage]);
+
+  return {
+    ...basic,
     sanitizeContent,
     flushPendingHistoryItem,
     logger,
     gitService,
-    thinkingBlocksRef,
   };
 }