@lobehub/lobehub 2.0.0-next.150 → 2.0.0-next.151

package/packages/database/migrations/meta/_journal.json

@@ -399,6 +399,13 @@
       "when": 1764685643024,
       "tag": "0056_update_agent_slug_index",
       "breakpoints": true
+    },
+    {
+      "idx": 57,
+      "version": "7",
+      "when": 1764734167674,
+      "tag": "0057_add_topic_user_memory_extract_status",
+      "breakpoints": true
     }
   ],
   "version": "6"

package/packages/database/src/core/migrations.json

@@ -223,7 +223,10 @@
     "hash": "9646161fa041354714f823d726af27247bcd6e60fa3be5698c0d69f337a5700b"
   },
   {
-    "sql": ["DROP TABLE \"user_budgets\";", "\nDROP TABLE \"user_subscriptions\";"],
+    "sql": [
+      "DROP TABLE \"user_budgets\";",
+      "\nDROP TABLE \"user_subscriptions\";"
+    ],
     "bps": true,
     "folderMillis": 1729699958471,
     "hash": "7dad43a2a25d1aec82124a4e53f8d82f8505c3073f23606c1dc5d2a4598eacf9"
@@ -295,7 +298,9 @@
     "hash": "845a692ceabbfc3caf252a97d3e19a213bc0c433df2689900135f9cfded2cf49"
   },
   {
-    "sql": ["ALTER TABLE \"messages\" ADD COLUMN \"reasoning\" jsonb;"],
+    "sql": [
+      "ALTER TABLE \"messages\" ADD COLUMN \"reasoning\" jsonb;"
+    ],
     "bps": true,
     "folderMillis": 1737609172353,
     "hash": "2cb36ae4fcdd7b7064767e04bfbb36ae34518ff4bb1b39006f2dd394d1893868"
@@ -510,7 +515,9 @@
     "hash": "a7ccf007fd185ff922823148d1eae6fafe652fc98d2fd2793f84a84f29e93cd1"
   },
   {
-    "sql": ["ALTER TABLE \"ai_providers\" ADD COLUMN \"config\" jsonb;"],
+    "sql": [
+      "ALTER TABLE \"ai_providers\" ADD COLUMN \"config\" jsonb;"
+    ],
     "bps": true,
     "folderMillis": 1749309388370,
     "hash": "39cea379f08ee4cb944875c0b67f7791387b508c2d47958bb4cd501ed1ef33eb"
@@ -628,7 +635,9 @@
     "hash": "1ba9b1f74ea13348da98d6fcdad7867ab4316ed565bf75d84d160c526cdac14b"
   },
   {
-    "sql": ["ALTER TABLE \"agents\" ADD COLUMN IF NOT EXISTS \"virtual\" boolean DEFAULT false;"],
+    "sql": [
+      "ALTER TABLE \"agents\" ADD COLUMN IF NOT EXISTS \"virtual\" boolean DEFAULT false;"
+    ],
     "bps": true,
     "folderMillis": 1759116400580,
     "hash": "433ddae88e785f2db734e49a4c115eee93e60afe389f7919d66e5ba9aa159a37"
@@ -678,13 +687,17 @@
     "hash": "4bdc6505797d7a33b622498c138cfd47f637239f6905e1c484cd01d9d5f21d6b"
   },
   {
-    "sql": ["ALTER TABLE \"user_settings\" ADD COLUMN IF NOT EXISTS \"image\" jsonb;"],
+    "sql": [
+      "ALTER TABLE \"user_settings\" ADD COLUMN IF NOT EXISTS \"image\" jsonb;"
+    ],
     "bps": true,
     "folderMillis": 1760108430562,
     "hash": "ce09b301abb80f6563abc2f526bdd20b4f69bae430f09ba2179b9e3bfec43067"
   },
   {
-    "sql": ["ALTER TABLE \"documents\" ADD COLUMN IF NOT EXISTS \"editor_data\" jsonb;"],
+    "sql": [
+      "ALTER TABLE \"documents\" ADD COLUMN IF NOT EXISTS \"editor_data\" jsonb;"
+    ],
     "bps": true,
     "folderMillis": 1761554153406,
     "hash": "bf2f21293e90e11cf60a784cf3ec219eafa95f7545d7d2f9d1449c0b0949599a"
@@ -764,13 +777,17 @@
     "hash": "923ccbdf46c32be9a981dabd348e6923b4a365444241e9b8cc174bf5b914cbc5"
   },
   {
-    "sql": ["ALTER TABLE \"agents\" ADD COLUMN IF NOT EXISTS \"market_identifier\" text;\n"],
+    "sql": [
+      "ALTER TABLE \"agents\" ADD COLUMN IF NOT EXISTS \"market_identifier\" text;\n"
+    ],
     "bps": true,
     "folderMillis": 1762870034882,
     "hash": "4178aacb4b8892b7fd15d29209bbf9b1d1f9d7c406ba796f27542c0bcd919680"
   },
   {
-    "sql": ["ALTER TABLE \"message_plugins\" ADD COLUMN IF NOT EXISTS \"intervention\" jsonb;\n"],
+    "sql": [
+      "ALTER TABLE \"message_plugins\" ADD COLUMN IF NOT EXISTS \"intervention\" jsonb;\n"
+    ],
     "bps": true,
     "folderMillis": 1762911968658,
     "hash": "552a032cc0e595277232e70b5f9338658585bafe9481ae8346a5f322b673a68b"
@@ -799,7 +816,9 @@
     "hash": "f823b521f4d25e5dc5ab238b372727d2d2d7f0aed27b5eabc8a9608ce4e50568"
   },
   {
-    "sql": ["ALTER TABLE \"agents\" ADD COLUMN IF NOT EXISTS \"editor_data\" jsonb;"],
+    "sql": [
+      "ALTER TABLE \"agents\" ADD COLUMN IF NOT EXISTS \"editor_data\" jsonb;"
+    ],
     "bps": true,
     "folderMillis": 1764215503726,
     "hash": "4188893a9083b3c7baebdbad0dd3f9d9400ede7584ca2394f5c64305dc9ec7b0"
@@ -840,7 +859,9 @@
     "hash": "2c103eee82bdf329944fb622dd9c2b9f20df80eb54f23eb9254d2285de413099"
   },
   {
-    "sql": ["ALTER TABLE \"user_settings\" ADD COLUMN IF NOT EXISTS \"market\" jsonb;"],
+    "sql": [
+      "ALTER TABLE \"user_settings\" ADD COLUMN IF NOT EXISTS \"market\" jsonb;"
+    ],
     "bps": true,
     "folderMillis": 1764335703306,
     "hash": "28c0d738c0b1fdf5fd871363be1a1477b4accbabdc140fe8dc6e9b339aae2c89"
@@ -910,5 +931,13 @@
     "bps": true,
     "folderMillis": 1764685643024,
     "hash": "6e7ac7f964eb03efa3cb0d2fd35ded23e25c3abf955c4c2a51418f8daef54af9"
+  },
+  {
+    "sql": [
+      "CREATE INDEX IF NOT EXISTS \"topics_extract_status_gin_idx\" ON \"topics\" USING gin ((metadata->'userMemoryExtractStatus') jsonb_path_ops);\n"
+    ],
+    "bps": true,
+    "folderMillis": 1764734167674,
+    "hash": "89c134be2948d3afc360d6bac11dea0c6fd5c902bf6093ed077033adb920fd02"
   }
-]
+]

package/packages/database/src/schemas/topic.ts

@@ -1,5 +1,6 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix  */
 import type { ChatTopicMetadata } from '@lobechat/types';
+import { sql } from 'drizzle-orm';
 import { boolean, index, jsonb, pgTable, primaryKey, text, uniqueIndex } from 'drizzle-orm/pg-core';
 import { createInsertSchema } from 'drizzle-zod';
 
@@ -39,6 +40,10 @@ export const topics = pgTable(
     index('topics_session_id_idx').on(t.sessionId),
     index('topics_group_id_idx').on(t.groupId),
     index('topics_agent_id_idx').on(t.agentId),
+    index('topics_extract_status_gin_idx').using(
+      'gin',
+      sql`(metadata->'userMemoryExtractStatus') jsonb_path_ops`,
+    ),
   ],
 );
 

package/packages/model-runtime/package.json

@@ -17,6 +17,7 @@
     "@lobechat/const": "workspace:*",
     "@lobechat/types": "workspace:*",
     "@lobechat/utils": "workspace:*",
+    "async-retry": "^1.3.3",
     "debug": "^4.4.3",
     "model-bank": "workspace:*",
     "openai": "^4.104.0"

package/packages/model-runtime/src/utils/asyncifyPolling.ts

@@ -1,3 +1,5 @@
+import retry from 'async-retry';
+
 export interface TaskResult<T> {
   data?: T;
   error?: any;
@@ -23,14 +25,14 @@ export interface AsyncifyPollingOptions<T, R> {
   checkStatus: (result: T) => TaskResult<R>;
 
   // Retry configuration
-  initialInterval?: number; 
+  initialInterval?: number;
   // Optional logger
   logger?: {
     debug?: (...args: any[]) => void;
     error?: (...args: any[]) => void;
-  }; 
+  };
   // Default 1.5
-  maxConsecutiveFailures?: number; 
+  maxConsecutiveFailures?: number;
   // Default 500ms
   maxInterval?: number; // Default 3
   maxRetries?: number; // Default Infinity
@@ -42,6 +44,24 @@ export interface AsyncifyPollingOptions<T, R> {
   pollingQuery: () => Promise<T>;
 }
 
+// Internal error class to signal that polling should continue
+class PendingError extends Error {
+  constructor() {
+    super('Task is pending, continue polling');
+    this.name = 'PendingError';
+  }
+}
+
+// Internal error class to signal that task has failed and should not retry
+class TaskFailedError extends Error {
+  originalError: any;
+  constructor(error: any) {
+    super(error instanceof Error ? error.message : String(error));
+    this.name = 'TaskFailedError';
+    this.originalError = error;
+  }
+}
+
 /**
  * Convert polling pattern to async/await pattern
  *
@@ -62,114 +82,117 @@ export async function asyncifyPolling<T, R>(options: AsyncifyPollingOptions<T, R
     logger,
   } = options;
 
-  let retries = 0;
   let consecutiveFailures = 0;
 
-  while (retries < maxRetries) {
-    let pollingResult: T;
-
-    try {
-      // Execute polling function
-      pollingResult = await pollingQuery();
-
-      // Reset consecutive failures counter on successful execution
-      consecutiveFailures = 0;
-    } catch (error) {
-      // Polling function execution failed (network error, etc.)
-      consecutiveFailures++;
-
-      logger?.error?.(
-        `Failed to execute polling function (attempt ${retries + 1}/${maxRetries === Infinity ? '∞' : maxRetries}, consecutive failures: ${consecutiveFailures}/${maxConsecutiveFailures}):`,
-        error,
-      );
-
-      // Handle custom error processing if provided
-      if (onPollingError) {
-        const errorResult = onPollingError({
-          consecutiveFailures,
-          error,
-          retries,
-        });
-
-        if (!errorResult.isContinuePolling) {
-          // Custom error handler decided to stop polling
-          throw errorResult.error || error;
-        }
-
-        // Custom error handler decided to continue polling
-        logger?.debug?.('Custom error handler decided to continue polling');
-      } else {
-        // Default behavior: check if maximum consecutive failures reached
-        if (consecutiveFailures >= maxConsecutiveFailures) {
-          throw new Error(
-            `Failed to execute polling function after ${consecutiveFailures} consecutive attempts: ${error}`,
+  // async-retry uses Infinity for retries when maxRetries is Infinity
+  // but we need to handle this case properly
+  const retriesConfig = maxRetries === Infinity ? 1_000_000 : maxRetries - 1;
+
+  try {
+    return await retry(
+      async (bail, attemptNumber) => {
+        const retries = attemptNumber - 1;
+
+        try {
+          // Execute polling function
+          const pollingResult = await pollingQuery();
+
+          // Reset consecutive failures counter on successful execution
+          consecutiveFailures = 0;
+
+          // Check task status
+          const statusResult = checkStatus(pollingResult);
+
+          logger?.debug?.(`Task status: ${statusResult.status} (attempt ${attemptNumber})`);
+
+          switch (statusResult.status) {
+            case 'success': {
+              return statusResult.data as R;
+            }
+
+            case 'failed': {
+              // Task logic failed, throw error immediately (not counted as consecutive failure)
+              bail(new TaskFailedError(statusResult.error || new Error('Task failed')));
+              // This return is never reached due to bail, but needed for type safety
+              return undefined as R;
+            }
+
+            default: {
+              // 'pending' or unknown status - continue polling by throwing PendingError
+              throw new PendingError();
+            }
+          }
+        } catch (error) {
+          // Re-throw internal errors that should be handled by async-retry
+          if (error instanceof PendingError) {
+            throw error;
+          }
+
+          // Polling function execution failed (network error, etc.)
+          consecutiveFailures++;
+
+          logger?.error?.(
+            `Failed to execute polling function (attempt ${attemptNumber}/${maxRetries === Infinity ? '∞' : maxRetries}, consecutive failures: ${consecutiveFailures}/${maxConsecutiveFailures}):`,
+            error,
           );
-        }
-      }
-
-      // Wait before retry and continue to next loop iteration
-      if (retries < maxRetries - 1) {
-        const currentInterval = Math.min(
-          initialInterval * Math.pow(backoffMultiplier, retries),
-          maxInterval,
-        );
-
-        logger?.debug?.(`Waiting ${currentInterval}ms before next retry`);
 
-        await new Promise((resolve) => {
-          setTimeout(resolve, currentInterval);
-        });
-      }
-
-      retries++;
-      continue;
-    }
-
-    // Check task status
-    const statusResult = checkStatus(pollingResult);
-
-    logger?.debug?.(`Task status: ${statusResult.status} (attempt ${retries + 1})`);
-
-    switch (statusResult.status) {
-      case 'success': {
-        return statusResult.data as R;
-      }
-
-      case 'failed': {
-        // Task logic failed, throw error immediately (not counted as consecutive failure)
-        throw statusResult.error || new Error('Task failed');
-      }
-
-      case 'pending': {
-        // Continue polling
-        break;
-      }
-
-      default: {
-        // Unknown status, treat as pending
-        break;
-      }
+          // Handle custom error processing if provided
+          if (onPollingError) {
+            const errorResult = onPollingError({
+              consecutiveFailures,
+              error,
+              retries,
+            });
+
+            if (!errorResult.isContinuePolling) {
+              // Custom error handler decided to stop polling
+              bail(errorResult.error || (error as Error));
+              return undefined as R;
+            }
+
+            // Custom error handler decided to continue polling
+            logger?.debug?.('Custom error handler decided to continue polling');
+            throw error; // Rethrow to trigger retry
+          } else {
+            // Default behavior: check if maximum consecutive failures reached
+            if (consecutiveFailures >= maxConsecutiveFailures) {
+              bail(
+                new Error(
+                  `Failed to execute polling function after ${consecutiveFailures} consecutive attempts: ${error}`,
+                ),
+              );
+              return undefined as R;
+            }
+          }
+
+          // Rethrow to trigger retry
+          throw error;
+        }
+      },
+      {
+        factor: backoffMultiplier,
+        maxTimeout: maxInterval,
+        minTimeout: initialInterval,
+        onRetry: (error, attempt) => {
+          if (!(error instanceof PendingError)) {
+            logger?.debug?.(`Retrying after error (attempt ${attempt})`);
+          }
+        },
+        randomize: false, // Disable jitter for predictable intervals
+        retries: retriesConfig,
+      },
+    );
+  } catch (error) {
+    // Handle TaskFailedError by throwing the original error
+    if (error instanceof TaskFailedError) {
+      throw error.originalError;
     }
 
-    // Wait before next retry if not the last attempt
-    if (retries < maxRetries - 1) {
-      // Calculate dynamic retry interval with exponential backoff
-      const currentInterval = Math.min(
-        initialInterval * Math.pow(backoffMultiplier, retries),
-        maxInterval,
-      );
-
-      logger?.debug?.(`Waiting ${currentInterval}ms before next retry`);
-
-      // Wait for retry interval
-      await new Promise((resolve) => {
-        setTimeout(resolve, currentInterval);
-      });
+    // Handle max retries exceeded
+    if (error instanceof PendingError) {
+      throw new Error(`Task timeout after ${maxRetries} attempts`);
     }
 
-    retries++;
+    throw error;
   }
-
-  // Maximum retries reached
-  throw new Error(`Task timeout after ${maxRetries} attempts`);
 }

package/packages/types/src/topic/topic.ts

@@ -24,9 +24,21 @@ export interface GroupedTopic {
   title?: string;
 }
 
+export interface TopicUserMemoryExtractRunState {
+  error?: string;
+  lastConversationDigest?: string;
+  lastMessageAt?: string;
+  lastRunAt?: string;
+  messageCount?: number;
+  processedMemoryCount?: number;
+  version?: string;
+}
+
 export interface ChatTopicMetadata {
   model?: string;
   provider?: string;
+  userMemoryExtractRunState?: TopicUserMemoryExtractRunState;
+  userMemoryExtractStatus?: 'pending' | 'completed' | 'failed';
 }
 
 export interface ChatTopicSummary {

package/src/server/services/mcp/index.test.ts

@@ -324,12 +324,13 @@ describe('MCPService', () => {
       expect(result).toHaveLength(1);
     });
 
-    it('should throw TRPCError when NoValidSessionId retry exceeds limit', async () => {
+    it('should throw original error when NoValidSessionId retry exceeds limit', async () => {
       // Fail more than 3 times
       mockClient.listTools.mockRejectedValue(new Error('NoValidSessionId'));
 
-      await expect(mcpService.listTools(mockParams)).rejects.toThrow(TRPCError);
-      expect(mockClient.listTools).toHaveBeenCalledTimes(5); // initial + 4 retry attempts (last one fails condition)
+      await expect(mcpService.listTools(mockParams)).rejects.toThrow('NoValidSessionId');
+      // async-retry: 1 initial + 3 retries = 4 attempts
+      expect(mockClient.listTools).toHaveBeenCalledTimes(4);
     });
 
     it('should throw TRPCError on other errors without retry', async () => {
@@ -340,23 +341,6 @@ describe('MCPService', () => {
       expect(mockClient.listTools).toHaveBeenCalledTimes(1);
     });
 
-    it('should pass skipCache option to getClient', async () => {
-      const mockTools = [
-        {
-          name: 'tool1',
-          description: 'Test tool',
-          inputSchema: { type: 'object' },
-        },
-      ];
-
-      mockClient.listTools.mockResolvedValue(mockTools);
-
-      await mcpService.listTools(mockParams, { skipCache: true });
-
-      // Verify getClient was called with skipCache
-      expect(mcpService.getClient).toHaveBeenCalledWith(mockParams, true);
-    });
-
     it('should throw TRPCError with correct error message', async () => {
       const error = new Error('Custom error message');
       mockClient.listTools.mockRejectedValue(error);

package/src/server/services/mcp/index.ts

@@ -4,6 +4,7 @@ import { LobeChatPluginApi, LobeChatPluginManifest, PluginSchema } from '@lobehu
 import { DeploymentOption } from '@lobehub/market-sdk';
 import { McpError } from '@modelcontextprotocol/sdk/types.js';
 import { TRPCError } from '@trpc/server';
+import retry from 'async-retry';
 import debug from 'debug';
 
 import {
@@ -36,48 +37,47 @@ export class MCPService {
   // --- MCP Interaction ---
 
   // listTools now accepts MCPClientParams
-  async listTools(
-    params: MCPClientParams,
-    { retryTime, skipCache }: { retryTime?: number; skipCache?: boolean } = {},
-  ): Promise<LobeChatPluginApi[]> {
-    const client = await this.getClient(params, skipCache); // Get client using params
+  async listTools(params: MCPClientParams): Promise<LobeChatPluginApi[]> {
     const loggableParams = this.sanitizeForLogging(params);
-    log(`Listing tools using client for params: %O`, loggableParams);
-
-    try {
-      const result = await client.listTools();
-      log(
-        `Tools listed successfully for params: %O, result count: %d`,
-        loggableParams,
-        result.length,
-      );
-      return result.map<LobeChatPluginApi>((item) => ({
-        // Assuming identifier is the unique name/id
-        description: item.description,
-        name: item.name,
-        parameters: item.inputSchema as PluginSchema,
-      }));
-    } catch (error) {
-      let nextReTryTime = retryTime || 0;
 
-      if ((error as Error).message === 'NoValidSessionId' && nextReTryTime <= 3) {
-        if (!nextReTryTime) {
-          nextReTryTime = 1;
-        } else {
-          nextReTryTime += 1;
+    return retry(
+      async (bail, attemptNumber) => {
+        // Skip cache on retry attempts
+        const skipCache = attemptNumber > 1;
+        const client = await this.getClient(params, skipCache);
+        log(`Listing tools using client for params: %O (attempt ${attemptNumber})`, loggableParams);
+
+        try {
+          const result = await client.listTools();
+          log(
+            `Tools listed successfully for params: %O, result count: %d`,
+            loggableParams,
+            result.length,
+          );
+          return result.map<LobeChatPluginApi>((item) => ({
+            // Assuming identifier is the unique name/id
+            description: item.description,
+            name: item.name,
+            parameters: item.inputSchema as PluginSchema,
+          }));
+        } catch (error) {
+          // Only retry for NoValidSessionId errors
+          if ((error as Error).message !== 'NoValidSessionId') {
+            console.error(`Error listing tools for params %O:`, loggableParams, error);
+            bail(
+              new TRPCError({
+                cause: error,
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `Error listing tools from MCP server: ${(error as Error).message}`,
+              }),
+            );
+            return []; // This line will never be reached due to bail, but needed for type safety
+          }
+          throw error; // Rethrow to trigger retry
         }
-
-        return this.listTools(params, { retryTime: nextReTryTime, skipCache: true });
-      }
-
-      console.error(`Error listing tools for params %O:`, loggableParams, error);
-      // Propagate a TRPCError for better handling upstream
-      throw new TRPCError({
-        cause: error,
-        code: 'INTERNAL_SERVER_ERROR',
-        message: `Error listing tools from MCP server: ${(error as Error).message}`,
-      });
-    }
+      },
+      { maxRetryTime: 1000, minTimeout: 100, retries: 3 },
+    );
   }
 
   // listTools now accepts MCPClientParams