flare-chat-core 0.2.1 → 0.2.3

package/src/chat-core/session/useChatSessionReducer.js

@@ -1,463 +1,64 @@
-import { useReducer, useCallback, useMemo } from 'react';
-
-const SESSION_LOADED = 'SESSION_LOADED';
-const SESSION_RESET = 'SESSION_RESET';
-const SESSION_ERROR = 'SESSION_ERROR';
-const TITLE_UPDATED = 'TITLE_UPDATED';
-const MESSAGES_REFRESHED = 'MESSAGES_REFRESHED';
-const MESSAGE_APPENDED = 'MESSAGE_APPENDED';
-const STREAMING_RESET = 'STREAMING_RESET';
-const STREAMING_CHUNK = 'STREAMING_CHUNK';
-const STREAMING_REPLACE = 'STREAMING_REPLACE';
-const AGENT_STATUS_SET = 'AGENT_STATUS_SET';
-const THINKING_TRACE_SET = 'THINKING_TRACE_SET';
-const EXECUTION_TRACE_SET = 'EXECUTION_TRACE_SET';
-const STREAMING_DONE = 'STREAMING_DONE';
-const DOC_GENERATED = 'DOC_GENERATED';
-const LEGEND_HINT_SHOWN = 'LEGEND_HINT_SHOWN';
-const EXECUTION_CARD_UPSERTED = 'EXECUTION_CARD_UPSERTED';
-const UI_CARDS_SET = 'UI_CARDS_SET';
-const LAST_USER_MESSAGE_SET = 'LAST_USER_MESSAGE_SET';
-const UI_CARD_UPDATED = 'UI_CARD_UPDATED';
-const INSTANCE_PROFILE_SET = 'INSTANCE_PROFILE_SET';
-const SESSION_PROMOTED = 'SESSION_PROMOTED';
-
-const initialStreaming = {
-  content: '',
-  agentStatus: null,
-  thinkingTrace: '',
-  executionTrace: null,
-};
-
-export const initialState = {
-  sessionId: null,
-  sessionTitle: '',
-  sessionStatus: 'active',
-  sessionDetail: null,
-  instanceProfile: null,
-  messages: [],
-  executionCards: [],
-  uiCards: [],
-  lastUserMessage: '',
-  generatedDoc: null,
-  streaming: initialStreaming,
-  sessionError: null,
-  legendHintsShown: {
-    knowledge_base: false,
-    ai: false,
-  },
-};
-
-function reducer(state, { type, payload }) {
-  switch (type) {
-    case SESSION_LOADED: {
-      const {
-        sessionId,
-        title,
-        status,
-        messages,
-        detail,
-      } = payload;
-      return {
-        ...state,
-        sessionId,
-        sessionTitle: title,
-        sessionStatus: status || 'active',
-        sessionDetail: (detail && typeof detail === 'object' && !Array.isArray(detail)) ? detail : null,
-        instanceProfile: state.instanceProfile,
-        messages,
-        executionCards: [],
-        uiCards: [],
-        lastUserMessage: '',
-        generatedDoc: null,
-        streaming: initialStreaming,
-        legendHintsShown: initialState.legendHintsShown,
-      };
-    }
-
-    case SESSION_RESET:
-      return { ...initialState, instanceProfile: state.instanceProfile };
-
-    case SESSION_ERROR:
-      return { ...state, sessionError: payload };
-
-    case TITLE_UPDATED:
-      return { ...state, sessionTitle: payload };
-
-    case MESSAGES_REFRESHED:
-      return { ...state, messages: payload };
-
-    case MESSAGE_APPENDED:
-      return {
-        ...state,
-        messages: [...state.messages, payload],
-        lastUserMessage: payload.role === 'user' ? payload.content : state.lastUserMessage,
-      };
-
-    case LAST_USER_MESSAGE_SET:
-      return { ...state, lastUserMessage: payload };
-
-    case UI_CARDS_SET:
-      return { ...state, uiCards: payload };
-
-    case UI_CARD_UPDATED: {
-      const nextCard = payload;
-      return {
-        ...state,
-        uiCards: state.uiCards.map((card) =>
-          card.id === nextCard.id ? { ...card, ...nextCard } : card
-        ),
-      };
-    }
-
-    case INSTANCE_PROFILE_SET:
-      return { ...state, instanceProfile: payload };
-
-    case SESSION_PROMOTED: {
-      const sessionId = String(payload?.sessionId || '').trim();
-      if (!sessionId) {
-        return state;
-      }
-      const title = String(payload?.title || '').trim();
-      const detailPayload = (
-        payload?.detail
-        && typeof payload.detail === 'object'
-        && !Array.isArray(payload.detail)
-      ) ? payload.detail : null;
-      const nextDetail = detailPayload
-        ? {
-            ...(state.sessionDetail && typeof state.sessionDetail === 'object' ? state.sessionDetail : {}),
-            ...detailPayload,
-            sessionId,
-          }
-        : (
-          state.sessionDetail && typeof state.sessionDetail === 'object'
-            ? {
-                ...state.sessionDetail,
-                sessionId,
-              }
-            : null
-        );
-      return {
-        ...state,
-        sessionId,
-        sessionTitle: title || state.sessionTitle,
-        sessionStatus: String(payload?.status || state.sessionStatus || 'active'),
-        sessionDetail: nextDetail,
-      };
-    }
-
-    case EXECUTION_CARD_UPSERTED: {
-      const nextCard = payload;
-      const cardKey = nextCard.step_id || `${nextCard.agent}-${nextCard.label}-${nextCard.stage}`;
-      const existingIndex = state.executionCards.findIndex((card) => {
-        const existingKey = card.step_id || `${card.agent}-${card.label}-${card.stage}`;
-        return existingKey === cardKey;
-      });
-
-      const updatedCards = existingIndex >= 0
-        ? state.executionCards.map((card, index) =>
-            index === existingIndex ? { ...card, ...nextCard } : card
-          )
-        : [...state.executionCards, nextCard];
-
-      return {
-        ...state,
-        executionCards: updatedCards.slice(-6),
-      };
-    }
-
-    case STREAMING_RESET:
-      return { ...state, streaming: initialStreaming };
-
-    case STREAMING_CHUNK:
-      return {
-        ...state,
-        streaming: {
-          ...state.streaming,
-          content: state.streaming.content + payload,
-        },
-      };
-
-    case STREAMING_REPLACE:
-      return {
-        ...state,
-        streaming: {
-          ...state.streaming,
-          content: String(payload || ''),
-        },
-      };
-
-    case AGENT_STATUS_SET:
-      return {
-        ...state,
-        streaming: { ...state.streaming, agentStatus: payload },
-      };
-
-    case THINKING_TRACE_SET:
-      return {
-        ...state,
-        streaming: { ...state.streaming, thinkingTrace: payload },
-      };
-
-    case EXECUTION_TRACE_SET:
-      return {
-        ...state,
-        streaming: {
-          ...state.streaming,
-          executionTrace: {
-            ...state.streaming.executionTrace,
-            ...payload,
-          },
-        },
-      };
-
-    case STREAMING_DONE: {
-      const newMessages = payload
-        ? [
-            ...state.messages,
-            {
-              message_id: `temp-assistant-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-              role: 'assistant',
-              content: payload,
-              created_at: new Date().toISOString(),
-            },
-          ]
-        : state.messages;
-
-      return {
-        ...state,
-        messages: newMessages,
-        streaming: initialStreaming,
-      };
-    }
-
-    case DOC_GENERATED:
-      return { ...state, generatedDoc: payload };
-
-    case LEGEND_HINT_SHOWN:
-      return {
-        ...state,
-        legendHintsShown: {
-          ...state.legendHintsShown,
-          [payload]: true,
-        },
-      };
-
-    default:
-      return state;
-  }
-}
-
-function requireAPI(api, name) {
-  if (!api) {
-    throw new Error(`${name} is required`);
-  }
-  return api;
-}
+import { useReducer, useMemo } from 'react';
+import {
+  initialState,
+  reducer,
+} from './chatSessionReducer.js';
+import { useSessionCrudActions } from './sessionActionsSessionCrud.js';
+import { useMessageActions } from './sessionActionsMessages.js';
+import { useStreamingActions } from './sessionActionsStreaming.js';
+import { useUiStateActions } from './sessionActionsUiState.js';
+
+export { initialState } from './chatSessionReducer.js';
 
 export default function useChatSessionReducer(deps = {}) {
   const { sessionAPI, messageAPI } = deps;
   const [state, dispatch] = useReducer(reducer, initialState);
 
-  const loadSession = useCallback(async (sessionId) => {
-    const sessionApi = requireAPI(sessionAPI, 'sessionAPI');
-    const messageApi = requireAPI(messageAPI, 'messageAPI');
-
-    const [detail, msgs] = await Promise.all([
-      sessionApi.get(sessionId),
-      messageApi.list(sessionId),
-    ]);
-
-    dispatch({
-      type: SESSION_LOADED,
-      payload: {
-        sessionId,
-        title: detail.title,
-        status: detail.status || 'active',
-        messages: msgs.messages,
-        detail,
-      },
-    });
-    return detail;
-  }, [sessionAPI, messageAPI]);
-
-  const createSession = useCallback(async ({
-    function_type,
-    title,
-    ...extraPayload
-  } = {}) => {
-    const sessionApi = requireAPI(sessionAPI, 'sessionAPI');
-    const response = await sessionApi.create({ function_type, title, ...extraPayload });
-
-    dispatch({
-      type: SESSION_LOADED,
-      payload: {
-        sessionId: response.sessionId,
-        title,
-        status: response.status || 'active',
-        messages: [],
-        detail: response,
-      },
-    });
-
-    return response.sessionId;
-  }, [sessionAPI]);
-
-  const createOrLoadSession = useCallback(async ({
-    function_type,
-    defaultTitle,
-    forceNew = false,
-    ...extraPayload
-  } = {}) => {
-    const sessionApi = requireAPI(sessionAPI, 'sessionAPI');
-    const messageApi = requireAPI(messageAPI, 'messageAPI');
-
-    let sessionId;
-    let title;
-
-    if (forceNew) {
-      title = defaultTitle;
-      const response = await sessionApi.create({ function_type, title, ...extraPayload });
-      sessionId = response.sessionId;
-    } else {
-      const sessionList = await sessionApi.list({
-        function_type,
-        status: 'active',
-        page: 1,
-        page_size: 1,
-        ...extraPayload,
-      });
-
-      if (sessionList.sessions.length > 0) {
-        sessionId = sessionList.sessions[0].sessionId;
-        title = sessionList.sessions[0].title;
-      } else {
-        title = defaultTitle;
-        const response = await sessionApi.create({ function_type, title, ...extraPayload });
-        sessionId = response.sessionId;
-      }
-    }
-
-    const [msgs, detail] = await Promise.all([
-      messageApi.list(sessionId),
-      sessionApi.get(sessionId),
-    ]);
-
-    dispatch({
-      type: SESSION_LOADED,
-      payload: {
-        sessionId,
-        title,
-        status: detail.status || 'active',
-        messages: msgs.messages,
-        detail,
-      },
-    });
-
-    return sessionId;
-  }, [sessionAPI, messageAPI]);
-
-  const resetSession = useCallback(() => {
-    dispatch({ type: SESSION_RESET });
-  }, []);
-
-  const updateTitle = useCallback(async (sessionId, title) => {
-    const sessionApi = requireAPI(sessionAPI, 'sessionAPI');
-    await sessionApi.update(sessionId, { title });
-    dispatch({ type: TITLE_UPDATED, payload: title });
-  }, [sessionAPI]);
-
-  const promoteSession = useCallback((payload = {}) => {
-    dispatch({ type: SESSION_PROMOTED, payload });
-  }, []);
-
-  const refreshMessages = useCallback(async (sessionId) => {
-    const messageApi = requireAPI(messageAPI, 'messageAPI');
-    const response = await messageApi.list(sessionId);
-    const messagesWithIds = response.messages.map((msg, index) => ({
-      ...msg,
-      message_id: msg.message_id || `fallback-${Date.now()}-${index}`,
-    }));
-    dispatch({ type: MESSAGES_REFRESHED, payload: messagesWithIds });
-  }, [messageAPI]);
-
-  const appendUserMessage = useCallback((content, metadata = {}) => {
-    const payloadMeta = (
-      metadata
-      && typeof metadata === 'object'
-      && !Array.isArray(metadata)
-    )
-      ? metadata
-      : {};
-    dispatch({
-      type: MESSAGE_APPENDED,
-      payload: {
-        message_id: `temp-user-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-        role: 'user',
-        content,
-        created_at: new Date().toISOString(),
-        ...payloadMeta,
-      },
-    });
-  }, []);
-
-  const setUICards = useCallback((cards) => {
-    dispatch({ type: UI_CARDS_SET, payload: Array.isArray(cards) ? cards : [] });
-  }, []);
-
-  const updateUICard = useCallback((card) => {
-    dispatch({ type: UI_CARD_UPDATED, payload: card });
-  }, []);
-
-  const setLastUserMessage = useCallback((content) => {
-    dispatch({ type: LAST_USER_MESSAGE_SET, payload: content || '' });
-  }, []);
-
-  const resetStreaming = useCallback(() => {
-    dispatch({ type: STREAMING_RESET });
-  }, []);
-
-  const appendStreamChunk = useCallback((chunk) => {
-    dispatch({ type: STREAMING_CHUNK, payload: chunk });
-  }, []);
-
-  const replaceStreamContent = useCallback((content) => {
-    dispatch({ type: STREAMING_REPLACE, payload: content });
-  }, []);
-
-  const setAgentStatus = useCallback((agentStatus) => {
-    dispatch({ type: AGENT_STATUS_SET, payload: agentStatus });
-  }, []);
-
-  const setThinkingTrace = useCallback((trace) => {
-    dispatch({ type: THINKING_TRACE_SET, payload: trace });
-  }, []);
-
-  const setExecutionTrace = useCallback((executionTrace) => {
-    dispatch({ type: EXECUTION_TRACE_SET, payload: executionTrace });
-    dispatch({ type: EXECUTION_CARD_UPSERTED, payload: executionTrace });
-  }, []);
-
-  const completeStreaming = useCallback((finalContent) => {
-    dispatch({ type: STREAMING_DONE, payload: finalContent });
-  }, []);
-
-  const setGeneratedDoc = useCallback((doc) => {
-    dispatch({ type: DOC_GENERATED, payload: doc });
-  }, []);
-
-  const markLegendHintShown = useCallback((sourceType) => {
-    dispatch({ type: LEGEND_HINT_SHOWN, payload: sourceType });
-  }, []);
-
-  const setSessionError = useCallback((error) => {
-    dispatch({ type: SESSION_ERROR, payload: error });
-  }, []);
-
-  const setInstanceProfile = useCallback((profile) => {
-    dispatch({ type: INSTANCE_PROFILE_SET, payload: profile || null });
-  }, []);
+  const sessionCrudActions = useSessionCrudActions({
+    dispatch,
+    sessionAPI,
+    messageAPI,
+  });
+  const messageActions = useMessageActions({
+    dispatch,
+    messageAPI,
+  });
+  const streamingActions = useStreamingActions({ dispatch });
+  const uiStateActions = useUiStateActions({ dispatch });
+
+  const {
+    loadSession,
+    createSession,
+    createOrLoadSession,
+    resetSession,
+    updateTitle,
+    promoteSession,
+  } = sessionCrudActions;
+  const {
+    refreshMessages,
+    appendUserMessage,
+  } = messageActions;
+  const {
+    resetStreaming,
+    appendStreamChunk,
+    replaceStreamContent,
+    setAgentStatus,
+    setThinkingTrace,
+    setExecutionTrace,
+    setKnowledgeSearch,
+    setSourcingCandidates,
+    setKnowledgeCitation,
+    completeStreaming,
+  } = streamingActions;
+  const {
+    setUICards,
+    updateUICard,
+    setLastUserMessage,
+    setGeneratedDoc,
+    markLegendHintShown,
+    setSessionError,
+    setInstanceProfile,
+  } = uiStateActions;
 
   return useMemo(() => ({
     sessionId: state.sessionId,
@@ -490,6 +91,9 @@ export default function useChatSessionReducer(deps = {}) {
     setAgentStatus,
     setThinkingTrace,
     setExecutionTrace,
+    setKnowledgeSearch,
+    setSourcingCandidates,
+    setKnowledgeCitation,
     completeStreaming,
     setGeneratedDoc,
     setInstanceProfile,
@@ -514,6 +118,9 @@ export default function useChatSessionReducer(deps = {}) {
     setAgentStatus,
     setThinkingTrace,
     setExecutionTrace,
+    setKnowledgeSearch,
+    setSourcingCandidates,
+    setKnowledgeCitation,
     completeStreaming,
     setGeneratedDoc,
     setInstanceProfile,

package/src/chat-core/session/useSessionListController.js

@@ -0,0 +1,67 @@
+import { useCallback, useState } from 'react';
+
+/**
+ * Session list lifecycle controller.
+ *
+ * @param {object} params - Hook params.
+ * @param {object} params.sessionAPI - Session API provider.
+ * @param {object} params.listParams - Session list query params.
+ * @param {Function} params.onStarted - Optional started callback.
+ * @param {Function} params.onSucceeded - Optional succeeded callback.
+ * @param {Function} params.onFailed - Optional failed callback.
+ * @returns {{sessions: Array<object>, loading: boolean, error: any, loadSessionList: Function}}
+ */
+export default function useSessionListController({
+  sessionAPI,
+  listParams = {},
+  onStarted,
+  onSucceeded,
+  onFailed,
+} = {}) {
+  const [sessions, setSessions] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [hasLoaded, setHasLoaded] = useState(false);
+
+  const loadSessionList = useCallback(async (options = {}) => {
+    if (!sessionAPI?.list) {
+      return [];
+    }
+    const background = options?.background === true;
+    const shouldShowLoading = !background && !hasLoaded;
+
+    onStarted?.();
+    if (shouldShowLoading) {
+      setLoading(true);
+    }
+    if (!background) {
+      setError(null);
+    }
+
+    try {
+      const response = await sessionAPI.list(listParams);
+      const resolvedSessions = Array.isArray(response?.sessions) ? response.sessions : [];
+      setSessions(resolvedSessions);
+      setHasLoaded(true);
+      onSucceeded?.(resolvedSessions);
+      return resolvedSessions;
+    } catch (nextError) {
+      setError(nextError);
+      onFailed?.(nextError);
+      throw nextError;
+    } finally {
+      if (shouldShowLoading) {
+        setLoading(false);
+      }
+    }
+  }, [hasLoaded, listParams, onFailed, onStarted, onSucceeded, sessionAPI]);
+
+  return {
+    sessions,
+    loading,
+    error,
+    loadSessionList,
+  };
+}
+
+export { useSessionListController };