flare-chat-core 0.2.2 → 0.2.4

package/src/chat-core/app/useCoreChatApp.js

@@ -1,115 +0,0 @@
-import { useEffect, useMemo, useRef } from 'react';
-import { useBasicConversationFacade } from '../facade/useBasicConversationFacade.js';
-
-/**
- * Core app-level chat orchestration hook.
- * Owns state/actions mapping for UI component libraries.
- */
-export default function useCoreChatApp({
-  sessionAPI,
-  messageAPI,
-  stream,
-  functionType,
-  defaultSessionTitle,
-  listParams,
-  createSessionPayload = {},
-} = {}) {
-  const didInitialRefreshRef = useRef(false);
-  const chat = useBasicConversationFacade({
-    sessionAPI,
-    messageAPI,
-    stream,
-    functionType,
-    defaultSessionTitle,
-    listParams,
-    defaultSessionPayload: createSessionPayload,
-  });
-
-  useEffect(() => {
-    if (didInitialRefreshRef.current) {
-      return;
-    }
-    didInitialRefreshRef.current = true;
-    chat.actions.refreshSessionList();
-  }, [chat.actions.refreshSessionList]);
-
-  const viewModel = useMemo(() => ({
-    sessionList: {
-      sessions: chat.state.sessions.items,
-      error: chat.state.sessions.error,
-      activeSessionId: chat.state.session.sessionId,
-      onSelectSession: chat.actions.selectSession,
-      onCreateSession: () => chat.actions.createSession(createSessionPayload),
-      onCreateProject: () => chat.actions.createSession(createSessionPayload),
-      onRenameSession: async (session, nextTitle) => {
-        const sessionId = String(session?.sessionId || session?.session_id || session?.id || '').trim();
-        const title = String(nextTitle || '').trim();
-        if (!sessionId || !title) {
-          return;
-        }
-        await chat.actions.updateTitle(sessionId, title);
-        await chat.actions.refreshSessionList();
-      },
-      onArchiveSession: async (session) => {
-        const sessionId = String(session?.sessionId || session?.session_id || session?.id || '').trim();
-        if (!sessionId || !sessionAPI?.update) {
-          return;
-        }
-        await sessionAPI.update(sessionId, { status: 'archived' });
-        const latestSessions = await chat.actions.refreshSessionList();
-        if (sessionId !== chat.state.session.sessionId) {
-          return;
-        }
-        const nextActive = Array.isArray(latestSessions)
-          ? latestSessions.find((item) => {
-            const id = String(item?.sessionId || item?.session_id || item?.id || '').trim();
-            const status = String(item?.status || 'active').trim();
-            return Boolean(id) && status !== 'archived';
-          })
-          : null;
-        const nextSessionId = String(
-          nextActive?.sessionId
-          || nextActive?.session_id
-          || nextActive?.id
-          || ''
-        ).trim();
-        if (nextSessionId) {
-          await chat.actions.selectSession(nextSessionId);
-          return;
-        }
-        chat.actions.resetSession();
-      },
-      projectItems: Array.isArray(chat.state.sessions.items) && chat.state.sessions.items.length > 0
-        ? null
-        : [],
-    },
-    timeline: {
-      items: chat.state.timeline.items,
-      loading: chat.state.composer.loading,
-    },
-    composer: {
-      value: chat.state.composer.inputValue,
-      loading: chat.state.composer.loading,
-      error: chat.state.composer.error,
-      fileList: chat.state.composer.fileList,
-      hintText: chat.state.session.error
-        ? String(chat.state.session.error?.message || chat.state.session.error)
-        : '',
-      onChange: (event) => chat.actions.setInputValue(event?.target?.value || ''),
-      onSend: (options = {}) => chat.actions.send(options),
-      onAttachFiles: (files) => chat.actions.attachFiles(files),
-      onRemoveFile: (file) => chat.actions.removeFile(file),
-    },
-    toolbar: {
-      onRefreshSessions: chat.actions.refreshSessionList,
-      onCreateSession: () => chat.actions.createSession(createSessionPayload),
-    },
-  }), [chat.actions, chat.state.composer.error, chat.state.composer.fileList, chat.state.composer.inputValue, chat.state.composer.loading, chat.state.session.error, chat.state.session.sessionId, chat.state.sessions.error, chat.state.sessions.items, chat.state.timeline.items, createSessionPayload, sessionAPI]);
-
-  return {
-    chat,
-    viewModel,
-  };
-}
-
-export { useCoreChatApp };

package/src/chat-core/facade/useBasicConversationFacade.js

@@ -1,280 +0,0 @@
-import { useCallback, useMemo } from 'react';
-import useChatSessionReducer from '../session/useChatSessionReducer.js';
-import { useChatInput } from '../input/useChatInput.js';
-import { useSSEStream } from '../stream/useSSEStream.js';
-import { buildTimelineItems } from '../messages/buildTimelineItems.js';
-import { useSessionListController } from '../session/useSessionListController.js';
-import { useStreamSendController } from '../stream/useStreamSendController.js';
-import { useBasicSendHandler } from '../orchestration/useBasicSendHandler.js';
-
-function normalizeRefs(value) {
-  if (!Array.isArray(value)) {
-    return null;
-  }
-  return value.filter((item) => item !== undefined && item !== null);
-}
-
-function resolvePromoteSessionPayload(raw = {}) {
-  const source = (
-    raw
-    && typeof raw === 'object'
-    && !Array.isArray(raw)
-  ) ? raw : {};
-  const sessionEnvelope = (
-    source.session
-    && typeof source.session === 'object'
-    && !Array.isArray(source.session)
-  ) ? source.session : {};
-  const payloadEnvelope = (
-    source.payload
-    && typeof source.payload === 'object'
-    && !Array.isArray(source.payload)
-  ) ? source.payload : {};
-  const payloadSessionEnvelope = (
-    payloadEnvelope.session
-    && typeof payloadEnvelope.session === 'object'
-    && !Array.isArray(payloadEnvelope.session)
-  ) ? payloadEnvelope.session : {};
-  const sessionId = String(
-    source.sessionId
-    || sessionEnvelope.session_id
-    || ''
-  ).trim();
-  const title = String(
-    payloadSessionEnvelope.title
-    || ''
-  ).trim();
-  return { sessionId, title };
-}
-
-/**
- * Basic conversation facade.
- *
- * Data flow:
- * 1) UI intent -> facade action
- * 2) facade preflight -> round execution
- * 3) stream event -> session state
- * 4) selector(buildTimelineItems) -> UI model
- */
-export default function useBasicConversationFacade({
-  sessionAPI,
-  messageAPI,
-  stream,
-  listParams = {},
-  functionType = 'chat_component_debug',
-  defaultSessionTitle = '新会话',
-  defaultSessionPayload = {},
-} = {}) {
-  const chatSession = useChatSessionReducer({ sessionAPI, messageAPI });
-  const chatInput = useChatInput();
-  const sseStream = useSSEStream(chatSession.sessionId);
-  const runtimeStream = stream || sseStream;
-
-  const sessionList = useSessionListController({
-    sessionAPI,
-    listParams,
-    onFailed: chatSession.setSessionError,
-  });
-
-  const streamSend = useStreamSendController({
-    stream: runtimeStream,
-    onStarted: () => {
-      chatSession.setSessionError(null);
-    },
-    onChunk: (chunk) => {
-      chatSession.appendStreamChunk(chunk);
-    },
-    onFailed: (error) => {
-      chatSession.setSessionError(error);
-    },
-  });
-
-  const resolveSendPreflight = useCallback(async (options = {}) => {
-    const content = String(options?.content ?? chatInput.inputValue ?? '').trim();
-    if (!content) {
-      return { blocked: true };
-    }
-
-    let sessionId = String(chatSession.sessionId || '').trim();
-    let createdNewSession = false;
-    if (!sessionId) {
-      sessionId = await chatSession.createSession({
-        function_type: functionType,
-        title: defaultSessionTitle,
-        ...defaultSessionPayload,
-      });
-      createdNewSession = true;
-    }
-
-    const streamOptions = (
-      options.streamOptions
-      && typeof options.streamOptions === 'object'
-      && !Array.isArray(options.streamOptions)
-    ) ? { ...options.streamOptions } : {};
-    const contextRefs = normalizeRefs(options.context_refs);
-    const knowledgeRefs = normalizeRefs(options.knowledge_refs);
-    if (contextRefs && !Object.prototype.hasOwnProperty.call(streamOptions, 'context_refs')) {
-      streamOptions.context_refs = contextRefs;
-    }
-    if (knowledgeRefs && !Object.prototype.hasOwnProperty.call(streamOptions, 'knowledge_refs')) {
-      streamOptions.knowledge_refs = knowledgeRefs;
-    }
-
-    return {
-      blocked: false,
-      content,
-      sessionId,
-      createdNewSession,
-      preserveInputOnError: options.preserveInputOnError === true,
-      attachedSessionFilesSnapshot: Array.isArray(chatInput.fileList) ? chatInput.fileList : [],
-      streamOptions,
-    };
-  }, [chatInput.fileList, chatInput.inputValue, chatSession, defaultSessionPayload, defaultSessionTitle, functionType]);
-
-  const executeSendRound = useCallback(async ({ sendPreflight }) => {
-    chatSession.appendUserMessage(sendPreflight.content);
-    chatSession.setLastUserMessage(sendPreflight.content);
-    chatSession.resetStreaming();
-    chatInput.clearInput();
-
-    await streamSend.executeStreamSend(
-      sendPreflight.content,
-      {
-        onTextReplace: (content) => {
-          chatSession.replaceStreamContent(content);
-        },
-        onAgentStatus: (agentStatus) => {
-          chatSession.setAgentStatus(agentStatus);
-        },
-        onThinkingTrace: (trace) => {
-          chatSession.setThinkingTrace(trace);
-        },
-        onExecutionTrace: (trace) => {
-          chatSession.setExecutionTrace(trace);
-        },
-        onKnowledgeSearch: (searchPayload) => {
-          chatSession.setKnowledgeSearch(searchPayload);
-        },
-        onSourcingCandidates: (sourcingPayload) => {
-          chatSession.setSourcingCandidates(sourcingPayload);
-        },
-        onKnowledgeCitation: (citationPayload) => {
-          chatSession.setKnowledgeCitation(citationPayload);
-        },
-        onPatchEvent: (patchEvent) => {
-          const patchSession = resolvePromoteSessionPayload(patchEvent);
-          if (!patchSession.sessionId) {
-            return;
-          }
-          if (patchSession.sessionId !== chatSession.sessionId || patchSession.title) {
-            chatSession.promoteSession({
-              sessionId: patchSession.sessionId,
-              ...(patchSession.title ? { title: patchSession.title } : {}),
-            });
-          }
-        },
-        onComplete: async (finalContent, doneMeta = {}) => {
-          const doneSession = resolvePromoteSessionPayload(doneMeta);
-          if (doneSession.sessionId && doneSession.sessionId !== chatSession.sessionId) {
-            chatSession.promoteSession({ sessionId: doneSession.sessionId });
-          }
-
-          chatSession.completeStreaming(finalContent, {
-            session_id: doneSession.sessionId || sendPreflight.sessionId,
-          });
-
-          if (sendPreflight.createdNewSession) {
-            void sessionList.loadSessionList({ background: true });
-          }
-        },
-      },
-      {
-        sessionIdOverride: sendPreflight.sessionId,
-        ...sendPreflight.streamOptions,
-      }
-    );
-  }, [chatInput, chatSession, sessionList, streamSend]);
-
-  const handleSendFailureRecovery = useCallback(({ preserveInputOnError, content }) => {
-    if (preserveInputOnError) {
-      chatInput.handleInputChange({ target: { value: content } });
-    }
-  }, [chatInput]);
-
-  const sendHandler = useBasicSendHandler({
-    resolveSendPreflight,
-    executeSendRound,
-    handleSendFailureRecovery,
-    emptyArray: [],
-  });
-
-  const createSession = useCallback(async (options = {}) => {
-    const mergedOptions = {
-      ...defaultSessionPayload,
-      ...options,
-    };
-    const sessionId = await chatSession.createSession({
-      function_type: functionType,
-      title: String(mergedOptions?.title || defaultSessionTitle),
-      project_id: mergedOptions?.project_id ?? null,
-      user_id: mergedOptions?.user_id ?? null,
-    });
-    await sessionList.loadSessionList({ background: true });
-    return sessionId;
-  }, [chatSession, defaultSessionPayload, defaultSessionTitle, functionType, sessionList]);
-
-  const selectSession = useCallback(async (sessionId) => {
-    await chatSession.loadSession(sessionId);
-  }, [chatSession]);
-
-  const refreshSessionList = useCallback(async () => {
-    return sessionList.loadSessionList({ background: true });
-  }, [sessionList]);
-
-  const timeline = useMemo(() => buildTimelineItems(chatSession, { loading: runtimeStream.loading }), [chatSession, runtimeStream.loading]);
-
-  const state = useMemo(() => ({
-    session: {
-      sessionId: chatSession.sessionId,
-      title: chatSession.sessionTitle,
-      detail: chatSession.sessionDetail,
-      error: chatSession.sessionError,
-    },
-    sessions: {
-      items: sessionList.sessions,
-      loading: sessionList.loading,
-      error: sessionList.error,
-    },
-    composer: {
-      inputValue: chatInput.inputValue,
-      fileList: chatInput.fileList,
-      isDragging: chatInput.isDragging,
-      loading: runtimeStream.loading,
-      error: runtimeStream.error,
-    },
-    timeline,
-  }), [chatInput.fileList, chatInput.inputValue, chatInput.isDragging, chatSession.sessionDetail, chatSession.sessionError, chatSession.sessionId, chatSession.sessionTitle, runtimeStream.error, runtimeStream.loading, sessionList.error, sessionList.loading, sessionList.sessions, timeline]);
-
-  const actions = useMemo(() => ({
-    createSession,
-    selectSession,
-    refreshSessionList,
-    resetSession: chatSession.resetSession,
-    loadSession: chatSession.loadSession,
-    updateTitle: chatSession.updateTitle,
-    setInputValue: (value) => chatInput.handleInputChange({ target: { value } }),
-    clearInput: chatInput.clearInput,
-    attachFiles: chatInput.appendFiles,
-    removeFile: chatInput.handleRemoveFile,
-    send: sendHandler.handleSend,
-    retry: runtimeStream.retry,
-    abort: runtimeStream.abort,
-  }), [chatInput, chatSession.loadSession, chatSession.resetSession, chatSession.updateTitle, createSession, refreshSessionList, runtimeStream.abort, runtimeStream.retry, selectSession, sendHandler.handleSend]);
-
-  return {
-    state,
-    actions,
-  };
-}
-
-export { useBasicConversationFacade };

package/src/chat-core/index.js

@@ -1,14 +0,0 @@
-export { useChatSessionReducer, initialState as chatSessionInitialState } from './session/index.js';
-export { useChatInput } from './input/useChatInput.js';
-export { useSSEStream } from './stream/useSSEStream.js';
-export { SSEClient } from './stream/sse-client.js';
-export * from './stream/sse-events.js';
-export { buildTimelineItems } from './messages/buildTimelineItems.js';
-export { useSessionListController } from './session/index.js';
-export { useStreamSendController } from './stream/useStreamSendController.js';
-export { useBasicSendHandler } from './orchestration/useBasicSendHandler.js';
-export { useBasicConversationFacade } from './facade/useBasicConversationFacade.js';
-export { useCoreChatApp } from './app/useCoreChatApp.js';
-export { useAppStream } from './app/useAppStream.js';
-export { createMockRuntime } from './app/mockRuntime.js';
-export * from './runtime/runtimeMode.js';

package/src/chat-core/input/useChatInput.js

@@ -1,103 +0,0 @@
-import { useState, useCallback } from 'react';
-
-function buildAttachmentFile(file, index = 0, status = 'ready') {
-  return {
-    uid: file?.uid || `${Date.now()}-${index}`,
-    name: file?.name || `附件-${index + 1}`,
-    size: Number.isFinite(file?.size) ? file.size : null,
-    type: file?.type || '',
-    originFileObj: file?.originFileObj || file || null,
-    status: file?.status || status,
-    error_message: file?.error_message || '',
-    created_at: file?.created_at || new Date().toISOString(),
-  };
-}
-
-export function useChatInput() {
-  const [inputValue, setInputValue] = useState('');
-  const [fileList, setFileList] = useState([]);
-  const [isDragging, setIsDragging] = useState(false);
-
-  const handleInputChange = useCallback((e) => {
-    setInputValue(e.target.value);
-  }, []);
-
-  const handleFileChange = useCallback(({ fileList: newFileList }) => {
-    setFileList(newFileList);
-  }, []);
-
-  const handleRemoveFile = useCallback((file) => {
-    setFileList((prev) => prev.filter((f) => f.uid !== file.uid));
-  }, []);
-
-  const handleDrop = useCallback((e) => {
-    e.preventDefault();
-    e.stopPropagation();
-    setIsDragging(false);
-
-    const files = Array.from(e.dataTransfer.files);
-    const newFiles = files.map((file, index) => buildAttachmentFile(file, index));
-
-    setFileList((prev) => [...prev, ...newFiles]);
-    return files.length;
-  }, []);
-
-  const appendFiles = useCallback((files = [], options = {}) => {
-    const normalized = Array.isArray(files)
-      ? files.map((file, index) => buildAttachmentFile(file, index, options.status || 'ready'))
-      : [];
-    if (normalized.length === 0) {
-      return;
-    }
-    setFileList((prev) => [...prev, ...normalized]);
-  }, []);
-
-  const updateFileStatus = useCallback((uid, status, errorMessage = '') => {
-    if (!uid) {
-      return;
-    }
-    setFileList((prev) => prev.map((file) => (
-      file.uid === uid
-        ? {
-            ...file,
-            status: status || file.status,
-            error_message: errorMessage || '',
-          }
-        : file
-    )));
-  }, []);
-
-  const handleDragOver = useCallback((e) => {
-    e.preventDefault();
-    e.stopPropagation();
-    setIsDragging(true);
-  }, []);
-
-  const handleDragLeave = useCallback((e) => {
-    e.preventDefault();
-    e.stopPropagation();
-    setIsDragging(false);
-  }, []);
-
-  const clearInput = useCallback(() => {
-    setInputValue('');
-    setFileList([]);
-  }, []);
-
-  return {
-    inputValue,
-    fileList,
-    isDragging,
-    handleInputChange,
-    handleFileChange,
-    handleRemoveFile,
-    appendFiles,
-    updateFileStatus,
-    handleDrop,
-    handleDragOver,
-    handleDragLeave,
-    clearInput,
-  };
-}
-
-export default useChatInput;

package/src/chat-core/messages/buildTimelineItems.analysis-route.test.mjs

@@ -1,36 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import { buildTimelineItems } from './buildTimelineItems.js';
-
-test('buildTimelineItems attaches analysis route metadata on sourcing_candidates artifact', () => {
-  const timeline = buildTimelineItems({
-    messages: [
-      {
-        message_id: 'm1',
-        role: 'user',
-        content: '请分析这些供应商',
-        created_at: '2026-04-21T00:00:00Z',
-      },
-    ],
-    streaming: {
-      content: '',
-      sourcingCandidates: {
-        run_id: 'sourcing-run-1',
-        candidates: [{ supplier_id: 'sup-1' }],
-        analysis_route: {
-          analysis_type: 'sourcing',
-          template_id: 'analysis_sourcing_default',
-          reason_codes: ['ROUTE_SIGNAL_SOURCING_INTENT'],
-          confidence: 0.82,
-        },
-      },
-      roundKey: 'rk-1',
-    },
-  });
-
-  const sourcingItem = timeline.items.find((item) => item.type === 'sourcing_candidates');
-  assert.ok(sourcingItem);
-  assert.equal(sourcingItem.analysisRoute.analysis_type, 'sourcing');
-  assert.equal(sourcingItem.analysisRoute.template_id, 'analysis_sourcing_default');
-});