@lobehub/lobehub 2.0.0-next.127 → 2.0.0-next.129

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

@@ -6,8 +6,8 @@ import { timestamps, timestamptz } from './_helpers';
 import { users } from './user';
 
 /**
- * OIDC 授权码
- * oidc-provider 需要持久化的模型之一
+ * OIDC authorization code
+ * One of the models that oidc-provider needs to persist
  */
 export const oidcAuthorizationCodes = pgTable('oidc_authorization_codes', {
   id: varchar('id', { length: 255 }).primaryKey(),
@@ -23,8 +23,8 @@ export const oidcAuthorizationCodes = pgTable('oidc_authorization_codes', {
 });
 
 /**
- * OIDC 访问令牌
- * oidc-provider 需要持久化的模型之一
+ * OIDC access token
+ * One of the models that oidc-provider needs to persist
  */
 export const oidcAccessTokens = pgTable('oidc_access_tokens', {
   id: varchar('id', { length: 255 }).primaryKey(),
@@ -40,8 +40,8 @@ export const oidcAccessTokens = pgTable('oidc_access_tokens', {
 });
 
 /**
- * OIDC 刷新令牌
- * oidc-provider 需要持久化的模型之一
+ * OIDC refresh token
+ * One of the models that oidc-provider needs to persist
  */
 export const oidcRefreshTokens = pgTable('oidc_refresh_tokens', {
   id: varchar('id', { length: 255 }).primaryKey(),
@@ -57,8 +57,8 @@ export const oidcRefreshTokens = pgTable('oidc_refresh_tokens', {
 });
 
 /**
- * OIDC 设备代码
- * oidc-provider 需要持久化的模型之一
+ * OIDC device code
+ * One of the models that oidc-provider needs to persist
  */
 export const oidcDeviceCodes = pgTable('oidc_device_codes', {
   id: varchar('id', { length: 255 }).primaryKey(),
@@ -73,8 +73,8 @@ export const oidcDeviceCodes = pgTable('oidc_device_codes', {
 });
 
 /**
- * OIDC 交互会话
- * oidc-provider 需要持久化的模型之一
+ * OIDC interaction session
+ * One of the models that oidc-provider needs to persist
  */
 export const oidcInteractions = pgTable('oidc_interactions', {
   id: varchar('id', { length: 255 }).primaryKey(),
@@ -84,8 +84,8 @@ export const oidcInteractions = pgTable('oidc_interactions', {
 });
 
 /**
- * OIDC 授权记录
- * oidc-provider 需要持久化的模型之一
+ * OIDC grant record
+ * One of the models that oidc-provider needs to persist
  */
 export const oidcGrants = pgTable('oidc_grants', {
   id: varchar('id', { length: 255 }).primaryKey(),
@@ -100,14 +100,14 @@ export const oidcGrants = pgTable('oidc_grants', {
 });
 
 /**
- * OIDC 客户端配置
- * 存储 OIDC 客户端配置信息
+ * OIDC client configuration
+ * Stores OIDC client configuration information
  */
 export const oidcClients = pgTable('oidc_clients', {
   id: varchar('id', { length: 255 }).primaryKey(), // client_id
   name: text('name').notNull(),
   description: text('description'),
-  clientSecret: varchar('client_secret', { length: 255 }), // 公共客户端可为 null
+  clientSecret: varchar('client_secret', { length: 255 }), // Can be null for public clients
   redirectUris: text('redirect_uris').array().notNull(),
   grants: text('grants').array().notNull(),
   responseTypes: text('response_types').array().notNull(),
@@ -123,8 +123,8 @@ export const oidcClients = pgTable('oidc_clients', {
 });
 
 /**
- * OIDC 会话
- * oidc-provider 需要持久化的模型之一
+ * OIDC session
+ * One of the models that oidc-provider needs to persist
  */
 export const oidcSessions = pgTable('oidc_sessions', {
   id: varchar('id', { length: 255 }).primaryKey(),
@@ -137,8 +137,8 @@ export const oidcSessions = pgTable('oidc_sessions', {
 });
 
 /**
- * OIDC 授权同意记录
- * 记录用户对客户端的授权同意历史
+ * OIDC authorization consent record
+ * Records user authorization consent history for clients
  */
 export const oidcConsents = pgTable(
   'oidc_consents',
@@ -159,39 +159,39 @@ export const oidcConsents = pgTable(
 );
 
 /**
- * 通用认证凭证传递表
- * 用于在不同客户端（桌面端、浏览器插件、移动端等）之间安全传递认证凭证
+ * Generic authentication credential handoff table
+ * Used to securely pass authentication credentials between different clients (desktop, browser extension, mobile, etc.)
  *
- * 工作流程:
- * 1. 客户端生成唯一的 handoff ID
- * 2. 将 handoff ID 作为参数附加到 OAuth redirect_uri
- * 3. 认证成功后，中间页将凭证存储到此表
- * 4. 客户端轮询此表获取凭证
- * 5. 成功获取后立即删除记录
+ * Workflow:
+ * 1. Client generates a unique handoff ID
+ * 2. Appends handoff ID as a parameter to OAuth redirect_uri
+ * 3. After successful authentication, intermediate page stores credentials in this table
+ * 4. Client polls this table to retrieve credentials
+ * 5. Record is immediately deleted after successful retrieval
  */
 export const oauthHandoffs = pgTable('oauth_handoffs', {
   /**
-   * 由客户端生成的一次性唯一标识符
-   * 用于客户端轮询时认领自己的凭证
+   * One-time unique identifier generated by the client
+   * Used for client polling to claim its own credentials
    */
   id: text('id').primaryKey(),
 
   /**
-   * 客户端类型标识
-   * 如: 'desktop', 'browser-extension', 'mobile-app' 等
+   * Client type identifier
+   * Examples: 'desktop', 'browser-extension', 'mobile-app', etc.
    */
   client: varchar('client', { length: 50 }).notNull(),
 
   /**
-   * 凭证数据的 JSON 载荷
-   * 灵活存储不同认证流程所需的各种数据
-   * 当前主要包含: { code: string; state: string }
+   * JSON payload for credential data
+   * Flexible storage for various data required by different authentication flows
+   * Currently mainly contains: { code: string; state: string }
    */
   payload: jsonb('payload').$type<Record<string, unknown>>().notNull(),
 
   /**
-   * 时间戳字段，用于 TTL 控制
-   * 凭证应在创建后 5 分钟内被消费，否则视为过期
+   * Timestamp fields for TTL control
+   * Credentials should be consumed within 5 minutes of creation, otherwise considered expired
    */
   ...timestamps,
 });

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

@@ -49,12 +49,17 @@ export const threads = pgTable(
       .primaryKey(),
 
     title: text('title'),
-    type: text('type', { enum: ['continuation', 'standalone'] }).notNull(),
-    status: text('status', { enum: ['active', 'deprecated', 'archived'] }).default('active'),
+    content: text('content'),
+    editor_data: jsonb('editor_data'),
+    type: text('type', { enum: ['continuation', 'standalone', 'isolation'] }).notNull(),
+    status: text('status', {
+      enum: ['active', 'processing', 'pending', 'inReview', 'todo', 'cancel'],
+    }),
+
     topicId: text('topic_id')
       .references(() => topics.id, { onDelete: 'cascade' })
       .notNull(),
-    sourceMessageId: text('source_message_id').notNull(),
+    sourceMessageId: text('source_message_id'),
     // @ts-ignore
     parentThreadId: text('parent_thread_id').references(() => threads.id, { onDelete: 'set null' }),
     clientId: text('client_id'),

package/packages/model-runtime/src/providers/newapi/index.ts

@@ -25,6 +25,62 @@ export interface NewAPIPricing {
   supported_endpoint_types?: string[];
 }
 
+/**
+ * Detect if running in browser environment
+ */
+const isBrowser = () => typeof window !== 'undefined' && typeof document !== 'undefined';
+
+/**
+ * Parse a pricing API HTTP response into a `NewAPIPricing[] | null`.
+ * Shared between browser and server branches to avoid duplicated logic.
+ */
+const parsePricingResponse = async (res: Response): Promise<NewAPIPricing[] | null> => {
+  if (!res.ok) {
+    return null;
+  }
+
+  try {
+    const body = await res.json();
+    return body?.success && body?.data ? (body.data as NewAPIPricing[]) : null;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Fetch pricing information with CORS bypass for client-side requests
+ * In browser environment, use /webapi/proxy to avoid CORS errors
+ */
+const fetchPricing = async (
+  pricingUrl: string,
+  apiKey: string,
+): Promise<NewAPIPricing[] | null> => {
+  try {
+    if (isBrowser()) {
+      // In browser environment, use the proxy endpoint to avoid CORS
+      // The proxy endpoint expects the URL as the request body
+      const proxyResponse = await fetch('/webapi/proxy', {
+        body: pricingUrl,
+        method: 'POST',
+      });
+
+      return await parsePricingResponse(proxyResponse);
+    } else {
+      // In server environment, fetch directly
+      const pricingResponse = await fetch(pricingUrl, {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+        },
+      });
+
+      return await parsePricingResponse(pricingResponse);
+    }
+  } catch (error) {
+    console.debug('Failed to fetch NewAPI pricing info:', error);
+    return null;
+  }
+};
+
 export const params = {
   debug: {
     chatCompletion: () => process.env.DEBUG_NEWAPI_CHAT_COMPLETION === '1',
@@ -42,25 +98,12 @@ export const params = {
 
     // Try to get pricing information to enrich model details
     let pricingMap: Map<string, NewAPIPricing> = new Map();
-    try {
-      // Use saved baseURL
-      const pricingResponse = await fetch(`${baseURL}/api/pricing`, {
-        headers: {
-          Authorization: `Bearer ${openAIClient.apiKey}`,
-        },
-      });
 
-      if (pricingResponse.ok) {
-        const pricingData = await pricingResponse.json();
-        if (pricingData.success && pricingData.data) {
-          (pricingData.data as NewAPIPricing[]).forEach((pricing) => {
-            pricingMap.set(pricing.model_name, pricing);
-          });
-        }
-      }
-    } catch (error) {
-      // If fetching pricing information fails, continue using the basic model information
-      console.debug('Failed to fetch NewAPI pricing info:', error);
+    const pricingList = await fetchPricing(`${baseURL}/api/pricing`, openAIClient.apiKey || '');
+    if (pricingList) {
+      pricingList.forEach((pricing) => {
+        pricingMap.set(pricing.model_name, pricing);
+      });
     }
 
     // Process the model list: determine the provider for each model based on priority rules

package/packages/model-runtime/src/runtimeMap.ts

@@ -112,6 +112,7 @@ export const providerRuntimeMap = {
   ppio: LobePPIOAI,
   qiniu: LobeQiniuAI,
   qwen: LobeQwenAI,
+  router: LobeNewAPIAI,
   sambanova: LobeSambaNovaAI,
   search1api: LobeSearch1API,
   sensenova: LobeSenseNovaAI,

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

@@ -16,7 +16,7 @@ export interface ThreadItem {
   id: string;
   lastActiveAt: Date;
   parentThreadId?: string;
-  sourceMessageId: string;
+  sourceMessageId?: string | null;
   status: ThreadStatus;
   title: string;
   topicId: string;
@@ -27,7 +27,7 @@ export interface ThreadItem {
 
 export interface CreateThreadParams {
   parentThreadId?: string;
-  sourceMessageId: string;
+  sourceMessageId?: string;
   title?: string;
   topicId: string;
   type: ThreadType;
@@ -35,7 +35,7 @@ export interface CreateThreadParams {
 
 export const createThreadSchema = z.object({
   parentThreadId: z.string().optional(),
-  sourceMessageId: z.string(),
+  sourceMessageId: z.string().optional(),
   title: z.string().optional(),
   topicId: z.string(),
   type: z.nativeEnum(ThreadType),

package/src/app/[variants]/(main)/settings/provider/features/ProviderConfig/UpdateProviderInfo/SettingModal.tsx

@@ -84,12 +84,16 @@ const CreateNewProvider = memo<CreateNewProviderProps>(({ onClose, open, initial
     {
       children: (
         <Select
-          optionRender={({ label, value }) => (
-            <Flexbox align={'center'} gap={8} horizontal>
-              <ProviderIcon provider={value as string} size={18} />
-              {label}
-            </Flexbox>
-          )}
+          optionRender={({ label, value }) => {
+            // Map 'router' to 'newapi' for displaying the correct icon
+            const iconProvider = value === 'router' ? 'newapi' : (value as string);
+            return (
+              <Flexbox align={'center'} gap={8} horizontal>
+                <ProviderIcon provider={iconProvider} size={18} />
+                {label}
+              </Flexbox>
+            );
+          }}
           options={CUSTOM_PROVIDER_SDK_OPTIONS}
           placeholder={t('createNewAiProvider.sdkType.placeholder')}
           variant={'filled'}

package/src/envs/redis.ts

@@ -0,0 +1,106 @@
+/* eslint-disable sort-keys-fix/sort-keys-fix */
+import { createEnv } from '@t3-oss/env-nextjs';
+import { z } from 'zod';
+
+import type { RedisConfig } from '@/libs/redis';
+
+type UpstashRedisConfig = { token: string; url: string };
+
+const parseNumber = (value?: string) => {
+  const parsed = Number.parseInt(value ?? '', 10);
+
+  return Number.isInteger(parsed) ? parsed : undefined;
+};
+
+const parseRedisTls = (value?: string) => {
+  if (!value) {
+    return false
+  }
+
+  const normalized = value.trim().toLowerCase();
+  return normalized === 'true' || normalized === '1';
+};
+
+export const getRedisEnv = () => {
+  return createEnv({
+    runtimeEnv: {
+      REDIS_DATABASE: parseNumber(process.env.REDIS_DATABASE),
+      REDIS_PASSWORD: process.env.REDIS_PASSWORD,
+      REDIS_PREFIX: process.env.REDIS_PREFIX || 'lobechat',
+      REDIS_TLS: parseRedisTls(process.env.REDIS_TLS),
+      REDIS_URL: process.env.REDIS_URL,
+      REDIS_USERNAME: process.env.REDIS_USERNAME,
+      UPSTASH_REDIS_REST_TOKEN: process.env.UPSTASH_REDIS_REST_TOKEN,
+      UPSTASH_REDIS_REST_URL: process.env.UPSTASH_REDIS_REST_URL,
+    },
+    server: {
+      REDIS_DATABASE: z.number().int().optional(),
+      REDIS_PASSWORD: z.string().optional(),
+      REDIS_PREFIX: z.string(),
+      REDIS_TLS: z.boolean().default(false),
+      REDIS_URL: z.string().url().optional(),
+      REDIS_USERNAME: z.string().optional(),
+      UPSTASH_REDIS_REST_TOKEN: z.string().optional(),
+      UPSTASH_REDIS_REST_URL: z.string().url().optional(),
+    },
+  });
+};
+
+export const redisEnv = getRedisEnv();
+
+export const getUpstashRedisConfig = (): UpstashRedisConfig | null => {
+  const upstashConfigSchema = z.union([
+    z.object({
+      token: z.string(),
+      url: z.string().url(),
+    }),
+    z.object({
+      token: z.undefined().optional(),
+      url: z.undefined().optional(),
+    }),
+  ]);
+
+  const parsed = upstashConfigSchema.safeParse({
+    token: redisEnv.UPSTASH_REDIS_REST_TOKEN,
+    url: redisEnv.UPSTASH_REDIS_REST_URL,
+  });
+
+  if (!parsed.success) throw parsed.error;
+  if (!parsed.data.token || !parsed.data.url) return null;
+
+  return parsed.data;
+};
+
+export const getRedisConfig = (): RedisConfig => {
+  const prefix = redisEnv.REDIS_PREFIX;
+
+  if (redisEnv.REDIS_URL) {
+    return {
+      database: redisEnv.REDIS_DATABASE,
+      enabled: true,
+      password: redisEnv.REDIS_PASSWORD,
+      prefix,
+      provider: 'redis',
+      tls: redisEnv.REDIS_TLS,
+      url: redisEnv.REDIS_URL,
+      username: redisEnv.REDIS_USERNAME,
+    };
+  }
+
+  const upstashConfig = getUpstashRedisConfig();
+  if (upstashConfig) {
+    return {
+      enabled: true,
+      prefix,
+      provider: 'upstash',
+      token: upstashConfig.token,
+      url: upstashConfig.url,
+    };
+  }
+
+  return {
+    enabled: false,
+    prefix,
+    provider: false,
+  };
+};

package/src/libs/redis/index.ts

@@ -0,0 +1,5 @@
+export * from './manager';
+export * from './redis';
+export * from './types';
+export * from './upstash';
+export * from './utils';

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

@@ -0,0 +1,107 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { RedisManager, initializeRedis, resetRedisClient } from './manager';
+import { DisabledRedisConfig } from './types';
+
+const {
+  mockIoRedisInitialize,
+  mockIoRedisDisconnect,
+  mockUpstashInitialize,
+  mockUpstashDisconnect,
+} = vi.hoisted(() => ({
+  mockIoRedisInitialize: vi.fn().mockResolvedValue(undefined),
+  mockIoRedisDisconnect: vi.fn().mockResolvedValue(undefined),
+  mockUpstashInitialize: vi.fn().mockResolvedValue(undefined),
+  mockUpstashDisconnect: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('./redis', () => {
+  const IoRedisRedisProvider = vi.fn().mockImplementation((config) => ({
+    provider: 'redis' as const,
+    config,
+    initialize: mockIoRedisInitialize,
+    disconnect: mockIoRedisDisconnect,
+  }));
+
+  return { IoRedisRedisProvider };
+});
+
+vi.mock('./upstash', () => {
+  const UpstashRedisProvider = vi.fn().mockImplementation((config) => ({
+    provider: 'upstash' as const,
+    config,
+    initialize: mockUpstashInitialize,
+    disconnect: mockUpstashDisconnect,
+  }));
+
+  return { UpstashRedisProvider };
+});
+
+afterEach(async () => {
+  vi.clearAllMocks();
+  await RedisManager.reset();
+});
+
+describe('RedisManager', () => {
+  it('returns null when redis is disabled', async () => {
+    const config = {
+      enabled: false,
+      prefix: 'test',
+      provider: false,
+    } satisfies DisabledRedisConfig;
+
+    const instance = await initializeRedis(config);
+
+    expect(instance).toBeNull();
+    expect(mockIoRedisInitialize).not.toHaveBeenCalled();
+    expect(mockUpstashInitialize).not.toHaveBeenCalled();
+  });
+
+  it('initializes ioredis provider once and memoizes the instance', async () => {
+    const config = {
+      database: 0,
+      enabled: true,
+      password: 'pwd',
+      prefix: 'test',
+      provider: 'redis' as const,
+      tls: false,
+      url: 'redis://localhost:6379',
+      username: 'user',
+    };
+    const [first, second] = await Promise.all([initializeRedis(config), initializeRedis(config)]);
+
+    expect(first).toBe(second);
+    expect(mockIoRedisInitialize).toHaveBeenCalledTimes(1);
+    expect(mockUpstashInitialize).not.toHaveBeenCalled();
+  });
+
+  it('initializes upstash provider when configured', async () => {
+    const config = {
+      enabled: true,
+      prefix: 'test',
+      provider: 'upstash' as const,
+      token: 'token',
+      url: 'https://example.upstash.io',
+    };
+    const instance = await initializeRedis(config);
+
+    expect(instance?.provider).toBe('upstash');
+    expect(mockUpstashInitialize).toHaveBeenCalledTimes(1);
+    expect(mockIoRedisInitialize).not.toHaveBeenCalled();
+  });
+
+  it('disconnects existing provider on reset', async () => {
+    const config = {
+      enabled: true,
+      prefix: 'test',
+      provider: 'redis' as const,
+      tls: false,
+      url: 'redis://localhost:6379',
+    };
+
+    await initializeRedis(config);
+    await resetRedisClient();
+
+    expect(mockIoRedisDisconnect).toHaveBeenCalledTimes(1);
+  });
+});

package/src/libs/redis/manager.ts

@@ -0,0 +1,56 @@
+import { IoRedisRedisProvider } from './redis';
+import { BaseRedisProvider, RedisConfig } from './types';
+import { UpstashRedisProvider } from './upstash';
+
+class RedisManager {
+  private static instance: BaseRedisProvider | null = null;
+  // NOTICE: initPromise keeps concurrent initialize() calls sharing the same in-flight setup,
+  // preventing multiple connections from being created in parallel.
+  private static initPromise: Promise<BaseRedisProvider | null> | null = null;
+
+  static async initialize(config: RedisConfig): Promise<BaseRedisProvider | null> {
+    if (RedisManager.instance) return RedisManager.instance;
+    if (RedisManager.initPromise) return RedisManager.initPromise;
+
+    RedisManager.initPromise = (async () => {
+      if (!config.enabled) {
+        RedisManager.instance = null;
+        return null;
+      }
+
+      let provider: BaseRedisProvider;
+
+      if (config.provider === 'redis') {
+        provider = new IoRedisRedisProvider(config);
+      } else if (config.provider === 'upstash') {
+        provider = new UpstashRedisProvider({ token: config.token, url: config.url });
+      } else {
+        throw new Error(`Unsupported redis provider: ${String((config as any).provider)}`);
+      }
+
+      await provider.initialize();
+      RedisManager.instance = provider;
+
+      return provider;
+    })().catch((error) => {
+      RedisManager.initPromise = null;
+      throw error;
+    });
+
+    return RedisManager.initPromise;
+  }
+
+  static async reset() {
+    if (RedisManager.instance) {
+      await RedisManager.instance.disconnect();
+    }
+
+    RedisManager.instance = null;
+    RedisManager.initPromise = null;
+  }
+}
+
+export const initializeRedis = (config: RedisConfig) => RedisManager.initialize(config);
+export const resetRedisClient = () => RedisManager.reset();
+export const isRedisEnabled = (config: RedisConfig) => config.enabled;
+export { RedisManager };