@lobehub/chat 1.122.6 → 1.123.0

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

@@ -0,0 +1,245 @@
+import urlJoin from 'url-join';
+
+import { createRouterRuntime } from '../RouterRuntime';
+import { responsesAPIModels } from '../const/models';
+import { ModelProvider } from '../types';
+import { ChatStreamPayload } from '../types/chat';
+import { detectModelProvider, processMultiProviderModelList } from '../utils/modelParse';
+
+export interface NewAPIModelCard {
+  created: number;
+  id: string;
+  object: string;
+  owned_by: string;
+  supported_endpoint_types?: string[];
+}
+
+export interface NewAPIPricing {
+  completion_ratio?: number;
+  enable_groups: string[];
+  model_name: string;
+  model_price?: number;
+  model_ratio?: number;
+  quota_type: number; // 0: 按量计费, 1: 按次计费
+  supported_endpoint_types?: string[];
+}
+
+const handlePayload = (payload: ChatStreamPayload) => {
+  // 处理 OpenAI responses API 模式
+  if (
+    responsesAPIModels.has(payload.model) ||
+    payload.model.includes('gpt-') ||
+    /^o\d/.test(payload.model)
+  ) {
+    return { ...payload, apiMode: 'responses' } as any;
+  }
+  return payload as any;
+};
+
+// 根据 owned_by 字段判断提供商
+const getProviderFromOwnedBy = (ownedBy: string): string => {
+  const normalizedOwnedBy = ownedBy.toLowerCase();
+
+  if (normalizedOwnedBy.includes('anthropic') || normalizedOwnedBy.includes('claude')) {
+    return 'anthropic';
+  }
+  if (normalizedOwnedBy.includes('google') || normalizedOwnedBy.includes('gemini')) {
+    return 'google';
+  }
+  if (normalizedOwnedBy.includes('xai') || normalizedOwnedBy.includes('grok')) {
+    return 'xai';
+  }
+
+  // 默认为 openai
+  return 'openai';
+};
+
+// 全局的模型路由映射，在 models 函数执行后被填充
+let globalModelRouteMap: Map<string, string> = new Map();
+
+export const LobeNewAPIAI = createRouterRuntime({
+  debug: {
+    chatCompletion: () => process.env.DEBUG_NEWAPI_CHAT_COMPLETION === '1',
+  },
+  defaultHeaders: {
+    'X-Client': 'LobeHub',
+  },
+  id: ModelProvider.NewAPI,
+  models: async ({ client: openAIClient }) => {
+    // 每次调用 models 时清空并重建路由映射
+    globalModelRouteMap.clear();
+
+    // 获取基础 URL（移除末尾的 /v1）
+    const baseURL = openAIClient.baseURL.replace(/\/v1\/?$/, '');
+
+      const modelsPage = (await openAIClient.models.list()) as any;
+      const modelList: NewAPIModelCard[] = modelsPage.data || [];
+
+      // 尝试获取 pricing 信息以补充模型详细信息
+      let pricingMap: Map<string, NewAPIPricing> = new Map();
+      try {
+        // 使用保存的 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);
+      }
+
+      // Process the model list: determine the provider for each model based on priority rules
+      const enrichedModelList = modelList.map((model) => {
+        let enhancedModel: any = { ...model };
+
+        // 1. 添加 pricing 信息
+        const pricing = pricingMap.get(model.id);
+        if (pricing) {
+          // NewAPI 的价格计算逻辑：
+          // - quota_type: 0 表示按量计费（按 token），1 表示按次计费
+          // - model_ratio: 相对于基础价格的倍率（基础价格 = $0.002/1K tokens）
+          // - model_price: 直接指定的价格（优先使用）
+          // - completion_ratio: 输出价格相对于输入价格的倍率
+          //
+          // LobeChat 需要的格式：美元/百万 token
+
+          let inputPrice: number | undefined;
+          let outputPrice: number | undefined;
+
+          if (pricing.quota_type === 0) {
+            // 按量计费
+            if (pricing.model_price && pricing.model_price > 0) {
+              // model_price is a direct price value; need to confirm its unit.
+              // Assumption: model_price is the price per 1,000 tokens (i.e., $/1K tokens).
+              // To convert to price per 1,000,000 tokens ($/1M tokens), multiply by 1,000,000 / 1,000 = 1,000.
+              // Since the base price is $0.002/1K tokens, multiplying by 2 gives $2/1M tokens.
+              // Therefore, inputPrice = model_price * 2 converts the price to $/1M tokens for LobeChat.
+              inputPrice = pricing.model_price * 2;
+            } else if (pricing.model_ratio) {
+              // model_ratio × $0.002/1K = model_ratio × $2/1M
+              inputPrice = pricing.model_ratio * 2; // 转换为 $/1M tokens
+            }
+
+            if (inputPrice !== undefined) {
+              // 计算输出价格
+              outputPrice = inputPrice * (pricing.completion_ratio || 1);
+
+              enhancedModel.pricing = {
+                input: inputPrice,
+                output: outputPrice,
+              };
+            }
+          }
+          // quota_type === 1 按次计费暂不支持
+        }
+
+        // 2. 根据优先级处理 provider 信息并缓存路由
+        let detectedProvider = 'openai'; // 默认
+
+        // 优先级1：使用 supported_endpoint_types
+        if (model.supported_endpoint_types && model.supported_endpoint_types.length > 0) {
+          if (model.supported_endpoint_types.includes('anthropic')) {
+            detectedProvider = 'anthropic';
+          } else if (model.supported_endpoint_types.includes('gemini')) {
+            detectedProvider = 'google';
+          } else if (model.supported_endpoint_types.includes('xai')) {
+            detectedProvider = 'xai';
+          }
+        }
+        // 优先级2：使用 owned_by 字段
+        else if (model.owned_by) {
+          detectedProvider = getProviderFromOwnedBy(model.owned_by);
+        }
+        // 优先级3：基于模型名称检测
+        else {
+          detectedProvider = detectModelProvider(model.id);
+        }
+
+        // 将检测到的 provider 信息附加到模型上，供路由使用
+        enhancedModel._detectedProvider = detectedProvider;
+        // 同时更新全局路由映射表
+        globalModelRouteMap.set(model.id, detectedProvider);
+
+        return enhancedModel;
+      });
+
+      // 使用 processMultiProviderModelList 处理模型能力
+      const processedModels = await processMultiProviderModelList(enrichedModelList, 'newapi');
+
+      // 如果我们检测到了 provider，确保它被正确应用
+      return processedModels.map((model: any) => {
+        if (model._detectedProvider) {
+          // Here you can adjust certain model properties as needed.
+          // FIXME: The current data structure does not support storing provider information, and the official NewAPI does not provide a corresponding field. Consider extending the model schema if provider tracking is required in the future.
+          delete model._detectedProvider; // Remove temporary field
+        }
+        return model;
+      });
+    },
+    // 使用动态 routers 配置，在构造时获取用户的 baseURL
+    routers: (options) => {
+      // 使用全局的模型路由映射
+      const userBaseURL = options.baseURL?.replace(/\/v1\/?$/, '') || '';
+      
+      return [
+      {
+        apiType: 'anthropic',
+        models: () =>
+          Promise.resolve(
+            Array.from(globalModelRouteMap.entries())
+              .filter(([, provider]) => provider === 'anthropic')
+              .map(([modelId]) => modelId),
+          ),
+        options: {
+          // Anthropic 在 NewAPI 中使用 /v1 路径，会自动转换为 /v1/messages
+          baseURL: urlJoin(userBaseURL, '/v1'),
+        },
+      },
+      {
+        apiType: 'google',
+        models: () =>
+          Promise.resolve(
+            Array.from(globalModelRouteMap.entries())
+              .filter(([, provider]) => provider === 'google')
+              .map(([modelId]) => modelId),
+          ),
+        options: {
+          // Gemini 在 NewAPI 中使用 /v1beta 路径
+          baseURL: urlJoin(userBaseURL, '/v1beta'),
+        },
+      },
+      {
+        apiType: 'xai',
+        models: () =>
+          Promise.resolve(
+            Array.from(globalModelRouteMap.entries())
+              .filter(([, provider]) => provider === 'xai')
+              .map(([modelId]) => modelId),
+          ),
+        options: {
+          // xAI 使用标准 OpenAI 格式，走 /v1 路径
+          baseURL: urlJoin(userBaseURL, '/v1'),
+        },
+      },
+      {
+        apiType: 'openai',
+        options: {
+          baseURL: urlJoin(userBaseURL, '/v1'),
+          chatCompletion: {
+            handlePayload,
+          },
+        },
+      },
+      ];
+    },
+});

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

@@ -30,6 +30,7 @@ import { LobeMistralAI } from './mistral';
 import { LobeModelScopeAI } from './modelscope';
 import { LobeMoonshotAI } from './moonshot';
 import { LobeNebiusAI } from './nebius';
+import { LobeNewAPIAI } from './newapi';
 import { LobeNovitaAI } from './novita';
 import { LobeNvidiaAI } from './nvidia';
 import { LobeOllamaAI } from './ollama';
@@ -91,6 +92,7 @@ export const providerRuntimeMap = {
   modelscope: LobeModelScopeAI,
   moonshot: LobeMoonshotAI,
   nebius: LobeNebiusAI,
+  newapi: LobeNewAPIAI,
   novita: LobeNovitaAI,
   nvidia: LobeNvidiaAI,
   ollama: LobeOllamaAI,

package/packages/model-runtime/src/types/type.ts

@@ -60,6 +60,7 @@ export enum ModelProvider {
   ModelScope = 'modelscope',
   Moonshot = 'moonshot',
   Nebius = 'nebius',
+  NewAPI = 'newapi',
   Novita = 'novita',
   Nvidia = 'nvidia',
   Ollama = 'ollama',

package/packages/types/src/user/settings/keyVaults.ts

@@ -69,6 +69,7 @@ export interface UserKeyVaults extends SearchEngineKeyVaults {
   modelscope?: OpenAICompatibleKeyVault;
   moonshot?: OpenAICompatibleKeyVault;
   nebius?: OpenAICompatibleKeyVault;
+  newapi?: OpenAICompatibleKeyVault;
   novita?: OpenAICompatibleKeyVault;
   nvidia?: OpenAICompatibleKeyVault;
   ollama?: OpenAICompatibleKeyVault;

package/packages/utils/src/server/__tests__/auth.test.ts

@@ -28,7 +28,7 @@ vi.mock('@/libs/clerk-auth', () => ({
   },
 }));
 
-vi.mock('@/libs/next-auth/edge', () => ({
+vi.mock('@/libs/next-auth', () => ({
   default: {
     auth: vi.fn().mockResolvedValue({
       user: {

package/packages/utils/src/server/auth.ts

@@ -12,9 +12,9 @@ export const getUserAuth = async () => {
   }
 
   if (enableNextAuth) {
-    const { default: NextAuthEdge } = await import('@/libs/next-auth/edge');
+    const { default: NextAuth } = await import('@/libs/next-auth');
 
-    const session = await NextAuthEdge.auth();
+    const session = await NextAuth.auth();
 
     const userId = session?.user.id;
 

package/src/app/(backend)/api/auth/adapter/route.ts

@@ -0,0 +1,137 @@
+import debug from 'debug';
+import { NextRequest, NextResponse } from 'next/server';
+
+import { serverDBEnv } from '@/config/db';
+import { serverDB } from '@/database/server';
+import { dateKeys } from '@/libs/next-auth/adapter';
+import { NextAuthUserService } from '@/server/services/nextAuthUser';
+
+const log = debug('lobe-next-auth:api:auth:adapter');
+
+/**
+ * @description Process the db query for the NextAuth adapter.
+ * Returns the db query result directly and let NextAuth handle the raw results.
+ * @returns {
+ *  success: boolean; // Only return false if the database query fails or the action is invalid.
+ *  data?: any;
+ *  error?: string;
+ * }
+ */
+export async function POST(req: NextRequest) {
+  try {
+    // try validate the request
+    if (
+      !req.headers.get('Authorization') ||
+      req.headers.get('Authorization')?.trim() !== `Bearer ${serverDBEnv.KEY_VAULTS_SECRET}`
+    ) {
+      log('Unauthorized request, missing or invalid Authorization header');
+      return NextResponse.json({ error: 'Unauthorized', success: false }, { status: 401 });
+    }
+
+    // Parse the request body
+    const data = await req.json();
+    log('Received request data:', data);
+    // Preprocess
+    if (data?.data) {
+      for (const key of dateKeys) {
+        if (data?.data && data.data[key]) {
+          data.data[key] = new Date(data.data[key]);
+          continue;
+        }
+      }
+    }
+    const service = new NextAuthUserService(serverDB);
+    let result;
+    switch (data.action) {
+      case 'createAuthenticator': {
+        result = await service.createAuthenticator(data.data);
+        break;
+      }
+      case 'createSession': {
+        result = await service.createSession(data.data);
+        break;
+      }
+      case 'createUser': {
+        result = await service.createUser(data.data);
+        break;
+      }
+      case 'createVerificationToken': {
+        result = await service.createVerificationToken(data.data);
+        break;
+      }
+      case 'deleteSession': {
+        result = await service.deleteSession(data.data);
+        break;
+      }
+      case 'deleteUser': {
+        result = await service.deleteUser(data.data);
+        break;
+      }
+      case 'getAccount': {
+        result = await service.getAccount(data.data.providerAccountId, data.data.provider);
+        break;
+      }
+      case 'getAuthenticator': {
+        result = await service.getAuthenticator(data.data);
+        break;
+      }
+      case 'getSessionAndUser': {
+        result = await service.getSessionAndUser(data.data);
+        break;
+      }
+      case 'getUser': {
+        result = await service.getUser(data.data);
+        break;
+      }
+      case 'getUserByAccount': {
+        result = await service.getUserByAccount(data.data);
+        break;
+      }
+      case 'getUserByEmail': {
+        result = await service.getUserByEmail(data.data);
+        break;
+      }
+      case 'linkAccount': {
+        result = await service.linkAccount(data.data);
+        break;
+      }
+      case 'listAuthenticatorsByUserId': {
+        result = await service.listAuthenticatorsByUserId(data.data);
+        break;
+      }
+      case 'unlinkAccount': {
+        result = await service.unlinkAccount(data.data);
+        break;
+      }
+      case 'updateAuthenticatorCounter': {
+        result = await service.updateAuthenticatorCounter(
+          data.data.credentialID,
+          data.data.counter,
+        );
+        break;
+      }
+      case 'updateSession': {
+        result = await service.updateSession(data.data);
+        break;
+      }
+      case 'updateUser': {
+        result = await service.updateUser(data.data);
+        break;
+      }
+      case 'useVerificationToken': {
+        result = await service.useVerificationToken(data.data);
+        break;
+      }
+      default: {
+        return NextResponse.json({ error: 'Invalid action', success: false }, { status: 400 });
+      }
+    }
+    return NextResponse.json({ data: result, success: true });
+  } catch (error) {
+    log('Error processing request:');
+    log(error);
+    return NextResponse.json({ error, success: false }, { status: 400 });
+  }
+}
+
+export const runtime = 'nodejs';

package/src/app/(backend)/api/webhooks/logto/route.ts

@@ -36,6 +36,15 @@ export const POST = async (req: Request): Promise<NextResponse> => {
         },
       );
     }
+    case 'User.SuspensionStatus.Updated': {
+      if (data.isSuspended) {
+        return nextAuthUserService.safeSignOutUser({
+          provider: 'logto',
+          providerAccountId: data.id,
+        });
+      }
+      return NextResponse.json({ message: 'user reactivated', success: true }, { status: 200 });
+    }
 
     default: {
       pino.warn(

package/src/app/[variants]/(main)/settings/provider/(detail)/newapi/page.tsx

@@ -0,0 +1,27 @@
+'use client';
+
+import { useTranslation } from 'react-i18next';
+
+import { NewAPIProviderCard } from '@/config/modelProviders';
+
+import ProviderDetail from '../[id]';
+
+const Page = () => {
+  const { t } = useTranslation('modelProvider');
+
+  return (
+    <ProviderDetail
+      {...NewAPIProviderCard}
+      settings={{
+        ...NewAPIProviderCard.settings,
+        proxyUrl: {
+          desc: t('newapi.apiUrl.desc'),
+          placeholder: 'https://any-newapi-provider.com/v1',
+          title: t('newapi.apiUrl.title'),
+        },
+      }}
+    />
+  );
+};
+
+export default Page;

package/src/config/auth.ts

@@ -18,6 +18,8 @@ declare global {
 
       NEXT_AUTH_DEBUG?: string;
 
+      NEXT_AUTH_SSO_SESSION_STRATEGY?: string;
+
       AUTH0_CLIENT_ID?: string;
       AUTH0_CLIENT_SECRET?: string;
       AUTH0_ISSUER?: string;
@@ -159,6 +161,7 @@ export const getAuthConfig = () => {
       NEXT_AUTH_SECRET: z.string().optional(),
       NEXT_AUTH_SSO_PROVIDERS: z.string().optional().default('auth0'),
       NEXT_AUTH_DEBUG: z.boolean().optional().default(false),
+      NEXT_AUTH_SSO_SESSION_STRATEGY: z.enum(['jwt', 'database']).optional().default('jwt'),
 
       // Auth0
       AUTH0_CLIENT_ID: z.string().optional(),
@@ -221,6 +224,7 @@ export const getAuthConfig = () => {
       NEXT_AUTH_SSO_PROVIDERS: process.env.NEXT_AUTH_SSO_PROVIDERS,
       NEXT_AUTH_SECRET: process.env.NEXT_AUTH_SECRET,
       NEXT_AUTH_DEBUG: !!process.env.NEXT_AUTH_DEBUG,
+      NEXT_AUTH_SSO_SESSION_STRATEGY: process.env.NEXT_AUTH_SSO_SESSION_STRATEGY || 'jwt',
 
       // Auth0
       AUTH0_CLIENT_ID: process.env.AUTH0_CLIENT_ID,

package/src/config/modelProviders/index.ts

@@ -32,6 +32,7 @@ import MistralProvider from './mistral';
 import ModelScopeProvider from './modelscope';
 import MoonshotProvider from './moonshot';
 import NebiusProvider from './nebius';
+import NewAPIProvider from './newapi';
 import NovitaProvider from './novita';
 import NvidiaProvider from './nvidia';
 import OllamaProvider from './ollama';
@@ -135,6 +136,7 @@ export const DEFAULT_MODEL_PROVIDER_LIST = [
   HuggingFaceProvider,
   CloudflareProvider,
   GithubProvider,
+  NewAPIProvider,
   BflProvider,
   NovitaProvider,
   PPIOProvider,
@@ -221,6 +223,7 @@ export { default as MistralProviderCard } from './mistral';
 export { default as ModelScopeProviderCard } from './modelscope';
 export { default as MoonshotProviderCard } from './moonshot';
 export { default as NebiusProviderCard } from './nebius';
+export { default as NewAPIProviderCard } from './newapi';
 export { default as NovitaProviderCard } from './novita';
 export { default as NvidiaProviderCard } from './nvidia';
 export { default as OllamaProviderCard } from './ollama';

package/src/config/modelProviders/newapi.ts

@@ -0,0 +1,17 @@
+import { ModelProviderCard } from '@/types/llm';
+
+const NewAPI: ModelProviderCard = {
+  chatModels: [],
+  checkModel: 'gpt-4o-mini',
+  description: '开源的多个 AI 服务聚合统一转发平台',
+  enabled: true,
+  id: 'newapi',
+  name: 'New API',
+  settings: {
+    sdkType: 'router',
+    showModelFetcher: true,
+  },
+  url: 'https://github.com/Calcium-Ion/new-api',
+};
+
+export default NewAPI;