flare-chat-core 0.2.0 → 0.2.2

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

@@ -0,0 +1,352 @@
+import {
+  SESSION_LOADED,
+  SESSION_RESET,
+  SESSION_ERROR,
+  TITLE_UPDATED,
+  MESSAGES_REFRESHED,
+  MESSAGE_APPENDED,
+  STREAMING_RESET,
+  STREAMING_CHUNK,
+  STREAMING_REPLACE,
+  AGENT_STATUS_SET,
+  THINKING_TRACE_SET,
+  EXECUTION_TRACE_SET,
+  STREAM_KNOWLEDGE_SEARCH_SET,
+  STREAM_SOURCING_CANDIDATES_SET,
+  STREAM_KNOWLEDGE_CITATION_SET,
+  STREAMING_DONE,
+  DOC_GENERATED,
+  LEGEND_HINT_SHOWN,
+  EXECUTION_CARD_UPSERTED,
+  UI_CARDS_SET,
+  LAST_USER_MESSAGE_SET,
+  UI_CARD_UPDATED,
+  INSTANCE_PROFILE_SET,
+  SESSION_PROMOTED,
+} from './chatSessionActionTypes.js';
+
+export const initialStreaming = {
+  content: '',
+  agentStatus: null,
+  thinkingTrace: '',
+  executionTrace: null,
+  knowledgeSearch: null,
+  sourcingCandidates: null,
+  knowledgeCitation: null,
+  roundKey: '',
+};
+
+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,
+  },
+};
+
+export 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 STREAM_KNOWLEDGE_SEARCH_SET:
+      return {
+        ...state,
+        streaming: {
+          ...state.streaming,
+          knowledgeSearch: (
+            payload
+            && typeof payload === 'object'
+            && !Array.isArray(payload)
+          ) ? payload : null,
+        },
+      };
+
+    case STREAM_SOURCING_CANDIDATES_SET:
+      return {
+        ...state,
+        streaming: {
+          ...state.streaming,
+          sourcingCandidates: (
+            payload
+            && typeof payload === 'object'
+            && !Array.isArray(payload)
+          ) ? payload : null,
+        },
+      };
+
+    case STREAM_KNOWLEDGE_CITATION_SET:
+      return {
+        ...state,
+        streaming: {
+          ...state.streaming,
+          knowledgeCitation: (
+            payload
+            && typeof payload === 'object'
+            && !Array.isArray(payload)
+          ) ? payload : null,
+        },
+      };
+
+    case STREAMING_DONE: {
+      const donePayload = (
+        payload
+        && typeof payload === 'object'
+        && !Array.isArray(payload)
+      ) ? payload : { content: payload };
+      const doneContent = String(donePayload.content || '');
+      const doneMeta = (
+        donePayload.meta
+        && typeof donePayload.meta === 'object'
+        && !Array.isArray(donePayload.meta)
+      ) ? donePayload.meta : {};
+      const newMessages = doneContent
+        ? [
+            ...state.messages,
+            {
+              message_id: `temp-assistant-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+              role: 'assistant',
+              content: doneContent,
+              created_at: new Date().toISOString(),
+              round_key: String(doneMeta.round_key || doneMeta.roundKey || '').trim(),
+              round_state: String(doneMeta.round_state || doneMeta.roundState || '').trim(),
+              chooser_state: (
+                doneMeta.chooser_state
+                && typeof doneMeta.chooser_state === 'object'
+                && !Array.isArray(doneMeta.chooser_state)
+              ) ? doneMeta.chooser_state : null,
+              knowledge_search: (
+                state.streaming.knowledgeSearch
+                && typeof state.streaming.knowledgeSearch === 'object'
+                && !Array.isArray(state.streaming.knowledgeSearch)
+              ) ? state.streaming.knowledgeSearch : null,
+              sourcing_candidates: (
+                state.streaming.sourcingCandidates
+                && typeof state.streaming.sourcingCandidates === 'object'
+                && !Array.isArray(state.streaming.sourcingCandidates)
+              ) ? state.streaming.sourcingCandidates : null,
+              knowledge_citation: (
+                state.streaming.knowledgeCitation
+                && typeof state.streaming.knowledgeCitation === 'object'
+                && !Array.isArray(state.streaming.knowledgeCitation)
+              ) ? state.streaming.knowledgeCitation : null,
+              agent_status: (
+                state.streaming.agentStatus
+                && typeof state.streaming.agentStatus === 'object'
+                && !Array.isArray(state.streaming.agentStatus)
+              ) ? state.streaming.agentStatus : null,
+              thinking_trace: String(state.streaming.thinkingTrace || ''),
+              execution_trace: (
+                state.streaming.executionTrace
+                && typeof state.streaming.executionTrace === 'object'
+                && !Array.isArray(state.streaming.executionTrace)
+              ) ? state.streaming.executionTrace : null,
+              context_usage: (
+                doneMeta.context_usage
+                && typeof doneMeta.context_usage === 'object'
+                && !Array.isArray(doneMeta.context_usage)
+              ) ? doneMeta.context_usage : null,
+            },
+          ]
+        : 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;
+  }
+}
+
+export function requireAPI(api, name) {
+  if (!api) {
+    throw new Error(`${name} is required`);
+  }
+  return api;
+}

package/src/chat-core/session/chatSessionReducer.streaming-done.test.mjs

@@ -0,0 +1,39 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { reducer, initialState } from './chatSessionReducer.js';
+import {
+  AGENT_STATUS_SET,
+  THINKING_TRACE_SET,
+  EXECUTION_TRACE_SET,
+  STREAM_KNOWLEDGE_SEARCH_SET,
+  STREAM_KNOWLEDGE_CITATION_SET,
+  STREAMING_DONE,
+} from './chatSessionActionTypes.js';
+
+test('STREAMING_DONE snapshots thinking/search/citation metadata into assistant message', () => {
+  let state = { ...initialState };
+  state = reducer(state, { type: AGENT_STATUS_SET, payload: { status: 'completed', stage: 'analysis' } });
+  state = reducer(state, { type: THINKING_TRACE_SET, payload: '阶段：上下文处理' });
+  state = reducer(state, { type: EXECUTION_TRACE_SET, payload: { step_id: 'knowledge_search', status: 'completed' } });
+  state = reducer(state, { type: STREAM_KNOWLEDGE_SEARCH_SET, payload: { run_id: 'retrieval-1', results: [{ id: 'r1' }] } });
+  state = reducer(state, { type: STREAM_KNOWLEDGE_CITATION_SET, payload: { run_id: 'retrieval-1', citations: [{ citation_id: 'cite_1' }] } });
+
+  state = reducer(state, {
+    type: STREAMING_DONE,
+    payload: {
+      content: '总结完成',
+      meta: {
+        context_usage: { token_budget: 1200 },
+      },
+    },
+  });
+
+  const lastMessage = state.messages[state.messages.length - 1];
+  assert.equal(lastMessage.role, 'assistant');
+  assert.equal(lastMessage.content, '总结完成');
+  assert.equal(lastMessage.thinking_trace, '阶段：上下文处理');
+  assert.equal(lastMessage.execution_trace?.step_id, 'knowledge_search');
+  assert.equal(lastMessage.knowledge_search?.run_id, 'retrieval-1');
+  assert.equal(lastMessage.knowledge_citation?.run_id, 'retrieval-1');
+  assert.equal(lastMessage.context_usage?.token_budget, 1200);
+});

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

@@ -0,0 +1,2 @@
+export { default as useChatSessionReducer, initialState } from './useChatSessionReducer.js';
+export { default as useSessionListController } from './useSessionListController.js';

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

@@ -0,0 +1,44 @@
+import { useCallback } from 'react';
+import {
+  MESSAGES_REFRESHED,
+  MESSAGE_APPENDED,
+} from './chatSessionActionTypes.js';
+import { requireAPI } from './chatSessionReducer.js';
+
+export function useMessageActions({ dispatch, messageAPI }) {
+  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 });
+  }, [dispatch, 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,
+      },
+    });
+  }, [dispatch]);
+
+  return {
+    refreshMessages,
+    appendUserMessage,
+  };
+}
+

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

@@ -0,0 +1,131 @@
+import { useCallback } from 'react';
+import {
+  SESSION_LOADED,
+  SESSION_RESET,
+  TITLE_UPDATED,
+  SESSION_PROMOTED,
+} from './chatSessionActionTypes.js';
+import { requireAPI } from './chatSessionReducer.js';
+
+export function useSessionCrudActions({ dispatch, sessionAPI, messageAPI }) {
+  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;
+  }, [dispatch, messageAPI, sessionAPI]);
+
+  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: String(response.title || title || '').trim(),
+        status: response.status || 'active',
+        messages: [],
+        detail: response,
+      },
+    });
+
+    return response.sessionId;
+  }, [dispatch, 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;
+  }, [dispatch, messageAPI, sessionAPI]);
+
+  const resetSession = useCallback(() => {
+    dispatch({ type: SESSION_RESET });
+  }, [dispatch]);
+
+  const updateTitle = useCallback(async (sessionId, title) => {
+    const sessionApi = requireAPI(sessionAPI, 'sessionAPI');
+    await sessionApi.update(sessionId, { title });
+    dispatch({ type: TITLE_UPDATED, payload: title });
+  }, [dispatch, sessionAPI]);
+
+  const promoteSession = useCallback((payload = {}) => {
+    dispatch({ type: SESSION_PROMOTED, payload });
+  }, [dispatch]);
+
+  return {
+    loadSession,
+    createSession,
+    createOrLoadSession,
+    resetSession,
+    updateTitle,
+    promoteSession,
+  };
+}

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

@@ -0,0 +1,80 @@
+import { useCallback } from 'react';
+import {
+  STREAMING_RESET,
+  STREAMING_CHUNK,
+  STREAMING_REPLACE,
+  AGENT_STATUS_SET,
+  THINKING_TRACE_SET,
+  EXECUTION_TRACE_SET,
+  STREAM_KNOWLEDGE_SEARCH_SET,
+  STREAM_SOURCING_CANDIDATES_SET,
+  STREAM_KNOWLEDGE_CITATION_SET,
+  EXECUTION_CARD_UPSERTED,
+  STREAMING_DONE,
+} from './chatSessionActionTypes.js';
+
+export function useStreamingActions({ dispatch }) {
+  const resetStreaming = useCallback(() => {
+    dispatch({ type: STREAMING_RESET });
+  }, [dispatch]);
+
+  const appendStreamChunk = useCallback((chunk) => {
+    dispatch({ type: STREAMING_CHUNK, payload: chunk });
+  }, [dispatch]);
+
+  const replaceStreamContent = useCallback((content) => {
+    dispatch({ type: STREAMING_REPLACE, payload: content });
+  }, [dispatch]);
+
+  const setAgentStatus = useCallback((agentStatus) => {
+    dispatch({ type: AGENT_STATUS_SET, payload: agentStatus });
+  }, [dispatch]);
+
+  const setThinkingTrace = useCallback((trace) => {
+    dispatch({ type: THINKING_TRACE_SET, payload: trace });
+  }, [dispatch]);
+
+  const setExecutionTrace = useCallback((executionTrace) => {
+    dispatch({ type: EXECUTION_TRACE_SET, payload: executionTrace });
+    dispatch({ type: EXECUTION_CARD_UPSERTED, payload: executionTrace });
+  }, [dispatch]);
+
+  const setKnowledgeSearch = useCallback((knowledgeSearch) => {
+    dispatch({ type: STREAM_KNOWLEDGE_SEARCH_SET, payload: knowledgeSearch });
+  }, [dispatch]);
+
+  const setSourcingCandidates = useCallback((sourcingCandidates) => {
+    dispatch({ type: STREAM_SOURCING_CANDIDATES_SET, payload: sourcingCandidates });
+  }, [dispatch]);
+
+  const setKnowledgeCitation = useCallback((knowledgeCitation) => {
+    dispatch({ type: STREAM_KNOWLEDGE_CITATION_SET, payload: knowledgeCitation });
+  }, [dispatch]);
+
+  const completeStreaming = useCallback((finalContent, finalMeta = null) => {
+    dispatch({
+      type: STREAMING_DONE,
+      payload: {
+        content: finalContent,
+        meta: (
+          finalMeta
+          && typeof finalMeta === 'object'
+          && !Array.isArray(finalMeta)
+        ) ? finalMeta : null,
+      },
+    });
+  }, [dispatch]);
+
+  return {
+    resetStreaming,
+    appendStreamChunk,
+    replaceStreamContent,
+    setAgentStatus,
+    setThinkingTrace,
+    setExecutionTrace,
+    setKnowledgeSearch,
+    setSourcingCandidates,
+    setKnowledgeCitation,
+    completeStreaming,
+  };
+}

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

@@ -0,0 +1,51 @@
+import { useCallback } from 'react';
+import {
+  UI_CARDS_SET,
+  UI_CARD_UPDATED,
+  LAST_USER_MESSAGE_SET,
+  DOC_GENERATED,
+  LEGEND_HINT_SHOWN,
+  SESSION_ERROR,
+  INSTANCE_PROFILE_SET,
+} from './chatSessionActionTypes.js';
+
+export function useUiStateActions({ dispatch }) {
+  const setUICards = useCallback((cards) => {
+    dispatch({ type: UI_CARDS_SET, payload: Array.isArray(cards) ? cards : [] });
+  }, [dispatch]);
+
+  const updateUICard = useCallback((card) => {
+    dispatch({ type: UI_CARD_UPDATED, payload: card });
+  }, [dispatch]);
+
+  const setLastUserMessage = useCallback((content) => {
+    dispatch({ type: LAST_USER_MESSAGE_SET, payload: content || '' });
+  }, [dispatch]);
+
+  const setGeneratedDoc = useCallback((doc) => {
+    dispatch({ type: DOC_GENERATED, payload: doc });
+  }, [dispatch]);
+
+  const markLegendHintShown = useCallback((sourceType) => {
+    dispatch({ type: LEGEND_HINT_SHOWN, payload: sourceType });
+  }, [dispatch]);
+
+  const setSessionError = useCallback((error) => {
+    dispatch({ type: SESSION_ERROR, payload: error });
+  }, [dispatch]);
+
+  const setInstanceProfile = useCallback((profile) => {
+    dispatch({ type: INSTANCE_PROFILE_SET, payload: profile || null });
+  }, [dispatch]);
+
+  return {
+    setUICards,
+    updateUICard,
+    setLastUserMessage,
+    setGeneratedDoc,
+    markLegendHintShown,
+    setSessionError,
+    setInstanceProfile,
+  };
+}
+