[Init] Initial commit - NetMesh terminal manager

application/state/useAIChatStreaming.ts

@@ -0,0 +1,269 @@
+/**
+ * useAIChatStreaming — React UI layer for AI chat streaming.
+ *
+ * Turn orchestration lives in AgentRuntime + TurnDrivers; this hook only
+ * manages streaming state, abort controllers, and UI callbacks.
+ */
+
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import type {
+  AIPermissionMode,
+  AIToolIntegrationMode,
+  AISession,
+  ChatMessage,
+  ChatMessageAttachment,
+  ExternalAgentConfig,
+  ProviderConfig,
+  WebSearchConfig,
+} from '../../infrastructure/ai/types';
+import type { ExecutorContext } from '../../infrastructure/ai/cattyAgent/executor';
+import { getAgentRuntime } from '../../infrastructure/ai/harness/globalAgentRuntime';
+import type {
+  TurnSteerInput,
+  TurnSteerResult,
+} from '../../infrastructure/ai/harness/turnDrivers/types';
+import { classifyError } from '../../infrastructure/ai/errorClassifier';
+import { latestAISessionsSnapshot } from './aiStateSnapshots';
+import {
+  generateId,
+  getNetcattyBridge,
+  type DefaultTargetSessionHint,
+  type TerminalSessionInfo,
+} from '../../infrastructure/ai/aiChatStreamingSupport';
+import { useAgentCompactionUi } from './useAgentCompactionUi';
+
+export { getNetcattyBridge } from '../../infrastructure/ai/aiChatStreamingSupport';
+export type { ActiveCompactionUi } from './useAgentCompactionUi';
+export type { DefaultTargetSessionHint } from '../../infrastructure/ai/aiChatStreamingSupport';
+
+const sharedStreamingSessionIds = new Set<string>();
+const sharedAbortControllers = new Map<string, AbortController>();
+const streamingSubscribers = new Set<() => void>();
+
+/** Whether a chat session still has an active stream (used to keep panel mounted while hidden). */
+export function isAIChatSessionStreaming(sessionId: string | null | undefined): boolean {
+  return !!sessionId && sharedStreamingSessionIds.has(sessionId);
+}
+
+function emitStreamingStoreChange(): void {
+  streamingSubscribers.forEach(listener => {
+    try {
+      listener();
+    } catch (err) {
+      console.error('[AIChatStreaming] Failed to notify streaming subscriber:', err);
+    }
+  });
+}
+
+export interface UseAIChatStreamingParams {
+  maxIterations: number;
+  addMessageToSession: (sessionId: string, message: ChatMessage) => void;
+  updateLastMessage: (sessionId: string, updater: (msg: ChatMessage) => ChatMessage) => void;
+  updateMessageById: (sessionId: string, messageId: string, updater: (msg: ChatMessage) => ChatMessage) => void;
+  persistContextCompaction?: (
+    sessionId: string,
+    compaction: import('../../infrastructure/ai/types').AISessionContextCompaction,
+  ) => void;
+}
+
+export interface UseAIChatStreamingReturn {
+  streamingSessionIds: Set<string>;
+  setStreamingForScope: (key: string, val: boolean) => void;
+  abortControllersRef: React.MutableRefObject<Map<string, AbortController>>;
+  sendToCattyAgent: (
+    sessionId: string,
+    sendScopeKey: string,
+    trimmed: string,
+    abortController: AbortController,
+    currentSession: AISession | undefined,
+    assistantMsgId: string,
+    context: SendToCattyContext,
+    attachments?: ChatMessageAttachment[],
+  ) => Promise<void>;
+  sendToExternalAgent: (
+    sessionId: string,
+    assistantMsgId: string,
+    trimmed: string,
+    agentConfig: ExternalAgentConfig,
+    abortController: AbortController,
+    attachedImages: Array<{ base64Data: string; mediaType: string; filename?: string; filePath?: string }>,
+    context: SendToExternalContext,
+  ) => Promise<void>;
+  steerExternalAgent: (input: TurnSteerInput) => Promise<TurnSteerResult>;
+  reportStreamError: (sessionId: string, abortSignal: AbortSignal, err: unknown) => void;
+  activeCompaction: import('./useAgentCompactionUi').ActiveCompactionUi | null;
+}
+
+export interface SendToCattyContext {
+  activeProvider: ProviderConfig | undefined;
+  activeModelId: string;
+  scopeType: 'terminal' | 'workspace';
+  scopeTargetId?: string;
+  scopeLabel?: string;
+  globalPermissionMode: AIPermissionMode;
+  commandBlocklist?: string[];
+  commandTimeout?: number;
+  responseIdleTimeout?: number;
+  terminalSessions: TerminalSessionInfo[];
+  webSearchConfig?: WebSearchConfig | null;
+  getExecutorContext?: () => ExecutorContext;
+  autoTitleSession: (sessionId: string, text: string) => void;
+  titleText?: string;
+  selectedUserSkillSlugs?: string[];
+  permissionMode?: AIPermissionMode;
+  forceCompaction?: boolean;
+}
+
+export interface SendToExternalContext {
+  existingSessionId?: string;
+  updateExternalSessionId?: (sessionId: string, externalSessionId: string | undefined) => void;
+  historyMessages?: Array<{ role: 'user' | 'assistant'; content: string }>;
+  terminalSessions: TerminalSessionInfo[];
+  defaultTargetSession?: DefaultTargetSessionHint;
+  providers: ProviderConfig[];
+  selectedAgentModel?: string;
+  toolIntegrationMode: AIToolIntegrationMode;
+  selectedUserSkillSlugs?: string[];
+  permissionMode: AIPermissionMode;
+}
+
+export function useAIChatStreaming({
+  maxIterations,
+  addMessageToSession,
+  updateLastMessage,
+  updateMessageById,
+  persistContextCompaction,
+}: UseAIChatStreamingParams): UseAIChatStreamingReturn {
+  const [streamingSessionIds, setStreamingSessions] = useState<Set<string>>(
+    () => new Set(sharedStreamingSessionIds),
+  );
+
+  useEffect(() => {
+    const syncFromStore = () => {
+      setStreamingSessions(new Set(sharedStreamingSessionIds));
+    };
+    streamingSubscribers.add(syncFromStore);
+    syncFromStore();
+    return () => {
+      streamingSubscribers.delete(syncFromStore);
+    };
+  }, []);
+
+  const setStreamingForScope = useCallback((key: string, val: boolean) => {
+    const hadKey = sharedStreamingSessionIds.has(key);
+    if (val) {
+      sharedStreamingSessionIds.add(key);
+    } else {
+      sharedStreamingSessionIds.delete(key);
+    }
+    if (hadKey !== val) {
+      emitStreamingStoreChange();
+    }
+  }, []);
+
+  const abortControllersRef = useRef<Map<string, AbortController>>(sharedAbortControllers);
+
+  const activeCompaction = useAgentCompactionUi();
+
+  const reportStreamError = useCallback((
+    sessionId: string,
+    abortSignal: AbortSignal,
+    err: unknown,
+  ) => {
+    if (abortSignal.aborted) return;
+    console.error('[AIChatSidePanel] Stream error (full):', err);
+    const errorInfo = classifyError(err);
+    updateLastMessage(sessionId, msg => ({
+      ...msg,
+      statusText: '',
+      executionStatus: msg.executionStatus === 'running' ? 'failed' : msg.executionStatus,
+    }));
+    addMessageToSession(sessionId, {
+      id: generateId(),
+      role: 'assistant',
+      content: '',
+      errorInfo,
+      timestamp: Date.now(),
+    });
+  }, [updateLastMessage, addMessageToSession]);
+
+  const uiCallbacks = useCallback(() => ({
+    addMessageToSession,
+    updateLastMessage,
+    updateMessageById,
+    reportStreamError,
+    setStreamingForScope,
+    getLatestSession: (sessionId: string) => latestAISessionsSnapshot?.find(s => s.id === sessionId),
+    persistContextCompaction,
+  }), [addMessageToSession, updateLastMessage, updateMessageById, reportStreamError, setStreamingForScope, persistContextCompaction]);
+
+  const sendToExternalAgent = useCallback(async (
+    sessionId: string,
+    assistantMsgId: string,
+    trimmed: string,
+    agentConfig: ExternalAgentConfig,
+    abortController: AbortController,
+    attachedImages: Array<{ base64Data: string; mediaType: string; filename?: string; filePath?: string }>,
+    context: SendToExternalContext,
+  ) => {
+    const bridge = getNetcattyBridge();
+    await getAgentRuntime().runTurn({
+      backend: 'external-sdk',
+      chatSessionId: sessionId,
+      assistantMsgId,
+      userText: trimmed,
+      signal: abortController.signal,
+      agentConfig,
+      attachedImages,
+      context,
+      bridge,
+      ui: uiCallbacks(),
+    });
+  }, [uiCallbacks]);
+
+  const steerExternalAgent = useCallback(async (input: TurnSteerInput) => {
+    return getAgentRuntime().steerTurn(input);
+  }, []);
+
+  const sendToCattyAgent = useCallback(async (
+    sessionId: string,
+    sendScopeKey: string,
+    trimmed: string,
+    abortController: AbortController,
+    currentSession: AISession | undefined,
+    assistantMsgId: string,
+    context: SendToCattyContext,
+    attachments?: ChatMessageAttachment[],
+  ) => {
+    const bridge = getNetcattyBridge();
+    try {
+      await getAgentRuntime().runTurn({
+        backend: 'catty',
+        chatSessionId: sessionId,
+        sendScopeKey,
+        userText: trimmed,
+        signal: abortController.signal,
+        currentSession,
+        assistantMsgId,
+        context,
+        attachments,
+        maxIterations,
+        bridge,
+        ui: uiCallbacks(),
+      });
+    } finally {
+      abortControllersRef.current.delete(sessionId);
+    }
+  }, [maxIterations, uiCallbacks]);
+
+  return {
+    streamingSessionIds,
+    setStreamingForScope,
+    abortControllersRef,
+    sendToCattyAgent,
+    sendToExternalAgent,
+    steerExternalAgent,
+    reportStreamError,
+    activeCompaction,
+  };
+}