@lobehub/lobehub 2.0.0-next.207 → 2.0.0-next.209

package/CHANGELOG.md

@@ -2,6 +2,58 @@
 
 # Changelog
 
+## [Version 2.0.0-next.209](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.208...v2.0.0-next.209)
+
+<sup>Released on **2026-01-04**</sup>
+
+#### 🐛 Bug Fixes
+
+- **model-runtime**: Handle array content in anthropic assistant messages.
+- **misc**: Use configured embedding provider instead of hardcoded OpenAI.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **model-runtime**: Handle array content in anthropic assistant messages, closes [#11206](https://github.com/lobehub/lobe-chat/issues/11206) ([b03845d](https://github.com/lobehub/lobe-chat/commit/b03845d))
+- **misc**: Use configured embedding provider instead of hardcoded OpenAI, closes [#11133](https://github.com/lobehub/lobe-chat/issues/11133) ([503c3eb](https://github.com/lobehub/lobe-chat/commit/503c3eb))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+## [Version 2.0.0-next.208](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.207...v2.0.0-next.208)
+
+<sup>Released on **2026-01-04**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Auto jump to group.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Auto jump to group, closes [#11187](https://github.com/lobehub/lobe-chat/issues/11187) ([e43578a](https://github.com/lobehub/lobe-chat/commit/e43578a))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.207](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.206...v2.0.0-next.207)
 
 <sup>Released on **2026-01-04**</sup>

package/changelog/v1.json

@@ -1,4 +1,22 @@
 [
+  {
+    "children": {
+      "fixes": [
+        "Use configured embedding provider instead of hardcoded OpenAI."
+      ]
+    },
+    "date": "2026-01-04",
+    "version": "2.0.0-next.209"
+  },
+  {
+    "children": {
+      "fixes": [
+        "Auto jump to group."
+      ]
+    },
+    "date": "2026-01-04",
+    "version": "2.0.0-next.208"
+  },
   {
     "children": {
       "fixes": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.207",
+  "version": "2.0.0-next.209",
   "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/model-runtime/src/core/contextBuilders/anthropic.test.ts

@@ -216,6 +216,33 @@ describe('anthropicHelpers', () => {
         role: 'assistant',
       });
     });
+
+    it('should correctly convert assistant message with array content but no tool_calls', async () => {
+      const message: OpenAIChatMessage = {
+        content: [
+          { thinking: 'Let me think about this...', type: 'thinking', signature: 'sig123' },
+          { type: 'text', text: 'Here is my response.' },
+        ],
+        role: 'assistant',
+      };
+      const result = await buildAnthropicMessage(message);
+      expect(result).toEqual({
+        content: [
+          { thinking: 'Let me think about this...', type: 'thinking', signature: 'sig123' },
+          { type: 'text', text: 'Here is my response.' },
+        ],
+        role: 'assistant',
+      });
+    });
+
+    it('should return undefined for assistant message with empty array content', async () => {
+      const message: OpenAIChatMessage = {
+        content: [],
+        role: 'assistant',
+      };
+      const result = await buildAnthropicMessage(message);
+      expect(result).toBeUndefined();
+    });
   });
 
   describe('buildAnthropicMessages', () => {

package/packages/model-runtime/src/core/contextBuilders/anthropic.ts

@@ -118,8 +118,15 @@ export const buildAnthropicMessage = async (
       }
 
       // or it's a plain assistant message
+      // Handle array content (e.g., content with thinking blocks)
+      if (Array.isArray(content)) {
+        const messageContent = await buildArrayContent(content);
+        if (messageContent.length === 0) return undefined;
+        return { content: messageContent, role: 'assistant' };
+      }
+
       // Anthropic API requires non-empty content, filter out empty/whitespace-only content
-      const textContent = (content as string)?.trim();
+      const textContent = content?.trim();
       if (!textContent) return undefined;
       return { content: textContent, role: 'assistant' };
     }

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

@@ -4,7 +4,7 @@ import { AIBaseModelCard } from 'model-bank';
 import type { ModelProviderKey } from '../types';
 
 export interface ModelProcessorConfig {
-  excludeKeywords?: readonly string[]; // 对符合的模型不添加标签
+  excludeKeywords?: readonly string[]; // Do not add tags to models that match
   functionCallKeywords?: readonly string[];
   imageOutputKeywords?: readonly string[];
   reasoningKeywords?: readonly string[];
@@ -13,10 +13,10 @@ export interface ModelProcessorConfig {
   visionKeywords?: readonly string[];
 }
 
-// 默认关键字：任意包含 -search 的模型 ID 视为支持联网搜索
+// Default keyword: any model ID containing -search is considered to support internet search
 const DEFAULT_SEARCH_KEYWORDS = ['-search'] as const;
 
-// 模型能力标签关键词配置
+// Model capability tag keyword configuration
 export const MODEL_LIST_CONFIGS = {
   anthropic: {
     functionCallKeywords: ['claude'],
@@ -136,7 +136,7 @@ export const MODEL_LIST_CONFIGS = {
   },
 } as const;
 
-// 模型所有者 (提供商) 关键词配置
+// Model owner (provider) keyword configuration
 export const MODEL_OWNER_DETECTION_CONFIG = {
   anthropic: ['claude'],
   comfyui: ['comfyui/'], // ComfyUI models detection - all ComfyUI models have comfyui/ prefix
@@ -159,7 +159,7 @@ export const MODEL_OWNER_DETECTION_CONFIG = {
   zhipu: ['glm'],
 } as const;
 
-// 图像模型关键词配置
+// Image model keyword configuration
 export const IMAGE_MODEL_KEYWORDS = [
   'dall-e',
   'dalle',
@@ -173,25 +173,25 @@ export const IMAGE_MODEL_KEYWORDS = [
   'wanxiang',
   'DESCRIBE',
   'UPSCALE',
-  '!gemini', // 排除 gemini 模型，即使包含 -image 也是 chat 模型
+  '!gemini', // Exclude gemini models, they are chat models even if they contain -image
   '-image',
   '^V3',
   '^V_2',
   '^V_1',
 ] as const;
 
-// 嵌入模型关键词配置
+// Embedding model keyword configuration
 export const EMBEDDING_MODEL_KEYWORDS = ['embedding', 'embed', 'bge', 'm3e'] as const;
 
 /**
- * 检测关键词列表是否匹配模型ID（支持多种匹配模式）
- * @param modelId 模型ID（小写）
- * @param keywords 关键词列表，支持以下前缀：
- *   - ^ 开头：只在模型ID开头匹配
- *   - ! 开头：排除匹配，优先级最高
- *   - re: 开头：正则表达式匹配（支持 !re: 正则排除）
- *   - 无前缀：包含匹配（默认行为）
- * @returns 是否匹配（排除逻辑优先）
+ * Detect whether a keyword list matches a model ID (supports multiple matching patterns)
+ * @param modelId Model ID (lowercase)
+ * @param keywords Keyword list, supports the following prefixes:
+ *   - ^ prefix: match only at the start of model ID
+ *   - ! prefix: exclude match, highest priority
+ *   - re: prefix: regular expression match (supports !re: for regex exclusion)
+ *   - no prefix: contains match (default behavior)
+ * @returns Whether it matches (exclusion logic takes priority)
  */
 const isKeywordListMatch = (modelId: string, keywords: readonly string[]): boolean => {
   const matchKeyword = (keyword: string): boolean => {
@@ -212,7 +212,7 @@ const isKeywordListMatch = (modelId: string, keywords: readonly string[]): boole
     return modelId.includes(rawKeyword);
   };
 
-  // 先检查排除规则（感叹号开头，包括 !re:）
+  // First check exclusion rules (starting with exclamation mark, including !re:)
   const excludeKeywords = keywords.filter((keyword) => keyword.startsWith('!'));
   const includeKeywords = keywords.filter((keyword) => !keyword.startsWith('!'));
 
@@ -222,15 +222,15 @@ const isKeywordListMatch = (modelId: string, keywords: readonly string[]): boole
     }
   }
 
-  // 检查包含规则
+  // Check inclusion rules
   return includeKeywords.some((keyword) => matchKeyword(keyword));
 };
 
 /**
- * 根据提供商类型查找对应的本地模型配置
- * @param modelId 模型ID
- * @param provider 提供商类型
- * @returns 匹配的本地模型配置
+ * Find the corresponding local model configuration based on provider type
+ * @param modelId Model ID
+ * @param provider Provider type
+ * @returns Matching local model configuration
  */
 const findKnownModelByProvider = async (
   modelId: string,
@@ -239,32 +239,32 @@ const findKnownModelByProvider = async (
   const lowerModelId = modelId.toLowerCase();
 
   try {
-    // 尝试动态导入对应的配置文件
+    // Attempt to dynamically import the corresponding configuration file
     const modules = await import('model-bank');
 
-    // 如果提供商配置文件不存在，跳过
+    // If provider configuration file doesn't exist, skip
     if (!(provider in modules)) {
       return null;
     }
 
     const providerModels = modules[provider as keyof typeof modules] as AIBaseModelCard[];
 
-    // 如果导入成功且有数据，进行查找
+    // If import succeeds and has data, perform search
     if (Array.isArray(providerModels)) {
       return providerModels.find((m) => m.id.toLowerCase() === lowerModelId);
     }
 
     return null;
   } catch {
-    // 如果导入失败（文件不存在或其他错误），返回 null
+    // If import fails (file doesn't exist or other error), return null
     return null;
   }
 };
 
 /**
- * 检测单个模型的提供商类型
- * @param modelId 模型ID
- * @returns 检测到的提供商配置键名，默认为 'openai'
+ * Detect the provider type of a single model
+ * @param modelId Model ID
+ * @returns Detected provider configuration key name, defaults to 'openai'
  */
 export const detectModelProvider = (modelId: string): keyof typeof MODEL_LIST_CONFIGS => {
   const lowerModelId = modelId.toLowerCase();
@@ -281,20 +281,20 @@ export const detectModelProvider = (modelId: string): keyof typeof MODEL_LIST_CO
 };
 
 /**
- * 将时间戳转换为日期字符串
- * @param timestamp 时间戳（秒）
- * @returns 格式化的日期字符串 (YYYY-MM-DD)
+ * Convert timestamp to date string
+ * @param timestamp Timestamp (seconds)
+ * @returns Formatted date string (YYYY-MM-DD)
  */
 const formatTimestampToDate = (timestamp: number): string | undefined => {
   if (timestamp === null || timestamp === undefined || Number.isNaN(timestamp)) return undefined;
 
-  // 支持秒级或毫秒级时间戳：
-  // - 如果是毫秒级（>= 1e12），直接当作毫秒；
-  // - 否则视为秒，需要 *1000 转为毫秒
+  // Support both second-level and millisecond-level timestamps:
+  // - If millisecond-level (>= 1e12), use as milliseconds directly;
+  // - Otherwise treat as seconds, need to *1000 to convert to milliseconds
   const msTimestamp = timestamp > 1e12 ? timestamp : timestamp * 1000;
   const date = new Date(msTimestamp);
 
-  // 验证解析结果和年份范围（只接受 4 位年份，避免超出 varchar(10) 的 YYYY-MM-DD）
+  // Validate parsing result and year range (only accept 4-digit years to avoid exceeding varchar(10) YYYY-MM-DD)
   const year = date.getUTCFullYear();
   if (year < 1000 || year > 9999) return undefined;
 
@@ -303,22 +303,22 @@ const formatTimestampToDate = (timestamp: number): string | undefined => {
 };
 
 /**
- * 处理 releasedAt 字段
- * @param model 模型对象
- * @param knownModel 已知模型配置
- * @returns 处理后的 releasedAt 值
+ * Process releasedAt field
+ * @param model Model object
+ * @param knownModel Known model configuration
+ * @returns Processed releasedAt value
  */
 const processReleasedAt = (model: any, knownModel?: any): string | undefined => {
-  // 优先检查 model.created
+  // Check model.created first
   if (model.created !== undefined && model.created !== null) {
-    // 检查是否为时间戳格式
+    // Check if it's in timestamp format
     if (typeof model.created === 'number' && model.created > 1_630_000_000) {
-      // AiHubMix 错误时间戳为 1626777600
+      // AiHubMix incorrect timestamp is 1626777600
       return formatTimestampToDate(model.created);
     }
-    // 如果 created 是字符串且已经是日期格式，直接返回
+    // If created is a string and already in date format, return directly
     if (typeof model.created === 'string') {
-      // Anthropic：若为 '2025-02-19T00:00:00Z' 只取日期部分
+      // Anthropic: if it's '2025-02-19T00:00:00Z', only take the date part
       if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/.test(model.created)) {
         return model.created.split('T')[0];
       }
@@ -326,17 +326,17 @@ const processReleasedAt = (model: any, knownModel?: any): string | undefined =>
     }
   }
 
-  // 回退到原有逻辑
+  // Fall back to original logic
   return model.releasedAt ?? knownModel?.releasedAt ?? undefined;
 };
 
 /**
- * 处理模型显示名称
- * @param displayName 原始显示名称
- * @returns 处理后的显示名称
+ * Process model display name
+ * @param displayName Original display name
+ * @returns Processed display name
  */
 const processDisplayName = (displayName: string): string => {
-  // 如果包含 "Gemini 2.5 Flash Image Preview"，替换对应部分为 "Nano Banana"
+  // If it contains "Gemini 2.5 Flash Image Preview", replace the corresponding part with "Nano Banana"
   if (displayName.includes('Gemini 2.5 Flash Image Preview')) {
     return displayName.replace('Gemini 2.5 Flash Image Preview', 'Nano Banana');
   }
@@ -345,9 +345,9 @@ const processDisplayName = (displayName: string): string => {
 };
 
 /**
- * 获取模型提供商的本地配置
- * @param provider 模型提供商
- * @returns 模型提供商的本地配置
+ * Get the local configuration of the model provider
+ * @param provider Model provider
+ * @returns Local configuration of the model provider
  */
 const getProviderLocalConfig = async (provider?: ModelProviderKey): Promise<any[] | null> => {
   let providerLocalConfig: any[] | null = null;
@@ -357,7 +357,7 @@ const getProviderLocalConfig = async (provider?: ModelProviderKey): Promise<any[
 
       providerLocalConfig = modules[provider];
     } catch {
-      // 如果配置文件不存在或导入失败，保持为 null
+      // If configuration file doesn't exist or import fails, keep as null
       providerLocalConfig = null;
     }
   }
@@ -365,16 +365,16 @@ const getProviderLocalConfig = async (provider?: ModelProviderKey): Promise<any[
 };
 
 /**
- * 获取模型本地配置
- * @param providerLocalConfig 模型提供商的本地配置
- * @param model 模型对象
- * @returns 模型本地配置
+ * Get model local configuration
+ * @param providerLocalConfig Local configuration of the model provider
+ * @param model Model object
+ * @returns Model local configuration
  */
 const getModelLocalEnableConfig = (
   providerLocalConfig: any[],
   model: { id: string },
 ): any | null => {
-  // 如果提供了 providerid 且有本地配置，尝试从中获取模型的 enabled 状态
+  // If providerid is provided and has local configuration, try to get the model's enabled status from it
   let providerLocalModelConfig = null;
   if (providerLocalConfig && Array.isArray(providerLocalConfig)) {
     providerLocalModelConfig = providerLocalConfig.find((m) => m.id === model.id);
@@ -383,7 +383,7 @@ const getModelLocalEnableConfig = (
 };
 
 /**
- * 处理模型卡片的通用逻辑
+ * Common logic for processing model cards
  */
 const processModelCard = (
   model: { [key: string]: any; id: string },
@@ -522,11 +522,11 @@ const processModelCard = (
 };
 
 /**
- * 处理单一提供商的模型列表
- * @param modelList 模型列表
- * @param config 提供商配置
- * @param provider 提供商类型（可选，用于优先匹配对应的本地配置, 当提供了 provider 时，才会尝试从本地配置覆盖 enabled）
- * @returns 处理后的模型卡片列表
+ * Process model list for a single provider
+ * @param modelList Model list
+ * @param config Provider configuration
+ * @param provider Provider type (optional, used to prioritize matching corresponding local configuration, will only attempt to override enabled from local configuration when provider is provided)
+ * @returns Processed model card list
  */
 export const processModelList = async (
   modelList: Array<{ id: string }>,
@@ -535,19 +535,19 @@ export const processModelList = async (
 ): Promise<ChatModelCard[]> => {
   const { LOBE_DEFAULT_MODEL_LIST } = await import('model-bank');
 
-  // 如果提供了 provider，尝试获取该提供商的本地配置
+  // If provider is provided, try to get the local configuration for that provider
   const providerLocalConfig = await getProviderLocalConfig(provider as ModelProviderKey);
 
   return Promise.all(
     modelList.map(async (model) => {
       let knownModel: any = null;
 
-      // 如果提供了provider，优先使用提供商特定的配置
+      // If provider is provided, prioritize using provider-specific configuration
       if (provider) {
         knownModel = await findKnownModelByProvider(model.id, provider);
       }
 
-      // 如果未找到，回退到全局配置
+      // If not found, fall back to global configuration
       if (!knownModel) {
         knownModel = LOBE_DEFAULT_MODEL_LIST.find(
           (m) => model.id.toLowerCase() === m.id.toLowerCase(),
@@ -556,13 +556,13 @@ export const processModelList = async (
 
       const processedModel = processModelCard(model, config, knownModel);
 
-      // 如果提供了 provider 且有本地配置，尝试从中获取模型的 enabled 状态
+      // If provider is provided and has local configuration, try to get the model's enabled status from it
       const providerLocalModelConfig = getModelLocalEnableConfig(
         providerLocalConfig as any[],
         model,
       );
 
-      // 如果找到了本地配置中的模型，使用其 enabled 状态
+      // If model is found in local configuration, use its enabled status
       if (
         processedModel &&
         providerLocalModelConfig &&
@@ -577,10 +577,10 @@ export const processModelList = async (
 };
 
 /**
- * 处理混合提供商的模型列表
- * @param modelList 模型列表
- * @param providerid 可选的提供商ID，用于获取其本地配置文件
- * @returns 处理后的模型卡片列表
+ * Process model list for mixed providers
+ * @param modelList Model list
+ * @param providerid Optional provider ID, used to get its local configuration file
+ * @returns Processed model card list
  */
 export const processMultiProviderModelList = async (
   modelList: Array<{ id: string }>,
@@ -588,7 +588,7 @@ export const processMultiProviderModelList = async (
 ): Promise<ChatModelCard[]> => {
   const { LOBE_DEFAULT_MODEL_LIST } = await import('model-bank');
 
-  // 如果提供了 providerid，尝试获取该提供商的本地配置
+  // If providerid is provided, try to get the local configuration for that provider
   const providerLocalConfig = await getProviderLocalConfig(providerid);
 
   return Promise.all(
@@ -596,17 +596,17 @@ export const processMultiProviderModelList = async (
       const detectedProvider = detectModelProvider(model.id);
       const config = MODEL_LIST_CONFIGS[detectedProvider];
 
-      // 优先使用提供商特定的配置
+      // Prioritize using provider-specific configuration
       let knownModel = await findKnownModelByProvider(model.id, detectedProvider);
 
-      // 如果未找到，回退到全局配置
+      // If not found, fall back to global configuration
       if (!knownModel) {
         knownModel = LOBE_DEFAULT_MODEL_LIST.find(
           (m) => model.id.toLowerCase() === m.id.toLowerCase(),
         );
       }
 
-      // 如果提供了 providerid 且有本地配置，尝试从中获取模型的 enabled 状态
+      // If providerid is provided and has local configuration, try to get the model's enabled status from it
       const providerLocalModelConfig = getModelLocalEnableConfig(
         providerLocalConfig as any[],
         model,
@@ -614,7 +614,7 @@ export const processMultiProviderModelList = async (
 
       const processedModel = processModelCard(model, config, knownModel);
 
-      // 如果找到了本地配置中的模型，使用其 enabled 状态
+      // If model is found in local configuration, use its enabled status
       if (
         processedModel &&
         providerLocalModelConfig &&

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

@@ -5,20 +5,20 @@ interface UriParserResult {
 }
 
 export const parseDataUri = (dataUri: string): UriParserResult => {
-  // 正则表达式匹配整个 Data URI 结构
+  // Regular expression to match the entire Data URI structure
   const dataUriMatch = dataUri.match(/^data:([^;]+);base64,(.+)$/);
 
   if (dataUriMatch) {
-    // 如果是合法的 Data URI
+    // If it's a valid Data URI
     return { base64: dataUriMatch[2], mimeType: dataUriMatch[1], type: 'base64' };
   }
 
   try {
     new URL(dataUri);
-    // 如果是合法的 URL
+    // If it's a valid URL
     return { base64: null, mimeType: null, type: 'url' };
   } catch {
-    // 既不是 Data URI 也不是合法 URL
+    // Neither a Data URI nor a valid URL
     return { base64: null, mimeType: null, type: null };
   }
 };

package/src/app/[variants]/(main)/home/_layout/Header/components/AddButton.tsx

@@ -18,7 +18,7 @@ const AddButton = memo(() => {
     createGroupChatMenuItem,
     createPageMenuItem,
     createAgent,
-    isValidatingAgent,
+    isMutatingAgent,
     isCreatingGroup,
   } = useCreateMenuItems();
 
@@ -39,7 +39,7 @@ const AddButton = memo(() => {
     <Flexbox horizontal>
       <ActionIcon
         icon={CreateBotIcon}
-        loading={isValidatingAgent || isCreatingGroup}
+        loading={isMutatingAgent || isCreatingGroup}
         onClick={handleMainIconClick}
         size={DESKTOP_HEADER_ICON_SIZE}
         title={tChat('newAgent')}

package/src/app/[variants]/(main)/home/_layout/hooks/useCreateMenuItems.tsx

@@ -6,10 +6,10 @@ import { BotIcon, FileTextIcon, FolderCogIcon, FolderPlus } from 'lucide-react';
 import { useCallback, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useNavigate } from 'react-router-dom';
+import useSWRMutation from 'swr/mutation';
 
 import { useGroupTemplates } from '@/components/ChatGroupWizard/templates';
 import { DEFAULT_CHAT_GROUP_CHAT_CONFIG } from '@/const/settings';
-import { useActionSWR } from '@/libs/swr';
 import { type GroupMemberConfig, chatGroupService } from '@/services/chatGroup';
 import { useAgentStore } from '@/store/agent';
 import { useAgentGroupStore } from '@/store/agentGroup';
@@ -51,22 +51,22 @@ export const useCreateMenuItems = () => {
   const [isCreatingSessionGroup, setIsCreatingSessionGroup] = useState(false);
 
   // SWR-based agent creation with auto navigation to profile
-  const { mutate: mutateAgent, isValidating: isValidatingAgent } = useActionSWR(
+  const { trigger: mutateAgent, isMutating: isMutatingAgent } = useSWRMutation(
     'agent.createAgent',
     async () => {
       const result = await storeCreateAgent({});
-      navigate(`/agent/${result.agentId}/profile`);
       return result;
     },
     {
-      onSuccess: async () => {
+      onSuccess: async (result) => {
+        navigate(`/agent/${result.agentId}/profile`);
         await refreshAgentList();
       },
     },
   );
 
   // SWR-based group creation with auto navigation to profile
-  const { mutate: mutateGroup, isValidating: isValidatingGroup } = useActionSWR(
+  const { trigger: mutateGroup, isMutating: isMutatingGroup } = useSWRMutation(
     'group.createGroup',
     async () => {
       const groupId = await createGroup(
@@ -77,11 +77,11 @@ export const useCreateMenuItems = () => {
         [],
         true, // silent mode - don't switch session, we'll navigate instead
       );
-      navigate(`/group/${groupId}/profile`);
       return groupId;
     },
     {
-      onSuccess: async () => {
+      onSuccess: async (groupId) => {
+        navigate(`/group/${groupId}/profile`);
         await refreshAgentList();
         await loadGroups();
       },
@@ -329,7 +329,7 @@ export const useCreateMenuItems = () => {
     // Loading states
     isCreatingGroup,
     isCreatingSessionGroup,
-    isLoading: isValidatingAgent || isValidatingGroup || isCreatingGroup || isCreatingSessionGroup,
-    isValidatingAgent,
+    isLoading: isMutatingAgent || isMutatingGroup || isCreatingGroup || isCreatingSessionGroup,
+    isMutatingAgent,
   };
 };

package/src/helpers/parserPlaceholder/index.test.ts

@@ -1,6 +1,10 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { parsePlaceholderVariablesMessages } from './index';
+import {
+  VARIABLE_GENERATORS,
+  parsePlaceholderVariables,
+  parsePlaceholderVariablesMessages,
+} from './index';
 
 // Mock dependencies
 vi.mock('@lobechat/utils', () => ({
@@ -48,7 +52,7 @@ vi.mock('@/store/chat/selectors', () => ({
   },
 }));
 
-vi.mock('./GlobalAgentContextManager', () => ({
+vi.mock('../GlobalAgentContextManager', () => ({
   globalAgentContextManager: {
     getContext: () => ({
       homePath: '/Users/test',
@@ -330,3 +334,358 @@ describe('parsePlaceholderVariablesMessages', () => {
     });
   });
 });
+
+describe('parsePlaceholderVariables', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2025-06-06T06:06:06.666Z'));
+    vi.spyOn(Math, 'random').mockReturnValue(0.5);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  describe('basic variable replacement', () => {
+    it('should replace a single variable', () => {
+      const text = 'Hello {{username}}!';
+      const result = parsePlaceholderVariables(text);
+      expect(result).toBe('Hello testuser!');
+    });
+
+    it('should replace multiple variables', () => {
+      const text = 'User: {{username}}, Email: {{email}}';
+      const result = parsePlaceholderVariables(text);
+      expect(result).toBe('User: testuser, Email: test@example.com');
+    });
+
+    it('should return original text if no variables present', () => {
+      const text = 'Hello world!';
+      const result = parsePlaceholderVariables(text);
+      expect(result).toBe('Hello world!');
+    });
+
+    it('should handle empty string', () => {
+      const result = parsePlaceholderVariables('');
+      expect(result).toBe('');
+    });
+
+    it('should preserve unknown variables', () => {
+      const text = 'Hello {{unknown_var}}!';
+      const result = parsePlaceholderVariables(text);
+      expect(result).toBe('Hello {{unknown_var}}!');
+    });
+  });
+
+  describe('recursive depth handling', () => {
+    it('should handle default depth of 2', () => {
+      const text = 'Test {{username}}';
+      const result = parsePlaceholderVariables(text);
+      expect(result).toBe('Test testuser');
+    });
+
+    it('should handle custom depth', () => {
+      const text = 'Test {{username}}';
+      const result = parsePlaceholderVariables(text, 1);
+      expect(result).toBe('Test testuser');
+    });
+
+    it('should handle depth of 0', () => {
+      const text = 'Test {{username}}';
+      const result = parsePlaceholderVariables(text, 0);
+      // With depth 0, no replacements should occur
+      expect(result).toBe('Test {{username}}');
+    });
+
+    it('should stop early if no more replacements needed', () => {
+      const text = 'Static text';
+      const result = parsePlaceholderVariables(text, 10);
+      expect(result).toBe('Static text');
+    });
+  });
+
+  describe('special characters and edge cases', () => {
+    it('should handle variables with spaces', () => {
+      const text = 'Hello {{ username }}!';
+      const result = parsePlaceholderVariables(text);
+      // The regex trims spaces, so this should work
+      expect(result).toBe('Hello testuser!');
+    });
+
+    it('should handle consecutive variables', () => {
+      const text = '{{username}}{{email}}';
+      const result = parsePlaceholderVariables(text);
+      expect(result).toBe('testusertest@example.com');
+    });
+
+    it('should handle variables at start and end', () => {
+      const text = '{{username}} middle {{email}}';
+      const result = parsePlaceholderVariables(text);
+      expect(result).toBe('testuser middle test@example.com');
+    });
+
+    it('should handle malformed brackets', () => {
+      const text = '{username} or {{{username}}}';
+      const result = parsePlaceholderVariables(text);
+      // Only {{username}} should be replaced
+      expect(result).toContain('{username}');
+    });
+  });
+});
+
+describe('VARIABLE_GENERATORS', () => {
+  describe('time-related variables', () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
+      vi.setSystemTime(new Date('2025-06-06T06:06:06.666Z'));
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    it('should generate year', () => {
+      expect(VARIABLE_GENERATORS.year()).toBe('2025');
+    });
+
+    it('should generate month with padding', () => {
+      expect(VARIABLE_GENERATORS.month()).toBe('06');
+    });
+
+    it('should generate day with padding', () => {
+      expect(VARIABLE_GENERATORS.day()).toBe('06');
+    });
+
+    it('should generate hour with padding', () => {
+      expect(VARIABLE_GENERATORS.hour()).toBe('06');
+    });
+
+    it('should generate minute with padding', () => {
+      expect(VARIABLE_GENERATORS.minute()).toBe('06');
+    });
+
+    it('should generate second with padding', () => {
+      expect(VARIABLE_GENERATORS.second()).toBe('06');
+    });
+
+    it('should generate ISO timestamp', () => {
+      expect(VARIABLE_GENERATORS.iso()).toBe('2025-06-06T06:06:06.666Z');
+    });
+
+    it('should generate timestamp', () => {
+      const result = VARIABLE_GENERATORS.timestamp();
+      expect(result).toBe(Date.now().toString());
+    });
+
+    it('should generate date string', () => {
+      const result = VARIABLE_GENERATORS.date();
+      expect(result).toBeTruthy();
+      expect(typeof result).toBe('string');
+    });
+
+    it('should generate time string', () => {
+      const result = VARIABLE_GENERATORS.time();
+      expect(result).toBeTruthy();
+      expect(typeof result).toBe('string');
+    });
+
+    it('should generate datetime string', () => {
+      const result = VARIABLE_GENERATORS.datetime();
+      expect(result).toBeTruthy();
+      expect(typeof result).toBe('string');
+    });
+
+    it('should generate weekday', () => {
+      const result = VARIABLE_GENERATORS.weekday();
+      expect(result).toBe('Friday');
+    });
+
+    it('should generate locale', () => {
+      const result = VARIABLE_GENERATORS.locale();
+      expect(result).toBeTruthy();
+      expect(typeof result).toBe('string');
+    });
+
+    it('should generate timezone', () => {
+      const result = VARIABLE_GENERATORS.timezone();
+      expect(result).toBeTruthy();
+      expect(typeof result).toBe('string');
+    });
+  });
+
+  describe('random value variables', () => {
+    beforeEach(() => {
+      vi.spyOn(Math, 'random').mockReturnValue(0.5);
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it('should generate random number', () => {
+      expect(VARIABLE_GENERATORS.random()).toBe('500001');
+    });
+
+    it('should generate random boolean', () => {
+      expect(VARIABLE_GENERATORS.random_bool()).toBe('false');
+    });
+
+    it('should generate random float', () => {
+      expect(VARIABLE_GENERATORS.random_float()).toBe('50.00');
+    });
+
+    it('should generate random integer', () => {
+      expect(VARIABLE_GENERATORS.random_int()).toBe('51');
+    });
+
+    it('should generate random hex color', () => {
+      const result = VARIABLE_GENERATORS.random_hex();
+      // Math.floor(0.5 * 16777215) = 8388607 = 0x7fffff
+      expect(result).toBe('7fffff');
+      expect(result.length).toBe(6);
+    });
+
+    it('should generate random string', () => {
+      const result = VARIABLE_GENERATORS.random_string();
+      expect(result).toBeTruthy();
+      expect(typeof result).toBe('string');
+    });
+
+    it('should generate random digit', () => {
+      expect(VARIABLE_GENERATORS.random_digit()).toBe('5');
+    });
+
+    it('should generate different random booleans', () => {
+      vi.spyOn(Math, 'random').mockReturnValue(0.6);
+      expect(VARIABLE_GENERATORS.random_bool()).toBe('true');
+
+      vi.spyOn(Math, 'random').mockReturnValue(0.4);
+      expect(VARIABLE_GENERATORS.random_bool()).toBe('false');
+    });
+  });
+
+  describe('UUID variables', () => {
+    it('should generate full UUID', () => {
+      expect(VARIABLE_GENERATORS.uuid()).toBe('mocked-uuid-12345');
+    });
+
+    it('should generate short UUID', () => {
+      expect(VARIABLE_GENERATORS.uuid_short()).toBe('mocked');
+    });
+  });
+
+  describe('user information variables', () => {
+    it('should get username', () => {
+      expect(VARIABLE_GENERATORS.username()).toBe('testuser');
+    });
+
+    it('should get nickname', () => {
+      expect(VARIABLE_GENERATORS.nickname()).toBe('Test User');
+    });
+
+    it('should get email', () => {
+      expect(VARIABLE_GENERATORS.email()).toBe('test@example.com');
+    });
+  });
+
+  describe('model information variables', () => {
+    it('should get current model', () => {
+      expect(VARIABLE_GENERATORS.model()).toBe('gpt-4');
+    });
+
+    it('should get current provider', () => {
+      expect(VARIABLE_GENERATORS.provider()).toBe('openai');
+    });
+  });
+
+  describe('desktop path variables', () => {
+    it('should get home path', () => {
+      expect(VARIABLE_GENERATORS.homePath()).toBe('/Users/test');
+    });
+
+    it('should get desktop path', () => {
+      expect(VARIABLE_GENERATORS.desktopPath()).toBe('/Users/test/Desktop');
+    });
+
+    it('should get documents path', () => {
+      expect(VARIABLE_GENERATORS.documentsPath()).toBe('/Users/test/Documents');
+    });
+
+    it('should get downloads path', () => {
+      expect(VARIABLE_GENERATORS.downloadsPath()).toBe('/Users/test/Downloads');
+    });
+
+    it('should return empty string for missing music path', () => {
+      expect(VARIABLE_GENERATORS.musicPath()).toBe('');
+    });
+
+    it('should return empty string for missing pictures path', () => {
+      expect(VARIABLE_GENERATORS.picturesPath()).toBe('');
+    });
+
+    it('should return empty string for missing videos path', () => {
+      expect(VARIABLE_GENERATORS.videosPath()).toBe('');
+    });
+
+    it('should return empty string for missing userData path', () => {
+      expect(VARIABLE_GENERATORS.userDataPath()).toBe('');
+    });
+
+    it('should return default message for working directory when not specified', () => {
+      const result = VARIABLE_GENERATORS.workingDirectory();
+      expect(result).toBe('(not specified, use user Desktop directory as default)');
+    });
+  });
+
+  describe('platform variables', () => {
+    const originalNavigator = global.navigator;
+
+    beforeEach(() => {
+      Object.defineProperty(global, 'navigator', {
+        writable: true,
+        configurable: true,
+        value: {
+          language: 'en-US',
+          platform: 'MacIntel',
+          userAgent:
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36',
+        },
+      });
+    });
+
+    afterEach(() => {
+      Object.defineProperty(global, 'navigator', {
+        writable: true,
+        configurable: true,
+        value: originalNavigator,
+      });
+    });
+
+    it('should get language', () => {
+      expect(VARIABLE_GENERATORS.language()).toBe('en-US');
+    });
+
+    it('should get platform', () => {
+      expect(VARIABLE_GENERATORS.platform()).toBe('MacIntel');
+    });
+
+    it('should get user agent', () => {
+      const result = VARIABLE_GENERATORS.user_agent();
+      expect(result).toContain('Mozilla/5.0');
+      expect(result).toContain('Chrome/132.0.0.0');
+    });
+
+    it('should return empty string when navigator is undefined', () => {
+      Object.defineProperty(global, 'navigator', {
+        writable: true,
+        configurable: true,
+        value: undefined,
+      });
+
+      expect(VARIABLE_GENERATORS.language()).toBe('');
+      expect(VARIABLE_GENERATORS.platform()).toBe('');
+      expect(VARIABLE_GENERATORS.user_agent()).toBe('');
+    });
+  });
+});

package/src/server/routers/lambda/userMemories.ts

@@ -15,7 +15,6 @@ import {
 } from '@lobechat/memory-user-memory';
 import { LayersEnum, type SearchMemoryResult, searchMemorySchema } from '@lobechat/types';
 import { type SQL, and, asc, eq, gte, lte } from 'drizzle-orm';
-import { ModelProvider } from 'model-bank';
 import pMap from 'p-map';
 import { z } from 'zod';
 
@@ -135,11 +134,14 @@ const searchUserMemories = async (
 };
 
 const getEmbeddingRuntime = async (serverDB: LobeChatDatabase, userId: string) => {
-  const provider = ENABLE_BUSINESS_FEATURES ? BRANDING_PROVIDER : ModelProvider.OpenAI;
-  // Read user's provider config from database
-  const agentRuntime = await initModelRuntimeFromDB(serverDB, userId, provider);
-  const { model: embeddingModel } =
+  const { provider, model: embeddingModel } =
     getServerDefaultFilesConfig().embeddingModel || DEFAULT_USER_MEMORY_EMBEDDING_MODEL_ITEM;
+  // Read user's provider config from database
+  const agentRuntime = await initModelRuntimeFromDB(
+    serverDB,
+    userId,
+    ENABLE_BUSINESS_FEATURES ? BRANDING_PROVIDER : provider,
+  );
 
   return { agentRuntime, embeddingModel };
 };