@lobehub/lobehub 2.0.0-next.35 → 2.0.0-next.37

package/src/services/upload.ts

@@ -68,13 +68,13 @@ class UploadService {
     const state = getElectronStoreState();
     const isSyncActive = electronSyncSelectors.isSyncActive(state);
 
-    // 桌面端上传逻辑（并且没开启 sync 同步）
+    // Desktop upload logic (when sync is not enabled)
     if (isDesktop && !isSyncActive) {
       const data = await this.uploadToDesktopS3(file, { directory, pathname });
       return { data, success: true };
     }
 
-    // 服务端上传逻辑
+    // Server-side upload logic
     if (isServerMode) {
       // if is server mode, upload to server s3,
 
@@ -83,7 +83,7 @@ class UploadService {
     }
 
     // upload to client s3
-    // 客户端上传逻辑
+    // Client-side upload logic
     if (!skipCheckFileType && !file.type.startsWith('image') && !file.type.startsWith('video')) {
       onNotSupported?.();
       return { data: undefined as unknown as FileMetadata, success: false };
@@ -103,18 +103,18 @@ class UploadService {
     base64Data: string,
     options: UploadFileToS3Options = {},
   ): Promise<UploadBase64ToS3Result> => {
-    // 解析 base64 数据
+    // Parse base64 data
     const { base64, mimeType, type } = parseDataUri(base64Data);
 
     if (!base64 || !mimeType || type !== 'base64') {
       throw new Error('Invalid base64 data for image');
     }
 
-    // 将 base64 转换为 Blob
+    // Convert base64 to Blob
     const byteCharacters = atob(base64);
     const byteArrays = [];
 
-    // 分块处理以避免内存问题
+    // Process in chunks to avoid memory issues
     for (let offset = 0; offset < byteCharacters.length; offset += 1024) {
       const slice = byteCharacters.slice(offset, offset + 1024);
 
@@ -129,14 +129,14 @@ class UploadService {
 
     const blob = new Blob(byteArrays, { type: mimeType });
 
-    // 确定文件扩展名
+    // Determine file extension
     const fileExtension = mimeType.split('/')[1] || 'png';
     const fileName = `${options.filename || `image_${dayjs().format('YYYY-MM-DD-hh-mm-ss')}`}.${fileExtension}`;
 
-    // 创建文件对象
+    // Create file object
     const file = new File([blob], fileName, { type: mimeType });
 
-    // 使用统一的上传方法
+    // Use unified upload method
     const { data: metadata } = await this.uploadFileToS3(file, options);
     const hash = sha256(await file.arrayBuffer());
 
@@ -221,7 +221,7 @@ class UploadService {
     const fileArrayBuffer = await file.arrayBuffer();
     const hash = sha256(fileArrayBuffer);
 
-    // 生成文件路径元数据
+    // Generate file path metadata
     const { pathname } = generateFilePathMetadata(file.name, options);
 
     const { desktopFileAPI } = await import('@/services/electron/file');
@@ -261,7 +261,7 @@ class UploadService {
       preSignUrl: string;
     }
   > => {
-    // 生成文件路径元数据
+    // Generate file path metadata
     const { date, dirname, filename, pathname } = generateFilePathMetadata(file.name, options);
 
     const preSignUrl = await lambdaClient.upload.createS3PreSignedUrl.mutate({ pathname });

package/src/services/utils/abortableRequest.test.ts

@@ -0,0 +1,161 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { abortableRequest } from './abortableRequest';
+
+describe('AbortableRequestManager', () => {
+  beforeEach(() => {
+    abortableRequest.cancelAll();
+  });
+
+  describe('execute', () => {
+    it('should execute request successfully', async () => {
+      const mockFetcher = vi.fn(async (signal: AbortSignal) => {
+        return 'result';
+      });
+
+      const result = await abortableRequest.execute('test-key', mockFetcher);
+
+      expect(result).toBe('result');
+      expect(mockFetcher).toHaveBeenCalledTimes(1);
+      expect(mockFetcher).toHaveBeenCalledWith(expect.any(AbortSignal));
+    });
+
+    it('should cancel previous request when new request with same key is triggered', async () => {
+      let firstRequestAborted = false;
+      let secondRequestAborted = false;
+
+      const firstFetcher = vi.fn(
+        async (signal: AbortSignal) =>
+          new Promise((resolve, reject) => {
+            signal.addEventListener('abort', () => {
+              firstRequestAborted = true;
+              reject(new Error('Aborted'));
+            });
+            setTimeout(() => resolve('first'), 100);
+          }),
+      );
+
+      const secondFetcher = vi.fn(
+        async (signal: AbortSignal) =>
+          new Promise((resolve, reject) => {
+            signal.addEventListener('abort', () => {
+              secondRequestAborted = true;
+              reject(new Error('Aborted'));
+            });
+            setTimeout(() => resolve('second'), 100);
+          }),
+      );
+
+      // Start first request
+      const firstPromise = abortableRequest.execute('same-key', firstFetcher);
+
+      // Start second request with same key (should cancel first)
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      const secondPromise = abortableRequest.execute('same-key', secondFetcher);
+
+      // First should be aborted
+      await expect(firstPromise).rejects.toThrow('Aborted');
+      expect(firstRequestAborted).toBe(true);
+
+      // Second should succeed
+      const result = await secondPromise;
+      expect(result).toBe('second');
+      expect(secondRequestAborted).toBe(false);
+    });
+
+    it('should allow concurrent requests with different keys', async () => {
+      const fetcher1 = vi.fn(async () => 'result1');
+      const fetcher2 = vi.fn(async () => 'result2');
+
+      const [result1, result2] = await Promise.all([
+        abortableRequest.execute('key1', fetcher1),
+        abortableRequest.execute('key2', fetcher2),
+      ]);
+
+      expect(result1).toBe('result1');
+      expect(result2).toBe('result2');
+      expect(fetcher1).toHaveBeenCalledTimes(1);
+      expect(fetcher2).toHaveBeenCalledTimes(1);
+    });
+
+    it('should clean up controller after request completes', async () => {
+      const fetcher = vi.fn(async () => 'result');
+
+      await abortableRequest.execute('cleanup-test', fetcher);
+
+      // Manually check that controller is cleaned up by starting a new request
+      // and verifying it doesn't abort anything (since map should be empty)
+      let aborted = false;
+      const fetcher2 = vi.fn(
+        async (signal: AbortSignal) =>
+          new Promise((resolve) => {
+            signal.addEventListener('abort', () => {
+              aborted = true;
+            });
+            setTimeout(() => resolve('result2'), 50);
+          }),
+      );
+
+      await abortableRequest.execute('cleanup-test', fetcher2);
+      expect(aborted).toBe(false);
+    });
+  });
+
+  describe('cancel', () => {
+    it('should cancel specific request by key', async () => {
+      let aborted = false;
+      const fetcher = vi.fn(
+        async (signal: AbortSignal) =>
+          new Promise((resolve, reject) => {
+            signal.addEventListener('abort', () => {
+              aborted = true;
+              reject(new Error('Cancelled'));
+            });
+            setTimeout(() => resolve('result'), 100);
+          }),
+      );
+
+      const promise = abortableRequest.execute('cancel-key', fetcher);
+
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      abortableRequest.cancel('cancel-key');
+
+      await expect(promise).rejects.toThrow('Cancelled');
+      expect(aborted).toBe(true);
+    });
+
+    it('should do nothing when canceling non-existent key', () => {
+      expect(() => abortableRequest.cancel('non-existent')).not.toThrow();
+    });
+  });
+
+  describe('cancelAll', () => {
+    it('should cancel all pending requests', async () => {
+      const results = { req1: false, req2: false, req3: false };
+
+      const createFetcher = (key: keyof typeof results) =>
+        vi.fn(
+          async (signal: AbortSignal) =>
+            new Promise((resolve, reject) => {
+              signal.addEventListener('abort', () => {
+                results[key] = true;
+                reject(new Error('Cancelled'));
+              });
+              setTimeout(() => resolve(`result-${key}`), 100);
+            }),
+        );
+
+      const promise1 = abortableRequest.execute('key1', createFetcher('req1'));
+      const promise2 = abortableRequest.execute('key2', createFetcher('req2'));
+      const promise3 = abortableRequest.execute('key3', createFetcher('req3'));
+
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      abortableRequest.cancelAll();
+
+      await expect(Promise.all([promise1, promise2, promise3])).rejects.toThrow();
+      expect(results.req1).toBe(true);
+      expect(results.req2).toBe(true);
+      expect(results.req3).toBe(true);
+    });
+  });
+});

package/src/services/utils/abortableRequest.ts

@@ -0,0 +1,67 @@
+/**
+ * Abortable Request Manager
+ *
+ * Provides race condition control for async requests by canceling previous
+ * requests when a new one with the same key is triggered.
+ *
+ * @example
+ * ```ts
+ * const result = await abortableRequest.execute(
+ *   'update-user-profile',
+ *   (signal) => api.updateProfile(data, { signal })
+ * );
+ * ```
+ */
+class AbortableRequestManager {
+  private controllers = new Map<string, AbortController>();
+
+  /**
+   * Execute a request with race condition control
+   * @param key - Unique key to identify the request group
+   * @param fetcher - Request function that accepts AbortSignal
+   * @returns Promise with the request result
+   */
+  async execute<T>(key: string, fetcher: (signal: AbortSignal) => Promise<T>): Promise<T> {
+    // Cancel previous request with same key
+    const existingController = this.controllers.get(key);
+    if (existingController) {
+      existingController.abort('New request triggered');
+    }
+
+    const controller = new AbortController();
+    this.controllers.set(key, controller);
+
+    try {
+      return await fetcher(controller.signal);
+    } finally {
+      // Clean up controller if it's still the active one
+      if (this.controllers.get(key) === controller) {
+        this.controllers.delete(key);
+      }
+    }
+  }
+
+  /**
+   * Manually cancel a request by key
+   * @param key - Request key to cancel
+   */
+  cancel(key: string): void {
+    const controller = this.controllers.get(key);
+    if (controller) {
+      controller.abort('Manually cancelled');
+      this.controllers.delete(key);
+    }
+  }
+
+  /**
+   * Cancel all pending requests
+   */
+  cancelAll(): void {
+    for (const controller of this.controllers.values()) {
+      controller.abort('All requests cancelled');
+    }
+    this.controllers.clear();
+  }
+}
+
+export const abortableRequest = new AbortableRequestManager();

package/src/store/chat/agents/GeneralChatAgent.ts

@@ -0,0 +1,137 @@
+import {
+  Agent,
+  AgentInstruction,
+  AgentRuntimeContext,
+  AgentState,
+  GeneralAgentCallLLMInstructionPayload,
+  GeneralAgentCallLLMResultPayload,
+  GeneralAgentCallToolResultPayload,
+  GeneralAgentCallToolsBatchInstructionPayload,
+  GeneralAgentCallingToolInstructionPayload,
+  GeneralAgentConfig,
+} from '@lobechat/agent-runtime';
+
+/**
+ * ChatAgent - The "Brain" of the chat agent
+ *
+ * This agent implements a simple but powerful decision loop:
+ * 1. user_input → call_llm (with optional RAG/Search preprocessing)
+ * 2. llm_result → check for tool_calls
+ *    - If has tool_calls → call_tools_batch (parallel execution)
+ *    - If no tool_calls → finish
+ * 3. tools_batch_result → call_llm (process tool results)
+ *
+ * Note: RAG and Search workflow preprocessing are handled externally
+ * before creating the agent runtime, keeping the agent logic simple.
+ */
+export class GeneralChatAgent implements Agent {
+  private config: GeneralAgentConfig;
+
+  constructor(config: GeneralAgentConfig) {
+    this.config = config;
+  }
+
+  async runner(
+    context: AgentRuntimeContext,
+    state: AgentState,
+  ): Promise<AgentInstruction | AgentInstruction[]> {
+    switch (context.phase) {
+      case 'init':
+      case 'user_input': {
+        // User input received, call LLM to generate response
+        // At this point, messages may have been preprocessed with RAG/Search
+        return {
+          payload: {
+            ...(context.payload as any),
+            messages: state.messages,
+          } as GeneralAgentCallLLMInstructionPayload,
+          type: 'call_llm',
+        };
+      }
+
+      case 'llm_result': {
+        // LLM response received, check if it contains tool calls
+        const { hasToolsCalling, toolsCalling, parentMessageId } =
+          context.payload as GeneralAgentCallLLMResultPayload;
+
+        if (hasToolsCalling && toolsCalling && toolsCalling.length > 0) {
+          // No intervention needed, proceed with tool execution
+          // Use batch execution for multiple tool calls to improve performance
+          if (toolsCalling.length > 1) {
+            return {
+              payload: {
+                parentMessageId,
+                toolsCalling,
+              } as GeneralAgentCallToolsBatchInstructionPayload,
+              type: 'call_tools_batch',
+            };
+          } else if (toolsCalling.length === 1) {
+            // Single tool executes directly
+            return {
+              payload: {
+                parentMessageId,
+                toolCalling: toolsCalling[0],
+              } as GeneralAgentCallingToolInstructionPayload,
+              type: 'call_tool',
+            };
+          }
+        }
+
+        // No tool calls, conversation is complete
+        return {
+          reason: 'completed',
+          reasonDetail: 'LLM response completed without tool calls',
+          type: 'finish',
+        };
+      }
+
+      case 'tool_result': {
+        const { parentMessageId } = context.payload as GeneralAgentCallToolResultPayload;
+
+        return {
+          payload: {
+            messages: state.messages,
+            model: this.config.modelRuntimeConfig?.model,
+            parentMessageId,
+            provider: this.config.modelRuntimeConfig?.provider,
+            tools: state.tools,
+          } as GeneralAgentCallLLMInstructionPayload,
+          type: 'call_llm',
+        };
+      }
+
+      case 'tools_batch_result': {
+        const { parentMessageId } = context.payload as GeneralAgentCallToolResultPayload;
+        return {
+          payload: {
+            messages: state.messages,
+            model: this.config.modelRuntimeConfig?.model,
+            parentMessageId,
+            provider: this.config.modelRuntimeConfig?.provider,
+            tools: state.tools,
+          } as GeneralAgentCallLLMInstructionPayload,
+          type: 'call_llm',
+        };
+      }
+
+      case 'error': {
+        // Error occurred, finish execution
+        const { error } = context.payload as { error: any };
+        return {
+          reason: 'error_recovery',
+          reasonDetail: error?.message || 'Unknown error occurred',
+          type: 'finish',
+        };
+      }
+
+      default: {
+        // Unknown phase, finish execution
+        return {
+          reason: 'agent_decision',
+          reasonDetail: `Unknown phase: ${context.phase}`,
+          type: 'finish',
+        };
+      }
+    }
+  }
+}