@lobehub/lobehub 2.0.0-next.78 → 2.0.0-next.79

package/src/store/chat/slices/operation/selectors.ts

@@ -0,0 +1,246 @@
+import type { ChatStoreState } from '@/store/chat/initialState';
+import { messageMapKey } from '@/store/chat/utils/messageMapKey';
+
+import type { Operation, OperationType } from './types';
+
+// === Basic Queries ===
+/**
+ * Get all operations
+ */
+const getAllOperations = (s: ChatStoreState): Operation[] => {
+  return Object.values(s.operations);
+};
+
+/**
+ * Get operations for current context (active session and topic)
+ */
+const getCurrentContextOperations = (s: ChatStoreState): Operation[] => {
+  const { activeId, activeTopicId } = s;
+  if (!activeId) return [];
+
+  const contextKey = messageMapKey(activeId, activeTopicId);
+  const operationIds = s.operationsByContext[contextKey] || [];
+  return operationIds.map((id) => s.operations[id]).filter(Boolean);
+};
+
+/**
+ * Get all running operations
+ */
+const getRunningOperations = (s: ChatStoreState): Operation[] => {
+  return Object.values(s.operations).filter((op) => op.status === 'running');
+};
+
+/**
+ * Get operation by ID
+ */
+const getOperationById =
+  (operationId: string) =>
+  (s: ChatStoreState): Operation | undefined => {
+    return s.operations[operationId];
+  };
+
+/**
+ * Get operation context from message ID
+ * Useful for automatic context retrieval
+ */
+const getOperationContextFromMessage =
+  (messageId: string) =>
+  (s: ChatStoreState): Operation['context'] | undefined => {
+    const operationId = s.messageOperationMap[messageId];
+    if (!operationId) return undefined;
+
+    const operation = s.operations[operationId];
+    return operation?.context;
+  };
+
+/**
+ * Get operations by message ID
+ */
+const getOperationsByMessage =
+  (messageId: string) =>
+  (s: ChatStoreState): Operation[] => {
+    const operationIds = s.operationsByMessage[messageId] || [];
+    return operationIds.map((id) => s.operations[id]).filter(Boolean);
+  };
+
+/**
+ * Get operations by type
+ */
+const getOperationsByType =
+  (type: OperationType) =>
+  (s: ChatStoreState): Operation[] => {
+    const operationIds = s.operationsByType[type] || [];
+    return operationIds.map((id) => s.operations[id]).filter(Boolean);
+  };
+
+// === Status Checks ===
+/**
+ * Check if there's any running operation
+ */
+const hasAnyRunningOperation = (s: ChatStoreState): boolean => {
+  return Object.values(s.operations).some((op) => op.status === 'running');
+};
+
+/**
+ * Check if there's a running operation of specific type
+ */
+const hasRunningOperationType =
+  (type: OperationType) =>
+  (s: ChatStoreState): boolean => {
+    const operationIds = s.operationsByType[type] || [];
+    return operationIds.some((id) => {
+      const op = s.operations[id];
+      return op && op.status === 'running';
+    });
+  };
+
+/**
+ * Check if can interrupt (has running operations that can be cancelled)
+ */
+const canInterrupt = (s: ChatStoreState): boolean => {
+  const currentOps = getCurrentContextOperations(s);
+  return currentOps.some((op) => op.status === 'running');
+};
+
+/**
+ * Check if can send message (no blocking operations running)
+ */
+const canSendMessage = (s: ChatStoreState): boolean => {
+  // Cannot send if there's any running operation in current context
+  const currentOps = getCurrentContextOperations(s);
+  const hasRunningOp = currentOps.some((op) => op.status === 'running');
+
+  return !hasRunningOp;
+};
+
+// === UI Helpers ===
+/**
+ * Get active operation types (for debugging/display)
+ */
+const getActiveOperationTypes = (s: ChatStoreState): OperationType[] => {
+  const runningOps = getRunningOperations(s);
+  const types = new Set(runningOps.map((op) => op.type));
+  return Array.from(types);
+};
+
+/**
+ * Get current operation label for UI display
+ * Returns the label of the most recent running operation in current context
+ */
+const getCurrentOperationLabel = (s: ChatStoreState): string => {
+  const currentOps = getCurrentContextOperations(s);
+  const runningOps = currentOps.filter((op) => op.status === 'running');
+
+  if (runningOps.length === 0) return '';
+
+  // Get the most recent running operation
+  const latestOp = runningOps.reduce((latest, op) => {
+    return op.metadata.startTime > latest.metadata.startTime ? op : latest;
+  });
+
+  return latestOp.label || latestOp.type;
+};
+
+/**
+ * Get current operation progress
+ * Returns the progress of the most recent running operation with progress info
+ */
+const getCurrentOperationProgress = (s: ChatStoreState): number | undefined => {
+  const currentOps = getCurrentContextOperations(s);
+  const runningOps = currentOps.filter((op) => op.status === 'running');
+
+  if (runningOps.length === 0) return undefined;
+
+  // Find the most recent operation with progress
+  const opsWithProgress = runningOps.filter((op) => op.metadata.progress);
+
+  if (opsWithProgress.length === 0) return undefined;
+
+  const latestOp = opsWithProgress.reduce((latest, op) => {
+    return op.metadata.startTime > latest.metadata.startTime ? op : latest;
+  });
+
+  return latestOp.metadata.progress?.percentage;
+};
+
+// === Backward Compatibility ===
+/**
+ * Check if AI is generating (for backward compatibility)
+ * Equivalent to: hasRunningOperationType('generateAI')
+ */
+const isAIGenerating = (s: ChatStoreState): boolean => {
+  return hasRunningOperationType('generateAI')(s);
+};
+
+/**
+ * Check if continuing (for backward compatibility)
+ */
+const isContinuing = (s: ChatStoreState): boolean => {
+  return hasRunningOperationType('continue')(s);
+};
+
+/**
+ * Check if in RAG flow (for backward compatibility)
+ */
+const isInRAGFlow = (s: ChatStoreState): boolean => {
+  return hasRunningOperationType('rag')(s);
+};
+
+/**
+ * Check if in search workflow (for backward compatibility)
+ */
+const isInSearchWorkflow = (s: ChatStoreState): boolean => {
+  return hasRunningOperationType('searchWorkflow')(s);
+};
+
+/**
+ * Check if a specific message is being processed
+ */
+const isMessageProcessing =
+  (messageId: string) =>
+  (s: ChatStoreState): boolean => {
+    const operations = getOperationsByMessage(messageId)(s);
+    return operations.some((op) => op.status === 'running');
+  };
+
+/**
+ * Check if regenerating (for backward compatibility)
+ */
+const isRegenerating = (s: ChatStoreState): boolean => {
+  return hasRunningOperationType('regenerate')(s);
+};
+
+/**
+ * Check if sending message (for backward compatibility)
+ * Equivalent to: hasRunningOperationType('sendMessage')
+ */
+const isSendingMessage = (s: ChatStoreState): boolean => {
+  return hasRunningOperationType('sendMessage')(s);
+};
+
+/**
+ * Operation Selectors
+ */
+export const operationSelectors = {
+  canInterrupt,
+  canSendMessage,
+  getActiveOperationTypes,
+  getAllOperations,
+  getCurrentContextOperations,
+  getCurrentOperationLabel,
+  getCurrentOperationProgress,
+  getOperationById,
+  getOperationContextFromMessage,
+  getOperationsByMessage,
+  getOperationsByType,
+  getRunningOperations,
+  hasAnyRunningOperation,
+  hasRunningOperationType,
+  isAIGenerating,
+  isContinuing,
+  isInRAGFlow,
+  isInSearchWorkflow,
+  isMessageProcessing,
+  isRegenerating,
+  isSendingMessage,
+};

package/src/store/chat/slices/operation/types.ts

@@ -0,0 +1,134 @@
+/* eslint-disable typescript-sort-keys/interface, sort-keys-fix/sort-keys-fix */
+/**
+ * Operation Type Definitions
+ * Unified operation state management for all async operations
+ */
+
+/**
+ * Operation type enumeration - covers all async operations
+ */
+export type OperationType =
+  // === Message sending ===
+  | 'sendMessage' // Send message to server
+  | 'createTopic' // Auto create topic
+
+  // === AI generation ===
+  | 'generateAI' // AI generate response (entire agent runtime execution)
+  | 'reasoning' // AI reasoning process (child operation)
+  | 'regenerate' // Regenerate message
+  | 'continue' // Continue generation
+
+  // === RAG and retrieval ===
+  | 'rag' // RAG retrieval flow (child operation)
+  | 'searchWorkflow' // Search workflow
+
+  // === Tool calling ===
+  | 'toolCalling' // Tool calling (streaming, child operation)
+  | 'pluginApi' // Plugin API call
+  | 'builtinToolSearch' // Builtin tool: search
+  | 'builtinToolInterpreter' // Builtin tool: code interpreter
+  | 'builtinToolLocalSystem' // Builtin tool: local system
+
+  // === Group Chat ===
+  | 'supervisorDecision' // Supervisor decision
+  | 'groupAgentGenerate' // Group agent generate
+
+  // === Others ===
+  | 'topicSummary' // Topic summary
+  | 'historySummary'; // History summary
+
+/**
+ * Operation status
+ */
+export type OperationStatus =
+  | 'pending' // Waiting to start (not currently used)
+  | 'running' // Executing
+  | 'paused' // Paused (for user intervention scenarios)
+  | 'completed' // Successfully completed
+  | 'cancelled' // User cancelled
+  | 'failed'; // Execution failed
+
+/**
+ * Operation context - business entity associations
+ * Captured when Operation is created, never changes afterwards
+ */
+export interface OperationContext {
+  sessionId?: string; // Associated session ID (normal session or group)
+  topicId?: string | null; // Associated topic ID (null means default topic)
+  messageId?: string; // Associated message ID
+  threadId?: string; // Associated thread ID (Portal Thread)
+  groupId?: string; // Associated group ID (Group Chat)
+  agentId?: string; // Associated agent ID (specific agent in Group Chat)
+}
+
+/**
+ * Operation metadata
+ */
+export interface OperationMetadata {
+  // Progress information
+  progress?: {
+    current: number;
+    total: number;
+    percentage?: number;
+  };
+
+  // Performance information
+  startTime: number;
+  endTime?: number;
+  duration?: number;
+
+  // Error information
+  error?: {
+    type: string;
+    message: string;
+    code?: string;
+    details?: any;
+  };
+
+  // Cancel information
+  cancelReason?: string;
+
+  // Other metadata (extensible)
+  [key: string]: any;
+}
+
+/**
+ * Operation definition
+ */
+export interface Operation {
+  // === Basic information ===
+  id: string; // Unique operation ID (using nanoid)
+  type: OperationType; // Operation type
+  status: OperationStatus; // Operation status
+
+  // === Context (core: capture and fix business context) ===
+  context: OperationContext; // Associated entities, captured at creation
+
+  // === Control ===
+  abortController: AbortController; // Abort controller
+
+  // === Metadata ===
+  metadata: OperationMetadata;
+
+  // === Dependencies ===
+  parentOperationId?: string; // Parent operation ID (for operation nesting)
+  childOperationIds?: string[]; // Child operation IDs
+
+  // === UI display ===
+  label?: string; // Operation display label (for UI)
+  description?: string; // Operation description (for tooltip)
+}
+
+/**
+ * Operation filter for querying operations
+ */
+export interface OperationFilter {
+  type?: OperationType | OperationType[];
+  status?: OperationStatus | OperationStatus[];
+  sessionId?: string;
+  topicId?: string | null;
+  messageId?: string;
+  threadId?: string;
+  groupId?: string;
+  agentId?: string;
+}

package/src/store/chat/store.ts

@@ -16,6 +16,7 @@ import { ChatAIChatAction, chatAiChat } from './slices/aiChat/actions';
 import { ChatTTSAction, chatTTS } from './slices/tts/action';
 import { ChatThreadAction, chatThreadMessage } from './slices/thread/action';
 import { chatAiGroupChat, ChatGroupChatAction } from './slices/aiChat/actions/generateAIGroupChat';
+import { OperationActions, operationActions } from './slices/operation/actions';
 
 export interface ChatStoreAction
   extends ChatMessageAction,
@@ -27,7 +28,8 @@ export interface ChatStoreAction
     ChatTTSAction,
     ChatPluginAction,
     ChatBuiltinToolAction,
-    ChatPortalAction {}
+    ChatPortalAction,
+    OperationActions {}
 
 export type ChatStore = ChatStoreAction & ChatStoreState;
 
@@ -46,6 +48,7 @@ const createStore: StateCreator<ChatStore, [['zustand/devtools', never]]> = (...
   ...chatToolSlice(...params),
   ...chatPlugin(...params),
   ...chatPortalSlice(...params),
+  ...operationActions(...params),
 
   // cloud
 });