@vybestack/llxprt-ui 0.7.0-nightly.251211.5750c518a

package/src/hooks/useSessionManager.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useSessionManager } from './useSessionManager';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+describe('useSessionManager', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nui-session-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('initial state', () => {
+    it('should start with null session and idle status', () => {
+      const { result } = renderHook(() => useSessionManager());
+
+      expect(result.current.session).toBeNull();
+      expect(result.current.status).toBe('idle');
+      expect(result.current.error).toBeNull();
+    });
+
+    it('should return false for hasSession initially', () => {
+      const { result } = renderHook(() => useSessionManager());
+
+      expect(result.current.hasSession).toBe(false);
+    });
+  });
+
+  describe('destroySession', () => {
+    it('should reset state to idle', () => {
+      const { result } = renderHook(() => useSessionManager());
+
+      act(() => {
+        result.current.destroySession();
+      });
+
+      expect(result.current.session).toBeNull();
+      expect(result.current.status).toBe('idle');
+      expect(result.current.error).toBeNull();
+    });
+  });
+
+  describe('createSession', () => {
+    it('should set status to initializing when called', () => {
+      const { result } = renderHook(() => useSessionManager());
+
+      // Start the async operation but don't await it yet
+      act(() => {
+        void result.current.createSession({
+          model: 'gemini-2.5-flash',
+          workingDir: tempDir,
+        });
+      });
+
+      // During initialization, status should be initializing
+      expect(result.current.status).toBe('initializing');
+    });
+
+    // Session creation can be slow on Windows CI
+    it(
+      'should complete session creation with result',
+      { timeout: 15000 },
+      async () => {
+        const { result } = renderHook(() => useSessionManager());
+
+        await act(async () => {
+          await result.current.createSession({
+            model: 'gemini-2.5-flash',
+            workingDir: tempDir,
+          });
+        });
+
+        // After completion, status should be either ready or error (not initializing)
+        expect(result.current.status).not.toBe('initializing');
+        expect(['ready', 'error']).toContain(result.current.status);
+      },
+    );
+  });
+});

package/src/hooks/useSessionManager.ts

@@ -0,0 +1,101 @@
+import { useCallback, useState, useRef, useEffect } from 'react';
+import type {
+  ConfigSession,
+  ConfigSessionOptions,
+} from '../features/config/configSession';
+import { createConfigSession } from '../features/config/configSession';
+import { getLogger } from '../lib/logger';
+
+export type SessionStatus = 'idle' | 'initializing' | 'ready' | 'error';
+
+export interface UseSessionManagerReturn {
+  session: ConfigSession | null;
+  sessionOptions: ConfigSessionOptions | null;
+  status: SessionStatus;
+  error: string | null;
+  hasSession: boolean;
+  createSession: (options: ConfigSessionOptions) => Promise<void>;
+  destroySession: () => void;
+}
+
+const logger = getLogger('nui:session-manager');
+
+export function useSessionManager(): UseSessionManagerReturn {
+  const [session, setSession] = useState<ConfigSession | null>(null);
+  const [sessionOptions, setSessionOptions] =
+    useState<ConfigSessionOptions | null>(null);
+  const [status, setStatus] = useState<SessionStatus>('idle');
+  const [error, setError] = useState<string | null>(null);
+  const sessionRef = useRef<ConfigSession | null>(null);
+
+  const destroySession = useCallback(() => {
+    if (sessionRef.current) {
+      logger.debug('Disposing existing session');
+      sessionRef.current.dispose();
+      sessionRef.current = null;
+    }
+    setSession(null);
+    setSessionOptions(null);
+    setStatus('idle');
+    setError(null);
+  }, []);
+
+  const createSession = useCallback(
+    async (options: ConfigSessionOptions): Promise<void> => {
+      logger.debug('Creating new session', {
+        model: options.model,
+        provider: options.provider,
+      });
+
+      // Dispose existing session first
+      if (sessionRef.current) {
+        sessionRef.current.dispose();
+        sessionRef.current = null;
+      }
+
+      setStatus('initializing');
+      setError(null);
+      setSession(null);
+
+      try {
+        const newSession = createConfigSession(options);
+        await newSession.initialize();
+
+        sessionRef.current = newSession;
+        setSession(newSession);
+        setSessionOptions(options);
+        setStatus('ready');
+
+        const registry = newSession.config.getToolRegistry();
+        const tools = registry.getFunctionDeclarations();
+        logger.debug('Session ready', { toolCount: tools.length });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger.error('Session initialization failed', { error: message });
+        setError(message);
+        setStatus('error');
+        setSession(null);
+      }
+    },
+    [],
+  );
+
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      if (sessionRef.current) {
+        sessionRef.current.dispose();
+      }
+    };
+  }, []);
+
+  return {
+    session,
+    sessionOptions,
+    status,
+    error,
+    hasSession: session !== null && status === 'ready',
+    createSession,
+    destroySession,
+  };
+}

package/src/hooks/useStreamingLifecycle.ts

@@ -0,0 +1,71 @@
+import type { Dispatch, RefObject, SetStateAction } from 'react';
+import { useCallback, useRef } from 'react';
+import type { ConfigSession } from '../features/config/configSession';
+import type { ToolConfirmationEvent } from '../features/config';
+import type { ToolCall } from './useChatStore';
+import { useStreamingResponder } from './useStreamingResponder';
+import type { ScheduleFn } from './useToolScheduler';
+
+interface UseStreamingLifecycleResult {
+  streamRunId: RefObject<number>;
+  mountedRef: RefObject<boolean>;
+  abortRef: RefObject<AbortController | null>;
+  cancelStreaming: () => void;
+  startStreamingResponder: (
+    prompt: string,
+    session: ConfigSession | null,
+  ) => Promise<void>;
+}
+
+export function useStreamingLifecycle(
+  appendMessage: (
+    role: 'user' | 'model' | 'thinking' | 'system',
+    text: string,
+  ) => string,
+  appendToMessage: (id: string, text: string) => void,
+  appendToolCall: (
+    callId: string,
+    name: string,
+    params: Record<string, unknown>,
+  ) => string,
+  updateToolCall: (
+    callId: string,
+    update: Partial<Omit<ToolCall, 'id' | 'kind' | 'callId'>>,
+  ) => void,
+  setResponderWordCount: Dispatch<SetStateAction<number>>,
+  setStreamState: Dispatch<SetStateAction<'idle' | 'busy'>>,
+  scheduleTools: ScheduleFn,
+  onConfirmationNeeded?: (event: ToolConfirmationEvent) => void,
+): UseStreamingLifecycleResult {
+  const streamRunId = useRef(0);
+  const mountedRef = useRef(true);
+  const abortRef = useRef<AbortController | null>(null);
+
+  const startStreamingResponder = useStreamingResponder(
+    appendMessage,
+    appendToMessage,
+    appendToolCall,
+    updateToolCall,
+    setResponderWordCount,
+    setStreamState,
+    streamRunId,
+    mountedRef,
+    abortRef,
+    scheduleTools,
+    onConfirmationNeeded,
+  );
+
+  const cancelStreaming = useCallback(() => {
+    streamRunId.current += 1;
+    abortRef.current?.abort();
+    setStreamState('idle');
+  }, [setStreamState]);
+
+  return {
+    streamRunId,
+    mountedRef,
+    abortRef,
+    cancelStreaming,
+    startStreamingResponder,
+  };
+}

package/src/hooks/useStreamingResponder.ts

@@ -0,0 +1,401 @@
+import type { Dispatch, SetStateAction } from 'react';
+import { useCallback } from 'react';
+import type { Role, StreamState, ToolCall } from './useChatStore';
+import type { ConfigSession } from '../features/config/configSession';
+import type { AdapterEvent, ToolConfirmationEvent } from '../features/config';
+import { sendMessageWithSession } from '../features/config';
+import type {
+  ToolCallRequestInfo,
+  CompletedToolCall,
+} from '@vybestack/llxprt-code-core';
+import type { ScheduleFn } from './useToolScheduler';
+import { getLogger } from '../lib/logger';
+
+const logger = getLogger('nui:streaming-responder');
+
+type StateSetter<T> = Dispatch<SetStateAction<T>>;
+
+interface RefHandle<T> {
+  current: T;
+}
+
+interface StreamContext {
+  modelMessageId: string | null;
+  thinkingMessageId: string | null;
+  /** Track tool calls by their backend callId */
+  toolCalls: Map<string, string>;
+}
+
+function countWords(text: string): number {
+  const matches = text.trim().match(/\S+/g);
+  return matches ? matches.length : 0;
+}
+
+type ToolCallUpdate = Partial<Omit<ToolCall, 'id' | 'kind' | 'callId'>>;
+
+function handleAdapterEvent(
+  event: AdapterEvent,
+  context: StreamContext,
+  appendMessage: (role: Role, text: string) => string,
+  appendToMessage: (id: string, text: string) => void,
+  appendToolCall: (
+    callId: string,
+    name: string,
+    params: Record<string, unknown>,
+  ) => string,
+  updateToolCall: (callId: string, update: ToolCallUpdate) => void,
+  setResponderWordCount: StateSetter<number>,
+  scheduleTools: ScheduleFn,
+  signal: AbortSignal,
+  onConfirmationNeeded?: (event: ToolConfirmationEvent) => void,
+): StreamContext {
+  if (event.type === 'text_delta') {
+    const text = event.text;
+    // Skip empty or whitespace-only text when starting a new message
+    if (context.modelMessageId === null) {
+      if (text.trim() === '') {
+        return context;
+      }
+      const id = appendMessage('model', text);
+      setResponderWordCount((count) => count + countWords(text));
+      return { ...context, modelMessageId: id };
+    }
+    appendToMessage(context.modelMessageId, text);
+    setResponderWordCount((count) => count + countWords(text));
+    return context;
+  }
+  if (event.type === 'thinking_delta') {
+    const text = event.text;
+    // Skip empty or whitespace-only text when starting a new message
+    if (context.thinkingMessageId === null) {
+      if (text.trim() === '') {
+        return context;
+      }
+      const id = appendMessage('thinking', text);
+      setResponderWordCount((count) => count + countWords(text));
+      return { ...context, thinkingMessageId: id };
+    }
+    appendToMessage(context.thinkingMessageId, text);
+    setResponderWordCount((count) => count + countWords(text));
+    return context;
+  }
+  if (event.type === 'tool_pending') {
+    // Create a new ToolCall entry in UI
+    const entryId = appendToolCall(event.id, event.name, event.params);
+    const newToolCalls = new Map(context.toolCalls);
+    newToolCalls.set(event.id, entryId);
+
+    // Schedule the tool call via the scheduler (handles confirmation flow)
+    const request: ToolCallRequestInfo = {
+      callId: event.id,
+      name: event.name,
+      args: event.params,
+      isClientInitiated: false,
+      prompt_id: `nui-${Date.now()}`,
+    };
+    scheduleTools(request, signal);
+
+    // Reset message IDs since model output may continue after tool
+    return {
+      modelMessageId: null,
+      thinkingMessageId: null,
+      toolCalls: newToolCalls,
+    };
+  }
+  if (event.type === 'tool_result') {
+    // Update existing tool call with result
+    updateToolCall(event.id, {
+      status: event.success ? 'complete' : 'error',
+      output: event.output,
+      errorMessage: event.errorMessage,
+    });
+    return context;
+  }
+  if (event.type === 'tool_confirmation') {
+    // Update tool call with confirmation details
+    updateToolCall(event.id, {
+      status: 'confirming',
+      confirmation: {
+        confirmationType: event.confirmationType,
+        question: event.question,
+        preview: event.preview,
+        canAllowAlways: event.canAllowAlways,
+      },
+    });
+    // Notify UI that confirmation is needed
+    if (onConfirmationNeeded) {
+      onConfirmationNeeded(event);
+    }
+    return context;
+  }
+  if (event.type === 'tool_cancelled') {
+    updateToolCall(event.id, { status: 'cancelled' });
+    return context;
+  }
+  if (event.type === 'error') {
+    appendMessage('system', `Error: ${event.message}`);
+    return context;
+  }
+  // Handle complete and unknown events - no action needed
+  return context;
+}
+
+export type UseStreamingResponderFunction = (
+  prompt: string,
+  session: ConfigSession | null,
+) => Promise<void>;
+
+/**
+ * Callback to handle completed tools - sends responses back to the model
+ */
+export type OnToolsCompleteCallback = (
+  session: ConfigSession,
+  completedTools: CompletedToolCall[],
+  signal: AbortSignal,
+) => Promise<void>;
+
+export function useStreamingResponder(
+  appendMessage: (role: Role, text: string) => string,
+  appendToMessage: (id: string, text: string) => void,
+  appendToolCall: (
+    callId: string,
+    name: string,
+    params: Record<string, unknown>,
+  ) => string,
+  updateToolCall: (
+    callId: string,
+    update: Partial<Omit<ToolCall, 'id' | 'kind' | 'callId'>>,
+  ) => void,
+  setResponderWordCount: StateSetter<number>,
+  setStreamState: StateSetter<StreamState>,
+  streamRunId: RefHandle<number>,
+  mountedRef: RefHandle<boolean>,
+  abortRef: RefHandle<AbortController | null>,
+  scheduleTools: ScheduleFn,
+  onConfirmationNeeded?: (event: ToolConfirmationEvent) => void,
+): UseStreamingResponderFunction {
+  return useCallback(
+    async (prompt: string, session: ConfigSession | null) => {
+      // Validate session exists
+      if (session === null) {
+        appendMessage(
+          'system',
+          'No active session. Load a profile first with /profile load <name>',
+        );
+        return;
+      }
+
+      streamRunId.current += 1;
+      const currentRun = streamRunId.current;
+
+      if (abortRef.current) {
+        abortRef.current.abort();
+      }
+      const controller = new AbortController();
+      abortRef.current = controller;
+      setStreamState('busy');
+
+      let context: StreamContext = {
+        modelMessageId: null,
+        thinkingMessageId: null,
+        toolCalls: new Map(),
+      };
+
+      let hasScheduledTools = false;
+
+      try {
+        // Stream messages from the model
+        for await (const event of sendMessageWithSession(
+          session,
+          prompt,
+          controller.signal,
+        )) {
+          if (!mountedRef.current || streamRunId.current !== currentRun) {
+            break;
+          }
+          // Track if any tools were scheduled
+          if (event.type === 'tool_pending') {
+            hasScheduledTools = true;
+          }
+          context = handleAdapterEvent(
+            event,
+            context,
+            appendMessage,
+            appendToMessage,
+            appendToolCall,
+            updateToolCall,
+            setResponderWordCount,
+            scheduleTools,
+            controller.signal,
+            onConfirmationNeeded,
+          );
+        }
+        // Tool execution is handled by the scheduler via callbacks
+        // The scheduler will call onAllToolCallsComplete when tools finish
+        // If tools were scheduled, DON'T set idle here - let the tool completion callback do it
+      } catch (error) {
+        if (!controller.signal.aborted) {
+          const message =
+            error instanceof Error ? error.message : String(error);
+          appendMessage('system', `Error: ${message}`);
+        }
+      } finally {
+        // Only set idle if no tools were scheduled (tools will set idle when complete)
+        // Also set idle if aborted or component unmounted
+        const wasAborted = controller.signal.aborted;
+        const isCurrent = streamRunId.current === currentRun;
+
+        if (
+          mountedRef.current &&
+          isCurrent &&
+          (wasAborted || !hasScheduledTools)
+        ) {
+          setStreamState('idle');
+        }
+        // Only clear abortRef if no tools were scheduled
+        // If tools are scheduled, we need to keep the controller for continuation
+        if (abortRef.current === controller && !hasScheduledTools) {
+          abortRef.current = null;
+        }
+      }
+    },
+    [
+      appendMessage,
+      appendToMessage,
+      appendToolCall,
+      updateToolCall,
+      abortRef,
+      mountedRef,
+      setResponderWordCount,
+      setStreamState,
+      streamRunId,
+      scheduleTools,
+      onConfirmationNeeded,
+    ],
+  );
+}
+
+/**
+ * Continue streaming after tools complete - sends tool responses to model
+ * Returns true if new tools were scheduled, false if conversation turn is complete
+ */
+export async function continueStreamingAfterTools(
+  session: ConfigSession,
+  completedTools: CompletedToolCall[],
+  signal: AbortSignal,
+  appendMessage: (role: Role, text: string) => string,
+  appendToMessage: (id: string, text: string) => void,
+  appendToolCall: (
+    callId: string,
+    name: string,
+    params: Record<string, unknown>,
+  ) => string,
+  updateToolCall: (
+    callId: string,
+    update: Partial<Omit<ToolCall, 'id' | 'kind' | 'callId'>>,
+  ) => void,
+  setResponderWordCount: StateSetter<number>,
+  scheduleTools: ScheduleFn,
+  setStreamState: StateSetter<StreamState>,
+  onConfirmationNeeded?: (event: ToolConfirmationEvent) => void,
+): Promise<boolean> {
+  logger.debug(
+    'continueStreamingAfterTools called',
+    'toolCount:',
+    completedTools.length,
+  );
+
+  // Collect all response parts from completed tools
+  const responseParts = completedTools.flatMap(
+    (tool) => tool.response.responseParts,
+  );
+
+  logger.debug(
+    'continueStreamingAfterTools: collected response parts',
+    'count:',
+    responseParts.length,
+  );
+
+  if (responseParts.length === 0) {
+    // No response parts to send - this might happen if all tools had validation errors
+    // Check if there were any errors we should report
+    const errors = completedTools
+      .filter((tool) => tool.response.error)
+      .map((tool) => tool.response.error?.message);
+
+    logger.debug(
+      'continueStreamingAfterTools: no response parts',
+      'errorCount:',
+      errors.length,
+    );
+
+    if (errors.length > 0) {
+      // Append error messages to chat so user can see what went wrong
+      for (const error of errors) {
+        if (error) {
+          appendMessage('system', `Tool error: ${error}`);
+        }
+      }
+    }
+
+    setStreamState('idle');
+    return false;
+  }
+
+  // Send tool responses back to model
+  const client = session.getClient();
+  const promptId = `nui-continuation-${Date.now()}`;
+  const stream = client.sendMessageStream(responseParts, signal, promptId);
+
+  let context: StreamContext = {
+    modelMessageId: null,
+    thinkingMessageId: null,
+    toolCalls: new Map(),
+  };
+
+  let hasScheduledTools = false;
+
+  try {
+    for await (const coreEvent of stream) {
+      if (signal.aborted) {
+        break;
+      }
+      // Transform and handle the event
+      const { transformEvent } =
+        await import('../features/config/llxprtAdapter');
+      const event = transformEvent(coreEvent);
+
+      // Track if any tools were scheduled during continuation
+      if (event.type === 'tool_pending') {
+        hasScheduledTools = true;
+      }
+
+      context = handleAdapterEvent(
+        event,
+        context,
+        appendMessage,
+        appendToMessage,
+        appendToolCall,
+        updateToolCall,
+        setResponderWordCount,
+        scheduleTools,
+        signal,
+        onConfirmationNeeded,
+      );
+    }
+  } catch (error) {
+    // Handle errors during continuation streaming
+    if (!signal.aborted) {
+      const message = error instanceof Error ? error.message : String(error);
+      appendMessage('system', `Continuation error: ${message}`);
+    }
+  } finally {
+    // Only set idle if no new tools were scheduled and not aborted
+    // If tools were scheduled, the scheduler will handle setting idle when they complete
+    if (!hasScheduledTools && !signal.aborted) {
+      setStreamState('idle');
+    }
+  }
+
+  return hasScheduledTools;
+}

package/src/hooks/useSuggestionSetup.ts

@@ -0,0 +1,23 @@
+import { useEffect } from 'react';
+import {
+  setThemeSuggestions,
+  setProfileSuggestions,
+} from '../features/completion';
+import { listAvailableProfiles } from '../features/config';
+import type { ThemeDefinition } from '../features/theme';
+
+export function useSuggestionSetup(themes: ThemeDefinition[]): void {
+  useEffect(() => {
+    setThemeSuggestions(
+      themes.map((entry) => ({ slug: entry.slug, name: entry.name })),
+    );
+  }, [themes]);
+
+  useEffect(() => {
+    listAvailableProfiles()
+      .then((profiles) => setProfileSuggestions(profiles))
+      .catch(() => {
+        return;
+      });
+  }, []);
+}