@lobehub/lobehub 2.0.0-next.36 → 2.0.0-next.38

package/packages/database/src/models/__tests__/apiKey.test.ts

@@ -0,0 +1,444 @@
+// @vitest-environment node
+import { eq } from 'drizzle-orm';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { apiKeys, users } from '../../schemas';
+import { LobeChatDatabase } from '../../type';
+import { ApiKeyModel } from '../apiKey';
+import { getTestDB } from './_util';
+
+const serverDB: LobeChatDatabase = await getTestDB();
+
+const userId = 'api-key-model-test-user-id';
+const apiKeyModel = new ApiKeyModel(serverDB, userId);
+
+beforeEach(async () => {
+  await serverDB.delete(users);
+  await serverDB.insert(users).values([{ id: userId }, { id: 'user2' }]);
+});
+
+afterEach(async () => {
+  await serverDB.delete(users).where(eq(users.id, userId));
+  await serverDB.delete(apiKeys).where(eq(apiKeys.userId, userId));
+});
+
+describe('ApiKeyModel', () => {
+  describe('create', () => {
+    it('should create a new API key without encryption', async () => {
+      const params = {
+        enabled: true,
+        name: 'Test API Key',
+      };
+
+      const result = await apiKeyModel.create(params);
+
+      expect(result.id).toBeDefined();
+      expect(result.name).toBe(params.name);
+      expect(result.enabled).toBe(params.enabled);
+      expect(result.key).toBeDefined();
+      expect(result.key).toMatch(/^lb-[\da-z]{16}$/);
+      expect(result.userId).toBe(userId);
+
+      const apiKey = await serverDB.query.apiKeys.findFirst({
+        where: eq(apiKeys.id, result.id),
+      });
+      expect(apiKey).toMatchObject({ ...params, userId });
+    });
+
+    it('should create a new API key with encryption', async () => {
+      const mockEncryptor = vi.fn().mockResolvedValue('encrypted-key-value');
+      const params = {
+        enabled: true,
+        name: 'Encrypted API Key',
+      };
+
+      const result = await apiKeyModel.create(params, mockEncryptor);
+
+      expect(result.id).toBeDefined();
+      expect(result.name).toBe(params.name);
+      expect(result.key).toBe('encrypted-key-value');
+      expect(mockEncryptor).toHaveBeenCalledWith(expect.stringMatching(/^lb-[\da-z]{16}$/));
+
+      const apiKey = await serverDB.query.apiKeys.findFirst({
+        where: eq(apiKeys.id, result.id),
+      });
+      expect(apiKey?.key).toBe('encrypted-key-value');
+    });
+
+    it('should create API key with expiration date', async () => {
+      const expiresAt = new Date('2025-12-31');
+      const params = {
+        enabled: true,
+        expiresAt,
+        name: 'Expiring Key',
+      };
+
+      const result = await apiKeyModel.create(params);
+
+      expect(result.expiresAt).toEqual(expiresAt);
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete an API key by id', async () => {
+      const { id } = await apiKeyModel.create({ name: 'Test Key', enabled: true });
+
+      await apiKeyModel.delete(id);
+
+      const apiKey = await serverDB.query.apiKeys.findFirst({
+        where: eq(apiKeys.id, id),
+      });
+      expect(apiKey).toBeUndefined();
+    });
+
+    it('should only delete API keys for the current user', async () => {
+      const { id: key1 } = await apiKeyModel.create({ name: 'User 1 Key', enabled: true });
+
+      const anotherApiKeyModel = new ApiKeyModel(serverDB, 'user2');
+      const { id: key2 } = await anotherApiKeyModel.create({ name: 'User 2 Key', enabled: true });
+
+      await apiKeyModel.delete(key2);
+
+      const key2Still = await serverDB.query.apiKeys.findFirst({
+        where: eq(apiKeys.id, key2),
+      });
+      expect(key2Still).toBeDefined();
+
+      await apiKeyModel.delete(key1);
+
+      const key1Deleted = await serverDB.query.apiKeys.findFirst({
+        where: eq(apiKeys.id, key1),
+      });
+      expect(key1Deleted).toBeUndefined();
+    });
+  });
+
+  describe('deleteAll', () => {
+    it('should delete all API keys for the user', async () => {
+      await apiKeyModel.create({ name: 'Test Key 1', enabled: true });
+      await apiKeyModel.create({ name: 'Test Key 2', enabled: true });
+
+      await apiKeyModel.deleteAll();
+
+      const userKeys = await serverDB.query.apiKeys.findMany({
+        where: eq(apiKeys.userId, userId),
+      });
+      expect(userKeys).toHaveLength(0);
+    });
+
+    it('should only delete API keys for the user, not others', async () => {
+      await apiKeyModel.create({ name: 'Test Key 1', enabled: true });
+      await apiKeyModel.create({ name: 'Test Key 2', enabled: true });
+
+      const anotherApiKeyModel = new ApiKeyModel(serverDB, 'user2');
+      await anotherApiKeyModel.create({ name: 'User 2 Key', enabled: true });
+
+      await apiKeyModel.deleteAll();
+
+      const userKeys = await serverDB.query.apiKeys.findMany({
+        where: eq(apiKeys.userId, userId),
+      });
+      const total = await serverDB.query.apiKeys.findMany();
+      expect(userKeys).toHaveLength(0);
+      expect(total).toHaveLength(1);
+    });
+  });
+
+  describe('query', () => {
+    it('should query API keys for the user without decryption', async () => {
+      await apiKeyModel.create({ name: 'Key 1', enabled: true });
+      await apiKeyModel.create({ name: 'Key 2', enabled: true });
+
+      const keys = await apiKeyModel.query();
+      expect(keys).toHaveLength(2);
+      expect(keys[0].key).toMatch(/^lb-[\da-z]{16}$/);
+    });
+
+    it('should query API keys ordered by updatedAt desc', async () => {
+      const key1 = await apiKeyModel.create({ name: 'Key 1', enabled: true });
+      // Wait a bit to ensure different timestamps
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      const key2 = await apiKeyModel.create({ name: 'Key 2', enabled: true });
+
+      const keys = await apiKeyModel.query();
+      expect(keys).toHaveLength(2);
+      expect(keys[0].id).toBe(key2.id);
+      expect(keys[1].id).toBe(key1.id);
+    });
+
+    it('should query API keys with decryption', async () => {
+      const mockEncryptor = vi.fn().mockResolvedValue('encrypted-key');
+      const mockDecryptor = vi.fn().mockResolvedValue({ plaintext: 'decrypted-key-value' });
+
+      await apiKeyModel.create({ name: 'Encrypted Key', enabled: true }, mockEncryptor);
+
+      const keys = await apiKeyModel.query(mockDecryptor);
+
+      expect(keys).toHaveLength(1);
+      expect(keys[0].key).toBe('decrypted-key-value');
+      expect(mockDecryptor).toHaveBeenCalledWith('encrypted-key');
+    });
+
+    it('should only query API keys for the current user', async () => {
+      await apiKeyModel.create({ name: 'User 1 Key', enabled: true });
+
+      const anotherApiKeyModel = new ApiKeyModel(serverDB, 'user2');
+      await anotherApiKeyModel.create({ name: 'User 2 Key', enabled: true });
+
+      const keys = await apiKeyModel.query();
+      expect(keys).toHaveLength(1);
+      expect(keys[0].name).toBe('User 1 Key');
+    });
+  });
+
+  describe('findByKey', () => {
+    it('should find API key by key value without encryption', async () => {
+      // Use a valid hex format key since validateApiKeyFormat checks for hex pattern
+      const validKey = 'lb-abcdef0123456789';
+      await serverDB.insert(apiKeys).values({
+        enabled: true,
+        key: validKey,
+        name: 'Test Key',
+        userId,
+      });
+
+      const found = await apiKeyModel.findByKey(validKey);
+
+      expect(found).toBeDefined();
+      expect(found?.key).toBe(validKey);
+      expect(found?.name).toBe('Test Key');
+    });
+
+    it('should find API key by key value with encryption', async () => {
+      const mockEncryptor = vi.fn().mockResolvedValue('encrypted-key-value');
+      const created = await apiKeyModel.create({ name: 'Test Key', enabled: true }, mockEncryptor);
+
+      const testKey = 'lb-0123456789abcdef';
+      mockEncryptor.mockResolvedValue('encrypted-key-value');
+      const found = await apiKeyModel.findByKey(testKey, mockEncryptor);
+
+      expect(mockEncryptor).toHaveBeenCalledWith(testKey);
+    });
+
+    it('should return null for invalid key format', async () => {
+      const found = await apiKeyModel.findByKey('invalid-key-format');
+
+      expect(found).toBeNull();
+    });
+
+    it('should return undefined for non-existent key', async () => {
+      const found = await apiKeyModel.findByKey('lb-0123456789abcdef');
+
+      expect(found).toBeUndefined();
+    });
+  });
+
+  describe('validateKey', () => {
+    it('should validate enabled and non-expired key with valid hex format', async () => {
+      const futureDate = new Date();
+      futureDate.setFullYear(futureDate.getFullYear() + 1);
+
+      // Use a valid hex format key
+      const validKey = 'lb-0123456789abcdef';
+      await serverDB.insert(apiKeys).values({
+        enabled: true,
+        expiresAt: futureDate,
+        key: validKey,
+        name: 'Valid Key',
+        userId,
+      });
+
+      const isValid = await apiKeyModel.validateKey(validKey);
+
+      expect(isValid).toBe(true);
+    });
+
+    it('should validate enabled key without expiration with valid hex format', async () => {
+      // Use a valid hex format key
+      const validKey = 'lb-fedcba9876543210';
+      await serverDB.insert(apiKeys).values({
+        enabled: true,
+        key: validKey,
+        name: 'Valid Key',
+        userId,
+      });
+
+      const isValid = await apiKeyModel.validateKey(validKey);
+
+      expect(isValid).toBe(true);
+    });
+
+    it('should reject non-existent key', async () => {
+      const isValid = await apiKeyModel.validateKey('lb-0123456789abcdef');
+
+      expect(isValid).toBe(false);
+    });
+
+    it('should reject disabled key', async () => {
+      const validKey = 'lb-1111111111111111';
+      await serverDB.insert(apiKeys).values({
+        enabled: false,
+        key: validKey,
+        name: 'Disabled Key',
+        userId,
+      });
+
+      const isValid = await apiKeyModel.validateKey(validKey);
+
+      expect(isValid).toBe(false);
+    });
+
+    it('should reject expired key', async () => {
+      const pastDate = new Date();
+      pastDate.setFullYear(pastDate.getFullYear() - 1);
+
+      const validKey = 'lb-2222222222222222';
+      await serverDB.insert(apiKeys).values({
+        enabled: true,
+        expiresAt: pastDate,
+        key: validKey,
+        name: 'Expired Key',
+        userId,
+      });
+
+      const isValid = await apiKeyModel.validateKey(validKey);
+
+      expect(isValid).toBe(false);
+    });
+
+    it('should reject invalid key format', async () => {
+      const isValid = await apiKeyModel.validateKey('invalid-format');
+
+      expect(isValid).toBe(false);
+    });
+  });
+
+  describe('update', () => {
+    it('should update API key properties', async () => {
+      const { id } = await apiKeyModel.create({ name: 'Test Key', enabled: true });
+
+      await apiKeyModel.update(id, { name: 'Updated Key', enabled: false });
+
+      const updated = await serverDB.query.apiKeys.findFirst({
+        where: eq(apiKeys.id, id),
+      });
+      expect(updated).toMatchObject({
+        enabled: false,
+        id,
+        name: 'Updated Key',
+        userId,
+      });
+    });
+
+    it('should update expiration date', async () => {
+      const { id } = await apiKeyModel.create({ name: 'Test Key', enabled: true });
+
+      const newExpiresAt = new Date('2026-12-31');
+      await apiKeyModel.update(id, { expiresAt: newExpiresAt });
+
+      const updated = await serverDB.query.apiKeys.findFirst({
+        where: eq(apiKeys.id, id),
+      });
+      expect(updated?.expiresAt).toEqual(newExpiresAt);
+    });
+
+    it('should only update API keys for the current user', async () => {
+      const { id: key1 } = await apiKeyModel.create({ name: 'User 1 Key', enabled: true });
+
+      const anotherApiKeyModel = new ApiKeyModel(serverDB, 'user2');
+      const { id: key2 } = await anotherApiKeyModel.create({ name: 'User 2 Key', enabled: true });
+
+      await apiKeyModel.update(key2, { name: 'Attempted Update' });
+
+      const key2Still = await serverDB.query.apiKeys.findFirst({
+        where: eq(apiKeys.id, key2),
+      });
+      expect(key2Still?.name).toBe('User 2 Key');
+    });
+  });
+
+  describe('findById', () => {
+    it('should find API key by id', async () => {
+      const { id } = await apiKeyModel.create({ name: 'Test Key', enabled: true });
+
+      const found = await apiKeyModel.findById(id);
+
+      expect(found).toMatchObject({
+        enabled: true,
+        id,
+        name: 'Test Key',
+        userId,
+      });
+    });
+
+    it('should return undefined for non-existent id', async () => {
+      const found = await apiKeyModel.findById(999_999);
+
+      expect(found).toBeUndefined();
+    });
+
+    it('should only find API keys for the current user', async () => {
+      const anotherApiKeyModel = new ApiKeyModel(serverDB, 'user2');
+      const { id: key2 } = await anotherApiKeyModel.create({ name: 'User 2 Key', enabled: true });
+
+      const found = await apiKeyModel.findById(key2);
+
+      expect(found).toBeUndefined();
+    });
+  });
+
+  describe('updateLastUsed', () => {
+    it('should update lastUsedAt timestamp', async () => {
+      const { id } = await apiKeyModel.create({ name: 'Test Key', enabled: true });
+
+      const beforeUpdate = await serverDB.query.apiKeys.findFirst({
+        where: eq(apiKeys.id, id),
+      });
+      expect(beforeUpdate?.lastUsedAt).toBeNull();
+
+      await apiKeyModel.updateLastUsed(id);
+
+      const afterUpdate = await serverDB.query.apiKeys.findFirst({
+        where: eq(apiKeys.id, id),
+      });
+      expect(afterUpdate?.lastUsedAt).toBeInstanceOf(Date);
+    });
+
+    it('should only update API keys for the current user', async () => {
+      const anotherApiKeyModel = new ApiKeyModel(serverDB, 'user2');
+      const { id: key2 } = await anotherApiKeyModel.create({ name: 'User 2 Key', enabled: true });
+
+      await apiKeyModel.updateLastUsed(key2);
+
+      const key2Still = await serverDB.query.apiKeys.findFirst({
+        where: eq(apiKeys.id, key2),
+      });
+      expect(key2Still?.lastUsedAt).toBeNull();
+    });
+
+    it('should update existing lastUsedAt to a new timestamp', async () => {
+      const { id } = await apiKeyModel.create({ name: 'Test Key', enabled: true });
+
+      await apiKeyModel.updateLastUsed(id);
+
+      const firstUpdate = await serverDB.query.apiKeys.findFirst({
+        where: eq(apiKeys.id, id),
+      });
+      const firstTimestamp = firstUpdate?.lastUsedAt;
+
+      // Wait to ensure different timestamp
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      await apiKeyModel.updateLastUsed(id);
+
+      const secondUpdate = await serverDB.query.apiKeys.findFirst({
+        where: eq(apiKeys.id, id),
+      });
+      const secondTimestamp = secondUpdate?.lastUsedAt;
+
+      expect(secondTimestamp).toBeDefined();
+      expect(firstTimestamp).toBeDefined();
+      expect(secondTimestamp!.getTime()).toBeGreaterThan(firstTimestamp!.getTime());
+    });
+  });
+});

package/packages/web-crawler/src/crawImpl/browserless.ts

@@ -56,7 +56,7 @@ export const browserless: CrawlImpl = async (url, { filterOptions }) => {
     if (
       !!result.content &&
       result.title &&
-      // Just a moment... 说明被 CF 拦截了
+      // "Just a moment..." indicates being blocked by CloudFlare
       result.title.trim() !== 'Just a moment...'
     ) {
       return {

package/packages/web-crawler/src/crawImpl/naive.ts

@@ -6,25 +6,25 @@ import { htmlToMarkdown } from '../utils/htmlToMarkdown';
 import { DEFAULT_TIMEOUT, withTimeout } from '../utils/withTimeout';
 
 const mixinHeaders = {
-  // 接受的内容类型
+  // Accepted content types
   'Accept':
     'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
-  // 接受的编码方式
+  // Accepted encoding methods
   'Accept-Encoding': 'gzip, deflate, br',
-  // 接受的语言
+  // Accepted languages
   'Accept-Language': 'en-US,en;q=0.9,zh;q=0.8',
-  // 缓存控制
+  // Cache control
   'Cache-Control': 'max-age=0',
-  // 连接类型
+  // Connection type
   'Connection': 'keep-alive',
-  // 表明请求来自哪个站点
+  // Indicates which site the request is from
   'Referer': 'https://www.google.com/',
-  // 升级不安全请求
+  // Upgrade insecure requests
   'Upgrade-Insecure-Requests': '1',
-  // 模拟真实浏览器的 User-Agent
+  // Simulate real browser User-Agent
   'User-Agent':
     'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36',
-  // 防止跨站请求伪造
+  // Prevent cross-site request forgery
   'sec-ch-ua': '"Google Chrome";v="121", "Not A(Brand";v="99", "Chromium";v="121"',
   'sec-ch-ua-mobile': '?0',
   'sec-ch-ua-platform': '"Windows"',

package/packages/web-crawler/src/crawler.ts

@@ -19,8 +19,8 @@ export class Crawler {
   }
 
   /**
-   * 爬取网页内容
-   * @param options 爬取选项
+   * Crawl webpage content
+   * @param options Crawl options
    */
   async crawl({
     url,
@@ -31,14 +31,14 @@ export class Crawler {
     impls?: CrawlImplType[];
     url: string;
   }): Promise<CrawlUniformResult> {
-    // 应用URL规则
+    // Apply URL rules
     const {
       transformedUrl,
       filterOptions: ruleFilterOptions,
       impls: ruleImpls,
     } = applyUrlRules(url, crawUrlRules);
 
-    // 合并用户提供的过滤选项和规则中的过滤选项，用户选项优先
+    // Merge user-provided filter options and rule filter options, user options take priority
     const mergedFilterOptions = {
       ...ruleFilterOptions,
       ...userFilterOptions,
@@ -53,7 +53,7 @@ export class Crawler {
       ? (userImpls.filter((impl) => Object.keys(crawlImpls).includes(impl)) as CrawlImplType[])
       : systemImpls;
 
-    //   按照内置的实现顺序依次尝试
+    // Try each implementation in the built-in order
     for (const impl of finalImpls) {
       try {
         const res = await crawlImpls[impl](transformedUrl, { filterOptions: mergedFilterOptions });

package/packages/web-crawler/src/urlRules.ts

@@ -1,32 +1,32 @@
 import { CrawlUrlRule } from './type';
 
 export const crawUrlRules: CrawlUrlRule[] = [
-  // 搜狗微信链接，使用 search1api
+  // Sogou WeChat links, use search1api
   {
     impls: ['search1api'],
     urlPattern: 'https://weixin.sogou.com/link(.*)',
   },
-  // 搜狗链接，使用 search1api
+  // Sogou links, use search1api
   {
     impls: ['search1api'],
     urlPattern: 'https://sogou.com/link(.*)',
   },
-  // YouTube 链接，使用 search1api，格式化 markdown，且可以返回字幕内容
+  // YouTube links, use search1api, formatted as markdown, can return subtitle content
   {
     impls: ['search1api'],
     urlPattern: 'https://www.youtube.com/watch(.*)',
   },
-  // Reddit 链接，使用 search1api，格式化 markdown，包含标题、作者、互动数量、具体评论内容等
+  // Reddit links, use search1api, formatted as markdown, includes title, author, interaction count, specific comment content, etc.
   {
     impls: ['search1api'],
     urlPattern: 'https://www.reddit.com/r/(.*)/comments/(.*)',
   },
-  // 微信公众号有爬虫防护，优先使用 search1api，jina 作为兜底（目前 jina 爬取会被风控）
+  // WeChat official accounts have crawler protection, use search1api first, jina as fallback (currently jina crawling may be blocked)
   {
     impls: ['search1api', 'jina'],
     urlPattern: 'https://mp.weixin.qq.com(.*)',
   },
-  // github 源码解析
+  // GitHub source code parsing
   {
     filterOptions: {
       enableReadability: false,
@@ -43,7 +43,7 @@ export const crawUrlRules: CrawlUrlRule[] = [
     // GitHub discussion
     urlPattern: 'https://github.com/(.*)/discussions/(.*)',
   },
-  // 所有 PDF 都用 jina
+  // All PDFs use jina
   {
     impls: ['jina'],
     urlPattern: 'https://(.*).pdf',
@@ -53,7 +53,7 @@ export const crawUrlRules: CrawlUrlRule[] = [
     impls: ['jina'],
     urlPattern: 'https://arxiv.org/pdf/(.*)',
   },
-  // 知乎有爬虫防护，使用 jina
+  // Zhihu has crawler protection, use jina
   {
     impls: ['jina'],
     urlPattern: 'https://zhuanlan.zhihu.com(.*)',
@@ -63,7 +63,7 @@ export const crawUrlRules: CrawlUrlRule[] = [
     urlPattern: 'https://zhihu.com(.*)',
   },
   {
-    // Medium 文章转换为 Scribe.rip
+    // Convert Medium articles to Scribe.rip
     urlPattern: 'https://medium.com/(.*)',
     urlTransform: 'https://scribe.rip/$1',
   },
@@ -74,10 +74,10 @@ export const crawUrlRules: CrawlUrlRule[] = [
     impls: ['jina', 'browserless'],
     urlPattern: 'https://(twitter.com|x.com)/(.*)',
   },
-  // 体育数据网站规则
+  // Sports data website rules
   {
     filterOptions: {
-      // 对体育数据表格禁用 Readability 并且转换为纯文本
+      // Disable Readability for sports data tables and convert to plain text
       enableReadability: false,
       pureText: true,
     },
@@ -94,13 +94,13 @@ export const crawUrlRules: CrawlUrlRule[] = [
     impls: ['jina'],
     urlPattern: 'https://cvpr.thecvf.com(.*)',
   },
-  // 飞书用 jina
+  // Feishu use jina
   // https://github.com/lobehub/lobe-chat/issues/6879
   {
     impls: ['jina'],
     urlPattern: 'https://(.*).feishu.cn/(.*)',
   },
-  // 小红书存在爬虫防护，使用 Search1API 或 Jina (备用)
+  // Xiaohongshu has crawler protection, use Search1API or Jina (fallback)
   {
     impls: ['search1api', 'jina'],
     urlPattern: 'https://(.*).xiaohongshu.com/(.*)',

package/packages/web-crawler/src/utils/appUrlRules.ts

@@ -9,14 +9,14 @@ export const applyUrlRules = (
   transformedUrl: string;
 } => {
   for (const rule of urlRules) {
-    // 转换为正则表达式
+    // Convert to regular expression
     const regex = new RegExp(rule.urlPattern);
     const match = url.match(regex);
 
     if (match) {
       if (rule.urlTransform) {
-        // 如果有转换规则，进行 URL 转换
-        // 替换 $1, $2 等占位符为捕获组内容
+        // If there is a transformation rule, perform URL transformation
+        // Replace placeholders like $1, $2 with capture group content
         const transformedUrl = rule.urlTransform.replaceAll(
           /\$(\d+)/g,
           (_, index) => match[parseInt(index)] || '',
@@ -28,7 +28,7 @@ export const applyUrlRules = (
           transformedUrl,
         };
       } else {
-        // 没有转换规则但匹配了模式，只返回过滤选项
+        // No transformation rule but pattern matched, only return filter options
         return {
           filterOptions: rule.filterOptions,
           impls: rule.impls,
@@ -38,6 +38,6 @@ export const applyUrlRules = (
     }
   }
 
-  // 没有匹配任何规则，返回原始 URL
+  // No rule matched, return original URL
   return { transformedUrl: url };
 };

package/src/features/Conversation/components/Extras/Usage/UsageDetail/index.tsx

@@ -217,6 +217,9 @@ const TokenDetail = memo<TokenDetailProps>(({ meta, model, provider }) => {
         <Icon icon={isShowCredit ? BadgeCent : CoinsIcon} />
         <AnimatedNumber
           formatter={(value) => (formatShortenNumber(value) as string).toLowerCase?.()}
+          // Force remount when switching between token/credit to prevent unwanted animation
+          // See: https://github.com/lobehub/lobe-chat/pull/10098
+          key={isShowCredit ? 'credit' : 'token'}
           value={totalCount}
         />
       </Center>

package/src/libs/trpc/client/lambda.ts

@@ -84,7 +84,7 @@ const customHttpBatchLink = httpBatchLink({
     // dynamic import to avoid circular dependency
     const { createHeaderWithAuth } = await import('@/services/_auth');
 
-    let provider: ModelProvider = ModelProvider.OpenAI;
+    let provider: ModelProvider | undefined;
     // for image page, we need to get the provider from the store
     log('Getting provider from store for image page: %s', location.pathname);
     if (location.pathname === '/image') {
@@ -96,8 +96,9 @@ const customHttpBatchLink = httpBatchLink({
       log('Getting provider from store for image page: %s', provider);
     }
 
-    // TODO: we need to support provider select for chat page
-    const headers = await createHeaderWithAuth({ provider });
+    // Only include provider in JWT for image operations
+    // For other operations (like knowledge base embedding), let server use its own config
+    const headers = await createHeaderWithAuth(provider ? { provider } : undefined);
     log('Headers: %O', headers);
     return headers;
   },