flare-chat-core 0.2.1 → 0.2.2

package/src/app/core-chat-entry/useWorkspaceController.jsx

@@ -0,0 +1,226 @@
+import React, { useMemo, useState } from 'react';
+import {
+  CHAT_UI_THEME_TOKENS,
+  DEFAULT_CHAT_UI_THEME,
+  KnowledgeHubDrawerContent,
+} from 'flare-chat-ui';
+import { useChatCorePipelines } from './useChatCorePipelines.js';
+import {
+  RESOLVED_UI_LABELS,
+  STARTER_SCENARIOS,
+} from './constants.js';
+import {
+  selectActiveSession,
+  selectProjectItems,
+} from './selectors.js';
+import { useProjectSourceUpload } from './useProjectSourceUpload.js';
+import { useProjectNameEditing } from './useProjectNameEditing.js';
+import { useWorkspacePanels } from './useWorkspacePanels.js';
+import { useWorkspaceComposerController } from './useWorkspaceComposerController.jsx';
+import { useWorkspaceCanvasController } from './useWorkspaceCanvasController.jsx';
+
+export function useWorkspaceController({
+  functionType = 'chat_component_debug',
+  defaultSessionTitle = '调试会话',
+  projectId = 'project_demo_001',
+  userId = 'user_demo_001',
+  backendMode = 'real',
+  kernelBaseUrl = 'http://127.0.0.1:18002',
+  apiBaseUrl = '',
+  apiToken = '',
+  defaultProjectName = '本地演示项目',
+  sessionAPI,
+  messageAPI,
+} = {}) {
+  const {
+    apiReadinessGate,
+    blockedApiError,
+    realApi,
+    viewModel,
+  } = useChatCorePipelines({
+    functionType,
+    defaultSessionTitle,
+    projectId,
+    userId,
+    backendMode,
+    kernelBaseUrl,
+    apiBaseUrl,
+    apiToken,
+    sessionAPI,
+    messageAPI,
+  });
+
+  const themeTokens = CHAT_UI_THEME_TOKENS[DEFAULT_CHAT_UI_THEME];
+  const [activeWorkspaceTab, setActiveWorkspaceTab] = useState('chats');
+  const [showAllScenarios, setShowAllScenarios] = useState(false);
+  const {
+    knowledgeHubPopoverOpen,
+    setKnowledgeHubPopoverOpen,
+    showCanvasPanel,
+    setShowCanvasPanel,
+    canvasActiveTabKey,
+    setCanvasActiveTabKey,
+    handleOpenKnowledgeHub,
+    handleToggleWorkspacePanel,
+  } = useWorkspacePanels();
+  const [canvasFullscreenOpen, setCanvasFullscreenOpen] = useState(false);
+  const {
+    projectNameEditing,
+    projectNameDraft,
+    setProjectNameDraft,
+    projectDisplayName,
+    handleProjectNameStartEdit,
+    handleProjectNameCancel,
+    handleProjectNameSave,
+  } = useProjectNameEditing({ defaultProjectName });
+
+  const {
+    fileInputRef: sourceFileInputRef,
+    sourceActionError,
+    sourceItems,
+    sourceRemovingId,
+    sourceSyncLoading,
+    sourceUploadLoading,
+    sourceUploadProgressItems,
+    handleOpenSourcePicker,
+    handleSourceFileChange,
+    handleRemoveSource,
+    handleRetrySource,
+    handleViewSourceDetail,
+  } = useProjectSourceUpload({
+    projectId,
+    userId,
+    sourceAPI: realApi?.sourceAPI || null,
+    shouldLoadSources: activeWorkspaceTab === 'sources' || knowledgeHubPopoverOpen,
+  });
+
+  const sessions = Array.isArray(viewModel.sessionList.sessions) ? viewModel.sessionList.sessions : [];
+  const activeSessionId = viewModel.sessionList.activeSessionId;
+  const activeSession = selectActiveSession(sessions, activeSessionId);
+  const projectItems = selectProjectItems({
+    projectId,
+    projectDisplayName,
+    sessions,
+  });
+  const projectSlot = projectItems[0] || null;
+  const hasProject = Boolean(projectSlot?.name && String(projectSlot.name).trim());
+
+  const visibleScenarios = useMemo(() => (
+    showAllScenarios ? STARTER_SCENARIOS : STARTER_SCENARIOS.slice(0, 2)
+  ), [showAllScenarios]);
+
+  const handleProjectNameStartEditForSlot = () => {
+    handleProjectNameStartEdit(projectSlot);
+  };
+
+  const {
+    actionGuards,
+    inputState,
+    composerNode,
+    composerModeKey,
+    languageGuardEnabled,
+    friendlyToneEnabled,
+    evidenceStrictMode,
+    evidenceHitScoreThreshold,
+  } = useWorkspaceComposerController({
+    userId,
+    projectId,
+    activeSessionId,
+    realApi,
+    viewModel,
+    apiReadinessGate,
+    blockedApiError,
+    sourceItems,
+    activeWorkspaceTab,
+    setActiveWorkspaceTab,
+    setShowCanvasPanel,
+    setCanvasActiveTabKey,
+    themeTokens,
+  });
+
+  const {
+    canvasPanelNode,
+    renderedTimelineItems,
+    handleUICardAction,
+    generativeRegistry,
+  } = useWorkspaceCanvasController({
+    apiBaseUrl,
+    projectId,
+    userId,
+    activeSessionId,
+    timeline: viewModel.timeline,
+    composerModeKey,
+    evidenceStrictMode,
+    evidenceHitScoreThreshold,
+    showCanvasPanel,
+    setShowCanvasPanel,
+    canvasActiveTabKey,
+    setCanvasActiveTabKey,
+    canvasFullscreenOpen,
+    setCanvasFullscreenOpen,
+    inputState,
+    themeTokens,
+    languageGuardEnabled,
+    friendlyToneEnabled,
+  });
+
+  const knowledgeHubPopoverContent = (
+    <KnowledgeHubDrawerContent
+      resolvedUILabels={RESOLVED_UI_LABELS}
+      sourceUploadLoading={sourceUploadLoading}
+      sourceSyncLoading={sourceSyncLoading}
+      sourceActionError={sourceActionError}
+      sourceItems={sourceItems}
+      sourceUploadProgressItems={sourceUploadProgressItems}
+      handleOpenSourcePicker={handleOpenSourcePicker}
+      handleRemoveSource={handleRemoveSource}
+      handleViewSourceDetail={handleViewSourceDetail}
+    />
+  );
+
+  return {
+    themeTokens,
+    viewModel,
+    actionGuards,
+    apiReadinessGate,
+    hasProject,
+    projectItems,
+    projectSlot,
+    activeSession,
+    sessions,
+    projectNameEditing,
+    projectNameDraft,
+    setProjectNameDraft,
+    handleProjectNameSave,
+    handleProjectNameCancel,
+    projectDisplayName,
+    handleProjectNameStartEdit: handleProjectNameStartEditForSlot,
+    activeWorkspaceTab,
+    setActiveWorkspaceTab,
+    knowledgeHubPopoverContent,
+    knowledgeHubPopoverOpen,
+    setKnowledgeHubPopoverOpen,
+    handleOpenKnowledgeHub,
+    showCanvasPanel,
+    handleToggleWorkspacePanel,
+    composerNode,
+    handleOpenSourcePicker,
+    handleRemoveSource,
+    handleRetrySource,
+    handleViewSourceDetail,
+    sourceActionError,
+    sourceItems,
+    sourceRemovingId,
+    sourceSyncLoading,
+    sourceUploadLoading,
+    canvasPanelNode,
+    renderedTimelineItems,
+    handleUICardAction,
+    generativeRegistry,
+    showAllScenarios,
+    setShowAllScenarios,
+    visibleScenarios,
+    sourceFileInputRef,
+    handleSourceFileChange,
+  };
+}

package/src/app/core-chat-entry/useWorkspacePanels.js

@@ -0,0 +1,55 @@
+import { useCallback, useEffect, useState } from 'react';
+
+export function useWorkspacePanels() {
+  const [knowledgeHubPopoverOpen, setKnowledgeHubPopoverOpen] = useState(false);
+  const [showCanvasPanel, setShowCanvasPanel] = useState(false);
+  const [canvasActiveTabKey, setCanvasActiveTabKey] = useState('requirement');
+  const [canvasFocusEvidenceAnchorId, setCanvasFocusEvidenceAnchorId] = useState('');
+
+  const handleOpenKnowledgeHub = useCallback(() => {
+    setKnowledgeHubPopoverOpen(true);
+  }, []);
+
+  const handleToggleWorkspacePanel = useCallback(() => {
+    setShowCanvasPanel((prev) => !prev);
+  }, []);
+
+  const handleUICardAction = useCallback((action) => {
+    const actionType = String(action?.type || action?.action_key || '').trim();
+    if (actionType === 'open_evidence_citation') {
+      const citationId = String(action?.citation_id || '').trim();
+      setShowCanvasPanel(true);
+      setCanvasActiveTabKey('evidence');
+      setCanvasFocusEvidenceAnchorId(citationId ? `retrieval-evidence-${citationId}` : '');
+      return;
+    }
+    if (actionType.includes('canvas') || actionType.includes('evidence') || actionType.includes('sourcing')) {
+      setShowCanvasPanel(true);
+      setCanvasActiveTabKey(actionType.includes('sourcing') ? 'sourcing' : 'evidence');
+    }
+  }, []);
+
+  useEffect(() => {
+    if (!canvasFocusEvidenceAnchorId) {
+      return;
+    }
+    const timer = setTimeout(() => setCanvasFocusEvidenceAnchorId(''), 1600);
+    return () => clearTimeout(timer);
+  }, [canvasFocusEvidenceAnchorId]);
+
+  return {
+    knowledgeHubPopoverOpen,
+    setKnowledgeHubPopoverOpen,
+    showCanvasPanel,
+    setShowCanvasPanel,
+    canvasActiveTabKey,
+    setCanvasActiveTabKey,
+    canvasFocusEvidenceAnchorId,
+    setCanvasFocusEvidenceAnchorId,
+    handleOpenKnowledgeHub,
+    handleToggleWorkspacePanel,
+    handleUICardAction,
+  };
+}
+
+export default useWorkspacePanels;

package/src/app/hooks/useComposerAttachmentSync.js

@@ -0,0 +1,223 @@
+import { useCallback, useEffect, useMemo, useRef } from 'react';
+import {
+  collectReadyAttachmentRefs,
+  hasNonReadyComposerAttachments,
+} from '../core-chat-entry/attachmentSendRefs.js';
+
+export function useComposerAttachmentSync({
+  composerFileList,
+  onSyncFileList,
+  realSourceApi,
+  projectId,
+  userId,
+  activeSessionId,
+} = {}) {
+  const composerFileListRef = useRef(Array.isArray(composerFileList) ? composerFileList : []);
+  const attachmentUploadTaskRef = useRef(new Set());
+  const attachmentPollingTaskRef = useRef(new Set());
+
+  useEffect(() => {
+    composerFileListRef.current = Array.isArray(composerFileList) ? composerFileList : [];
+  }, [composerFileList]);
+
+  const syncComposerFilePatch = useCallback((uid, patch = {}) => {
+    const normalizedUid = String(uid || '').trim();
+    if (!normalizedUid || typeof onSyncFileList !== 'function') {
+      return;
+    }
+    const currentList = Array.isArray(composerFileListRef.current)
+      ? composerFileListRef.current
+      : [];
+    let changed = false;
+    const nextList = currentList.map((item) => {
+      if (String(item?.uid || '').trim() !== normalizedUid) {
+        return item;
+      }
+      changed = true;
+      return {
+        ...item,
+        ...patch,
+      };
+    });
+    if (!changed) {
+      return;
+    }
+    composerFileListRef.current = nextList;
+    onSyncFileList(nextList);
+  }, [onSyncFileList]);
+
+  const pollComposerAttachmentStatus = useCallback((sourceId, fileUid) => {
+    const normalizedSourceId = String(sourceId || '').trim();
+    const normalizedFileUid = String(fileUid || '').trim();
+    if (
+      !normalizedSourceId
+      || !normalizedFileUid
+      || attachmentPollingTaskRef.current.has(normalizedSourceId)
+      || typeof realSourceApi?.listProjectSources !== 'function'
+    ) {
+      return;
+    }
+
+    attachmentPollingTaskRef.current.add(normalizedSourceId);
+    const wait = (ms) => new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+    const maxPollCount = 80;
+    const pollIntervalMs = 1500;
+
+    void (async () => {
+      let pollCount = 0;
+      while (pollCount < maxPollCount) {
+        pollCount += 1;
+        const fileExists = composerFileListRef.current.some((item) => String(item?.uid || '').trim() === normalizedFileUid);
+        if (!fileExists) {
+          return;
+        }
+        try {
+          const response = await realSourceApi.listProjectSources(projectId, activeSessionId || undefined);
+          const sources = Array.isArray(response?.sources) ? response.sources : [];
+          const matchedSource = sources.find((item) => {
+            const currentSourceId = String(item?.source_id || item?.id || '').trim();
+            return currentSourceId === normalizedSourceId;
+          });
+          if (matchedSource) {
+            const nextStatus = String(matchedSource.status || '').trim().toLowerCase() || 'uploaded';
+            syncComposerFilePatch(normalizedFileUid, {
+              source_id: normalizedSourceId,
+              status: nextStatus,
+              error_message: String(matchedSource?.error_message || ''),
+            });
+            if (nextStatus === 'ready' || nextStatus.startsWith('failed') || nextStatus === 'error') {
+              return;
+            }
+          }
+        } catch (error) {
+          syncComposerFilePatch(normalizedFileUid, {
+            error_message: String(error?.message || ''),
+          });
+        }
+        await wait(pollIntervalMs);
+      }
+      syncComposerFilePatch(normalizedFileUid, {
+        status: 'failed',
+        error_message: '文件处理超时，请重试',
+      });
+    })().finally(() => {
+      attachmentPollingTaskRef.current.delete(normalizedSourceId);
+    });
+  }, [activeSessionId, projectId, realSourceApi, syncComposerFilePatch]);
+
+  useEffect(() => {
+    if (typeof realSourceApi?.uploadSourceFile !== 'function') {
+      return;
+    }
+
+    const currentFileList = Array.isArray(composerFileList) ? composerFileList : [];
+    currentFileList.forEach((item) => {
+      const fileUid = String(item?.uid || '').trim();
+      if (!fileUid || attachmentUploadTaskRef.current.has(fileUid)) {
+        return;
+      }
+      const sourceId = String(item?.source_id || '').trim();
+      if (sourceId) {
+        const status = String(item?.status || '').trim().toLowerCase();
+        if (status && status !== 'ready') {
+          pollComposerAttachmentStatus(sourceId, fileUid);
+        }
+        return;
+      }
+      const status = String(item?.status || '').trim().toLowerCase();
+      if (status.startsWith('failed')) {
+        return;
+      }
+      const uploadableFile = item?.originFileObj || null;
+      if (!(uploadableFile instanceof File)) {
+        syncComposerFilePatch(fileUid, {
+          status: 'failed',
+          error_message: '缺少可上传文件',
+        });
+        return;
+      }
+
+      attachmentUploadTaskRef.current.add(fileUid);
+      syncComposerFilePatch(fileUid, {
+        status: 'uploading',
+        error_message: '',
+      });
+
+      void (async () => {
+        try {
+          const uploaded = await realSourceApi.uploadSourceFile({
+            project_id: projectId,
+            user_id: userId,
+            session_id: activeSessionId || null,
+            file: uploadableFile,
+            filename: item?.name || uploadableFile?.name || 'upload.bin',
+          });
+          const uploadedSourceId = String(uploaded?.source_id || uploaded?.id || '').trim();
+          if (!uploadedSourceId) {
+            syncComposerFilePatch(fileUid, {
+              status: 'failed',
+              error_message: '上传成功但未返回 source_id',
+            });
+            return;
+          }
+          const uploadedStatus = String(uploaded?.status || 'uploaded').trim().toLowerCase() || 'uploaded';
+          syncComposerFilePatch(fileUid, {
+            ...uploaded,
+            source_id: uploadedSourceId,
+            status: uploadedStatus,
+            error_message: String(uploaded?.error_message || ''),
+          });
+          if (uploadedStatus === 'ready' || uploadedStatus.startsWith('failed') || uploadedStatus === 'error') {
+            return;
+          }
+          pollComposerAttachmentStatus(uploadedSourceId, fileUid);
+        } catch (error) {
+          syncComposerFilePatch(fileUid, {
+            status: 'failed',
+            error_message: String(error?.message || '上传失败'),
+          });
+        } finally {
+          attachmentUploadTaskRef.current.delete(fileUid);
+        }
+      })();
+    });
+  }, [
+    activeSessionId,
+    composerFileList,
+    pollComposerAttachmentStatus,
+    projectId,
+    userId,
+    realSourceApi,
+    syncComposerFilePatch,
+  ]);
+
+  const readyAttachmentRefs = useMemo(
+    () => collectReadyAttachmentRefs(composerFileList),
+    [composerFileList],
+  );
+  const hasNonReadyAttachments = useMemo(
+    () => hasNonReadyComposerAttachments(composerFileList),
+    [composerFileList],
+  );
+  const syncErrors = useMemo(() => {
+    const list = Array.isArray(composerFileList) ? composerFileList : [];
+    return list
+      .map((item) => ({
+        uid: String(item?.uid || '').trim(),
+        source_id: String(item?.source_id || '').trim(),
+        error_message: String(item?.error_message || '').trim(),
+      }))
+      .filter((item) => item.error_message);
+  }, [composerFileList]);
+
+  return {
+    composerFileListRef,
+    hasNonReadyAttachments,
+    readyAttachmentRefs,
+    syncErrors,
+  };
+}
+
+export default useComposerAttachmentSync;

package/src/app/hooks/useComposerChooserHandlers.js

@@ -0,0 +1,52 @@
+import { useCallback } from 'react';
+
+function buildDraftRoundKey({ activeSessionId, composerValue }) {
+  return `${String(activeSessionId || 'draft')}:${String(composerValue || '').trim()}`;
+}
+
+export function useComposerChooserHandlers({
+  setComposerModeKey,
+  setSourcingChooser,
+  setShowCanvasPanel,
+  setCanvasActiveTabKey,
+  setSourcingChooserDismissDraftKey,
+  activeSessionId,
+  composerValue,
+} = {}) {
+  const onComposerActionSelect = useCallback((choice) => {
+    const actionKey = String(choice?.action?.action_key || '').trim();
+    const draftRoundKey = buildDraftRoundKey({ activeSessionId, composerValue });
+    if (actionKey === 'open_sourcing') {
+      setComposerModeKey('intelligent_sourcing');
+      setSourcingChooser(null);
+      setShowCanvasPanel(true);
+      setCanvasActiveTabKey('sourcing');
+      return;
+    }
+    if (actionKey === 'dismiss_sourcing_once') {
+      setSourcingChooser(null);
+      setSourcingChooserDismissDraftKey(draftRoundKey);
+    }
+  }, [
+    activeSessionId,
+    composerValue,
+    setCanvasActiveTabKey,
+    setComposerModeKey,
+    setShowCanvasPanel,
+    setSourcingChooser,
+    setSourcingChooserDismissDraftKey,
+  ]);
+
+  const onComposerChooserDismiss = useCallback(() => {
+    const draftRoundKey = buildDraftRoundKey({ activeSessionId, composerValue });
+    setSourcingChooser(null);
+    setSourcingChooserDismissDraftKey(draftRoundKey);
+  }, [activeSessionId, composerValue, setSourcingChooser, setSourcingChooserDismissDraftKey]);
+
+  return {
+    onComposerActionSelect,
+    onComposerChooserDismiss,
+  };
+}
+
+export default useComposerChooserHandlers;

package/src/app/hooks/useSendWithContextRefs.js

@@ -0,0 +1,140 @@
+import { useCallback } from 'react';
+import { detectSourcingIntent } from '../../chat-core/pipelines/preprocess-message.js';
+import {
+  collectSourceIdStrings,
+  mergeSourceReferenceLists,
+} from '../core-chat-entry/attachmentSendRefs.js';
+
+function normalizeText(value) {
+  return String(value || '').trim();
+}
+
+export function isSourcingRefreshCommand(value) {
+  const normalized = normalizeText(value);
+  if (!normalized) {
+    return false;
+  }
+  if (normalized === '继续' || normalized === '继续寻源') {
+    return true;
+  }
+  return normalized.includes('换一批') || normalized.includes('再来一批');
+}
+
+export function resolveSourcingPayloadExtra({
+  streamOptions,
+  isSourcingMode,
+  currentInput,
+  latestSourcingQuery,
+  latestSourcingResultIds,
+}) {
+  const payloadExtra = (
+    streamOptions?.payloadExtra
+    && typeof streamOptions.payloadExtra === 'object'
+    && !Array.isArray(streamOptions.payloadExtra)
+  ) ? { ...streamOptions.payloadExtra } : {};
+  if (!isSourcingMode) {
+    return payloadExtra;
+  }
+
+  const normalizedInput = normalizeText(currentInput);
+  const normalizedLatestQuery = normalizeText(latestSourcingQuery);
+  if (normalizedLatestQuery) {
+    const hasSourcingIntentInInput = detectSourcingIntent(normalizedInput);
+    if (!hasSourcingIntentInInput || isSourcingRefreshCommand(normalizedInput)) {
+      payloadExtra.sourcing_query = normalizedLatestQuery;
+    }
+  }
+  if (isSourcingRefreshCommand(normalizedInput)) {
+    payloadExtra.append_mode = true;
+    payloadExtra.lock_existing_order = true;
+    payloadExtra.base_result_ids = Array.isArray(latestSourcingResultIds)
+      ? latestSourcingResultIds.map((item) => normalizeText(item)).filter(Boolean)
+      : [];
+  }
+  return payloadExtra;
+}
+
+export function useSendWithContextRefs({
+  composerModeKey,
+  setSourcingChooser,
+  sourceItems,
+  composer,
+  activeWorkspaceTab,
+  setActiveWorkspaceTab,
+  composerFileListRef,
+  hasNonReadyAttachments,
+  readyAttachmentRefs,
+  latestSourcingQuery = '',
+  latestSourcingResultIds = [],
+} = {}) {
+  return useCallback(async (options = {}) => {
+    const streamOptions = (
+      options?.streamOptions
+      && typeof options.streamOptions === 'object'
+      && !Array.isArray(options.streamOptions)
+    ) ? { ...options.streamOptions } : {};
+    const normalizedModeKey = String(streamOptions.modeKey || composerModeKey || '').trim();
+    const isSourcingMode = normalizedModeKey === 'intelligent_sourcing';
+    const currentInput = String(composer?.value || '').trim();
+
+    if (hasNonReadyAttachments) {
+      return false;
+    }
+
+    setSourcingChooser(null);
+    const currentComposerFileList = Array.isArray(composerFileListRef?.current)
+      ? composerFileListRef.current
+      : [];
+    const projectReadyRefs = Array.isArray(sourceItems)
+      ? sourceItems.filter((item) => String(item?.status || '').trim().toLowerCase() === 'ready')
+      : [];
+    const sourcingDefaultRefs = isSourcingMode ? mergeSourceReferenceLists(projectReadyRefs) : [];
+    const mergedRefs = mergeSourceReferenceLists(
+      options?.context_refs,
+      options?.knowledge_refs,
+      readyAttachmentRefs,
+      sourcingDefaultRefs,
+    );
+    const mergedKnowledgeRefIds = collectSourceIdStrings(
+      options?.context_refs,
+      options?.knowledge_refs,
+      readyAttachmentRefs,
+      sourcingDefaultRefs,
+    );
+    streamOptions.payloadExtra = resolveSourcingPayloadExtra({
+      streamOptions,
+      isSourcingMode,
+      currentInput,
+      latestSourcingQuery,
+      latestSourcingResultIds,
+    });
+
+    const sendResult = await composer.onSend({
+      ...options,
+      ...(currentInput ? { content: currentInput } : {}),
+      streamOptions,
+      context_refs: mergedRefs,
+      knowledge_refs: mergedKnowledgeRefIds,
+      attachedSessionFilesSnapshot: currentComposerFileList,
+    });
+
+    if (sendResult === true && activeWorkspaceTab === 'sources') {
+      setActiveWorkspaceTab('chats');
+    }
+    return sendResult;
+  }, [
+    activeWorkspaceTab,
+    composer,
+    composerFileListRef,
+    composerModeKey,
+    hasNonReadyAttachments,
+    readyAttachmentRefs,
+    setActiveWorkspaceTab,
+    setSourcingChooser,
+    sourceItems,
+    latestSourcingQuery,
+    latestSourcingResultIds,
+  ]);
+}
+
+export default useSendWithContextRefs;