Add files using upload-large-folder tool

projects/ui/qwen-code/packages/cli/src/ui/hooks/useHistoryManager.ts

@@ -0,0 +1,111 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useRef, useCallback } from 'react';
+import { HistoryItem } from '../types.js';
+
+// Type for the updater function passed to updateHistoryItem
+type HistoryItemUpdater = (
+  prevItem: HistoryItem,
+) => Partial<Omit<HistoryItem, 'id'>>;
+
+export interface UseHistoryManagerReturn {
+  history: HistoryItem[];
+  addItem: (itemData: Omit<HistoryItem, 'id'>, baseTimestamp: number) => number; // Returns the generated ID
+  updateItem: (
+    id: number,
+    updates: Partial<Omit<HistoryItem, 'id'>> | HistoryItemUpdater,
+  ) => void;
+  clearItems: () => void;
+  loadHistory: (newHistory: HistoryItem[]) => void;
+}
+
+/**
+ * Custom hook to manage the chat history state.
+ *
+ * Encapsulates the history array, message ID generation, adding items,
+ * updating items, and clearing the history.
+ */
+export function useHistory(): UseHistoryManagerReturn {
+  const [history, setHistory] = useState<HistoryItem[]>([]);
+  const messageIdCounterRef = useRef(0);
+
+  // Generates a unique message ID based on a timestamp and a counter.
+  const getNextMessageId = useCallback((baseTimestamp: number): number => {
+    messageIdCounterRef.current += 1;
+    return baseTimestamp + messageIdCounterRef.current;
+  }, []);
+
+  const loadHistory = useCallback((newHistory: HistoryItem[]) => {
+    setHistory(newHistory);
+  }, []);
+
+  // Adds a new item to the history state with a unique ID.
+  const addItem = useCallback(
+    (itemData: Omit<HistoryItem, 'id'>, baseTimestamp: number): number => {
+      const id = getNextMessageId(baseTimestamp);
+      const newItem: HistoryItem = { ...itemData, id } as HistoryItem;
+
+      setHistory((prevHistory) => {
+        if (prevHistory.length > 0) {
+          const lastItem = prevHistory[prevHistory.length - 1];
+          // Prevent adding duplicate consecutive user messages
+          if (
+            lastItem.type === 'user' &&
+            newItem.type === 'user' &&
+            lastItem.text === newItem.text
+          ) {
+            return prevHistory; // Don't add the duplicate
+          }
+        }
+        return [...prevHistory, newItem];
+      });
+      return id; // Return the generated ID (even if not added, to keep signature)
+    },
+    [getNextMessageId],
+  );
+
+  /**
+   * Updates an existing history item identified by its ID.
+   * @deprecated Prefer not to update history item directly as we are currently
+   * rendering all history items in <Static /> for performance reasons. Only use
+   * if ABSOLUTELY NECESSARY
+   */
+  //
+  const updateItem = useCallback(
+    (
+      id: number,
+      updates: Partial<Omit<HistoryItem, 'id'>> | HistoryItemUpdater,
+    ) => {
+      setHistory((prevHistory) =>
+        prevHistory.map((item) => {
+          if (item.id === id) {
+            // Apply updates based on whether it's an object or a function
+            const newUpdates =
+              typeof updates === 'function' ? updates(item) : updates;
+            return { ...item, ...newUpdates } as HistoryItem;
+          }
+          return item;
+        }),
+      );
+    },
+    [],
+  );
+
+  // Clears the entire history state and resets the ID counter.
+  const clearItems = useCallback(() => {
+    setHistory([]);
+    messageIdCounterRef.current = 0;
+  }, []);
+
+  return {
+    history,
+    addItem,
+    updateItem,
+    clearItems,
+    loadHistory,
+  };
+}

projects/ui/qwen-code/packages/cli/src/ui/hooks/useInputHistory.test.ts

@@ -0,0 +1,261 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { act, renderHook } from '@testing-library/react';
+import { useInputHistory } from './useInputHistory.js';
+
+describe('useInputHistory', () => {
+  const mockOnSubmit = vi.fn();
+  const mockOnChange = vi.fn();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  const userMessages = ['message 1', 'message 2', 'message 3'];
+
+  it('should initialize with historyIndex -1 and empty originalQueryBeforeNav', () => {
+    const { result } = renderHook(() =>
+      useInputHistory({
+        userMessages: [],
+        onSubmit: mockOnSubmit,
+        isActive: true,
+        currentQuery: '',
+        onChange: mockOnChange,
+      }),
+    );
+
+    // Internal state is not directly testable, but we can infer from behavior.
+    // Attempting to navigate down should do nothing if historyIndex is -1.
+    act(() => {
+      result.current.navigateDown();
+    });
+    expect(mockOnChange).not.toHaveBeenCalled();
+  });
+
+  describe('handleSubmit', () => {
+    it('should call onSubmit with trimmed value and reset history', () => {
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages,
+          onSubmit: mockOnSubmit,
+          isActive: true,
+          currentQuery: '  test query  ',
+          onChange: mockOnChange,
+        }),
+      );
+
+      act(() => {
+        result.current.handleSubmit('  submit value  ');
+      });
+
+      expect(mockOnSubmit).toHaveBeenCalledWith('submit value');
+      // Check if history is reset (e.g., by trying to navigate down)
+      act(() => {
+        result.current.navigateDown();
+      });
+      expect(mockOnChange).not.toHaveBeenCalled();
+    });
+
+    it('should not call onSubmit if value is empty after trimming', () => {
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages,
+          onSubmit: mockOnSubmit,
+          isActive: true,
+          currentQuery: '',
+          onChange: mockOnChange,
+        }),
+      );
+
+      act(() => {
+        result.current.handleSubmit('   ');
+      });
+
+      expect(mockOnSubmit).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('navigateUp', () => {
+    it('should not navigate if isActive is false', () => {
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages,
+          onSubmit: mockOnSubmit,
+          isActive: false,
+          currentQuery: 'current',
+          onChange: mockOnChange,
+        }),
+      );
+      act(() => {
+        const navigated = result.current.navigateUp();
+        expect(navigated).toBe(false);
+      });
+      expect(mockOnChange).not.toHaveBeenCalled();
+    });
+
+    it('should not navigate if userMessages is empty', () => {
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages: [],
+          onSubmit: mockOnSubmit,
+          isActive: true,
+          currentQuery: 'current',
+          onChange: mockOnChange,
+        }),
+      );
+      act(() => {
+        const navigated = result.current.navigateUp();
+        expect(navigated).toBe(false);
+      });
+      expect(mockOnChange).not.toHaveBeenCalled();
+    });
+
+    it('should call onChange with the last message when navigating up from initial state', () => {
+      const currentQuery = 'current query';
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages,
+          onSubmit: mockOnSubmit,
+          isActive: true,
+          currentQuery,
+          onChange: mockOnChange,
+        }),
+      );
+
+      act(() => {
+        result.current.navigateUp();
+      });
+
+      expect(mockOnChange).toHaveBeenCalledWith(userMessages[2]); // Last message
+    });
+
+    it('should store currentQuery as originalQueryBeforeNav on first navigateUp', () => {
+      const currentQuery = 'original user input';
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages,
+          onSubmit: mockOnSubmit,
+          isActive: true,
+          currentQuery,
+          onChange: mockOnChange,
+        }),
+      );
+
+      act(() => {
+        result.current.navigateUp(); // historyIndex becomes 0
+      });
+      expect(mockOnChange).toHaveBeenCalledWith(userMessages[2]);
+
+      // Navigate down to restore original query
+      act(() => {
+        result.current.navigateDown(); // historyIndex becomes -1
+      });
+      expect(mockOnChange).toHaveBeenCalledWith(currentQuery);
+    });
+
+    it('should navigate through history messages on subsequent navigateUp calls', () => {
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages,
+          onSubmit: mockOnSubmit,
+          isActive: true,
+          currentQuery: '',
+          onChange: mockOnChange,
+        }),
+      );
+
+      act(() => {
+        result.current.navigateUp(); // Navigates to 'message 3'
+      });
+      expect(mockOnChange).toHaveBeenCalledWith(userMessages[2]);
+
+      act(() => {
+        result.current.navigateUp(); // Navigates to 'message 2'
+      });
+      expect(mockOnChange).toHaveBeenCalledWith(userMessages[1]);
+
+      act(() => {
+        result.current.navigateUp(); // Navigates to 'message 1'
+      });
+      expect(mockOnChange).toHaveBeenCalledWith(userMessages[0]);
+    });
+  });
+
+  describe('navigateDown', () => {
+    it('should not navigate if isActive is false', () => {
+      const initialProps = {
+        userMessages,
+        onSubmit: mockOnSubmit,
+        isActive: true, // Start active to allow setup navigation
+        currentQuery: 'current',
+        onChange: mockOnChange,
+      };
+      const { result, rerender } = renderHook(
+        (props) => useInputHistory(props),
+        {
+          initialProps,
+        },
+      );
+
+      // First navigate up to have something in history
+      act(() => {
+        result.current.navigateUp();
+      });
+      mockOnChange.mockClear(); // Clear calls from setup
+
+      // Set isActive to false for the actual test
+      rerender({ ...initialProps, isActive: false });
+
+      act(() => {
+        const navigated = result.current.navigateDown();
+        expect(navigated).toBe(false);
+      });
+      expect(mockOnChange).not.toHaveBeenCalled();
+    });
+
+    it('should not navigate if historyIndex is -1 (not in history navigation)', () => {
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages,
+          onSubmit: mockOnSubmit,
+          isActive: true,
+          currentQuery: 'current',
+          onChange: mockOnChange,
+        }),
+      );
+      act(() => {
+        const navigated = result.current.navigateDown();
+        expect(navigated).toBe(false);
+      });
+      expect(mockOnChange).not.toHaveBeenCalled();
+    });
+
+    it('should restore originalQueryBeforeNav when navigating down to initial state', () => {
+      const originalQuery = 'my original input';
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages,
+          onSubmit: mockOnSubmit,
+          isActive: true,
+          currentQuery: originalQuery,
+          onChange: mockOnChange,
+        }),
+      );
+
+      act(() => {
+        result.current.navigateUp(); // Navigates to 'message 3', stores 'originalQuery'
+      });
+      expect(mockOnChange).toHaveBeenCalledWith(userMessages[2]);
+      mockOnChange.mockClear();
+
+      act(() => {
+        result.current.navigateDown(); // Navigates back to original query
+      });
+      expect(mockOnChange).toHaveBeenCalledWith(originalQuery);
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/hooks/useInputHistory.ts

@@ -0,0 +1,111 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useCallback } from 'react';
+
+interface UseInputHistoryProps {
+  userMessages: readonly string[];
+  onSubmit: (value: string) => void;
+  isActive: boolean;
+  currentQuery: string; // Renamed from query to avoid confusion
+  onChange: (value: string) => void;
+}
+
+export interface UseInputHistoryReturn {
+  handleSubmit: (value: string) => void;
+  navigateUp: () => boolean;
+  navigateDown: () => boolean;
+}
+
+export function useInputHistory({
+  userMessages,
+  onSubmit,
+  isActive,
+  currentQuery,
+  onChange,
+}: UseInputHistoryProps): UseInputHistoryReturn {
+  const [historyIndex, setHistoryIndex] = useState<number>(-1);
+  const [originalQueryBeforeNav, setOriginalQueryBeforeNav] =
+    useState<string>('');
+
+  const resetHistoryNav = useCallback(() => {
+    setHistoryIndex(-1);
+    setOriginalQueryBeforeNav('');
+  }, []);
+
+  const handleSubmit = useCallback(
+    (value: string) => {
+      const trimmedValue = value.trim();
+      if (trimmedValue) {
+        onSubmit(trimmedValue); // Parent handles clearing the query
+      }
+      resetHistoryNav();
+    },
+    [onSubmit, resetHistoryNav],
+  );
+
+  const navigateUp = useCallback(() => {
+    if (!isActive) return false;
+    if (userMessages.length === 0) return false;
+
+    let nextIndex = historyIndex;
+    if (historyIndex === -1) {
+      // Store the current query from the parent before navigating
+      setOriginalQueryBeforeNav(currentQuery);
+      nextIndex = 0;
+    } else if (historyIndex < userMessages.length - 1) {
+      nextIndex = historyIndex + 1;
+    } else {
+      return false; // Already at the oldest message
+    }
+
+    if (nextIndex !== historyIndex) {
+      setHistoryIndex(nextIndex);
+      const newValue = userMessages[userMessages.length - 1 - nextIndex];
+      onChange(newValue);
+      return true;
+    }
+    return false;
+  }, [
+    historyIndex,
+    setHistoryIndex,
+    onChange,
+    userMessages,
+    isActive,
+    currentQuery, // Use currentQuery from props
+    setOriginalQueryBeforeNav,
+  ]);
+
+  const navigateDown = useCallback(() => {
+    if (!isActive) return false;
+    if (historyIndex === -1) return false; // Not currently navigating history
+
+    const nextIndex = historyIndex - 1;
+    setHistoryIndex(nextIndex);
+
+    if (nextIndex === -1) {
+      // Reached the end of history navigation, restore original query
+      onChange(originalQueryBeforeNav);
+    } else {
+      const newValue = userMessages[userMessages.length - 1 - nextIndex];
+      onChange(newValue);
+    }
+    return true;
+  }, [
+    historyIndex,
+    setHistoryIndex,
+    originalQueryBeforeNav,
+    onChange,
+    userMessages,
+    isActive,
+  ]);
+
+  return {
+    handleSubmit,
+    navigateUp,
+    navigateDown,
+  };
+}

projects/ui/qwen-code/packages/cli/src/ui/hooks/useKeypress.test.ts

@@ -0,0 +1,280 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { renderHook, act } from '@testing-library/react';
+import { useKeypress, Key } from './useKeypress.js';
+import { KeypressProvider } from '../contexts/KeypressContext.js';
+import { useStdin } from 'ink';
+import { EventEmitter } from 'events';
+import { PassThrough } from 'stream';
+
+// Mock the 'ink' module to control stdin
+vi.mock('ink', async (importOriginal) => {
+  const original = await importOriginal<typeof import('ink')>();
+  return {
+    ...original,
+    useStdin: vi.fn(),
+  };
+});
+
+// Mock the 'readline' module
+vi.mock('readline', () => {
+  const mockedReadline = {
+    createInterface: vi.fn().mockReturnValue({ close: vi.fn() }),
+    // The paste workaround involves replacing stdin with a PassThrough stream.
+    // This mock ensures that when emitKeypressEvents is called on that
+    // stream, we simulate the 'keypress' events that the hook expects.
+    emitKeypressEvents: vi.fn((stream: EventEmitter) => {
+      if (stream instanceof PassThrough) {
+        stream.on('data', (data) => {
+          const str = data.toString();
+          for (const char of str) {
+            stream.emit('keypress', null, {
+              name: char,
+              sequence: char,
+              ctrl: false,
+              meta: false,
+              shift: false,
+            });
+          }
+        });
+      }
+    }),
+  };
+  return {
+    ...mockedReadline,
+    default: mockedReadline,
+  };
+});
+
+class MockStdin extends EventEmitter {
+  isTTY = true;
+  setRawMode = vi.fn();
+  on = this.addListener;
+  removeListener = this.removeListener;
+  write = vi.fn();
+  resume = vi.fn();
+
+  private isLegacy = false;
+
+  setLegacy(isLegacy: boolean) {
+    this.isLegacy = isLegacy;
+  }
+
+  // Helper to simulate a full paste event.
+  paste(text: string) {
+    if (this.isLegacy) {
+      const PASTE_START = '\x1B[200~';
+      const PASTE_END = '\x1B[201~';
+      this.emit('data', Buffer.from(`${PASTE_START}${text}${PASTE_END}`));
+    } else {
+      this.emit('keypress', null, { name: 'paste-start' });
+      this.emit('keypress', null, { sequence: text });
+      this.emit('keypress', null, { name: 'paste-end' });
+    }
+  }
+
+  // Helper to simulate the start of a paste, without the end.
+  startPaste(text: string) {
+    if (this.isLegacy) {
+      this.emit('data', Buffer.from('\x1B[200~' + text));
+    } else {
+      this.emit('keypress', null, { name: 'paste-start' });
+      this.emit('keypress', null, { sequence: text });
+    }
+  }
+
+  // Helper to simulate a single keypress event.
+  pressKey(key: Partial<Key>) {
+    if (this.isLegacy) {
+      this.emit('data', Buffer.from(key.sequence ?? ''));
+    } else {
+      this.emit('keypress', null, key);
+    }
+  }
+}
+
+describe('useKeypress', () => {
+  let stdin: MockStdin;
+  const mockSetRawMode = vi.fn();
+  const onKeypress = vi.fn();
+  let originalNodeVersion: string;
+
+  const wrapper = ({ children }: { children: React.ReactNode }) =>
+    React.createElement(KeypressProvider, null, children);
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    stdin = new MockStdin();
+    (useStdin as vi.Mock).mockReturnValue({
+      stdin,
+      setRawMode: mockSetRawMode,
+    });
+
+    originalNodeVersion = process.versions.node;
+    vi.unstubAllEnvs();
+  });
+
+  afterEach(() => {
+    Object.defineProperty(process.versions, 'node', {
+      value: originalNodeVersion,
+      configurable: true,
+    });
+  });
+
+  const setNodeVersion = (version: string) => {
+    Object.defineProperty(process.versions, 'node', {
+      value: version,
+      configurable: true,
+    });
+  };
+
+  it('should not listen if isActive is false', () => {
+    renderHook(() => useKeypress(onKeypress, { isActive: false }), {
+      wrapper,
+    });
+    act(() => stdin.pressKey({ name: 'a' }));
+    expect(onKeypress).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    { key: { name: 'a', sequence: 'a' } },
+    { key: { name: 'left', sequence: '\x1b[D' } },
+    { key: { name: 'right', sequence: '\x1b[C' } },
+    { key: { name: 'up', sequence: '\x1b[A' } },
+    { key: { name: 'down', sequence: '\x1b[B' } },
+  ])('should listen for keypress when active for key $key.name', ({ key }) => {
+    renderHook(() => useKeypress(onKeypress, { isActive: true }), { wrapper });
+    act(() => stdin.pressKey(key));
+    expect(onKeypress).toHaveBeenCalledWith(expect.objectContaining(key));
+  });
+
+  it('should set and release raw mode', () => {
+    const { unmount } = renderHook(
+      () => useKeypress(onKeypress, { isActive: true }),
+      { wrapper },
+    );
+    expect(mockSetRawMode).toHaveBeenCalledWith(true);
+    unmount();
+    expect(mockSetRawMode).toHaveBeenCalledWith(false);
+  });
+
+  it('should stop listening after being unmounted', () => {
+    const { unmount } = renderHook(
+      () => useKeypress(onKeypress, { isActive: true }),
+      { wrapper },
+    );
+    unmount();
+    act(() => stdin.pressKey({ name: 'a' }));
+    expect(onKeypress).not.toHaveBeenCalled();
+  });
+
+  it('should correctly identify alt+enter (meta key)', () => {
+    renderHook(() => useKeypress(onKeypress, { isActive: true }), { wrapper });
+    const key = { name: 'return', sequence: '\x1B\r' };
+    act(() => stdin.pressKey(key));
+    expect(onKeypress).toHaveBeenCalledWith(
+      expect.objectContaining({ ...key, meta: true, paste: false }),
+    );
+  });
+
+  describe.each([
+    {
+      description: 'Modern Node (>= v20)',
+      setup: () => setNodeVersion('20.0.0'),
+      isLegacy: false,
+    },
+    {
+      description: 'Legacy Node (< v20)',
+      setup: () => setNodeVersion('18.0.0'),
+      isLegacy: true,
+    },
+    {
+      description: 'Workaround Env Var',
+      setup: () => {
+        setNodeVersion('20.0.0');
+        vi.stubEnv('PASTE_WORKAROUND', 'true');
+      },
+      isLegacy: true,
+    },
+  ])('in $description', ({ setup, isLegacy }) => {
+    beforeEach(() => {
+      setup();
+      stdin.setLegacy(isLegacy);
+    });
+
+    it('should process a paste as a single event', () => {
+      renderHook(() => useKeypress(onKeypress, { isActive: true }), {
+        wrapper,
+      });
+      const pasteText = 'hello world';
+      act(() => stdin.paste(pasteText));
+
+      expect(onKeypress).toHaveBeenCalledTimes(1);
+      expect(onKeypress).toHaveBeenCalledWith({
+        name: '',
+        ctrl: false,
+        meta: false,
+        shift: false,
+        paste: true,
+        sequence: pasteText,
+      });
+    });
+
+    it('should handle keypress interspersed with pastes', () => {
+      renderHook(() => useKeypress(onKeypress, { isActive: true }), {
+        wrapper,
+      });
+
+      const keyA = { name: 'a', sequence: 'a' };
+      act(() => stdin.pressKey(keyA));
+      expect(onKeypress).toHaveBeenCalledWith(
+        expect.objectContaining({ ...keyA, paste: false }),
+      );
+
+      const pasteText = 'pasted';
+      act(() => stdin.paste(pasteText));
+      expect(onKeypress).toHaveBeenCalledWith(
+        expect.objectContaining({ paste: true, sequence: pasteText }),
+      );
+
+      const keyB = { name: 'b', sequence: 'b' };
+      act(() => stdin.pressKey(keyB));
+      expect(onKeypress).toHaveBeenCalledWith(
+        expect.objectContaining({ ...keyB, paste: false }),
+      );
+
+      expect(onKeypress).toHaveBeenCalledTimes(3);
+    });
+
+    it('should emit partial paste content if unmounted mid-paste', () => {
+      const { unmount } = renderHook(
+        () => useKeypress(onKeypress, { isActive: true }),
+        { wrapper },
+      );
+      const pasteText = 'incomplete paste';
+
+      act(() => stdin.startPaste(pasteText));
+
+      // No event should be fired yet.
+      expect(onKeypress).not.toHaveBeenCalled();
+
+      // Unmounting should trigger the flush.
+      unmount();
+
+      expect(onKeypress).toHaveBeenCalledTimes(1);
+      expect(onKeypress).toHaveBeenCalledWith({
+        name: '',
+        ctrl: false,
+        meta: false,
+        shift: false,
+        paste: true,
+        sequence: pasteText,
+      });
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/hooks/useKeypress.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useEffect } from 'react';
+import {
+  useKeypressContext,
+  KeypressHandler,
+  Key,
+} from '../contexts/KeypressContext.js';
+
+export { Key };
+
+/**
+ * A hook that listens for keypress events from stdin.
+ *
+ * @param onKeypress - The callback function to execute on each keypress.
+ * @param options - Options to control the hook's behavior.
+ * @param options.isActive - Whether the hook should be actively listening for input.
+ */
+export function useKeypress(
+  onKeypress: KeypressHandler,
+  { isActive }: { isActive: boolean },
+) {
+  const { subscribe, unsubscribe } = useKeypressContext();
+
+  useEffect(() => {
+    if (!isActive) {
+      return;
+    }
+
+    subscribe(onKeypress);
+    return () => {
+      unsubscribe(onKeypress);
+    };
+  }, [isActive, onKeypress, subscribe, unsubscribe]);
+}

projects/ui/qwen-code/packages/cli/src/ui/hooks/useKittyKeyboardProtocol.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState } from 'react';
+import {
+  isKittyProtocolEnabled,
+  isKittyProtocolSupported,
+} from '../utils/kittyProtocolDetector.js';
+
+export interface KittyProtocolStatus {
+  supported: boolean;
+  enabled: boolean;
+  checking: boolean;
+}
+
+/**
+ * Hook that returns the cached Kitty keyboard protocol status.
+ * Detection is done once at app startup to avoid repeated queries.
+ */
+export function useKittyKeyboardProtocol(): KittyProtocolStatus {
+  const [status] = useState<KittyProtocolStatus>({
+    supported: isKittyProtocolSupported(),
+    enabled: isKittyProtocolEnabled(),
+    checking: false,
+  });
+
+  return status;
+}

projects/ui/qwen-code/packages/cli/src/ui/hooks/useLoadingIndicator.test.ts

@@ -0,0 +1,139 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useLoadingIndicator } from './useLoadingIndicator.js';
+import { StreamingState } from '../types.js';
+import {
+  WITTY_LOADING_PHRASES,
+  PHRASE_CHANGE_INTERVAL_MS,
+} from './usePhraseCycler.js';
+
+describe('useLoadingIndicator', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers(); // Restore real timers after each test
+    act(() => vi.runOnlyPendingTimers);
+  });
+
+  it('should initialize with default values when Idle', () => {
+    const { result } = renderHook(() =>
+      useLoadingIndicator(StreamingState.Idle),
+    );
+    expect(result.current.elapsedTime).toBe(0);
+    expect(result.current.currentLoadingPhrase).toBe(WITTY_LOADING_PHRASES[0]);
+  });
+
+  it('should reflect values when Responding', async () => {
+    const { result } = renderHook(() =>
+      useLoadingIndicator(StreamingState.Responding),
+    );
+
+    // Initial state before timers advance
+    expect(result.current.elapsedTime).toBe(0);
+    expect(WITTY_LOADING_PHRASES).toContain(
+      result.current.currentLoadingPhrase,
+    );
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(PHRASE_CHANGE_INTERVAL_MS + 1);
+    });
+
+    // Phrase should cycle if PHRASE_CHANGE_INTERVAL_MS has passed
+    expect(WITTY_LOADING_PHRASES).toContain(
+      result.current.currentLoadingPhrase,
+    );
+  });
+
+  it('should show waiting phrase and retain elapsedTime when WaitingForConfirmation', async () => {
+    const { result, rerender } = renderHook(
+      ({ streamingState }) => useLoadingIndicator(streamingState),
+      { initialProps: { streamingState: StreamingState.Responding } },
+    );
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(60000);
+    });
+    expect(result.current.elapsedTime).toBe(60);
+
+    act(() => {
+      rerender({ streamingState: StreamingState.WaitingForConfirmation });
+    });
+
+    expect(result.current.currentLoadingPhrase).toBe(
+      'Waiting for user confirmation...',
+    );
+    expect(result.current.elapsedTime).toBe(60); // Elapsed time should be retained
+
+    // Timer should not advance further
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(2000);
+    });
+    expect(result.current.elapsedTime).toBe(60);
+  });
+
+  it('should reset elapsedTime and use a witty phrase when transitioning from WaitingForConfirmation to Responding', async () => {
+    const { result, rerender } = renderHook(
+      ({ streamingState }) => useLoadingIndicator(streamingState),
+      { initialProps: { streamingState: StreamingState.Responding } },
+    );
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(5000); // 5s
+    });
+    expect(result.current.elapsedTime).toBe(5);
+
+    act(() => {
+      rerender({ streamingState: StreamingState.WaitingForConfirmation });
+    });
+    expect(result.current.elapsedTime).toBe(5);
+    expect(result.current.currentLoadingPhrase).toBe(
+      'Waiting for user confirmation...',
+    );
+
+    act(() => {
+      rerender({ streamingState: StreamingState.Responding });
+    });
+    expect(result.current.elapsedTime).toBe(0); // Should reset
+    expect(WITTY_LOADING_PHRASES).toContain(
+      result.current.currentLoadingPhrase,
+    );
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(1000);
+    });
+    expect(result.current.elapsedTime).toBe(1);
+  });
+
+  it('should reset timer and phrase when streamingState changes from Responding to Idle', async () => {
+    const { result, rerender } = renderHook(
+      ({ streamingState }) => useLoadingIndicator(streamingState),
+      { initialProps: { streamingState: StreamingState.Responding } },
+    );
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(10000); // 10s
+    });
+    expect(result.current.elapsedTime).toBe(10);
+
+    act(() => {
+      rerender({ streamingState: StreamingState.Idle });
+    });
+
+    expect(result.current.elapsedTime).toBe(0);
+    expect(result.current.currentLoadingPhrase).toBe(WITTY_LOADING_PHRASES[0]);
+
+    // Timer should not advance
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(2000);
+    });
+    expect(result.current.elapsedTime).toBe(0);
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/hooks/useLoadingIndicator.ts

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { StreamingState } from '../types.js';
+import { useTimer } from './useTimer.js';
+import { usePhraseCycler } from './usePhraseCycler.js';
+import { useState, useEffect, useRef } from 'react'; // Added useRef
+
+export const useLoadingIndicator = (streamingState: StreamingState) => {
+  const [timerResetKey, setTimerResetKey] = useState(0);
+  const isTimerActive = streamingState === StreamingState.Responding;
+
+  const elapsedTimeFromTimer = useTimer(isTimerActive, timerResetKey);
+
+  const isPhraseCyclingActive = streamingState === StreamingState.Responding;
+  const isWaiting = streamingState === StreamingState.WaitingForConfirmation;
+  const currentLoadingPhrase = usePhraseCycler(
+    isPhraseCyclingActive,
+    isWaiting,
+  );
+
+  const [retainedElapsedTime, setRetainedElapsedTime] = useState(0);
+  const prevStreamingStateRef = useRef<StreamingState | null>(null);
+
+  useEffect(() => {
+    if (
+      prevStreamingStateRef.current === StreamingState.WaitingForConfirmation &&
+      streamingState === StreamingState.Responding
+    ) {
+      setTimerResetKey((prevKey) => prevKey + 1);
+      setRetainedElapsedTime(0); // Clear retained time when going back to responding
+    } else if (
+      streamingState === StreamingState.Idle &&
+      prevStreamingStateRef.current === StreamingState.Responding
+    ) {
+      setTimerResetKey((prevKey) => prevKey + 1); // Reset timer when becoming idle from responding
+      setRetainedElapsedTime(0);
+    } else if (streamingState === StreamingState.WaitingForConfirmation) {
+      // Capture the time when entering WaitingForConfirmation
+      // elapsedTimeFromTimer will hold the last value from when isTimerActive was true.
+      setRetainedElapsedTime(elapsedTimeFromTimer);
+    }
+
+    prevStreamingStateRef.current = streamingState;
+  }, [streamingState, elapsedTimeFromTimer]);
+
+  return {
+    elapsedTime:
+      streamingState === StreamingState.WaitingForConfirmation
+        ? retainedElapsedTime
+        : elapsedTimeFromTimer,
+    currentLoadingPhrase,
+  };
+};

projects/ui/qwen-code/packages/cli/src/ui/hooks/useLogger.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useEffect } from 'react';
+import { sessionId, Logger } from '@qwen-code/qwen-code-core';
+
+/**
+ * Hook to manage the logger instance.
+ */
+export const useLogger = () => {
+  const [logger, setLogger] = useState<Logger | null>(null);
+
+  useEffect(() => {
+    const newLogger = new Logger(sessionId);
+    /**
+     * Start async initialization, no need to await. Using await slows down the
+     * time from launch to see the gemini-cli prompt and it's better to not save
+     * messages than for the cli to hanging waiting for the logger to loading.
+     */
+    newLogger
+      .initialize()
+      .then(() => {
+        setLogger(newLogger);
+      })
+      .catch(() => {});
+  }, []);
+
+  return logger;
+};

projects/ui/qwen-code/packages/cli/src/ui/hooks/useMessageQueue.test.ts

@@ -0,0 +1,226 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useMessageQueue } from './useMessageQueue.js';
+import { StreamingState } from '../types.js';
+
+describe('useMessageQueue', () => {
+  let mockSubmitQuery: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    mockSubmitQuery = vi.fn();
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.clearAllMocks();
+  });
+
+  it('should initialize with empty queue', () => {
+    const { result } = renderHook(() =>
+      useMessageQueue({
+        streamingState: StreamingState.Idle,
+        submitQuery: mockSubmitQuery,
+      }),
+    );
+
+    expect(result.current.messageQueue).toEqual([]);
+    expect(result.current.getQueuedMessagesText()).toBe('');
+  });
+
+  it('should add messages to queue', () => {
+    const { result } = renderHook(() =>
+      useMessageQueue({
+        streamingState: StreamingState.Responding,
+        submitQuery: mockSubmitQuery,
+      }),
+    );
+
+    act(() => {
+      result.current.addMessage('Test message 1');
+      result.current.addMessage('Test message 2');
+    });
+
+    expect(result.current.messageQueue).toEqual([
+      'Test message 1',
+      'Test message 2',
+    ]);
+  });
+
+  it('should filter out empty messages', () => {
+    const { result } = renderHook(() =>
+      useMessageQueue({
+        streamingState: StreamingState.Responding,
+        submitQuery: mockSubmitQuery,
+      }),
+    );
+
+    act(() => {
+      result.current.addMessage('Valid message');
+      result.current.addMessage('   '); // Only whitespace
+      result.current.addMessage(''); // Empty
+      result.current.addMessage('Another valid message');
+    });
+
+    expect(result.current.messageQueue).toEqual([
+      'Valid message',
+      'Another valid message',
+    ]);
+  });
+
+  it('should clear queue', () => {
+    const { result } = renderHook(() =>
+      useMessageQueue({
+        streamingState: StreamingState.Responding,
+        submitQuery: mockSubmitQuery,
+      }),
+    );
+
+    act(() => {
+      result.current.addMessage('Test message');
+    });
+
+    expect(result.current.messageQueue).toEqual(['Test message']);
+
+    act(() => {
+      result.current.clearQueue();
+    });
+
+    expect(result.current.messageQueue).toEqual([]);
+  });
+
+  it('should return queued messages as text with double newlines', () => {
+    const { result } = renderHook(() =>
+      useMessageQueue({
+        streamingState: StreamingState.Responding,
+        submitQuery: mockSubmitQuery,
+      }),
+    );
+
+    act(() => {
+      result.current.addMessage('Message 1');
+      result.current.addMessage('Message 2');
+      result.current.addMessage('Message 3');
+    });
+
+    expect(result.current.getQueuedMessagesText()).toBe(
+      'Message 1\n\nMessage 2\n\nMessage 3',
+    );
+  });
+
+  it('should auto-submit queued messages when transitioning to Idle', () => {
+    const { result, rerender } = renderHook(
+      ({ streamingState }) =>
+        useMessageQueue({
+          streamingState,
+          submitQuery: mockSubmitQuery,
+        }),
+      {
+        initialProps: { streamingState: StreamingState.Responding },
+      },
+    );
+
+    // Add some messages
+    act(() => {
+      result.current.addMessage('Message 1');
+      result.current.addMessage('Message 2');
+    });
+
+    expect(result.current.messageQueue).toEqual(['Message 1', 'Message 2']);
+
+    // Transition to Idle
+    rerender({ streamingState: StreamingState.Idle });
+
+    expect(mockSubmitQuery).toHaveBeenCalledWith('Message 1\n\nMessage 2');
+    expect(result.current.messageQueue).toEqual([]);
+  });
+
+  it('should not auto-submit when queue is empty', () => {
+    const { rerender } = renderHook(
+      ({ streamingState }) =>
+        useMessageQueue({
+          streamingState,
+          submitQuery: mockSubmitQuery,
+        }),
+      {
+        initialProps: { streamingState: StreamingState.Responding },
+      },
+    );
+
+    // Transition to Idle with empty queue
+    rerender({ streamingState: StreamingState.Idle });
+
+    expect(mockSubmitQuery).not.toHaveBeenCalled();
+  });
+
+  it('should not auto-submit when not transitioning to Idle', () => {
+    const { result, rerender } = renderHook(
+      ({ streamingState }) =>
+        useMessageQueue({
+          streamingState,
+          submitQuery: mockSubmitQuery,
+        }),
+      {
+        initialProps: { streamingState: StreamingState.Responding },
+      },
+    );
+
+    // Add messages
+    act(() => {
+      result.current.addMessage('Message 1');
+    });
+
+    // Transition to WaitingForConfirmation (not Idle)
+    rerender({ streamingState: StreamingState.WaitingForConfirmation });
+
+    expect(mockSubmitQuery).not.toHaveBeenCalled();
+    expect(result.current.messageQueue).toEqual(['Message 1']);
+  });
+
+  it('should handle multiple state transitions correctly', () => {
+    const { result, rerender } = renderHook(
+      ({ streamingState }) =>
+        useMessageQueue({
+          streamingState,
+          submitQuery: mockSubmitQuery,
+        }),
+      {
+        initialProps: { streamingState: StreamingState.Idle },
+      },
+    );
+
+    // Start responding
+    rerender({ streamingState: StreamingState.Responding });
+
+    // Add messages while responding
+    act(() => {
+      result.current.addMessage('First batch');
+    });
+
+    // Go back to idle - should submit
+    rerender({ streamingState: StreamingState.Idle });
+
+    expect(mockSubmitQuery).toHaveBeenCalledWith('First batch');
+    expect(result.current.messageQueue).toEqual([]);
+
+    // Start responding again
+    rerender({ streamingState: StreamingState.Responding });
+
+    // Add more messages
+    act(() => {
+      result.current.addMessage('Second batch');
+    });
+
+    // Go back to idle - should submit again
+    rerender({ streamingState: StreamingState.Idle });
+
+    expect(mockSubmitQuery).toHaveBeenCalledWith('Second batch');
+    expect(mockSubmitQuery).toHaveBeenCalledTimes(2);
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/hooks/useMessageQueue.ts

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useCallback, useEffect, useState } from 'react';
+import { StreamingState } from '../types.js';
+
+export interface UseMessageQueueOptions {
+  streamingState: StreamingState;
+  submitQuery: (query: string) => void;
+}
+
+export interface UseMessageQueueReturn {
+  messageQueue: string[];
+  addMessage: (message: string) => void;
+  clearQueue: () => void;
+  getQueuedMessagesText: () => string;
+}
+
+/**
+ * Hook for managing message queuing during streaming responses.
+ * Allows users to queue messages while the AI is responding and automatically
+ * sends them when streaming completes.
+ */
+export function useMessageQueue({
+  streamingState,
+  submitQuery,
+}: UseMessageQueueOptions): UseMessageQueueReturn {
+  const [messageQueue, setMessageQueue] = useState<string[]>([]);
+
+  // Add a message to the queue
+  const addMessage = useCallback((message: string) => {
+    const trimmedMessage = message.trim();
+    if (trimmedMessage.length > 0) {
+      setMessageQueue((prev) => [...prev, trimmedMessage]);
+    }
+  }, []);
+
+  // Clear the entire queue
+  const clearQueue = useCallback(() => {
+    setMessageQueue([]);
+  }, []);
+
+  // Get all queued messages as a single text string
+  const getQueuedMessagesText = useCallback(() => {
+    if (messageQueue.length === 0) return '';
+    return messageQueue.join('\n\n');
+  }, [messageQueue]);
+
+  // Process queued messages when streaming becomes idle
+  useEffect(() => {
+    if (streamingState === StreamingState.Idle && messageQueue.length > 0) {
+      // Combine all messages with double newlines for clarity
+      const combinedMessage = messageQueue.join('\n\n');
+      // Clear the queue and submit
+      setMessageQueue([]);
+      submitQuery(combinedMessage);
+    }
+  }, [streamingState, messageQueue, submitQuery]);
+
+  return {
+    messageQueue,
+    addMessage,
+    clearQueue,
+    getQueuedMessagesText,
+  };
+}

projects/ui/qwen-code/packages/cli/src/ui/hooks/usePhraseCycler.test.ts

@@ -0,0 +1,145 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import {
+  usePhraseCycler,
+  WITTY_LOADING_PHRASES,
+  PHRASE_CHANGE_INTERVAL_MS,
+} from './usePhraseCycler.js';
+
+describe('usePhraseCycler', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should initialize with the first witty phrase when not active and not waiting', () => {
+    const { result } = renderHook(() => usePhraseCycler(false, false));
+    expect(result.current).toBe(WITTY_LOADING_PHRASES[0]);
+  });
+
+  it('should show "Waiting for user confirmation..." when isWaiting is true', () => {
+    const { result, rerender } = renderHook(
+      ({ isActive, isWaiting }) => usePhraseCycler(isActive, isWaiting),
+      { initialProps: { isActive: true, isWaiting: false } },
+    );
+    rerender({ isActive: true, isWaiting: true });
+    expect(result.current).toBe('Waiting for user confirmation...');
+  });
+
+  it('should not cycle phrases if isActive is false and not waiting', () => {
+    const { result } = renderHook(() => usePhraseCycler(false, false));
+    act(() => {
+      vi.advanceTimersByTime(PHRASE_CHANGE_INTERVAL_MS * 2);
+    });
+    expect(result.current).toBe(WITTY_LOADING_PHRASES[0]);
+  });
+
+  it('should cycle through witty phrases when isActive is true and not waiting', () => {
+    const { result } = renderHook(() => usePhraseCycler(true, false));
+    // Initial phrase should be one of the witty phrases
+    expect(WITTY_LOADING_PHRASES).toContain(result.current);
+    const _initialPhrase = result.current;
+
+    act(() => {
+      vi.advanceTimersByTime(PHRASE_CHANGE_INTERVAL_MS);
+    });
+    // Phrase should change and be one of the witty phrases
+    expect(WITTY_LOADING_PHRASES).toContain(result.current);
+
+    const _secondPhrase = result.current;
+    act(() => {
+      vi.advanceTimersByTime(PHRASE_CHANGE_INTERVAL_MS);
+    });
+    expect(WITTY_LOADING_PHRASES).toContain(result.current);
+  });
+
+  it('should reset to a witty phrase when isActive becomes true after being false (and not waiting)', () => {
+    // Ensure there are at least two phrases for this test to be meaningful.
+    if (WITTY_LOADING_PHRASES.length < 2) {
+      return;
+    }
+
+    // Mock Math.random to make the test deterministic.
+    let callCount = 0;
+    vi.spyOn(Math, 'random').mockImplementation(() => {
+      // Cycle through 0, 1, 0, 1, ...
+      const val = callCount % 2;
+      callCount++;
+      return val / WITTY_LOADING_PHRASES.length;
+    });
+
+    const { result, rerender } = renderHook(
+      ({ isActive, isWaiting }) => usePhraseCycler(isActive, isWaiting),
+      { initialProps: { isActive: false, isWaiting: false } },
+    );
+
+    // Activate
+    rerender({ isActive: true, isWaiting: false });
+    const firstActivePhrase = result.current;
+    expect(WITTY_LOADING_PHRASES).toContain(firstActivePhrase);
+    // With our mock, this should be the first phrase.
+    expect(firstActivePhrase).toBe(WITTY_LOADING_PHRASES[0]);
+
+    act(() => {
+      vi.advanceTimersByTime(PHRASE_CHANGE_INTERVAL_MS);
+    });
+
+    // Phrase should change to the second phrase.
+    expect(result.current).not.toBe(firstActivePhrase);
+    expect(result.current).toBe(WITTY_LOADING_PHRASES[1]);
+
+    // Set to inactive - should reset to the default initial phrase
+    rerender({ isActive: false, isWaiting: false });
+    expect(result.current).toBe(WITTY_LOADING_PHRASES[0]);
+
+    // Set back to active - should pick a random witty phrase (which our mock controls)
+    act(() => {
+      rerender({ isActive: true, isWaiting: false });
+    });
+    // The random mock will now return 0, so it should be the first phrase again.
+    expect(result.current).toBe(WITTY_LOADING_PHRASES[0]);
+  });
+
+  it('should clear phrase interval on unmount when active', () => {
+    const { unmount } = renderHook(() => usePhraseCycler(true, false));
+    const clearIntervalSpy = vi.spyOn(global, 'clearInterval');
+    unmount();
+    expect(clearIntervalSpy).toHaveBeenCalledOnce();
+  });
+
+  it('should reset to a witty phrase when transitioning from waiting to active', () => {
+    const { result, rerender } = renderHook(
+      ({ isActive, isWaiting }) => usePhraseCycler(isActive, isWaiting),
+      { initialProps: { isActive: true, isWaiting: false } },
+    );
+
+    const _initialPhrase = result.current;
+    expect(WITTY_LOADING_PHRASES).toContain(_initialPhrase);
+
+    // Cycle to a different phrase (potentially)
+    act(() => {
+      vi.advanceTimersByTime(PHRASE_CHANGE_INTERVAL_MS);
+    });
+    if (WITTY_LOADING_PHRASES.length > 1) {
+      // This check is probabilistic with random selection
+    }
+    expect(WITTY_LOADING_PHRASES).toContain(result.current);
+
+    // Go to waiting state
+    rerender({ isActive: false, isWaiting: true });
+    expect(result.current).toBe('Waiting for user confirmation...');
+
+    // Go back to active cycling - should pick a random witty phrase
+    rerender({ isActive: true, isWaiting: false });
+    expect(WITTY_LOADING_PHRASES).toContain(result.current);
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/hooks/usePhraseCycler.ts

@@ -0,0 +1,198 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useEffect, useRef } from 'react';
+
+export const WITTY_LOADING_PHRASES = [
+  "I'm Feeling Lucky",
+  'Shipping awesomeness... ',
+  'Painting the serifs back on...',
+  'Navigating the slime mold...',
+  'Consulting the digital spirits...',
+  'Reticulating splines...',
+  'Warming up the AI hamsters...',
+  'Asking the magic conch shell...',
+  'Generating witty retort...',
+  'Polishing the algorithms...',
+  "Don't rush perfection (or my code)...",
+  'Brewing fresh bytes...',
+  'Counting electrons...',
+  'Engaging cognitive processors...',
+  'Checking for syntax errors in the universe...',
+  'One moment, optimizing humor...',
+  'Shuffling punchlines...',
+  'Untangling neural nets...',
+  'Compiling brilliance...',
+  'Loading wit.exe...',
+  'Summoning the cloud of wisdom...',
+  'Preparing a witty response...',
+  "Just a sec, I'm debugging reality...",
+  'Confuzzling the options...',
+  'Tuning the cosmic frequencies...',
+  'Crafting a response worthy of your patience...',
+  'Compiling the 1s and 0s...',
+  'Resolving dependencies... and existential crises...',
+  'Defragmenting memories... both RAM and personal...',
+  'Rebooting the humor module...',
+  'Caching the essentials (mostly cat memes)...',
+  'Optimizing for ludicrous speed',
+  "Swapping bits... don't tell the bytes...",
+  'Garbage collecting... be right back...',
+  'Assembling the interwebs...',
+  'Converting coffee into code...',
+  'Updating the syntax for reality...',
+  'Rewiring the synapses...',
+  'Looking for a misplaced semicolon...',
+  "Greasin' the cogs of the machine...",
+  'Pre-heating the servers...',
+  'Calibrating the flux capacitor...',
+  'Engaging the improbability drive...',
+  'Channeling the Force...',
+  'Aligning the stars for optimal response...',
+  'So say we all...',
+  'Loading the next great idea...',
+  "Just a moment, I'm in the zone...",
+  'Preparing to dazzle you with brilliance...',
+  "Just a tick, I'm polishing my wit...",
+  "Hold tight, I'm crafting a masterpiece...",
+  "Just a jiffy, I'm debugging the universe...",
+  "Just a moment, I'm aligning the pixels...",
+  "Just a sec, I'm optimizing the humor...",
+  "Just a moment, I'm tuning the algorithms...",
+  'Warp speed engaged...',
+  'Mining for more Dilithium crystals...',
+  "Don't panic...",
+  'Following the white rabbit...',
+  'The truth is in here... somewhere...',
+  'Blowing on the cartridge...',
+  'Loading... Do a barrel roll!',
+  'Waiting for the respawn...',
+  'Finishing the Kessel Run in less than 12 parsecs...',
+  "The cake is not a lie, it's just still loading...",
+  'Fiddling with the character creation screen...',
+  "Just a moment, I'm finding the right meme...",
+  "Pressing 'A' to continue...",
+  'Herding digital cats...',
+  'Polishing the pixels...',
+  'Finding a suitable loading screen pun...',
+  'Distracting you with this witty phrase...',
+  'Almost there... probably...',
+  'Our hamsters are working as fast as they can...',
+  'Giving Cloudy a pat on the head...',
+  'Petting the cat...',
+  'Rickrolling my boss...',
+  'Never gonna give you up, never gonna let you down...',
+  'Slapping the bass...',
+  'Tasting the snozberries...',
+  "I'm going the distance, I'm going for speed...",
+  'Is this the real life? Is this just fantasy?...',
+  "I've got a good feeling about this...",
+  'Poking the bear...',
+  'Doing research on the latest memes...',
+  'Figuring out how to make this more witty...',
+  'Hmmm... let me think...',
+  'What do you call a fish with no eyes? A fsh...',
+  'Why did the computer go to therapy? It had too many bytes...',
+  "Why don't programmers like nature? It has too many bugs...",
+  'Why do programmers prefer dark mode? Because light attracts bugs...',
+  'Why did the developer go broke? Because they used up all their cache...',
+  "What can you do with a broken pencil? Nothing, it's pointless...",
+  'Applying percussive maintenance...',
+  'Searching for the correct USB orientation...',
+  'Ensuring the magic smoke stays inside the wires...',
+  'Rewriting in Rust for no particular reason...',
+  'Trying to exit Vim...',
+  'Spinning up the hamster wheel...',
+  "That's not a bug, it's an undocumented feature...",
+  'Engage.',
+  "I'll be back... with an answer.",
+  'My other process is a TARDIS...',
+  'Communing with the machine spirit...',
+  'Letting the thoughts marinate...',
+  'Just remembered where I put my keys...',
+  'Pondering the orb...',
+  "I've seen things you people wouldn't believe... like a user who reads loading messages.",
+  'Initiating thoughtful gaze...',
+  "What's a computer's favorite snack? Microchips.",
+  "Why do Java developers wear glasses? Because they don't C#.",
+  'Charging the laser... pew pew!',
+  'Dividing by zero... just kidding!',
+  'Looking for an adult superviso... I mean, processing.',
+  'Making it go beep boop.',
+  'Buffering... because even AIs need a moment.',
+  'Entangling quantum particles for a faster response...',
+  'Polishing the chrome... on the algorithms.',
+  'Are you not entertained? (Working on it!)',
+  'Summoning the code gremlins... to help, of course.',
+  'Just waiting for the dial-up tone to finish...',
+  'Recalibrating the humor-o-meter.',
+  'My other loading screen is even funnier.',
+  "Pretty sure there's a cat walking on the keyboard somewhere...",
+  'Enhancing... Enhancing... Still loading.',
+  "It's not a bug, it's a feature... of this loading screen.",
+  'Have you tried turning it off and on again? (The loading screen, not me.)',
+  'Constructing additional pylons...',
+  'New line? That’s Ctrl+J.',
+];
+
+export const PHRASE_CHANGE_INTERVAL_MS = 15000;
+
+/**
+ * Custom hook to manage cycling through loading phrases.
+ * @param isActive Whether the phrase cycling should be active.
+ * @param isWaiting Whether to show a specific waiting phrase.
+ * @returns The current loading phrase.
+ */
+export const usePhraseCycler = (isActive: boolean, isWaiting: boolean) => {
+  const [currentLoadingPhrase, setCurrentLoadingPhrase] = useState(
+    WITTY_LOADING_PHRASES[0],
+  );
+  const phraseIntervalRef = useRef<NodeJS.Timeout | null>(null);
+
+  useEffect(() => {
+    if (isWaiting) {
+      setCurrentLoadingPhrase('Waiting for user confirmation...');
+      if (phraseIntervalRef.current) {
+        clearInterval(phraseIntervalRef.current);
+        phraseIntervalRef.current = null;
+      }
+    } else if (isActive) {
+      if (phraseIntervalRef.current) {
+        clearInterval(phraseIntervalRef.current);
+      }
+      // Select an initial random phrase
+      const initialRandomIndex = Math.floor(
+        Math.random() * WITTY_LOADING_PHRASES.length,
+      );
+      setCurrentLoadingPhrase(WITTY_LOADING_PHRASES[initialRandomIndex]);
+
+      phraseIntervalRef.current = setInterval(() => {
+        // Select a new random phrase
+        const randomIndex = Math.floor(
+          Math.random() * WITTY_LOADING_PHRASES.length,
+        );
+        setCurrentLoadingPhrase(WITTY_LOADING_PHRASES[randomIndex]);
+      }, PHRASE_CHANGE_INTERVAL_MS);
+    } else {
+      // Idle or other states, clear the phrase interval
+      // and reset to the first phrase for next active state.
+      if (phraseIntervalRef.current) {
+        clearInterval(phraseIntervalRef.current);
+        phraseIntervalRef.current = null;
+      }
+      setCurrentLoadingPhrase(WITTY_LOADING_PHRASES[0]);
+    }
+
+    return () => {
+      if (phraseIntervalRef.current) {
+        clearInterval(phraseIntervalRef.current);
+        phraseIntervalRef.current = null;
+      }
+    };
+  }, [isActive, isWaiting]);
+
+  return currentLoadingPhrase;
+};

projects/ui/qwen-code/packages/cli/src/ui/hooks/usePrivacySettings.test.ts

@@ -0,0 +1,242 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { renderHook, waitFor } from '@testing-library/react';
+import {
+  Config,
+  CodeAssistServer,
+  LoggingContentGenerator,
+  UserTierId,
+  GeminiClient,
+  ContentGenerator,
+} from '@qwen-code/qwen-code-core';
+import { OAuth2Client } from 'google-auth-library';
+import { usePrivacySettings } from './usePrivacySettings.js';
+
+// Mock the dependencies
+vi.mock('@qwen-code/qwen-code-core', () => {
+  // Mock classes for instanceof checks
+  class MockCodeAssistServer {
+    projectId = 'test-project-id';
+    loadCodeAssist = vi.fn();
+    getCodeAssistGlobalUserSetting = vi.fn();
+    setCodeAssistGlobalUserSetting = vi.fn();
+
+    constructor(
+      _client?: GeminiClient,
+      _projectId?: string,
+      _httpOptions?: Record<string, unknown>,
+      _sessionId?: string,
+      _userTier?: UserTierId,
+    ) {}
+  }
+
+  class MockLoggingContentGenerator {
+    getWrapped = vi.fn();
+
+    constructor(
+      _wrapped?: ContentGenerator,
+      _config?: Record<string, unknown>,
+    ) {}
+  }
+
+  return {
+    Config: vi.fn(),
+    CodeAssistServer: MockCodeAssistServer,
+    LoggingContentGenerator: MockLoggingContentGenerator,
+    GeminiClient: vi.fn(),
+    UserTierId: {
+      FREE: 'free-tier',
+      LEGACY: 'legacy-tier',
+      STANDARD: 'standard-tier',
+    },
+  };
+});
+
+describe('usePrivacySettings', () => {
+  let mockConfig: Config;
+  let mockClient: GeminiClient;
+  let mockCodeAssistServer: CodeAssistServer;
+  let mockLoggingContentGenerator: LoggingContentGenerator;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Create mock CodeAssistServer instance
+    mockCodeAssistServer = new CodeAssistServer(
+      null as unknown as OAuth2Client,
+      'test-project-id',
+    ) as unknown as CodeAssistServer;
+    (
+      mockCodeAssistServer.loadCodeAssist as ReturnType<typeof vi.fn>
+    ).mockResolvedValue({
+      currentTier: { id: UserTierId.FREE },
+    });
+    (
+      mockCodeAssistServer.getCodeAssistGlobalUserSetting as ReturnType<
+        typeof vi.fn
+      >
+    ).mockResolvedValue({
+      freeTierDataCollectionOptin: true,
+    });
+    (
+      mockCodeAssistServer.setCodeAssistGlobalUserSetting as ReturnType<
+        typeof vi.fn
+      >
+    ).mockResolvedValue({
+      freeTierDataCollectionOptin: false,
+    });
+
+    // Create mock LoggingContentGenerator that wraps the CodeAssistServer
+    mockLoggingContentGenerator = new LoggingContentGenerator(
+      mockCodeAssistServer,
+      null as unknown as Config,
+    ) as unknown as LoggingContentGenerator;
+    (
+      mockLoggingContentGenerator.getWrapped as ReturnType<typeof vi.fn>
+    ).mockReturnValue(mockCodeAssistServer);
+
+    // Create mock GeminiClient
+    mockClient = {
+      getContentGenerator: vi.fn().mockReturnValue(mockLoggingContentGenerator),
+    } as unknown as GeminiClient;
+
+    // Create mock Config
+    mockConfig = {
+      getGeminiClient: vi.fn().mockReturnValue(mockClient),
+    } as unknown as Config;
+  });
+
+  it('should handle LoggingContentGenerator wrapper correctly and not throw "Oauth not being used" error', async () => {
+    const { result } = renderHook(() => usePrivacySettings(mockConfig));
+
+    // Initial state should be loading
+    expect(result.current.privacyState.isLoading).toBe(true);
+    expect(result.current.privacyState.error).toBeUndefined();
+
+    // Wait for the hook to complete
+    await waitFor(() => {
+      expect(result.current.privacyState.isLoading).toBe(false);
+    });
+
+    // Should not have the "Oauth not being used" error
+    expect(result.current.privacyState.error).toBeUndefined();
+    expect(result.current.privacyState.isFreeTier).toBe(true);
+    expect(result.current.privacyState.dataCollectionOptIn).toBe(true);
+
+    // Verify that getWrapped was called to unwrap the LoggingContentGenerator
+    expect(mockLoggingContentGenerator.getWrapped).toHaveBeenCalled();
+  });
+
+  it('should work with direct CodeAssistServer (no wrapper)', async () => {
+    // Test case where the content generator is directly a CodeAssistServer
+    const directServer = new CodeAssistServer(
+      null as unknown as OAuth2Client,
+      'test-project-id',
+    ) as unknown as CodeAssistServer;
+    (directServer.loadCodeAssist as ReturnType<typeof vi.fn>).mockResolvedValue(
+      {
+        currentTier: { id: UserTierId.FREE },
+      },
+    );
+    (
+      directServer.getCodeAssistGlobalUserSetting as ReturnType<typeof vi.fn>
+    ).mockResolvedValue({
+      freeTierDataCollectionOptin: true,
+    });
+
+    mockClient.getContentGenerator = vi.fn().mockReturnValue(directServer);
+
+    const { result } = renderHook(() => usePrivacySettings(mockConfig));
+
+    await waitFor(() => {
+      expect(result.current.privacyState.isLoading).toBe(false);
+    });
+
+    expect(result.current.privacyState.error).toBeUndefined();
+    expect(result.current.privacyState.isFreeTier).toBe(true);
+    expect(result.current.privacyState.dataCollectionOptIn).toBe(true);
+  });
+
+  it('should handle paid tier users correctly', async () => {
+    // Mock paid tier response
+    (
+      mockCodeAssistServer.loadCodeAssist as ReturnType<typeof vi.fn>
+    ).mockResolvedValue({
+      currentTier: { id: UserTierId.STANDARD },
+    });
+
+    const { result } = renderHook(() => usePrivacySettings(mockConfig));
+
+    await waitFor(() => {
+      expect(result.current.privacyState.isLoading).toBe(false);
+    });
+
+    expect(result.current.privacyState.error).toBeUndefined();
+    expect(result.current.privacyState.isFreeTier).toBe(false);
+    expect(result.current.privacyState.dataCollectionOptIn).toBeUndefined();
+  });
+
+  it('should throw error when content generator is not a CodeAssistServer', async () => {
+    // Mock a non-CodeAssistServer content generator
+    const mockOtherGenerator = { someOtherMethod: vi.fn() };
+    (
+      mockLoggingContentGenerator.getWrapped as ReturnType<typeof vi.fn>
+    ).mockReturnValue(mockOtherGenerator);
+
+    const { result } = renderHook(() => usePrivacySettings(mockConfig));
+
+    await waitFor(() => {
+      expect(result.current.privacyState.isLoading).toBe(false);
+    });
+
+    expect(result.current.privacyState.error).toBe('Oauth not being used');
+  });
+
+  it('should throw error when CodeAssistServer has no projectId', async () => {
+    // Mock CodeAssistServer without projectId
+    const mockServerNoProject = {
+      ...mockCodeAssistServer,
+      projectId: undefined,
+    };
+    (
+      mockLoggingContentGenerator.getWrapped as ReturnType<typeof vi.fn>
+    ).mockReturnValue(mockServerNoProject);
+
+    const { result } = renderHook(() => usePrivacySettings(mockConfig));
+
+    await waitFor(() => {
+      expect(result.current.privacyState.isLoading).toBe(false);
+    });
+
+    expect(result.current.privacyState.error).toBe('Oauth not being used');
+  });
+
+  it('should update data collection opt-in setting', async () => {
+    const { result } = renderHook(() => usePrivacySettings(mockConfig));
+
+    // Wait for initial load
+    await waitFor(() => {
+      expect(result.current.privacyState.isLoading).toBe(false);
+    });
+
+    // Update the setting
+    await result.current.updateDataCollectionOptIn(false);
+
+    // Wait for update to complete
+    await waitFor(() => {
+      expect(result.current.privacyState.dataCollectionOptIn).toBe(false);
+    });
+
+    expect(
+      mockCodeAssistServer.setCodeAssistGlobalUserSetting,
+    ).toHaveBeenCalledWith({
+      cloudaicompanionProject: 'test-project-id',
+      freeTierDataCollectionOptin: false,
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/hooks/usePrivacySettings.ts

@@ -0,0 +1,150 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useEffect, useCallback } from 'react';
+import {
+  Config,
+  CodeAssistServer,
+  UserTierId,
+  LoggingContentGenerator,
+} from '@qwen-code/qwen-code-core';
+
+export interface PrivacyState {
+  isLoading: boolean;
+  error?: string;
+  isFreeTier?: boolean;
+  dataCollectionOptIn?: boolean;
+}
+
+export const usePrivacySettings = (config: Config) => {
+  const [privacyState, setPrivacyState] = useState<PrivacyState>({
+    isLoading: true,
+  });
+
+  useEffect(() => {
+    const fetchInitialState = async () => {
+      setPrivacyState({
+        isLoading: true,
+      });
+      try {
+        const server = getCodeAssistServer(config);
+        const tier = await getTier(server);
+        if (tier !== UserTierId.FREE) {
+          // We don't need to fetch opt-out info since non-free tier
+          // data gathering is already worked out some other way.
+          setPrivacyState({
+            isLoading: false,
+            isFreeTier: false,
+          });
+          return;
+        }
+
+        const optIn = await getRemoteDataCollectionOptIn(server);
+        setPrivacyState({
+          isLoading: false,
+          isFreeTier: true,
+          dataCollectionOptIn: optIn,
+        });
+      } catch (e) {
+        setPrivacyState({
+          isLoading: false,
+          error: e instanceof Error ? e.message : String(e),
+        });
+      }
+    };
+    fetchInitialState();
+  }, [config]);
+
+  const updateDataCollectionOptIn = useCallback(
+    async (optIn: boolean) => {
+      try {
+        const server = getCodeAssistServer(config);
+        const updatedOptIn = await setRemoteDataCollectionOptIn(server, optIn);
+        setPrivacyState({
+          isLoading: false,
+          isFreeTier: true,
+          dataCollectionOptIn: updatedOptIn,
+        });
+      } catch (e) {
+        setPrivacyState({
+          isLoading: false,
+          error: e instanceof Error ? e.message : String(e),
+        });
+      }
+    },
+    [config],
+  );
+
+  return {
+    privacyState,
+    updateDataCollectionOptIn,
+  };
+};
+
+function getCodeAssistServer(config: Config): CodeAssistServer {
+  let server = config.getGeminiClient().getContentGenerator();
+
+  // Unwrap LoggingContentGenerator if present
+  if (server instanceof LoggingContentGenerator) {
+    server = server.getWrapped();
+  }
+
+  // Neither of these cases should ever happen.
+  if (!(server instanceof CodeAssistServer)) {
+    throw new Error('Oauth not being used');
+  } else if (!server.projectId) {
+    throw new Error('Oauth not being used');
+  }
+  return server;
+}
+
+async function getTier(server: CodeAssistServer): Promise<UserTierId> {
+  const loadRes = await server.loadCodeAssist({
+    cloudaicompanionProject: server.projectId,
+    metadata: {
+      ideType: 'IDE_UNSPECIFIED',
+      platform: 'PLATFORM_UNSPECIFIED',
+      pluginType: 'GEMINI',
+      duetProject: server.projectId,
+    },
+  });
+  if (!loadRes.currentTier) {
+    throw new Error('User does not have a current tier');
+  }
+  return loadRes.currentTier.id;
+}
+
+async function getRemoteDataCollectionOptIn(
+  server: CodeAssistServer,
+): Promise<boolean> {
+  try {
+    const resp = await server.getCodeAssistGlobalUserSetting();
+    return resp.freeTierDataCollectionOptin;
+  } catch (error: unknown) {
+    if (error && typeof error === 'object' && 'response' in error) {
+      const gaxiosError = error as {
+        response?: {
+          status?: unknown;
+        };
+      };
+      if (gaxiosError.response?.status === 404) {
+        return true;
+      }
+    }
+    throw error;
+  }
+}
+
+async function setRemoteDataCollectionOptIn(
+  server: CodeAssistServer,
+  optIn: boolean,
+): Promise<boolean> {
+  const resp = await server.setCodeAssistGlobalUserSetting({
+    cloudaicompanionProject: server.projectId,
+    freeTierDataCollectionOptin: optIn,
+  });
+  return resp.freeTierDataCollectionOptin;
+}

projects/ui/qwen-code/packages/cli/src/ui/hooks/useQwenAuth.test.ts

@@ -0,0 +1,437 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useQwenAuth, DeviceAuthorizationInfo } from './useQwenAuth.js';
+import {
+  AuthType,
+  qwenOAuth2Events,
+  QwenOAuth2Event,
+} from '@qwen-code/qwen-code-core';
+import { LoadedSettings } from '../../config/settings.js';
+
+// Mock the qwenOAuth2Events
+vi.mock('@qwen-code/qwen-code-core', async () => {
+  const actual = await vi.importActual('@qwen-code/qwen-code-core');
+  const mockEmitter = {
+    on: vi.fn().mockReturnThis(),
+    off: vi.fn().mockReturnThis(),
+    emit: vi.fn().mockReturnThis(),
+  };
+  return {
+    ...actual,
+    qwenOAuth2Events: mockEmitter,
+    QwenOAuth2Event: {
+      AuthUri: 'authUri',
+      AuthProgress: 'authProgress',
+    },
+  };
+});
+
+const mockQwenOAuth2Events = vi.mocked(qwenOAuth2Events);
+
+describe('useQwenAuth', () => {
+  const mockDeviceAuth: DeviceAuthorizationInfo = {
+    verification_uri: 'https://oauth.qwen.com/device',
+    verification_uri_complete: 'https://oauth.qwen.com/device?user_code=ABC123',
+    user_code: 'ABC123',
+    expires_in: 1800,
+  };
+
+  const createMockSettings = (authType: AuthType): LoadedSettings =>
+    ({
+      merged: {
+        selectedAuthType: authType,
+      },
+    }) as LoadedSettings;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should initialize with default state when not Qwen auth', () => {
+    const settings = createMockSettings(AuthType.USE_GEMINI);
+    const { result } = renderHook(() => useQwenAuth(settings, false));
+
+    expect(result.current).toEqual({
+      isQwenAuthenticating: false,
+      deviceAuth: null,
+      authStatus: 'idle',
+      authMessage: null,
+      isQwenAuth: false,
+      cancelQwenAuth: expect.any(Function),
+    });
+  });
+
+  it('should initialize with default state when Qwen auth but not authenticating', () => {
+    const settings = createMockSettings(AuthType.QWEN_OAUTH);
+    const { result } = renderHook(() => useQwenAuth(settings, false));
+
+    expect(result.current).toEqual({
+      isQwenAuthenticating: false,
+      deviceAuth: null,
+      authStatus: 'idle',
+      authMessage: null,
+      isQwenAuth: true,
+      cancelQwenAuth: expect.any(Function),
+    });
+  });
+
+  it('should set up event listeners when Qwen auth and authenticating', () => {
+    const settings = createMockSettings(AuthType.QWEN_OAUTH);
+    renderHook(() => useQwenAuth(settings, true));
+
+    expect(mockQwenOAuth2Events.on).toHaveBeenCalledWith(
+      QwenOAuth2Event.AuthUri,
+      expect.any(Function),
+    );
+    expect(mockQwenOAuth2Events.on).toHaveBeenCalledWith(
+      QwenOAuth2Event.AuthProgress,
+      expect.any(Function),
+    );
+  });
+
+  it('should handle device auth event', () => {
+    const settings = createMockSettings(AuthType.QWEN_OAUTH);
+    let handleDeviceAuth: (deviceAuth: DeviceAuthorizationInfo) => void;
+
+    mockQwenOAuth2Events.on.mockImplementation((event, handler) => {
+      if (event === QwenOAuth2Event.AuthUri) {
+        handleDeviceAuth = handler;
+      }
+      return mockQwenOAuth2Events;
+    });
+
+    const { result } = renderHook(() => useQwenAuth(settings, true));
+
+    act(() => {
+      handleDeviceAuth!(mockDeviceAuth);
+    });
+
+    expect(result.current.deviceAuth).toEqual(mockDeviceAuth);
+    expect(result.current.authStatus).toBe('polling');
+    expect(result.current.isQwenAuthenticating).toBe(true);
+  });
+
+  it('should handle auth progress event - success', () => {
+    const settings = createMockSettings(AuthType.QWEN_OAUTH);
+    let handleAuthProgress: (
+      status: 'success' | 'error' | 'polling' | 'timeout' | 'rate_limit',
+      message?: string,
+    ) => void;
+
+    mockQwenOAuth2Events.on.mockImplementation((event, handler) => {
+      if (event === QwenOAuth2Event.AuthProgress) {
+        handleAuthProgress = handler;
+      }
+      return mockQwenOAuth2Events;
+    });
+
+    const { result } = renderHook(() => useQwenAuth(settings, true));
+
+    act(() => {
+      handleAuthProgress!('success', 'Authentication successful!');
+    });
+
+    expect(result.current.authStatus).toBe('success');
+    expect(result.current.authMessage).toBe('Authentication successful!');
+  });
+
+  it('should handle auth progress event - error', () => {
+    const settings = createMockSettings(AuthType.QWEN_OAUTH);
+    let handleAuthProgress: (
+      status: 'success' | 'error' | 'polling' | 'timeout' | 'rate_limit',
+      message?: string,
+    ) => void;
+
+    mockQwenOAuth2Events.on.mockImplementation((event, handler) => {
+      if (event === QwenOAuth2Event.AuthProgress) {
+        handleAuthProgress = handler;
+      }
+      return mockQwenOAuth2Events;
+    });
+
+    const { result } = renderHook(() => useQwenAuth(settings, true));
+
+    act(() => {
+      handleAuthProgress!('error', 'Authentication failed');
+    });
+
+    expect(result.current.authStatus).toBe('error');
+    expect(result.current.authMessage).toBe('Authentication failed');
+  });
+
+  it('should handle auth progress event - polling', () => {
+    const settings = createMockSettings(AuthType.QWEN_OAUTH);
+    let handleAuthProgress: (
+      status: 'success' | 'error' | 'polling' | 'timeout' | 'rate_limit',
+      message?: string,
+    ) => void;
+
+    mockQwenOAuth2Events.on.mockImplementation((event, handler) => {
+      if (event === QwenOAuth2Event.AuthProgress) {
+        handleAuthProgress = handler;
+      }
+      return mockQwenOAuth2Events;
+    });
+
+    const { result } = renderHook(() => useQwenAuth(settings, true));
+
+    act(() => {
+      handleAuthProgress!('polling', 'Waiting for user authorization...');
+    });
+
+    expect(result.current.authStatus).toBe('polling');
+    expect(result.current.authMessage).toBe(
+      'Waiting for user authorization...',
+    );
+  });
+
+  it('should handle auth progress event - rate_limit', () => {
+    const settings = createMockSettings(AuthType.QWEN_OAUTH);
+    let handleAuthProgress: (
+      status: 'success' | 'error' | 'polling' | 'timeout' | 'rate_limit',
+      message?: string,
+    ) => void;
+
+    mockQwenOAuth2Events.on.mockImplementation((event, handler) => {
+      if (event === QwenOAuth2Event.AuthProgress) {
+        handleAuthProgress = handler;
+      }
+      return mockQwenOAuth2Events;
+    });
+
+    const { result } = renderHook(() => useQwenAuth(settings, true));
+
+    act(() => {
+      handleAuthProgress!(
+        'rate_limit',
+        'Too many requests. The server is rate limiting our requests. Please select a different authentication method or try again later.',
+      );
+    });
+
+    expect(result.current.authStatus).toBe('rate_limit');
+    expect(result.current.authMessage).toBe(
+      'Too many requests. The server is rate limiting our requests. Please select a different authentication method or try again later.',
+    );
+  });
+
+  it('should handle auth progress event without message', () => {
+    const settings = createMockSettings(AuthType.QWEN_OAUTH);
+    let handleAuthProgress: (
+      status: 'success' | 'error' | 'polling' | 'timeout' | 'rate_limit',
+      message?: string,
+    ) => void;
+
+    mockQwenOAuth2Events.on.mockImplementation((event, handler) => {
+      if (event === QwenOAuth2Event.AuthProgress) {
+        handleAuthProgress = handler;
+      }
+      return mockQwenOAuth2Events;
+    });
+
+    const { result } = renderHook(() => useQwenAuth(settings, true));
+
+    act(() => {
+      handleAuthProgress!('success');
+    });
+
+    expect(result.current.authStatus).toBe('success');
+    expect(result.current.authMessage).toBe(null);
+  });
+
+  it('should clean up event listeners when auth type changes', () => {
+    const qwenSettings = createMockSettings(AuthType.QWEN_OAUTH);
+    const { rerender } = renderHook(
+      ({ settings, isAuthenticating }) =>
+        useQwenAuth(settings, isAuthenticating),
+      { initialProps: { settings: qwenSettings, isAuthenticating: true } },
+    );
+
+    // Change to non-Qwen auth
+    const geminiSettings = createMockSettings(AuthType.USE_GEMINI);
+    rerender({ settings: geminiSettings, isAuthenticating: true });
+
+    expect(mockQwenOAuth2Events.off).toHaveBeenCalledWith(
+      QwenOAuth2Event.AuthUri,
+      expect.any(Function),
+    );
+    expect(mockQwenOAuth2Events.off).toHaveBeenCalledWith(
+      QwenOAuth2Event.AuthProgress,
+      expect.any(Function),
+    );
+  });
+
+  it('should clean up event listeners when authentication stops', () => {
+    const settings = createMockSettings(AuthType.QWEN_OAUTH);
+    const { rerender } = renderHook(
+      ({ isAuthenticating }) => useQwenAuth(settings, isAuthenticating),
+      { initialProps: { isAuthenticating: true } },
+    );
+
+    // Stop authentication
+    rerender({ isAuthenticating: false });
+
+    expect(mockQwenOAuth2Events.off).toHaveBeenCalledWith(
+      QwenOAuth2Event.AuthUri,
+      expect.any(Function),
+    );
+    expect(mockQwenOAuth2Events.off).toHaveBeenCalledWith(
+      QwenOAuth2Event.AuthProgress,
+      expect.any(Function),
+    );
+  });
+
+  it('should clean up event listeners on unmount', () => {
+    const settings = createMockSettings(AuthType.QWEN_OAUTH);
+    const { unmount } = renderHook(() => useQwenAuth(settings, true));
+
+    unmount();
+
+    expect(mockQwenOAuth2Events.off).toHaveBeenCalledWith(
+      QwenOAuth2Event.AuthUri,
+      expect.any(Function),
+    );
+    expect(mockQwenOAuth2Events.off).toHaveBeenCalledWith(
+      QwenOAuth2Event.AuthProgress,
+      expect.any(Function),
+    );
+  });
+
+  it('should reset state when switching from Qwen auth to another auth type', () => {
+    const qwenSettings = createMockSettings(AuthType.QWEN_OAUTH);
+    let handleDeviceAuth: (deviceAuth: DeviceAuthorizationInfo) => void;
+
+    mockQwenOAuth2Events.on.mockImplementation((event, handler) => {
+      if (event === QwenOAuth2Event.AuthUri) {
+        handleDeviceAuth = handler;
+      }
+      return mockQwenOAuth2Events;
+    });
+
+    const { result, rerender } = renderHook(
+      ({ settings, isAuthenticating }) =>
+        useQwenAuth(settings, isAuthenticating),
+      { initialProps: { settings: qwenSettings, isAuthenticating: true } },
+    );
+
+    // Simulate device auth
+    act(() => {
+      handleDeviceAuth!(mockDeviceAuth);
+    });
+
+    expect(result.current.deviceAuth).toEqual(mockDeviceAuth);
+    expect(result.current.authStatus).toBe('polling');
+
+    // Switch to different auth type
+    const geminiSettings = createMockSettings(AuthType.USE_GEMINI);
+    rerender({ settings: geminiSettings, isAuthenticating: true });
+
+    expect(result.current.isQwenAuthenticating).toBe(false);
+    expect(result.current.deviceAuth).toBe(null);
+    expect(result.current.authStatus).toBe('idle');
+    expect(result.current.authMessage).toBe(null);
+  });
+
+  it('should reset state when authentication stops', () => {
+    const settings = createMockSettings(AuthType.QWEN_OAUTH);
+    let handleDeviceAuth: (deviceAuth: DeviceAuthorizationInfo) => void;
+
+    mockQwenOAuth2Events.on.mockImplementation((event, handler) => {
+      if (event === QwenOAuth2Event.AuthUri) {
+        handleDeviceAuth = handler;
+      }
+      return mockQwenOAuth2Events;
+    });
+
+    const { result, rerender } = renderHook(
+      ({ isAuthenticating }) => useQwenAuth(settings, isAuthenticating),
+      { initialProps: { isAuthenticating: true } },
+    );
+
+    // Simulate device auth
+    act(() => {
+      handleDeviceAuth!(mockDeviceAuth);
+    });
+
+    expect(result.current.deviceAuth).toEqual(mockDeviceAuth);
+    expect(result.current.authStatus).toBe('polling');
+
+    // Stop authentication
+    rerender({ isAuthenticating: false });
+
+    expect(result.current.isQwenAuthenticating).toBe(false);
+    expect(result.current.deviceAuth).toBe(null);
+    expect(result.current.authStatus).toBe('idle');
+    expect(result.current.authMessage).toBe(null);
+  });
+
+  it('should handle cancelQwenAuth function', () => {
+    const settings = createMockSettings(AuthType.QWEN_OAUTH);
+    let handleDeviceAuth: (deviceAuth: DeviceAuthorizationInfo) => void;
+
+    mockQwenOAuth2Events.on.mockImplementation((event, handler) => {
+      if (event === QwenOAuth2Event.AuthUri) {
+        handleDeviceAuth = handler;
+      }
+      return mockQwenOAuth2Events;
+    });
+
+    const { result } = renderHook(() => useQwenAuth(settings, true));
+
+    // Set up some state
+    act(() => {
+      handleDeviceAuth!(mockDeviceAuth);
+    });
+
+    expect(result.current.deviceAuth).toEqual(mockDeviceAuth);
+
+    // Cancel auth
+    act(() => {
+      result.current.cancelQwenAuth();
+    });
+
+    expect(result.current.isQwenAuthenticating).toBe(false);
+    expect(result.current.deviceAuth).toBe(null);
+    expect(result.current.authStatus).toBe('idle');
+    expect(result.current.authMessage).toBe(null);
+  });
+
+  it('should maintain isQwenAuth flag correctly', () => {
+    // Test with Qwen OAuth
+    const qwenSettings = createMockSettings(AuthType.QWEN_OAUTH);
+    const { result: qwenResult } = renderHook(() =>
+      useQwenAuth(qwenSettings, false),
+    );
+    expect(qwenResult.current.isQwenAuth).toBe(true);
+
+    // Test with other auth types
+    const geminiSettings = createMockSettings(AuthType.USE_GEMINI);
+    const { result: geminiResult } = renderHook(() =>
+      useQwenAuth(geminiSettings, false),
+    );
+    expect(geminiResult.current.isQwenAuth).toBe(false);
+
+    const oauthSettings = createMockSettings(AuthType.LOGIN_WITH_GOOGLE);
+    const { result: oauthResult } = renderHook(() =>
+      useQwenAuth(oauthSettings, false),
+    );
+    expect(oauthResult.current.isQwenAuth).toBe(false);
+  });
+
+  it('should set isQwenAuthenticating to true when starting authentication with Qwen auth', () => {
+    const settings = createMockSettings(AuthType.QWEN_OAUTH);
+    const { result } = renderHook(() => useQwenAuth(settings, true));
+
+    expect(result.current.isQwenAuthenticating).toBe(true);
+    expect(result.current.authStatus).toBe('idle');
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/hooks/useQwenAuth.ts

@@ -0,0 +1,120 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useCallback, useEffect } from 'react';
+import { LoadedSettings } from '../../config/settings.js';
+import {
+  AuthType,
+  qwenOAuth2Events,
+  QwenOAuth2Event,
+} from '@qwen-code/qwen-code-core';
+
+export interface DeviceAuthorizationInfo {
+  verification_uri: string;
+  verification_uri_complete: string;
+  user_code: string;
+  expires_in: number;
+}
+
+interface QwenAuthState {
+  isQwenAuthenticating: boolean;
+  deviceAuth: DeviceAuthorizationInfo | null;
+  authStatus:
+    | 'idle'
+    | 'polling'
+    | 'success'
+    | 'error'
+    | 'timeout'
+    | 'rate_limit';
+  authMessage: string | null;
+}
+
+export const useQwenAuth = (
+  settings: LoadedSettings,
+  isAuthenticating: boolean,
+) => {
+  const [qwenAuthState, setQwenAuthState] = useState<QwenAuthState>({
+    isQwenAuthenticating: false,
+    deviceAuth: null,
+    authStatus: 'idle',
+    authMessage: null,
+  });
+
+  const isQwenAuth = settings.merged.selectedAuthType === AuthType.QWEN_OAUTH;
+
+  // Set up event listeners when authentication starts
+  useEffect(() => {
+    if (!isQwenAuth || !isAuthenticating) {
+      // Reset state when not authenticating or not Qwen auth
+      setQwenAuthState({
+        isQwenAuthenticating: false,
+        deviceAuth: null,
+        authStatus: 'idle',
+        authMessage: null,
+      });
+      return;
+    }
+
+    setQwenAuthState((prev) => ({
+      ...prev,
+      isQwenAuthenticating: true,
+      authStatus: 'idle',
+    }));
+
+    // Set up event listeners
+    const handleDeviceAuth = (deviceAuth: DeviceAuthorizationInfo) => {
+      setQwenAuthState((prev) => ({
+        ...prev,
+        deviceAuth: {
+          verification_uri: deviceAuth.verification_uri,
+          verification_uri_complete: deviceAuth.verification_uri_complete,
+          user_code: deviceAuth.user_code,
+          expires_in: deviceAuth.expires_in,
+        },
+        authStatus: 'polling',
+      }));
+    };
+
+    const handleAuthProgress = (
+      status: 'success' | 'error' | 'polling' | 'timeout' | 'rate_limit',
+      message?: string,
+    ) => {
+      setQwenAuthState((prev) => ({
+        ...prev,
+        authStatus: status,
+        authMessage: message || null,
+      }));
+    };
+
+    // Add event listeners
+    qwenOAuth2Events.on(QwenOAuth2Event.AuthUri, handleDeviceAuth);
+    qwenOAuth2Events.on(QwenOAuth2Event.AuthProgress, handleAuthProgress);
+
+    // Cleanup event listeners when component unmounts or auth finishes
+    return () => {
+      qwenOAuth2Events.off(QwenOAuth2Event.AuthUri, handleDeviceAuth);
+      qwenOAuth2Events.off(QwenOAuth2Event.AuthProgress, handleAuthProgress);
+    };
+  }, [isQwenAuth, isAuthenticating]);
+
+  const cancelQwenAuth = useCallback(() => {
+    // Emit cancel event to stop polling
+    qwenOAuth2Events.emit(QwenOAuth2Event.AuthCancel);
+
+    setQwenAuthState({
+      isQwenAuthenticating: false,
+      deviceAuth: null,
+      authStatus: 'idle',
+      authMessage: null,
+    });
+  }, []);
+
+  return {
+    ...qwenAuthState,
+    isQwenAuth,
+    cancelQwenAuth,
+  };
+};

projects/ui/qwen-code/packages/cli/src/ui/hooks/useReactToolScheduler.ts

@@ -0,0 +1,309 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  Config,
+  ToolCallRequestInfo,
+  ExecutingToolCall,
+  ScheduledToolCall,
+  ValidatingToolCall,
+  WaitingToolCall,
+  CompletedToolCall,
+  CancelledToolCall,
+  CoreToolScheduler,
+  OutputUpdateHandler,
+  AllToolCallsCompleteHandler,
+  ToolCallsUpdateHandler,
+  ToolCall,
+  Status as CoreStatus,
+  EditorType,
+} from '@qwen-code/qwen-code-core';
+import { useCallback, useState, useMemo } from 'react';
+import {
+  HistoryItemToolGroup,
+  IndividualToolCallDisplay,
+  ToolCallStatus,
+  HistoryItemWithoutId,
+} from '../types.js';
+
+export type ScheduleFn = (
+  request: ToolCallRequestInfo | ToolCallRequestInfo[],
+  signal: AbortSignal,
+) => void;
+export type MarkToolsAsSubmittedFn = (callIds: string[]) => void;
+
+export type TrackedScheduledToolCall = ScheduledToolCall & {
+  responseSubmittedToGemini?: boolean;
+};
+export type TrackedValidatingToolCall = ValidatingToolCall & {
+  responseSubmittedToGemini?: boolean;
+};
+export type TrackedWaitingToolCall = WaitingToolCall & {
+  responseSubmittedToGemini?: boolean;
+};
+export type TrackedExecutingToolCall = ExecutingToolCall & {
+  responseSubmittedToGemini?: boolean;
+};
+export type TrackedCompletedToolCall = CompletedToolCall & {
+  responseSubmittedToGemini?: boolean;
+};
+export type TrackedCancelledToolCall = CancelledToolCall & {
+  responseSubmittedToGemini?: boolean;
+};
+
+export type TrackedToolCall =
+  | TrackedScheduledToolCall
+  | TrackedValidatingToolCall
+  | TrackedWaitingToolCall
+  | TrackedExecutingToolCall
+  | TrackedCompletedToolCall
+  | TrackedCancelledToolCall;
+
+export function useReactToolScheduler(
+  onComplete: (tools: CompletedToolCall[]) => Promise<void>,
+  config: Config,
+  setPendingHistoryItem: React.Dispatch<
+    React.SetStateAction<HistoryItemWithoutId | null>
+  >,
+  getPreferredEditor: () => EditorType | undefined,
+  onEditorClose: () => void,
+): [TrackedToolCall[], ScheduleFn, MarkToolsAsSubmittedFn] {
+  const [toolCallsForDisplay, setToolCallsForDisplay] = useState<
+    TrackedToolCall[]
+  >([]);
+
+  const outputUpdateHandler: OutputUpdateHandler = useCallback(
+    (toolCallId, outputChunk) => {
+      setPendingHistoryItem((prevItem) => {
+        if (prevItem?.type === 'tool_group') {
+          return {
+            ...prevItem,
+            tools: prevItem.tools.map((toolDisplay) =>
+              toolDisplay.callId === toolCallId &&
+              toolDisplay.status === ToolCallStatus.Executing
+                ? { ...toolDisplay, resultDisplay: outputChunk }
+                : toolDisplay,
+            ),
+          };
+        }
+        return prevItem;
+      });
+
+      setToolCallsForDisplay((prevCalls) =>
+        prevCalls.map((tc) => {
+          if (tc.request.callId === toolCallId && tc.status === 'executing') {
+            const executingTc = tc as TrackedExecutingToolCall;
+            return { ...executingTc, liveOutput: outputChunk };
+          }
+          return tc;
+        }),
+      );
+    },
+    [setPendingHistoryItem],
+  );
+
+  const allToolCallsCompleteHandler: AllToolCallsCompleteHandler = useCallback(
+    async (completedToolCalls) => {
+      await onComplete(completedToolCalls);
+    },
+    [onComplete],
+  );
+
+  const toolCallsUpdateHandler: ToolCallsUpdateHandler = useCallback(
+    (updatedCoreToolCalls: ToolCall[]) => {
+      setToolCallsForDisplay((prevTrackedCalls) =>
+        updatedCoreToolCalls.map((coreTc) => {
+          const existingTrackedCall = prevTrackedCalls.find(
+            (ptc) => ptc.request.callId === coreTc.request.callId,
+          );
+          const newTrackedCall: TrackedToolCall = {
+            ...coreTc,
+            responseSubmittedToGemini:
+              existingTrackedCall?.responseSubmittedToGemini ?? false,
+          } as TrackedToolCall;
+          return newTrackedCall;
+        }),
+      );
+    },
+    [setToolCallsForDisplay],
+  );
+
+  const scheduler = useMemo(
+    () =>
+      new CoreToolScheduler({
+        toolRegistry: config.getToolRegistry(),
+        outputUpdateHandler,
+        onAllToolCallsComplete: allToolCallsCompleteHandler,
+        onToolCallsUpdate: toolCallsUpdateHandler,
+        getPreferredEditor,
+        config,
+        onEditorClose,
+      }),
+    [
+      config,
+      outputUpdateHandler,
+      allToolCallsCompleteHandler,
+      toolCallsUpdateHandler,
+      getPreferredEditor,
+      onEditorClose,
+    ],
+  );
+
+  const schedule: ScheduleFn = useCallback(
+    (
+      request: ToolCallRequestInfo | ToolCallRequestInfo[],
+      signal: AbortSignal,
+    ) => {
+      void scheduler.schedule(request, signal);
+    },
+    [scheduler],
+  );
+
+  const markToolsAsSubmitted: MarkToolsAsSubmittedFn = useCallback(
+    (callIdsToMark: string[]) => {
+      setToolCallsForDisplay((prevCalls) =>
+        prevCalls.map((tc) =>
+          callIdsToMark.includes(tc.request.callId)
+            ? { ...tc, responseSubmittedToGemini: true }
+            : tc,
+        ),
+      );
+    },
+    [],
+  );
+
+  return [toolCallsForDisplay, schedule, markToolsAsSubmitted];
+}
+
+/**
+ * Maps a CoreToolScheduler status to the UI's ToolCallStatus enum.
+ */
+function mapCoreStatusToDisplayStatus(coreStatus: CoreStatus): ToolCallStatus {
+  switch (coreStatus) {
+    case 'validating':
+      return ToolCallStatus.Executing;
+    case 'awaiting_approval':
+      return ToolCallStatus.Confirming;
+    case 'executing':
+      return ToolCallStatus.Executing;
+    case 'success':
+      return ToolCallStatus.Success;
+    case 'cancelled':
+      return ToolCallStatus.Canceled;
+    case 'error':
+      return ToolCallStatus.Error;
+    case 'scheduled':
+      return ToolCallStatus.Pending;
+    default: {
+      const exhaustiveCheck: never = coreStatus;
+      console.warn(`Unknown core status encountered: ${exhaustiveCheck}`);
+      return ToolCallStatus.Error;
+    }
+  }
+}
+
+/**
+ * Transforms `TrackedToolCall` objects into `HistoryItemToolGroup` objects for UI display.
+ */
+export function mapToDisplay(
+  toolOrTools: TrackedToolCall[] | TrackedToolCall,
+): HistoryItemToolGroup {
+  const toolCalls = Array.isArray(toolOrTools) ? toolOrTools : [toolOrTools];
+
+  const toolDisplays = toolCalls.map(
+    (trackedCall): IndividualToolCallDisplay => {
+      let displayName: string;
+      let description: string;
+      let renderOutputAsMarkdown = false;
+
+      if (trackedCall.status === 'error') {
+        displayName =
+          trackedCall.tool === undefined
+            ? trackedCall.request.name
+            : trackedCall.tool.displayName;
+        description = JSON.stringify(trackedCall.request.args);
+      } else {
+        displayName = trackedCall.tool.displayName;
+        description = trackedCall.invocation.getDescription();
+        renderOutputAsMarkdown = trackedCall.tool.isOutputMarkdown;
+      }
+
+      const baseDisplayProperties: Omit<
+        IndividualToolCallDisplay,
+        'status' | 'resultDisplay' | 'confirmationDetails'
+      > = {
+        callId: trackedCall.request.callId,
+        name: displayName,
+        description,
+        renderOutputAsMarkdown,
+      };
+
+      switch (trackedCall.status) {
+        case 'success':
+          return {
+            ...baseDisplayProperties,
+            status: mapCoreStatusToDisplayStatus(trackedCall.status),
+            resultDisplay: trackedCall.response.resultDisplay,
+            confirmationDetails: undefined,
+          };
+        case 'error':
+          return {
+            ...baseDisplayProperties,
+            status: mapCoreStatusToDisplayStatus(trackedCall.status),
+            resultDisplay: trackedCall.response.resultDisplay,
+            confirmationDetails: undefined,
+          };
+        case 'cancelled':
+          return {
+            ...baseDisplayProperties,
+            status: mapCoreStatusToDisplayStatus(trackedCall.status),
+            resultDisplay: trackedCall.response.resultDisplay,
+            confirmationDetails: undefined,
+          };
+        case 'awaiting_approval':
+          return {
+            ...baseDisplayProperties,
+            status: mapCoreStatusToDisplayStatus(trackedCall.status),
+            resultDisplay: undefined,
+            confirmationDetails: trackedCall.confirmationDetails,
+          };
+        case 'executing':
+          return {
+            ...baseDisplayProperties,
+            status: mapCoreStatusToDisplayStatus(trackedCall.status),
+            resultDisplay:
+              (trackedCall as TrackedExecutingToolCall).liveOutput ?? undefined,
+            confirmationDetails: undefined,
+          };
+        case 'validating': // Fallthrough
+        case 'scheduled':
+          return {
+            ...baseDisplayProperties,
+            status: mapCoreStatusToDisplayStatus(trackedCall.status),
+            resultDisplay: undefined,
+            confirmationDetails: undefined,
+          };
+        default: {
+          const exhaustiveCheck: never = trackedCall;
+          return {
+            callId: (exhaustiveCheck as TrackedToolCall).request.callId,
+            name: 'Unknown Tool',
+            description: 'Encountered an unknown tool call state.',
+            status: ToolCallStatus.Error,
+            resultDisplay: 'Unknown tool call state',
+            confirmationDetails: undefined,
+            renderOutputAsMarkdown: false,
+          };
+        }
+      }
+    },
+  );
+
+  return {
+    type: 'tool_group',
+    tools: toolDisplays,
+  };
+}

projects/ui/qwen-code/packages/cli/src/ui/hooks/useRefreshMemoryCommand.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export const REFRESH_MEMORY_COMMAND_NAME = '/refreshmemory';

projects/ui/qwen-code/packages/cli/src/ui/hooks/useReverseSearchCompletion.test.tsx

@@ -0,0 +1,260 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/** @vitest-environment jsdom */
+
+import { describe, it, expect } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useReverseSearchCompletion } from './useReverseSearchCompletion.js';
+import { useTextBuffer } from '../components/shared/text-buffer.js';
+
+describe('useReverseSearchCompletion', () => {
+  function useTextBufferForTest(text: string) {
+    return useTextBuffer({
+      initialText: text,
+      initialCursorOffset: text.length,
+      viewport: { width: 80, height: 20 },
+      isValidPath: () => false,
+      onChange: () => {},
+    });
+  }
+
+  describe('Core Hook Behavior', () => {
+    describe('State Management', () => {
+      it('should initialize with default state', () => {
+        const mockShellHistory = ['echo hello'];
+
+        const { result } = renderHook(() =>
+          useReverseSearchCompletion(
+            useTextBufferForTest(''),
+            mockShellHistory,
+            false,
+          ),
+        );
+
+        expect(result.current.suggestions).toEqual([]);
+        expect(result.current.activeSuggestionIndex).toBe(-1);
+        expect(result.current.visibleStartIndex).toBe(0);
+        expect(result.current.showSuggestions).toBe(false);
+        expect(result.current.isLoadingSuggestions).toBe(false);
+      });
+
+      it('should reset state when reverseSearchActive becomes false', () => {
+        const mockShellHistory = ['echo hello'];
+        const { result, rerender } = renderHook(
+          ({ text, active }) => {
+            const textBuffer = useTextBufferForTest(text);
+            return useReverseSearchCompletion(
+              textBuffer,
+              mockShellHistory,
+              active,
+            );
+          },
+          { initialProps: { text: 'echo', active: true } },
+        );
+
+        // Simulate reverseSearchActive becoming false
+        rerender({ text: 'echo', active: false });
+
+        expect(result.current.suggestions).toEqual([]);
+        expect(result.current.activeSuggestionIndex).toBe(-1);
+        expect(result.current.visibleStartIndex).toBe(0);
+        expect(result.current.showSuggestions).toBe(false);
+      });
+
+      describe('Navigation', () => {
+        it('should handle navigateUp with no suggestions', () => {
+          const mockShellHistory = ['echo hello'];
+
+          const { result } = renderHook(() =>
+            useReverseSearchCompletion(
+              useTextBufferForTest('grep'),
+              mockShellHistory,
+              true,
+            ),
+          );
+
+          act(() => {
+            result.current.navigateUp();
+          });
+
+          expect(result.current.activeSuggestionIndex).toBe(-1);
+        });
+
+        it('should handle navigateDown with no suggestions', () => {
+          const mockShellHistory = ['echo hello'];
+          const { result } = renderHook(() =>
+            useReverseSearchCompletion(
+              useTextBufferForTest('grep'),
+              mockShellHistory,
+              true,
+            ),
+          );
+
+          act(() => {
+            result.current.navigateDown();
+          });
+
+          expect(result.current.activeSuggestionIndex).toBe(-1);
+        });
+
+        it('should navigate up through suggestions with wrap-around', () => {
+          const mockShellHistory = [
+            'ls -l',
+            'ls -la',
+            'cd /some/path',
+            'git status',
+            'echo "Hello, World!"',
+            'echo Hi',
+          ];
+
+          const { result } = renderHook(() =>
+            useReverseSearchCompletion(
+              useTextBufferForTest('echo'),
+              mockShellHistory,
+              true,
+            ),
+          );
+
+          expect(result.current.suggestions.length).toBe(2);
+          expect(result.current.activeSuggestionIndex).toBe(0);
+
+          act(() => {
+            result.current.navigateUp();
+          });
+
+          expect(result.current.activeSuggestionIndex).toBe(1);
+        });
+
+        it('should navigate down through suggestions with wrap-around', () => {
+          const mockShellHistory = [
+            'ls -l',
+            'ls -la',
+            'cd /some/path',
+            'git status',
+            'echo "Hello, World!"',
+            'echo Hi',
+          ];
+          const { result } = renderHook(() =>
+            useReverseSearchCompletion(
+              useTextBufferForTest('ls'),
+              mockShellHistory,
+              true,
+            ),
+          );
+
+          expect(result.current.suggestions.length).toBe(2);
+          expect(result.current.activeSuggestionIndex).toBe(0);
+
+          act(() => {
+            result.current.navigateDown();
+          });
+
+          expect(result.current.activeSuggestionIndex).toBe(1);
+        });
+
+        it('should handle navigation with multiple suggestions', () => {
+          const mockShellHistory = [
+            'ls -l',
+            'ls -la',
+            'cd /some/path/l',
+            'git status',
+            'echo "Hello, World!"',
+            'echo "Hi all"',
+          ];
+
+          const { result } = renderHook(() =>
+            useReverseSearchCompletion(
+              useTextBufferForTest('l'),
+              mockShellHistory,
+              true,
+            ),
+          );
+
+          expect(result.current.suggestions.length).toBe(5);
+          expect(result.current.activeSuggestionIndex).toBe(0);
+
+          act(() => {
+            result.current.navigateDown();
+          });
+          expect(result.current.activeSuggestionIndex).toBe(1);
+
+          act(() => {
+            result.current.navigateDown();
+          });
+          expect(result.current.activeSuggestionIndex).toBe(2);
+
+          act(() => {
+            result.current.navigateUp();
+          });
+          expect(result.current.activeSuggestionIndex).toBe(1);
+
+          act(() => {
+            result.current.navigateUp();
+          });
+          expect(result.current.activeSuggestionIndex).toBe(0);
+
+          act(() => {
+            result.current.navigateUp();
+          });
+          expect(result.current.activeSuggestionIndex).toBe(4);
+        });
+
+        it('should handle navigation with large suggestion lists and scrolling', () => {
+          const largeMockCommands = Array.from(
+            { length: 15 },
+            (_, i) => `echo ${i}`,
+          );
+
+          const { result } = renderHook(() =>
+            useReverseSearchCompletion(
+              useTextBufferForTest('echo'),
+              largeMockCommands,
+              true,
+            ),
+          );
+
+          expect(result.current.suggestions.length).toBe(15);
+          expect(result.current.activeSuggestionIndex).toBe(0);
+          expect(result.current.visibleStartIndex).toBe(0);
+
+          act(() => {
+            result.current.navigateUp();
+          });
+
+          expect(result.current.activeSuggestionIndex).toBe(14);
+          expect(result.current.visibleStartIndex).toBe(Math.max(0, 15 - 8));
+        });
+      });
+    });
+  });
+
+  describe('Filtering', () => {
+    it('filters history by buffer.text and sets showSuggestions', () => {
+      const history = ['foo', 'barfoo', 'baz'];
+      const { result } = renderHook(() =>
+        useReverseSearchCompletion(useTextBufferForTest('foo'), history, true),
+      );
+
+      // should only return the two entries containing "foo"
+      expect(result.current.suggestions.map((s) => s.value)).toEqual([
+        'foo',
+        'barfoo',
+      ]);
+      expect(result.current.showSuggestions).toBe(true);
+    });
+
+    it('hides suggestions when there are no matches', () => {
+      const history = ['alpha', 'beta'];
+      const { result } = renderHook(() =>
+        useReverseSearchCompletion(useTextBufferForTest('γ'), history, true),
+      );
+
+      expect(result.current.suggestions).toEqual([]);
+      expect(result.current.showSuggestions).toBe(false);
+    });
+  });
+});