@lobehub/lobehub 2.0.0-next.247 → 2.0.0-next.248

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+## [Version 2.0.0-next.248](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.247...v2.0.0-next.248)
+
+<sup>Released on **2026-01-09**</sup>
+
+#### ✨ Features
+
+- **userMemories**: Support to assign for extra headers when invoking upstash workflows.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's improved
+
+- **userMemories**: Support to assign for extra headers when invoking upstash workflows, closes [#11374](https://github.com/lobehub/lobe-chat/issues/11374) ([895e15e](https://github.com/lobehub/lobe-chat/commit/895e15e))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.247](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.246...v2.0.0-next.247)
 
 <sup>Released on **2026-01-09**</sup>

package/changelog/v1.json

@@ -1,4 +1,9 @@
 [
+  {
+    "children": {},
+    "date": "2026-01-09",
+    "version": "2.0.0-next.248"
+  },
   {
     "children": {},
     "date": "2026-01-09",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.247",
+  "version": "2.0.0-next.248",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/packages/utils/src/folderStructure.test.ts

@@ -0,0 +1,310 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildFolderTree, sanitizeFolderName, topologicalSortFolders } from './folderStructure';
+
+describe('folderStructure', () => {
+  describe('buildFolderTree', () => {
+    it('should handle single files without folders', () => {
+      const files = [new File(['content1'], 'file1.txt'), new File(['content2'], 'file2.txt')];
+
+      const result = buildFolderTree(files);
+
+      expect(result.folders).toEqual({});
+      expect(result.filesByFolder['']).toHaveLength(2);
+      expect(result.filesByFolder[''][0].name).toBe('file1.txt');
+      expect(result.filesByFolder[''][1].name).toBe('file2.txt');
+    });
+
+    it('should build folder structure from files with webkitRelativePath', () => {
+      const file1 = new File(['content'], 'file.txt');
+      (file1 as any).webkitRelativePath = 'folder1/file.txt';
+
+      const file2 = new File(['content'], 'file2.txt');
+      (file2 as any).webkitRelativePath = 'folder1/file2.txt';
+
+      const result = buildFolderTree([file1, file2]);
+
+      expect(result.folders).toEqual({
+        folder1: {
+          name: 'folder1',
+          parent: null,
+        },
+      });
+
+      expect(result.filesByFolder['folder1']).toHaveLength(2);
+      expect(result.filesByFolder['folder1'][0].name).toBe('file.txt');
+      expect(result.filesByFolder['folder1'][1].name).toBe('file2.txt');
+    });
+
+    it('should handle nested folder structures', () => {
+      const file1 = new File(['content'], 'deep.txt');
+      (file1 as any).webkitRelativePath = 'folder1/subfolder1/subfolder2/deep.txt';
+
+      const result = buildFolderTree([file1]);
+
+      expect(result.folders).toEqual({
+        'folder1': {
+          name: 'folder1',
+          parent: null,
+        },
+        'folder1/subfolder1': {
+          name: 'subfolder1',
+          parent: 'folder1',
+        },
+        'folder1/subfolder1/subfolder2': {
+          name: 'subfolder2',
+          parent: 'folder1/subfolder1',
+        },
+      });
+
+      expect(result.filesByFolder['folder1/subfolder1/subfolder2']).toHaveLength(1);
+      expect(result.filesByFolder['folder1/subfolder1/subfolder2'][0].name).toBe('deep.txt');
+    });
+
+    it('should handle multiple files in different folders', () => {
+      const file1 = new File(['content1'], 'file1.txt');
+      (file1 as any).webkitRelativePath = 'folder1/file1.txt';
+
+      const file2 = new File(['content2'], 'file2.txt');
+      (file2 as any).webkitRelativePath = 'folder2/file2.txt';
+
+      const file3 = new File(['content3'], 'file3.txt');
+      (file3 as any).webkitRelativePath = 'folder1/subfolder/file3.txt';
+
+      const result = buildFolderTree([file1, file2, file3]);
+
+      expect(result.folders).toEqual({
+        'folder1': {
+          name: 'folder1',
+          parent: null,
+        },
+        'folder2': {
+          name: 'folder2',
+          parent: null,
+        },
+        'folder1/subfolder': {
+          name: 'subfolder',
+          parent: 'folder1',
+        },
+      });
+
+      expect(result.filesByFolder['folder1']).toHaveLength(1);
+      expect(result.filesByFolder['folder2']).toHaveLength(1);
+      expect(result.filesByFolder['folder1/subfolder']).toHaveLength(1);
+    });
+
+    it('should not duplicate folders when processing multiple files in same folder', () => {
+      const file1 = new File(['content1'], 'file1.txt');
+      (file1 as any).webkitRelativePath = 'shared/file1.txt';
+
+      const file2 = new File(['content2'], 'file2.txt');
+      (file2 as any).webkitRelativePath = 'shared/file2.txt';
+
+      const file3 = new File(['content3'], 'file3.txt');
+      (file3 as any).webkitRelativePath = 'shared/file3.txt';
+
+      const result = buildFolderTree([file1, file2, file3]);
+
+      // Should only have one 'shared' folder entry
+      expect(Object.keys(result.folders)).toEqual(['shared']);
+      expect(result.folders['shared']).toEqual({
+        name: 'shared',
+        parent: null,
+      });
+
+      // All three files should be in the same folder
+      expect(result.filesByFolder['shared']).toHaveLength(3);
+    });
+
+    it('should handle mixed single files and folder files', () => {
+      const file1 = new File(['content1'], 'root.txt');
+
+      const file2 = new File(['content2'], 'nested.txt');
+      (file2 as any).webkitRelativePath = 'folder/nested.txt';
+
+      const result = buildFolderTree([file1, file2]);
+
+      expect(result.folders).toEqual({
+        folder: {
+          name: 'folder',
+          parent: null,
+        },
+      });
+
+      expect(result.filesByFolder['']).toHaveLength(1);
+      expect(result.filesByFolder[''][0].name).toBe('root.txt');
+      expect(result.filesByFolder['folder']).toHaveLength(1);
+      expect(result.filesByFolder['folder'][0].name).toBe('nested.txt');
+    });
+
+    it('should handle empty file array', () => {
+      const result = buildFolderTree([]);
+
+      expect(result.folders).toEqual({});
+      expect(result.filesByFolder).toEqual({});
+    });
+
+    it('should handle files with special characters in path', () => {
+      const file = new File(['content'], 'file.txt');
+      (file as any).webkitRelativePath = 'my-folder/sub_folder/file.txt';
+
+      const result = buildFolderTree([file]);
+
+      expect(result.folders).toEqual({
+        'my-folder': {
+          name: 'my-folder',
+          parent: null,
+        },
+        'my-folder/sub_folder': {
+          name: 'sub_folder',
+          parent: 'my-folder',
+        },
+      });
+    });
+  });
+
+  describe('topologicalSortFolders', () => {
+    it('should sort folders by depth (shallowest first)', () => {
+      const folders = {
+        'a/b/c': { name: 'c', parent: 'a/b' },
+        'a': { name: 'a', parent: null },
+        'a/b': { name: 'b', parent: 'a' },
+      };
+
+      const result = topologicalSortFolders(folders);
+
+      expect(result).toEqual(['a', 'a/b', 'a/b/c']);
+    });
+
+    it('should sort multiple root-level folders correctly', () => {
+      const folders = {
+        'folder2/sub': { name: 'sub', parent: 'folder2' },
+        'folder1': { name: 'folder1', parent: null },
+        'folder2': { name: 'folder2', parent: null },
+      };
+
+      const result = topologicalSortFolders(folders);
+
+      // Root folders should come before nested folders
+      expect(result[0]).toBe('folder1');
+      expect(result[1]).toBe('folder2');
+      expect(result[2]).toBe('folder2/sub');
+    });
+
+    it('should handle complex nested structures', () => {
+      const folders = {
+        'a/b/c/d': { name: 'd', parent: 'a/b/c' },
+        'x/y': { name: 'y', parent: 'x' },
+        'a': { name: 'a', parent: null },
+        'x': { name: 'x', parent: null },
+        'a/b': { name: 'b', parent: 'a' },
+        'a/b/c': { name: 'c', parent: 'a/b' },
+      };
+
+      const result = topologicalSortFolders(folders);
+
+      // Check that parents always come before children
+      expect(result.indexOf('a')).toBeLessThan(result.indexOf('a/b'));
+      expect(result.indexOf('a/b')).toBeLessThan(result.indexOf('a/b/c'));
+      expect(result.indexOf('a/b/c')).toBeLessThan(result.indexOf('a/b/c/d'));
+      expect(result.indexOf('x')).toBeLessThan(result.indexOf('x/y'));
+    });
+
+    it('should handle single folder', () => {
+      const folders = {
+        folder: { name: 'folder', parent: null },
+      };
+
+      const result = topologicalSortFolders(folders);
+
+      expect(result).toEqual(['folder']);
+    });
+
+    it('should handle empty folder object', () => {
+      const result = topologicalSortFolders({});
+
+      expect(result).toEqual([]);
+    });
+
+    it('should preserve order for folders at same depth', () => {
+      const folders = {
+        'a/b': { name: 'b', parent: 'a' },
+        'a/c': { name: 'c', parent: 'a' },
+        'a/d': { name: 'd', parent: 'a' },
+        'a': { name: 'a', parent: null },
+      };
+
+      const result = topologicalSortFolders(folders);
+
+      // Parent should be first
+      expect(result[0]).toBe('a');
+
+      // Siblings (same depth) should maintain their relative order
+      const siblings = result.slice(1);
+      expect(siblings).toHaveLength(3);
+      expect(siblings).toContain('a/b');
+      expect(siblings).toContain('a/c');
+      expect(siblings).toContain('a/d');
+    });
+  });
+
+  describe('sanitizeFolderName', () => {
+    it('should keep valid alphanumeric characters', () => {
+      expect(sanitizeFolderName('MyFolder123')).toBe('MyFolder123');
+    });
+
+    it('should keep spaces', () => {
+      expect(sanitizeFolderName('My Folder Name')).toBe('My Folder Name');
+    });
+
+    it('should keep hyphens and underscores', () => {
+      expect(sanitizeFolderName('my-folder_name')).toBe('my-folder_name');
+    });
+
+    it('should replace invalid characters with underscores', () => {
+      expect(sanitizeFolderName('folder/name')).toBe('folder_name');
+      expect(sanitizeFolderName('folder\\name')).toBe('folder_name');
+      expect(sanitizeFolderName('folder:name')).toBe('folder_name');
+      expect(sanitizeFolderName('folder*name')).toBe('folder_name');
+      expect(sanitizeFolderName('folder?name')).toBe('folder_name');
+      expect(sanitizeFolderName('folder"name')).toBe('folder_name');
+      expect(sanitizeFolderName('folder<name>')).toBe('folder_name_');
+      expect(sanitizeFolderName('folder|name')).toBe('folder_name');
+    });
+
+    it('should replace control characters with underscores', () => {
+      expect(sanitizeFolderName('folder\x00name')).toBe('folder_name');
+      expect(sanitizeFolderName('folder\x01name')).toBe('folder_name');
+      expect(sanitizeFolderName('folder\x1Fname')).toBe('folder_name');
+    });
+
+    it('should trim whitespace from start and end', () => {
+      expect(sanitizeFolderName('  folder  ')).toBe('folder');
+      expect(sanitizeFolderName('\tfolder\t')).toBe('_folder_');
+    });
+
+    it('should handle multiple invalid characters', () => {
+      expect(sanitizeFolderName('my/folder\\with:many*invalid?chars')).toBe(
+        'my_folder_with_many_invalid_chars',
+      );
+    });
+
+    it('should handle empty string', () => {
+      expect(sanitizeFolderName('')).toBe('');
+    });
+
+    it('should handle string with only invalid characters', () => {
+      expect(sanitizeFolderName('/:*?<>|')).toBe('_______');
+    });
+
+    it('should handle unicode characters correctly', () => {
+      expect(sanitizeFolderName('我的文件夹')).toBe('我的文件夹');
+      expect(sanitizeFolderName('папка')).toBe('папка');
+      expect(sanitizeFolderName('フォルダ')).toBe('フォルダ');
+    });
+
+    it('should handle mixed valid and invalid characters', () => {
+      expect(sanitizeFolderName('Project-2024_draft/final?')).toBe('Project-2024_draft_final_');
+    });
+  });
+});

package/src/app/(backend)/api/webhooks/memory-extraction/route.ts

@@ -10,7 +10,7 @@ import {
 } from '@/server/services/memory/userMemory/extract';
 
 export const POST = async (req: Request) => {
-  const { webhookHeaders } = parseMemoryExtractionConfig();
+  const { webhookHeaders, upstashWorkflowExtraHeaders } = parseMemoryExtractionConfig();
 
   if (webhookHeaders && Object.keys(webhookHeaders).length > 0) {
     for (const [key, value] of Object.entries(webhookHeaders)) {
@@ -43,6 +43,7 @@ export const POST = async (req: Request) => {
     if (params.mode === 'workflow') {
       const { workflowRunId } = await MemoryExtractionWorkflowService.triggerProcessUsers(
         buildWorkflowPayloadInput(params),
+        { extraHeaders: upstashWorkflowExtraHeaders },
       );
       return NextResponse.json(
         { message: 'Memory extraction scheduled via workflow.', workflowRunId },

package/src/app/(backend)/api/workflows/memory-user-memory/pipelines/chat-topic/process-user-topics/route.ts

@@ -9,11 +9,14 @@ import {
 } from '@/server/services/memory/userMemory/extract';
 import { forEachBatchSequential } from '@/server/services/memory/userMemory/topicBatching';
 import { MemorySourceType } from '@lobechat/types';
+import { parseMemoryExtractionConfig } from '@/server/globalConfig/parseMemoryExtractionConfig';
 
 const TOPIC_PAGE_SIZE = 50;
 const TOPIC_BATCH_SIZE = 4;
 
 export const { POST } = serve<MemoryExtractionPayloadInput>(async (context) => {
+  const { upstashWorkflowExtraHeaders } = parseMemoryExtractionConfig();
+
   const params = normalizeMemoryExtractionPayload(context.requestPayload || {});
   if (!params.userIds.length) {
     return { message: 'No user ids provided for topic processing.' };
@@ -37,7 +40,7 @@ export const { POST } = serve<MemoryExtractionPayloadInput>(async (context) => {
         userId,
         userIds: [userId],
       }),
-    });
+    }, { extraHeaders: upstashWorkflowExtraHeaders });
   };
 
   for (const userId of params.userIds) {
@@ -99,7 +102,7 @@ export const { POST } = serve<MemoryExtractionPayloadInput>(async (context) => {
             topicIds,
             userId,
             userIds: [userId],
-          }),
+          }, { extraHeaders: upstashWorkflowExtraHeaders }),
       );
     });
 

package/src/app/(backend)/api/workflows/memory-user-memory/pipelines/chat-topic/process-users/route.ts

@@ -8,11 +8,14 @@ import {
   buildWorkflowPayloadInput,
   normalizeMemoryExtractionPayload,
 } from '@/server/services/memory/userMemory/extract';
+import { parseMemoryExtractionConfig } from '@/server/globalConfig/parseMemoryExtractionConfig';
 
 const USER_PAGE_SIZE = 50;
 const USER_BATCH_SIZE = 10;
 
 export const { POST } = serve<MemoryExtractionPayloadInput>(async (context) => {
+  const { upstashWorkflowExtraHeaders } = parseMemoryExtractionConfig();
+
   const params = normalizeMemoryExtractionPayload(context.requestPayload || {});
   if (params.sources.length === 0) {
     return { message: 'No sources provided, skip memory extraction.' };
@@ -49,7 +52,7 @@ export const { POST } = serve<MemoryExtractionPayloadInput>(async (context) => {
           topicCursor: undefined,
           userId: userIds[0],
           userIds,
-        }),
+        }, { extraHeaders: upstashWorkflowExtraHeaders},),
       ),
     ),
   );
@@ -61,7 +64,7 @@ export const { POST } = serve<MemoryExtractionPayloadInput>(async (context) => {
           ...params,
           userCursor: { createdAt: cursor.createdAt.toISOString(), id: cursor.id },
         }),
-      }),
+      }, { extraHeaders: upstashWorkflowExtraHeaders }),
     );
   }
 

package/src/server/globalConfig/parseMemoryExtractionConfig.ts

@@ -48,6 +48,7 @@ export interface MemoryExtractionPrivateConfig {
     region?: string;
     secretAccessKey?: string;
   };
+  upstashWorkflowExtraHeaders?: Record<string, string>;
   webhookHeaders?: Record<string, string>;
   whitelistUsers?: string[];
 }
@@ -190,6 +191,16 @@ export const parseMemoryExtractionConfig = (): MemoryExtractionPrivateConfig =>
       return acc;
     }, {});
 
+  const upstashWorkflowExtraHeaders = process.env.MEMORY_USER_MEMORY_WORKFLOW_EXTRA_HEADERS?.split(',')
+    .filter(Boolean)
+    .reduce<Record<string, string>>((acc, pair) => {
+      const [key, value] = pair.split('=').map((s) => s.trim());
+      if (key && value) {
+        acc[key] = value;
+      }
+      return acc;
+    }, {});
+
   return {
     agentGateKeeper,
     agentLayerExtractor,
@@ -197,6 +208,7 @@ export const parseMemoryExtractionConfig = (): MemoryExtractionPrivateConfig =>
     embedding,
     featureFlags,
     observabilityS3: extractorObservabilityS3,
+    upstashWorkflowExtraHeaders,
     webhookHeaders,
     whitelistUsers,
   };

package/src/server/routers/async/caller.ts

@@ -38,7 +38,7 @@ export const createAsyncServerClient = async (userId: string) => {
 };
 
 /**
- * 用来推断 caller 类型辅助方法，但不实际调用 createAsyncCallerFactory，调用会报错：asyncRouter 没有初始化
+ * Helper method for inferring caller type, but does not actually call createAsyncCallerFactory. Calling it will throw an error: asyncRouter is not initialized
  */
 const helperFunc = () => {
   const dummyCreateCaller = createAsyncCallerFactory(asyncRouter);
@@ -52,8 +52,8 @@ interface CreateCallerOptions {
 }
 
 /**
- * 创建 caller 的工厂方法，使用 HTTP Client 调用
- * 使用方式统一成 caller.a.b() 的调用方式
+ * Factory method for creating caller, using HTTP Client to make calls
+ * Unified usage pattern: caller.a.b()
  */
 export const createAsyncCaller = async (
   options: CreateCallerOptions,

package/src/server/routers/async/image.ts

@@ -147,7 +147,7 @@ const categorizeError = (
     };
   }
 
-  // FIXME: 401 的问题应该放到 agentRuntime 中处理会更好
+  // FIXME: 401 errors should be handled in agentRuntime for better practice
   if (error.errorType === AgentRuntimeErrorType.InvalidProviderAPIKey || error?.status === 401) {
     return {
       errorMessage:

package/src/server/routers/async/ragEval.ts

@@ -63,7 +63,7 @@ export const ragEvalRouter = router({
         let questionEmbeddingId = evalRecord.questionEmbeddingId;
         let context = evalRecord.context;
 
-        // 如果不存在 questionEmbeddingId，那么就需要做一次 embedding
+        // If questionEmbeddingId does not exist, perform an embedding
         if (!questionEmbeddingId) {
           const embeddings = await modelRuntime.embeddings({
             dimensions: 1024,
@@ -83,7 +83,7 @@ export const ragEvalRouter = router({
           questionEmbeddingId = embeddingId;
         }
 
-        // 如果不存在 context，那么就需要做一次检索
+        // If context does not exist, perform a retrieval
         if (!context || context.length === 0) {
           const datasetRecord = await ctx.datasetRecordModel.findById(evalRecord.datasetRecordId);
 
@@ -99,7 +99,7 @@ export const ragEvalRouter = router({
           await ctx.evalRecordModel.update(evalRecord.id, { context });
         }
 
-        // 做一次生成 LLM 答案生成
+        // Generate LLM answer
         const { messages } = chainAnswerWithContext({ context, knowledge: [], question });
 
         const response = await modelRuntime.chat({

package/src/server/routers/lambda/_helpers/resolveContext.ts

@@ -54,14 +54,14 @@ export const resolveContext = async (
 };
 
 /**
- * 反向解析：从 sessionId 获取 agentId
+ * Reverse resolution: Get agentId from sessionId
  *
- * 用于 Topic Router 等需要 agentId 进行查询的场景
+ * Used in scenarios like Topic Router where agentId is needed for queries
  *
  * @param sessionId - session ID
- * @param db - 数据库实例
- * @param userId - 用户 ID
- * @returns agentId 或 undefined
+ * @param db - Database instance
+ * @param userId - User ID
+ * @returns agentId or undefined
  */
 export const resolveAgentIdFromSession = async (
   sessionId: string,
@@ -78,14 +78,14 @@ export const resolveAgentIdFromSession = async (
 };
 
 /**
- * 批量反向解析：从多个 sessionId 获取 agentId 映射
+ * Batch reverse resolution: Get agentId mapping from multiple sessionIds
  *
- * 用于需要批量解析 sessionId -> agentId 的场景（如 recentTopics）
+ * Used in scenarios requiring batch sessionId -> agentId resolution (e.g., recentTopics)
  *
- * @param sessionIds - session ID 数组
- * @param db - 数据库实例
- * @param userId - 用户 ID
- * @returns sessionId -> agentId 的映射 Map
+ * @param sessionIds - Array of session IDs
+ * @param db - Database instance
+ * @param userId - User ID
+ * @returns Map of sessionId -> agentId
  */
 export const batchResolveAgentIdFromSessions = async (
   sessionIds: string[],

package/src/server/routers/lambda/_schema/context.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod';
 
 /**
- * 会话上下文 Schema
- * 同时支持 agentId 和 sessionId，用于向后兼容
+ * Conversation context schema
+ * Supports both agentId and sessionId for backward compatibility
  *
- * 优先级：agentId > sessionId
- * 当同时提供时，agentId 会被用于解析对应的 sessionId
+ * Priority: agentId > sessionId
+ * When both are provided, agentId will be used to resolve the corresponding sessionId
  */
 export const conversationContextSchema = z.object({
   agentId: z.string().optional(),
@@ -16,8 +16,8 @@ export const conversationContextSchema = z.object({
 });
 
 /**
- * 简化版上下文
- * 用于 message 和 topic 的 CRUD 操作
+ * Simplified context
+ * Used for CRUD operations of messages and topics
  */
 export const basicContextSchema = z.object({
   agentId: z.string().optional(),

package/src/server/services/memory/userMemory/extract.ts

@@ -1841,30 +1841,30 @@ export class MemoryExtractionWorkflowService {
     return this.client;
   }
 
-  static triggerProcessUsers(payload: MemoryExtractionPayloadInput) {
+  static triggerProcessUsers(payload: MemoryExtractionPayloadInput, options?: { extraHeaders?: Record<string, string> }) {
     if (!payload.baseUrl) {
       throw new Error('Missing baseUrl for workflow trigger');
     }
 
     const url = getWorkflowUrl(WORKFLOW_PATHS.users, payload.baseUrl);
-    return this.getClient().trigger({ body: payload, url });
+    return this.getClient().trigger({ body: payload, headers: options?.extraHeaders, url });
   }
 
-  static triggerProcessUserTopics(payload: UserTopicWorkflowPayload) {
+  static triggerProcessUserTopics(payload: UserTopicWorkflowPayload, options?: { extraHeaders?: Record<string, string> }) {
     if (!payload.baseUrl) {
       throw new Error('Missing baseUrl for workflow trigger');
     }
 
     const url = getWorkflowUrl(WORKFLOW_PATHS.userTopics, payload.baseUrl);
-    return this.getClient().trigger({ body: payload, url });
+    return this.getClient().trigger({ body: payload, headers: options?.extraHeaders, url });
   }
 
-  static triggerProcessTopics(payload: MemoryExtractionPayloadInput) {
+  static triggerProcessTopics(payload: MemoryExtractionPayloadInput, options?: { extraHeaders?: Record<string, string> }) {
     if (!payload.baseUrl) {
       throw new Error('Missing baseUrl for workflow trigger');
     }
 
     const url = getWorkflowUrl(WORKFLOW_PATHS.topicBatch, payload.baseUrl);
-    return this.getClient().trigger({ body: payload, url });
+    return this.getClient().trigger({ body: payload, headers: options?.extraHeaders, url });
   }
 }

package/src/server/sitemap.ts

@@ -32,7 +32,7 @@ export enum SitemapType {
 
 export const LAST_MODIFIED = new Date().toISOString();
 
-// 每页条目数量
+// Number of items per page
 const ITEMS_PER_PAGE = 100;
 
 export class Sitemap {
@@ -40,19 +40,19 @@ export class Sitemap {
 
   private discoverService = new DiscoverService();
 
-  // 获取插件总页数
+  // Get total number of plugin pages
   async getPluginPageCount(): Promise<number> {
     const list = await this.discoverService.getPluginIdentifiers();
     return Math.ceil(list.length / ITEMS_PER_PAGE);
   }
 
-  // 获取助理总页数
+  // Get total number of assistant pages
   async getAssistantPageCount(): Promise<number> {
     const list = await this.discoverService.getAssistantIdentifiers();
     return Math.ceil(list.length / ITEMS_PER_PAGE);
   }
 
-  // 获取模型总页数
+  // Get total number of model pages
   async getModelPageCount(): Promise<number> {
     const list = await this.discoverService.getModelIdentifiers();
     return Math.ceil(list.length / ITEMS_PER_PAGE);
@@ -164,14 +164,14 @@ export class Sitemap {
       ),
     );
 
-    // 获取需要分页的类型的页数
+    // Get page counts for types that need pagination
     const [pluginPages, assistantPages, modelPages] = await Promise.all([
       this.getPluginPageCount(),
       this.getAssistantPageCount(),
       this.getModelPageCount(),
     ]);
 
-    // 生成分页sitemap链接
+    // Generate paginated sitemap links
     const paginatedSitemaps = [
       ...Array.from({ length: pluginPages }, (_, i) =>
         this._generateSitemapLink(
@@ -211,7 +211,7 @@ export class Sitemap {
       const pageAssistants = list.slice(startIndex, endIndex);
 
       const sitmap = pageAssistants
-        .filter((item) => item.identifier) // 过滤掉 identifier 为空的项目
+        .filter((item) => item.identifier) // Filter out items with empty identifiers
         .map((item) =>
           this._genSitemap(urlJoin('/community/assistant', item.identifier), {
             lastModified: item?.lastModified || LAST_MODIFIED,
@@ -220,7 +220,7 @@ export class Sitemap {
       return flatten(sitmap);
     }
 
-    // 如果没有指定页数，返回所有（向后兼容）
+    // If page number is not specified, return all (backward compatibility)
     const sitmap = list
       .filter((item) => item.identifier) // 过滤掉 identifier 为空的项目
       .map((item) =>
@@ -240,7 +240,7 @@ export class Sitemap {
       const pagePlugins = list.slice(startIndex, endIndex);
 
       const sitmap = pagePlugins
-        .filter((item) => item.identifier) // 过滤掉 identifier 为空的项目
+        .filter((item) => item.identifier) // Filter out items with empty identifiers
         .map((item) =>
           this._genSitemap(urlJoin('/community/plugin', item.identifier), {
             lastModified: item?.lastModified || LAST_MODIFIED,
@@ -249,7 +249,7 @@ export class Sitemap {
       return flatten(sitmap);
     }
 
-    // 如果没有指定页数，返回所有（向后兼容）
+    // If page number is not specified, return all (backward compatibility)
     const sitmap = list
       .filter((item) => item.identifier) // 过滤掉 identifier 为空的项目
       .map((item) =>
@@ -269,7 +269,7 @@ export class Sitemap {
       const pageModels = list.slice(startIndex, endIndex);
 
       const sitmap = pageModels
-        .filter((item) => item.identifier) // 过滤掉 identifier 为空的项目
+        .filter((item) => item.identifier) // Filter out items with empty identifiers
         .map((item) =>
           this._genSitemap(urlJoin('/community/model', item.identifier), {
             lastModified: item?.lastModified || LAST_MODIFIED,
@@ -278,7 +278,7 @@ export class Sitemap {
       return flatten(sitmap);
     }
 
-    // 如果没有指定页数，返回所有（向后兼容）
+    // If page number is not specified, return all (backward compatibility)
     const sitmap = list
       .filter((item) => item.identifier) // 过滤掉 identifier 为空的项目
       .map((item) =>