flare-chat-core 0.2.3 → 0.2.5

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

@@ -1,68 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,341 +0,0 @@
-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,
-  };
-}