@lobehub/lobehub 2.0.0-next.160 → 2.0.0-next.162

package/src/features/ChatInput/ActionBar/Tools/useControls.tsx

@@ -1,6 +1,10 @@
+import { KLAVIS_SERVER_TYPES, KlavisServerType } from '@lobechat/const';
 import { Avatar, Icon, ItemType } from '@lobehub/ui';
+import { useTheme } from 'antd-style';
 import isEqual from 'fast-deep-equal';
 import { ArrowRight, Store, ToyBrick } from 'lucide-react';
+import Image from 'next/image';
+import { memo, useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Flexbox } from 'react-layout-kit';
 
@@ -9,11 +13,37 @@ import { useCheckPluginsIsInstalled } from '@/hooks/useCheckPluginsIsInstalled';
 import { useFetchInstalledPlugins } from '@/hooks/useFetchInstalledPlugins';
 import { useAgentStore } from '@/store/agent';
 import { agentSelectors } from '@/store/agent/selectors';
+import { serverConfigSelectors, useServerConfigStore } from '@/store/serverConfig';
 import { useToolStore } from '@/store/tool';
-import { builtinToolSelectors, pluginSelectors } from '@/store/tool/selectors';
+import {
+  builtinToolSelectors,
+  klavisStoreSelectors,
+  pluginSelectors,
+} from '@/store/tool/selectors';
 
+import KlavisServerItem from './KlavisServerItem';
 import ToolItem from './ToolItem';
 
+/**
+ * Klavis 服务器图标组件
+ * 对于 string 类型的 icon，使用 Image 组件渲染
+ * 对于 IconType 类型的 icon，使用 Icon 组件渲染，并根据主题设置填充色
+ */
+const KlavisIcon = memo<Pick<KlavisServerType, 'icon' | 'label'>>(({ icon, label }) => {
+  const theme = useTheme();
+
+  if (typeof icon === 'string') {
+    return (
+      <Image alt={label} height={18} src={icon} style={{ flex: 'none' }} unoptimized width={18} />
+    );
+  }
+
+  // 使用主题色填充，在深色模式下自动适应
+  return <Icon fill={theme.colorText} icon={icon} size={18} />;
+});
+
+KlavisIcon.displayName = 'KlavisIcon';
+
 export const useControls = ({
   setModalOpen,
   setUpdating,
@@ -36,15 +66,67 @@ export const useControls = ({
   );
   const plugins = useAgentStore((s) => agentSelectors.currentAgentPlugins(s));
 
-  const [useFetchPluginStore] = useToolStore((s) => [s.useFetchPluginStore]);
+  // Klavis 相关状态
+  const allKlavisServers = useToolStore(klavisStoreSelectors.getServers, isEqual);
+  const isKlavisEnabledInEnv = useServerConfigStore(serverConfigSelectors.enableKlavis);
+
+  const [useFetchPluginStore, useFetchUserKlavisServers] = useToolStore((s) => [
+    s.useFetchPluginStore,
+    s.useFetchUserKlavisServers,
+  ]);
 
   useFetchPluginStore();
   useFetchInstalledPlugins();
   useCheckPluginsIsInstalled(plugins);
 
-  const items: ItemType[] = [
-    {
-      children: builtinList.map((item) => ({
+  // 使用 SWR 加载用户的 Klavis 集成（从数据库）
+  useFetchUserKlavisServers(isKlavisEnabledInEnv);
+
+  // 根据 identifier 获取已连接的服务器
+  const getServerByName = (identifier: string) => {
+    return allKlavisServers.find((server) => server.identifier === identifier);
+  };
+
+  // 获取所有 Klavis 服务器类型的 identifier 集合（用于过滤 builtinList）
+  // 这里使用 KLAVIS_SERVER_TYPES 而不是已连接的服务器，因为我们要过滤掉所有可能的 Klavis 类型
+  const allKlavisTypeIdentifiers = useMemo(
+    () => new Set(KLAVIS_SERVER_TYPES.map((type) => type.identifier)),
+    [],
+  );
+  // 过滤掉 builtinList 中的 klavis 工具（它们会单独显示在 Klavis 区域）
+  const filteredBuiltinList = useMemo(
+    () =>
+      isKlavisEnabledInEnv
+        ? builtinList.filter((item) => !allKlavisTypeIdentifiers.has(item.identifier))
+        : builtinList,
+    [builtinList, allKlavisTypeIdentifiers, isKlavisEnabledInEnv],
+  );
+
+  // Klavis 服务器列表项
+  const klavisServerItems = useMemo(
+    () =>
+      isKlavisEnabledInEnv
+        ? KLAVIS_SERVER_TYPES.map((type) => ({
+            icon: <KlavisIcon icon={type.icon} label={type.label} />,
+            key: type.identifier,
+            label: (
+              <KlavisServerItem
+                identifier={type.identifier}
+                label={type.label}
+                server={getServerByName(type.identifier)}
+                serverName={type.serverName}
+              />
+            ),
+          }))
+        : [],
+    [isKlavisEnabledInEnv, allKlavisServers],
+  );
+
+  // 合并 builtin 工具和 Klavis 服务器
+  const builtinItems = useMemo(
+    () => [
+      // 原有的 builtin 工具
+      ...filteredBuiltinList.map((item) => ({
         icon: <Avatar avatar={item.meta.avatar} size={20} style={{ flex: 'none' }} />,
         key: item.identifier,
         label: (
@@ -60,7 +142,16 @@ export const useControls = ({
           />
         ),
       })),
+      // Klavis 服务器
+      ...klavisServerItems,
+    ],
+    [filteredBuiltinList, klavisServerItems, checked, togglePlugin, setUpdating],
+  );
 
+  // 市场 tab 的 items
+  const marketItems: ItemType[] = [
+    {
+      children: builtinItems,
       key: 'builtins',
       label: t('tools.builtins.groupName'),
       type: 'group',
@@ -113,5 +204,82 @@ export const useControls = ({
     },
   ];
 
-  return items;
+  // 已安装 tab 的 items - 只显示已安装的插件
+  const installedPluginItems: ItemType[] = useMemo(() => {
+    const installedItems: ItemType[] = [];
+
+    // 已安装的 builtin 工具
+    const enabledBuiltinItems = filteredBuiltinList
+      .filter((item) => checked.includes(item.identifier))
+      .map((item) => ({
+        icon: <Avatar avatar={item.meta.avatar} size={20} style={{ flex: 'none' }} />,
+        key: item.identifier,
+        label: (
+          <ToolItem
+            checked={true}
+            id={item.identifier}
+            label={item.meta?.title}
+            onUpdate={async () => {
+              setUpdating(true);
+              await togglePlugin(item.identifier);
+              setUpdating(false);
+            }}
+          />
+        ),
+      }));
+
+    // 已连接的 Klavis 服务器（放在 builtin 里面）
+    const connectedKlavisItems = klavisServerItems.filter((item) =>
+      checked.includes(item.key as string),
+    );
+
+    // 合并 builtin 和 Klavis
+    const allBuiltinItems = [...enabledBuiltinItems, ...connectedKlavisItems];
+
+    if (allBuiltinItems.length > 0) {
+      installedItems.push({
+        children: allBuiltinItems,
+        key: 'installed-builtins',
+        label: t('tools.builtins.groupName'),
+        type: 'group',
+      });
+    }
+
+    // 已安装的插件
+    const installedPlugins = list
+      .filter((item) => checked.includes(item.identifier))
+      .map((item) => ({
+        icon: item?.avatar ? (
+          <PluginAvatar avatar={item.avatar} size={20} />
+        ) : (
+          <Icon icon={ToyBrick} size={20} />
+        ),
+        key: item.identifier,
+        label: (
+          <ToolItem
+            checked={true}
+            id={item.identifier}
+            label={item.title}
+            onUpdate={async () => {
+              setUpdating(true);
+              await togglePlugin(item.identifier);
+              setUpdating(false);
+            }}
+          />
+        ),
+      }));
+
+    if (installedPlugins.length > 0) {
+      installedItems.push({
+        children: installedPlugins,
+        key: 'installed-plugins',
+        label: t('tools.plugins.groupName'),
+        type: 'group',
+      });
+    }
+
+    return installedItems;
+  }, [filteredBuiltinList, list, klavisServerItems, checked, togglePlugin, setUpdating, t]);
+
+  return { installedPluginItems, marketItems };
 };

package/src/features/ChatInput/ActionBar/components/ActionDropdown.tsx

@@ -22,6 +22,7 @@ const useStyles = createStyles(({ css, prefixCls }) => ({
 export interface ActionDropdownProps extends DropdownProps {
   maxHeight?: number | string;
   maxWidth?: number | string;
+  minHeight?: number | string;
   minWidth?: number | string;
   /**
    * 是否在挂载时预渲染弹层，避免首次触发展开时的渲染卡顿
@@ -30,7 +31,7 @@ export interface ActionDropdownProps extends DropdownProps {
 }
 
 const ActionDropdown = memo<ActionDropdownProps>(
-  ({ menu, maxHeight, minWidth, maxWidth, children, placement = 'top', ...rest }) => {
+  ({ menu, maxHeight, minWidth, maxWidth, children, placement = 'top', minHeight, ...rest }) => {
     const { cx, styles } = useStyles();
     const isMobile = useIsMobile();
 
@@ -48,6 +49,7 @@ const ActionDropdown = memo<ActionDropdownProps>(
           style: {
             maxHeight,
             maxWidth: isMobile ? undefined : maxWidth,
+            minHeight,
             minWidth: isMobile ? undefined : minWidth,
             overflowX: 'hidden',
             overflowY: 'scroll',

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

@@ -67,6 +67,9 @@ vi.mock('@/store/tool/selectors', () => ({
   pluginSelectors: {
     installedPluginManifestList: () => [],
   },
+  klavisStoreSelectors: {
+    klavisAsLobeTools: () => [],
+  },
 }));
 
 vi.mock('../isCanUseFC', () => ({

package/src/helpers/toolEngineering/index.ts

@@ -9,7 +9,7 @@ import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
 import { getAgentStoreState } from '@/store/agent';
 import { agentSelectors } from '@/store/agent/selectors';
 import { getToolStoreState } from '@/store/tool';
-import { pluginSelectors } from '@/store/tool/selectors';
+import { klavisStoreSelectors, pluginSelectors } from '@/store/tool/selectors';
 import { KnowledgeBaseManifest } from '@/tools/knowledge-base';
 import { WebBrowsingManifest } from '@/tools/web-browsing';
 
@@ -45,8 +45,19 @@ export const createToolsEngine = (config: ToolsEngineConfig = {}): ToolsEngine =
     (tool) => tool.manifest as LobeChatPluginManifest,
   );
 
+  // Get Klavis tool manifests
+  const klavisTools = klavisStoreSelectors.klavisAsLobeTools(toolStoreState);
+  const klavisManifests = klavisTools
+    .map((tool) => tool.manifest as LobeChatPluginManifest)
+    .filter(Boolean);
+
   // Combine all manifests
-  const allManifests = [...pluginManifests, ...builtinManifests, ...additionalManifests];
+  const allManifests = [
+    ...pluginManifests,
+    ...builtinManifests,
+    ...klavisManifests,
+    ...additionalManifests,
+  ];
 
   return new ToolsEngine({
     defaultToolIds,

package/src/libs/better-auth/utils/config.ts

@@ -0,0 +1,91 @@
+import { authEnv } from '@/envs/auth';
+import { getRedisConfig } from '@/envs/redis';
+import { initializeRedis, isRedisEnabled } from '@/libs/redis';
+
+const APPLE_TRUSTED_ORIGIN = 'https://appleid.apple.com';
+
+/**
+ * Normalize a URL-like string to an origin with https fallback.
+ */
+export const normalizeOrigin = (url?: string) => {
+  if (!url) return undefined;
+
+  try {
+    const normalizedUrl = url.startsWith('http') ? url : `https://${url}`;
+
+    return new URL(normalizedUrl).origin;
+  } catch {
+    return undefined;
+  }
+};
+
+/**
+ * Build trusted origins with env override and Vercel-aware defaults.
+ */
+export const getTrustedOrigins = (enabledSSOProviders: string[]) => {
+  if (authEnv.AUTH_TRUSTED_ORIGINS) {
+    const originsFromEnv = authEnv.AUTH_TRUSTED_ORIGINS.split(',')
+      .map((item) => normalizeOrigin(item.trim()))
+      .filter(Boolean) as string[];
+
+    if (originsFromEnv.length > 0) return Array.from(new Set(originsFromEnv));
+  }
+
+  const defaults = [
+    authEnv.NEXT_PUBLIC_AUTH_URL,
+    normalizeOrigin(process.env.APP_URL),
+    normalizeOrigin(process.env.VERCEL_BRANCH_URL),
+    normalizeOrigin(process.env.VERCEL_URL),
+  ].filter(Boolean) as string[];
+
+  const baseTrustedOrigins = defaults.length > 0 ? Array.from(new Set(defaults)) : undefined;
+
+  if (!enabledSSOProviders.includes('apple')) return baseTrustedOrigins;
+
+  const mergedOrigins = new Set(baseTrustedOrigins || []);
+  mergedOrigins.add(APPLE_TRUSTED_ORIGIN);
+
+  return Array.from(mergedOrigins);
+};
+
+/**
+ * Build Better Auth secondaryStorage backed by Redis.
+ * Uses the shared Redis manager to avoid duplicate connections and prefixes keys to prevent clashes.
+ */
+export const createSecondaryStorage = () => {
+  const redisConfig = getRedisConfig();
+  if (!isRedisEnabled(redisConfig)) return undefined;
+
+  const secondaryStorageKeyPrefix = 'better-auth:';
+
+  const buildKey = (key: string) => `${secondaryStorageKeyPrefix}${key}`;
+
+  const getRedisClient = async () => {
+    const redisClient = await initializeRedis(redisConfig);
+    if (!redisClient) {
+      throw new Error('Redis secondary storage is enabled but failed to initialize');
+    }
+
+    return redisClient;
+  };
+
+  return {
+    delete: async (key: string) => {
+      const redisClient = await getRedisClient();
+      await redisClient.del(buildKey(key));
+    },
+    get: async (key: string) => {
+      const redisClient = await getRedisClient();
+      return (await redisClient.get(buildKey(key))) ?? null;
+    },
+    set: async (key: string, value: string, ttl?: number) => {
+      const redisClient = await getRedisClient();
+      if (typeof ttl === 'number') {
+        await redisClient.set(buildKey(key), value, { ex: ttl });
+        return;
+      }
+
+      await redisClient.set(buildKey(key), value);
+    },
+  };
+};

package/src/libs/klavis/index.ts

@@ -0,0 +1,36 @@
+import { KlavisClient } from 'klavis';
+
+import { getServerKlavisApiKey } from '@/config/klavis';
+
+/**
+ * Global Klavis Client instance cache (server-side only)
+ */
+let klavisClientInstance: { apiKey: string; client: KlavisClient } | undefined;
+
+/**
+ * Get or create Klavis Client instance (server-side only)
+ * The instance is cached and reused if the API key hasn't changed
+ */
+export const getKlavisClient = (): KlavisClient => {
+  const apiKey = getServerKlavisApiKey();
+
+  if (!apiKey) {
+    throw new Error('Klavis API key is not configured on server');
+  }
+
+  if (!klavisClientInstance || klavisClientInstance.apiKey !== apiKey) {
+    klavisClientInstance = {
+      apiKey,
+      client: new KlavisClient({ apiKey }),
+    };
+  }
+
+  return klavisClientInstance.client;
+};
+
+/**
+ * Check if Klavis client is available (has API key configured)
+ */
+export const isKlavisClientAvailable = (): boolean => {
+  return !!getServerKlavisApiKey();
+};

package/src/libs/redis/manager.ts

@@ -23,7 +23,11 @@ class RedisManager {
       if (config.provider === 'redis') {
         provider = new IoRedisRedisProvider(config);
       } else if (config.provider === 'upstash') {
-        provider = new UpstashRedisProvider({ token: config.token, url: config.url });
+        provider = new UpstashRedisProvider({
+          prefix: config.prefix,
+          token: config.token,
+          url: config.url,
+        });
       } else {
         throw new Error(`Unsupported redis provider: ${String((config as any).provider)}`);
       }

package/src/libs/redis/redis.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import { IoRedisConfig } from './types';
 

package/src/libs/redis/upstash.test.ts

@@ -5,7 +5,7 @@
 //
 // Read more here: https://github.com/capricorn86/happy-dom/issues/1042#issuecomment-3585851354
 import { Buffer } from 'node:buffer';
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import { UpstashConfig } from './types';
 
@@ -139,9 +139,9 @@ describe('mocked', () => {
     await provider.hset(bufKey, 'field', 'value');
     await provider.del(bufKey);
 
-    expect(mocks.mockSet).toHaveBeenCalledWith('buffer-key', 'value', undefined);
-    expect(mocks.mockHset).toHaveBeenCalledWith('buffer-key', { field: 'value' });
-    expect(mocks.mockDel).toHaveBeenCalledWith('buffer-key');
+    expect(mocks.mockSet).toHaveBeenCalledWith('mock:buffer-key', 'value', undefined);
+    expect(mocks.mockHset).toHaveBeenCalledWith('mock:buffer-key', { field: 'value' });
+    expect(mocks.mockDel).toHaveBeenCalledWith('mock:buffer-key');
   });
 
   it('passes set options through to upstash client', async () => {
@@ -149,6 +149,10 @@ describe('mocked', () => {
 
     await provider.set('key', 'value', { ex: 10, nx: true, get: true });
 
-    expect(mocks.mockSet).toHaveBeenCalledWith('key', 'value', { ex: 10, nx: true, get: true });
+    expect(mocks.mockSet).toHaveBeenCalledWith('mock:key', 'value', {
+      ex: 10,
+      nx: true,
+      get: true,
+    });
   });
 });

package/src/libs/redis/upstash.ts

@@ -20,9 +20,28 @@ import {
 export class UpstashRedisProvider implements BaseRedisProvider {
   provider: 'upstash' = 'upstash';
   private client: Redis;
+  private readonly prefix: string;
 
   constructor(options: UpstashConfig | RedisConfigNodejs) {
-    this.client = new Redis(options as RedisConfigNodejs);
+    const { prefix, ...clientOptions } = options as UpstashConfig & RedisConfigNodejs;
+    this.prefix = prefix ? `${prefix}:` : '';
+    this.client = new Redis(clientOptions as RedisConfigNodejs);
+  }
+
+  /**
+   * Build a fully qualified key assuming the input was already normalized.
+   * Avoids re-running normalization when callers have normalized keys (e.g. mset).
+   */
+  private addPrefixToKey(normalizedKey: string) {
+    return `${this.prefix}${normalizedKey}`;
+  }
+
+  private buildKey(key: RedisKey) {
+    return this.addPrefixToKey(normalizeRedisKey(key));
+  }
+
+  private buildKeys(keys: RedisKey[]) {
+    return normalizeRedisKeys(keys).map((key) => `${this.prefix}${key}`);
   }
 
   async initialize(): Promise<void> {
@@ -34,15 +53,11 @@ export class UpstashRedisProvider implements BaseRedisProvider {
   }
 
   async get(key: RedisKey): Promise<string | null> {
-    return this.client.get(normalizeRedisKey(key));
+    return this.client.get(this.buildKey(key));
   }
 
   async set(key: RedisKey, value: RedisValue, options?: SetOptions): Promise<RedisSetResult> {
-    const res = await this.client.set(
-      normalizeRedisKey(key),
-      value,
-      buildUpstashSetOptions(options),
-    );
+    const res = await this.client.set(this.buildKey(key), value, buildUpstashSetOptions(options));
     if (Buffer.isBuffer(res)) {
       return res.toString();
     }
@@ -51,55 +66,64 @@ export class UpstashRedisProvider implements BaseRedisProvider {
   }
 
   async setex(key: RedisKey, seconds: number, value: RedisValue): Promise<'OK'> {
-    return this.client.setex(normalizeRedisKey(key), seconds, value);
+    return this.client.setex(this.buildKey(key), seconds, value);
   }
 
   async del(...keys: RedisKey[]): Promise<number> {
-    return this.client.del(...normalizeRedisKeys(keys));
+    return this.client.del(...this.buildKeys(keys));
   }
 
   async exists(...keys: RedisKey[]): Promise<number> {
-    return this.client.exists(...normalizeRedisKeys(keys));
+    return this.client.exists(...this.buildKeys(keys));
   }
 
   async expire(key: RedisKey, seconds: number): Promise<number> {
-    return this.client.expire(normalizeRedisKey(key), seconds);
+    return this.client.expire(this.buildKey(key), seconds);
   }
 
   async ttl(key: RedisKey): Promise<number> {
-    return this.client.ttl(normalizeRedisKey(key));
+    return this.client.ttl(this.buildKey(key));
   }
 
   async incr(key: RedisKey): Promise<number> {
-    return this.client.incr(normalizeRedisKey(key));
+    return this.client.incr(this.buildKey(key));
   }
 
   async decr(key: RedisKey): Promise<number> {
-    return this.client.decr(normalizeRedisKey(key));
+    return this.client.decr(this.buildKey(key));
   }
 
   async mget(...keys: RedisKey[]): Promise<(string | null)[]> {
-    return this.client.mget(...normalizeRedisKeys(keys));
+    return this.client.mget(...this.buildKeys(keys));
   }
 
   async mset(values: RedisMSetArgument): Promise<'OK'> {
-    return this.client.mset(normalizeMsetValues(values));
+    const normalized = normalizeMsetValues(values);
+    const prefixed = Object.entries(normalized).reduce<Record<string, RedisValue>>(
+      (acc, [key, value]) => {
+        acc[this.addPrefixToKey(key)] = value;
+        return acc;
+      },
+      {},
+    );
+
+    return this.client.mset(prefixed);
   }
 
   async hget(key: RedisKey, field: RedisKey): Promise<string | null> {
-    return this.client.hget(normalizeRedisKey(key), normalizeRedisKey(field));
+    return this.client.hget(this.buildKey(key), normalizeRedisKey(field));
   }
 
   async hset(key: RedisKey, field: RedisKey, value: RedisValue): Promise<number> {
-    return this.client.hset(normalizeRedisKey(key), { [normalizeRedisKey(field)]: value });
+    return this.client.hset(this.buildKey(key), { [normalizeRedisKey(field)]: value });
   }
 
   async hdel(key: RedisKey, ...fields: RedisKey[]): Promise<number> {
-    return this.client.hdel(normalizeRedisKey(key), ...normalizeRedisKeys(fields));
+    return this.client.hdel(this.buildKey(key), ...normalizeRedisKeys(fields));
   }
 
   async hgetall(key: RedisKey): Promise<Record<string, string>> {
-    const res = await this.client.hgetall(normalizeRedisKey(key));
+    const res = await this.client.hgetall(this.buildKey(key));
     if (!res) {
       return {};
     }

package/src/locales/default/authError.ts

@@ -0,0 +1,40 @@
+export default {
+  actions: {
+    discord: '前往 Discord 反馈',
+    home: '返回首页',
+    retry: '重新登录',
+  },
+  codes: {
+    ACCOUNT_ALREADY_LINKED_TO_DIFFERENT_USER: '该账号已关联至其他用户',
+    ACCOUNT_NOT_FOUND: '未找到对应账号',
+    CREDENTIAL_ACCOUNT_NOT_FOUND: '凭证账号不存在',
+    EMAIL_CAN_NOT_BE_UPDATED: '当前账号邮箱不可修改',
+    EMAIL_NOT_VERIFIED: '请先完成邮箱验证',
+    FAILED_TO_CREATE_SESSION: '创建会话失败',
+    FAILED_TO_CREATE_USER: '创建用户失败',
+    FAILED_TO_GET_SESSION: '获取会话失败',
+    FAILED_TO_GET_USER_INFO: '获取用户信息失败',
+    FAILED_TO_UNLINK_LAST_ACCOUNT: '无法解绑最后一个关联账号',
+    FAILED_TO_UPDATE_USER: '更新用户信息失败',
+    ID_TOKEN_NOT_SUPPORTED: '当前身份令牌不被支持',
+    INVALID_EMAIL: '邮箱格式不正确',
+    INVALID_EMAIL_OR_PASSWORD: '邮箱或密码错误',
+    INVALID_PASSWORD: '密码格式无效',
+    INVALID_TOKEN: '令牌无效或已过期',
+    PASSWORD_TOO_LONG: '密码长度过长',
+    PASSWORD_TOO_SHORT: '密码长度过短',
+    PROVIDER_NOT_FOUND: '未找到对应的身份提供方配置',
+    RATE_LIMIT_EXCEEDED: '请求过于频繁，请稍后再试',
+    SESSION_EXPIRED: '会话已过期，请重新登录',
+    SOCIAL_ACCOUNT_ALREADY_LINKED: '该社交账号已被其他用户绑定',
+    UNEXPECTED_ERROR: '发生未知错误，请重试',
+    UNKNOWN: '发生未知错误，请重试或联系支持',
+    USER_ALREADY_EXISTS: '用户已存在',
+    USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: '邮箱已被使用，请尝试其他邮箱',
+    USER_ALREADY_HAS_PASSWORD: '该账号已设置密码',
+    USER_BANNED: '该用户已被封禁',
+    USER_EMAIL_NOT_FOUND: '未找到对应邮箱',
+    USER_NOT_FOUND: '未找到用户',
+  },
+  title: '身份验证出错',
+};

package/src/locales/default/index.ts

@@ -1,4 +1,5 @@
 import auth from './auth';
+import authError from './authError';
 import changelog from './changelog';
 import chat from './chat';
 import clerk from './clerk';
@@ -33,6 +34,7 @@ import welcome from './welcome';
 
 const resources = {
   auth,
+  authError,
   changelog,
   chat,
   clerk,