flare-chat-core 0.2.1 → 0.2.3

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

@@ -0,0 +1,68 @@
+import { useCallback, useMemo, useState } from 'react';
+
+function normalizeError(error, fallbackMessage) {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error || fallbackMessage));
+}
+
+export function useAppActionErrorGuards({
+  blocked = false,
+  blockedError,
+  sessionListError = null,
+  composerError = null,
+  onCreateProject,
+  onCreateSession,
+  onSend,
+} = {}) {
+  const [actionError, setActionError] = useState(null);
+
+  const handleCreateProject = useCallback(async () => {
+    if (blocked) {
+      setActionError(blockedError);
+      return;
+    }
+    try {
+      setActionError(null);
+      await onCreateProject?.();
+    } catch (nextError) {
+      setActionError(normalizeError(nextError, '创建项目失败'));
+    }
+  }, [blocked, blockedError, onCreateProject]);
+
+  const handleCreateSession = useCallback(async () => {
+    if (blocked) {
+      setActionError(blockedError);
+      return;
+    }
+    try {
+      setActionError(null);
+      await onCreateSession?.();
+    } catch (nextError) {
+      setActionError(normalizeError(nextError, '创建会话失败'));
+    }
+  }, [blocked, blockedError, onCreateSession]);
+
+  const handleSend = useCallback(async (options = {}) => {
+    if (blocked) {
+      setActionError(blockedError);
+      return;
+    }
+    setActionError(null);
+    const sendResult = await onSend?.(options);
+    if (sendResult instanceof Error) {
+      setActionError(sendResult);
+    }
+    return sendResult;
+  }, [blocked, blockedError, onSend]);
+
+  return useMemo(() => ({
+    actionError,
+    handleCreateProject,
+    handleCreateSession,
+    handleSend,
+    sessionPaneError: actionError || sessionListError || null,
+    streamError: actionError || composerError || null,
+  }), [actionError, composerError, handleCreateProject, handleCreateSession, handleSend, sessionListError]);
+}

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

@@ -0,0 +1,110 @@
+import { useMemo } from 'react';
+import { useCoreChatApp } from '../../chat-core/app/useCoreChatApp.js';
+import { useAppStream } from '../../chat-core/app/useAppStream.js';
+import { createMockRuntime } from '../../chat-core/app/mockRuntime.js';
+import { createSessionMessageAPI } from '../../adapters/session-message-api.js';
+import { useRealApiReadinessGate } from './useRealApiReadinessGate.js';
+
+export function useChatCorePipelines({
+  functionType,
+  defaultSessionTitle,
+  projectId,
+  userId,
+  backendMode,
+  kernelBaseUrl,
+  apiBaseUrl,
+  apiToken,
+  sessionAPI,
+  messageAPI,
+}) {
+  const normalizedApiBaseUrl = String(apiBaseUrl || '').trim();
+  const runtime = useMemo(() => createMockRuntime({
+    defaultFunctionType: functionType,
+    defaultSessionTitle,
+  }), [defaultSessionTitle, functionType]);
+
+  const scope = useMemo(() => ({
+    projectId,
+    userId,
+  }), [projectId, userId]);
+
+  const listParams = useMemo(() => ({
+    status: 'active',
+    page: 1,
+    page_size: 20,
+    function_type: functionType,
+    project_id: projectId,
+  }), [functionType, projectId]);
+
+  const shouldUseRealAPI = backendMode === 'real' && !sessionAPI && !messageAPI;
+  const apiReadinessGate = useRealApiReadinessGate({
+    enabled: shouldUseRealAPI,
+    apiBaseUrl: normalizedApiBaseUrl,
+    apiToken,
+  });
+  const blockedApiError = useMemo(() => (
+    apiReadinessGate.error || new Error('API 不可用，请检查配置与服务状态')
+  ), [apiReadinessGate.error]);
+  const blockedSessionAPI = useMemo(() => ({
+    list: async () => ({ sessions: [] }),
+    get: async () => {
+      throw blockedApiError;
+    },
+    create: async () => {
+      throw blockedApiError;
+    },
+    update: async () => {
+      throw blockedApiError;
+    },
+  }), [blockedApiError]);
+  const blockedMessageAPI = useMemo(() => ({
+    list: async () => {
+      throw blockedApiError;
+    },
+  }), [blockedApiError]);
+  const realApi = useMemo(() => {
+    if (!shouldUseRealAPI || apiReadinessGate.blocked) {
+      return null;
+    }
+    return createSessionMessageAPI({
+      baseUrl: normalizedApiBaseUrl,
+      token: apiToken,
+    });
+  }, [apiReadinessGate.blocked, apiToken, normalizedApiBaseUrl, shouldUseRealAPI]);
+  const resolvedSessionAPI = sessionAPI
+    || realApi?.sessionAPI
+    || (shouldUseRealAPI ? blockedSessionAPI : runtime.sessionAPI);
+  const resolvedMessageAPI = messageAPI
+    || realApi?.messageAPI
+    || (shouldUseRealAPI ? blockedMessageAPI : runtime.messageAPI);
+  const useRuntimePersistence = !shouldUseRealAPI && !sessionAPI && !messageAPI;
+
+  const stream = useAppStream({
+    runtime,
+    backendMode,
+    apiBaseUrl: normalizedApiBaseUrl,
+    kernelBaseUrl,
+    scope,
+    persistExchange: useRuntimePersistence ? runtime.appendExchange : null,
+  });
+
+  const { viewModel } = useCoreChatApp({
+    sessionAPI: resolvedSessionAPI,
+    messageAPI: resolvedMessageAPI,
+    stream,
+    functionType,
+    defaultSessionTitle,
+    listParams,
+    createSessionPayload: {
+      project_id: projectId,
+      user_id: userId,
+    },
+  });
+
+  return {
+    apiReadinessGate,
+    blockedApiError,
+    realApi,
+    viewModel,
+  };
+}

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

@@ -0,0 +1,89 @@
+import { useMemo } from 'react';
+
+function normalizeText(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function hasAnyKeyword(content, keywords = []) {
+  return keywords.some((keyword) => content.includes(String(keyword || '').trim().toLowerCase()));
+}
+
+function buildSuggestionFromInput({
+  inputValue,
+  activeModeKey,
+  tipRules = [],
+  contextFlags = {},
+}) {
+  const resolvedModeKey = String(activeModeKey || '').trim();
+  if (resolvedModeKey !== 'auto') {
+    return null;
+  }
+  const normalizedInput = normalizeText(inputValue);
+  const normalizedRules = Array.isArray(tipRules) ? tipRules : [];
+  if (!normalizedInput && normalizedRules.length === 0) {
+    return null;
+  }
+  const matchedRule = normalizedRules.find((rule) => {
+    const keywords = Array.isArray(rule?.keywords) ? rule.keywords : [];
+    const hasKeywordMatch = normalizedInput && hasAnyKeyword(normalizedInput, keywords);
+    const contextKey = String(rule?.whenContextKey || '').trim();
+    const hasContextMatch = contextKey ? contextFlags?.[contextKey] === true : false;
+    return hasKeywordMatch || hasContextMatch;
+  });
+  if (!matchedRule) {
+    return null;
+  }
+  return {
+    source: String(matchedRule.source || 'local_input_tip'),
+    modeKey: String(matchedRule.modeKey || '').trim(),
+    label: String(matchedRule.label || '').trim(),
+    reason: String(matchedRule.reason || '').trim(),
+    actionText: String(matchedRule.actionText || '').trim(),
+    statusOnly: matchedRule.statusOnly === true,
+  };
+}
+
+export default function useComposerModeSuggestion({
+  inputValue,
+  activeModeKey,
+  modeSuggestion,
+  modeSuggestionAction,
+  tipRules = [],
+  contextFlags = {},
+}) {
+  return useMemo(() => {
+    if (modeSuggestionAction && typeof modeSuggestionAction === 'object') {
+      return {
+        modeSuggestion: modeSuggestion || null,
+        modeSuggestionAction,
+        fromFallback: false,
+      };
+    }
+    const fallbackSuggestion = buildSuggestionFromInput({
+      inputValue,
+      activeModeKey,
+      tipRules,
+      contextFlags,
+    });
+    if (!fallbackSuggestion) {
+      return {
+        modeSuggestion: modeSuggestion || null,
+        modeSuggestionAction: null,
+        fromFallback: false,
+      };
+    }
+    return {
+      modeSuggestion: fallbackSuggestion,
+      modeSuggestionAction: {
+        source: 'mode_suggestion',
+        text: fallbackSuggestion.actionText || `启用${fallbackSuggestion.label || fallbackSuggestion.modeKey || ''}`,
+        action: {
+          action_type: 'switch_mode',
+          target_mode: fallbackSuggestion.modeKey,
+          label: fallbackSuggestion.actionText || '',
+        },
+      },
+      fromFallback: true,
+    };
+  }, [activeModeKey, contextFlags, inputValue, modeSuggestion, modeSuggestionAction, tipRules]);
+}

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

@@ -0,0 +1,22 @@
+import { useMemo } from 'react';
+
+export function useDevCapabilityStatusNote({
+  isDev = false,
+  mode = '',
+  labels = {},
+} = {}) {
+  return useMemo(() => {
+    if (!isDev) {
+      return '';
+    }
+    const normalizedMode = String(mode || '').trim().toLowerCase();
+    if (normalizedMode === 'persistent') {
+      return String(labels.persistent || '开发态：资料能力已接入持久化链路');
+    }
+    if (normalizedMode === 'local_fallback') {
+      return String(labels.localFallback || '开发态：资料能力当前为本地回退模式');
+    }
+    return String(labels.unknown || '开发态：资料能力状态未知');
+  }, [isDev, labels.localFallback, labels.persistent, labels.unknown, mode]);
+}
+

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

@@ -0,0 +1,41 @@
+import { useState } from 'react';
+
+export function useProjectNameEditing({ defaultProjectName } = {}) {
+  const initialName = String(defaultProjectName || '').trim() || '本地演示项目';
+  const [projectNameEditing, setProjectNameEditing] = useState(false);
+  const [projectNameDraft, setProjectNameDraft] = useState(initialName);
+  const [projectDisplayName, setProjectDisplayName] = useState(initialName);
+
+  const handleProjectNameStartEdit = (projectSlot) => {
+    if (!projectSlot?.key) {
+      return;
+    }
+    setProjectNameDraft(String(projectDisplayName || '').trim());
+    setProjectNameEditing(true);
+  };
+
+  const handleProjectNameCancel = () => {
+    setProjectNameEditing(false);
+    setProjectNameDraft('');
+  };
+
+  const handleProjectNameSave = () => {
+    const nextName = String(projectNameDraft || '').trim();
+    if (nextName) {
+      setProjectDisplayName(nextName);
+    }
+    handleProjectNameCancel();
+  };
+
+  return {
+    projectNameEditing,
+    projectNameDraft,
+    setProjectNameDraft,
+    projectDisplayName,
+    handleProjectNameStartEdit,
+    handleProjectNameCancel,
+    handleProjectNameSave,
+  };
+}
+
+export default useProjectNameEditing;

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

@@ -0,0 +1,341 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+const projectSourceListSingleflight = new Map();
+const SOURCE_STATUS_TERMINAL = new Set(['ready', 'failed', 'error']);
+
+function normalizeError(error, fallbackMessage) {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error || fallbackMessage));
+}
+
+function buildSourceItem(file, index, scopedProjectId) {
+  return {
+    id: `project-source-${Date.now()}-${index}`,
+    project_id: scopedProjectId,
+    message_id: null,
+    scope: 'project',
+    source: 'local_upload',
+    filename: String(file?.name || '').trim() || `资料 ${index + 1}`,
+    mime_type: String(file?.type || '').trim(),
+    size: Number.isFinite(file?.size) ? file.size : null,
+    created_at: new Date().toISOString(),
+    status: 'ready',
+    error_message: '',
+    persisted_to_project: false,
+  };
+}
+
+function buildSourceFileSignature(item = {}) {
+  return `${item.filename || ''}::${item.size || ''}::${item.mime_type || ''}`;
+}
+
+function parseSourceList(response) {
+  if (Array.isArray(response?.sources)) {
+    return response.sources;
+  }
+  if (Array.isArray(response?.data?.sources)) {
+    return response.data.sources;
+  }
+  return [];
+}
+
+function normalizeSourceStatus(status) {
+  return String(status || '').trim().toLowerCase();
+}
+
+function hasPendingSourceProcessing(items = []) {
+  if (!Array.isArray(items) || items.length === 0) {
+    return false;
+  }
+  return items.some((item) => !SOURCE_STATUS_TERMINAL.has(normalizeSourceStatus(item?.status)));
+}
+
+function createUploadProgressItem(file, index) {
+  return {
+    id: `upload-progress-${Date.now()}-${index}`,
+    filename: String(file?.name || '').trim() || `资料 ${index + 1}`,
+    progress: 0,
+    stage: 'reading',
+    error_message: '',
+  };
+}
+
+function readFileWithProgress(file, onProgress) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onprogress = (event) => {
+      if (!event.lengthComputable) {
+        return;
+      }
+      const percent = (event.loaded / event.total) * 80;
+      onProgress(percent);
+    };
+    reader.onload = () => {
+      onProgress(80);
+      resolve();
+    };
+    reader.onerror = () => {
+      reject(reader.error || new Error('读取文件失败'));
+    };
+    reader.readAsArrayBuffer(file);
+  });
+}
+
+export function useProjectSourceUpload({
+  projectId = '',
+  userId = '',
+  sourceAPI = null,
+  shouldLoadSources = true,
+} = {}) {
+  const fileInputRef = useRef(null);
+  const [sourceItems, setSourceItems] = useState([]);
+  const [sourceActionError, setSourceActionError] = useState(null);
+  const [sourceUploadLoading, setSourceUploadLoading] = useState(false);
+  const [sourceUploadProgressItems, setSourceUploadProgressItems] = useState([]);
+  const [sourceSyncLoading, setSourceSyncLoading] = useState(false);
+  const [sourceRemovingId, setSourceRemovingId] = useState('');
+  const [sourceEndpointUnavailable, setSourceEndpointUnavailable] = useState(false);
+
+  const canUsePersistentSourceAPI = (
+    typeof sourceAPI?.listProjectSources === 'function'
+    && typeof sourceAPI?.uploadSourceFile === 'function'
+    && typeof sourceAPI?.deleteProjectSource === 'function'
+    && !sourceEndpointUnavailable
+  );
+
+  const loadProjectSources = useCallback(async ({ silent = false } = {}) => {
+    const scopedProjectId = String(projectId || '').trim();
+    if (!canUsePersistentSourceAPI || !scopedProjectId) {
+      return;
+    }
+    if (!silent) {
+      setSourceSyncLoading(true);
+      setSourceActionError(null);
+    }
+    try {
+      const requestKey = scopedProjectId;
+      let pendingRequest = projectSourceListSingleflight.get(requestKey);
+      if (!pendingRequest) {
+        pendingRequest = sourceAPI.listProjectSources(scopedProjectId)
+          .finally(() => {
+            projectSourceListSingleflight.delete(requestKey);
+          });
+        projectSourceListSingleflight.set(requestKey, pendingRequest);
+      }
+      const response = await pendingRequest;
+      setSourceItems(parseSourceList(response));
+      setSourceEndpointUnavailable(false);
+    } catch (error) {
+      if (Number(error?.status) === 404) {
+        setSourceEndpointUnavailable(true);
+        if (!silent) {
+          setSourceActionError(null);
+        }
+        return;
+      }
+      if (!silent) {
+        setSourceActionError(normalizeError(error, '加载资料失败'));
+      }
+    } finally {
+      if (!silent) {
+        setSourceSyncLoading(false);
+      }
+    }
+  }, [canUsePersistentSourceAPI, projectId, sourceAPI]);
+
+  useEffect(() => {
+    if (!shouldLoadSources) {
+      return;
+    }
+    loadProjectSources();
+  }, [loadProjectSources, shouldLoadSources]);
+
+  useEffect(() => {
+    if (!shouldLoadSources) {
+      return undefined;
+    }
+    if (!canUsePersistentSourceAPI) {
+      return undefined;
+    }
+    if (!hasPendingSourceProcessing(sourceItems)) {
+      return undefined;
+    }
+    const timer = setInterval(() => {
+      void loadProjectSources({ silent: true });
+    }, 1500);
+    return () => {
+      clearInterval(timer);
+    };
+  }, [canUsePersistentSourceAPI, loadProjectSources, shouldLoadSources, sourceItems]);
+
+  const appendLocalSourceFiles = useCallback((nativeFiles = []) => {
+    setSourceItems((prev) => {
+      const existingSignatures = new Set(prev.map((item) => buildSourceFileSignature(item)));
+      const nextItems = nativeFiles
+        .map((file, index) => buildSourceItem(file, index, projectId))
+        .filter((item) => {
+          const signature = buildSourceFileSignature(item);
+          if (existingSignatures.has(signature)) {
+            return false;
+          }
+          existingSignatures.add(signature);
+          return true;
+        });
+      return [...nextItems, ...prev];
+    });
+  }, [projectId]);
+
+  const uploadSourceFiles = useCallback(async (nativeFiles = []) => {
+    const scopedProjectId = String(projectId || '').trim();
+    if (nativeFiles.length === 0) {
+      return;
+    }
+    setSourceUploadLoading(true);
+    setSourceActionError(null);
+    const progressItems = nativeFiles.map((file, index) => createUploadProgressItem(file, index));
+    setSourceUploadProgressItems((prev) => [...progressItems, ...prev]);
+    const updateProgressItem = (itemId, patch = {}) => {
+      setSourceUploadProgressItems((prev) => prev.map((item) => (item.id === itemId ? { ...item, ...patch } : item)));
+    };
+    try {
+      if (canUsePersistentSourceAPI && scopedProjectId) {
+        for (let index = 0; index < nativeFiles.length; index += 1) {
+          const file = nativeFiles[index];
+          const progressItem = progressItems[index];
+          await readFileWithProgress(file, (percent) => {
+            updateProgressItem(progressItem.id, {
+              stage: 'reading',
+              progress: percent,
+            });
+          });
+          updateProgressItem(progressItem.id, {
+            stage: 'uploading',
+            progress: 80,
+          });
+          await sourceAPI.uploadSourceFile({
+            project_id: scopedProjectId,
+            user_id: String(userId || '').trim() || null,
+            file,
+            filename: file.name,
+            onProgress: (percent) => {
+              const safePercent = Number.isFinite(percent) ? percent : 0;
+              const mappedPercent = 80 + (Math.max(0, Math.min(100, safePercent)) * 0.2);
+              updateProgressItem(progressItem.id, {
+                stage: 'uploading',
+                progress: mappedPercent,
+              });
+            },
+          });
+          updateProgressItem(progressItem.id, {
+            stage: 'done',
+            progress: 100,
+          });
+        }
+        await loadProjectSources();
+        return;
+      }
+      for (let index = 0; index < nativeFiles.length; index += 1) {
+        const file = nativeFiles[index];
+        const progressItem = progressItems[index];
+        await readFileWithProgress(file, (percent) => {
+          updateProgressItem(progressItem.id, {
+            stage: 'reading',
+            progress: percent,
+          });
+        });
+        updateProgressItem(progressItem.id, {
+          stage: 'uploading',
+          progress: 95,
+        });
+        appendLocalSourceFiles([file]);
+        updateProgressItem(progressItem.id, {
+          stage: 'done',
+          progress: 100,
+        });
+      }
+    } catch (error) {
+      const errorMessage = String(error?.message || '添加资料失败');
+      setSourceUploadProgressItems((prev) => prev.map((item) => (item.stage === 'done'
+        ? item
+        : {
+          ...item,
+          stage: 'error',
+          error_message: errorMessage,
+        })));
+      setSourceActionError(normalizeError(error, '添加资料失败'));
+    } finally {
+      setSourceUploadLoading(false);
+    }
+  }, [appendLocalSourceFiles, canUsePersistentSourceAPI, loadProjectSources, projectId, sourceAPI, userId]);
+
+  const handleOpenSourcePicker = useCallback((nativeFiles = []) => {
+    if (sourceUploadLoading) {
+      return;
+    }
+    if (Array.isArray(nativeFiles) && nativeFiles.length > 0) {
+      void uploadSourceFiles(nativeFiles);
+      return;
+    }
+    setSourceActionError(null);
+    fileInputRef.current?.click();
+  }, [sourceUploadLoading, uploadSourceFiles]);
+
+  const handleSourceFileChange = useCallback((event) => {
+    const nativeFiles = Array.from(event?.target?.files || []);
+    event.target.value = '';
+    void uploadSourceFiles(nativeFiles);
+  }, [uploadSourceFiles]);
+
+  const handleRemoveSource = useCallback(async (sourceId) => {
+    const scopedProjectId = String(projectId || '').trim();
+    const normalizedSourceId = String(sourceId || '').trim();
+    if (!normalizedSourceId) {
+      return;
+    }
+    setSourceActionError(null);
+    setSourceRemovingId(normalizedSourceId);
+    try {
+      if (canUsePersistentSourceAPI && scopedProjectId) {
+        await sourceAPI.deleteProjectSource(scopedProjectId, normalizedSourceId);
+        await loadProjectSources();
+      } else {
+        setSourceItems((prev) => prev.filter((item) => {
+          const currentSourceId = String(item?.source_id || item?.id || '').trim();
+          return currentSourceId !== normalizedSourceId;
+        }));
+      }
+    } catch (error) {
+      setSourceActionError(normalizeError(error, '删除资料失败'));
+    } finally {
+      setSourceRemovingId('');
+    }
+  }, [canUsePersistentSourceAPI, loadProjectSources, projectId, sourceAPI]);
+
+  const handleRetrySource = useCallback(() => {
+    if (canUsePersistentSourceAPI) {
+      loadProjectSources();
+      return;
+    }
+    setSourceActionError(null);
+  }, [canUsePersistentSourceAPI, loadProjectSources]);
+
+  const handleViewSourceDetail = useCallback(() => {}, []);
+
+  return {
+    fileInputRef,
+    sourceCapabilityMode: canUsePersistentSourceAPI ? 'persistent' : 'local_fallback',
+    sourceActionError,
+    sourceItems,
+    sourceRemovingId,
+    sourceSyncLoading,
+    sourceUploadLoading,
+    sourceUploadProgressItems,
+    handleOpenSourcePicker,
+    handleSourceFileChange,
+    handleRemoveSource,
+    handleRetrySource,
+    handleViewSourceDetail,
+  };
+}