@lobehub/lobehub 2.0.0-next.81 → 2.0.0-next.83

package/packages/model-runtime/src/core/openaiCompatibleFactory/index.ts

@@ -138,10 +138,10 @@ export interface OpenAICompatibleFactoryOptions<T extends Record<string, any> =
     useToolsCalling?: boolean;
   };
   models?:
-    | ((params: { client: OpenAI }) => Promise<ChatModelCard[]>)
-    | {
-        transformModel?: (model: OpenAI.Model) => ChatModelCard;
-      };
+  | ((params: { client: OpenAI }) => Promise<ChatModelCard[]>)
+  | {
+    transformModel?: (model: OpenAI.Model) => ChatModelCard;
+  };
   provider: string;
   responses?: {
     handlePayload?: (
@@ -205,6 +205,81 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
       this.logPrefix = `lobe-model-runtime:${this.id}`;
     }
 
+    /**
+     * Determine if should use Responses API based on various configuration options
+     * @param params - Configuration parameters
+     * @returns true if should use Responses API, false otherwise
+     */
+    private shouldUseResponsesAPI(params: {
+      /** Context for logging (e.g., 'chat', 'generateObject', 'tool calling') */
+      context?: string;
+      /** Factory/instance level useResponse flag */
+      flagUseResponse?: boolean;
+      /** Factory/instance level model patterns for Responses API */
+      flagUseResponseModels?: Array<string | RegExp>;
+      /** The model ID to check */
+      model?: string;
+      /** Explicit responseApi flag */
+      responseApi?: boolean;
+      /** User-specified API mode (highest priority) */
+      userApiMode?: string;
+    }): boolean {
+      const {
+        model,
+        userApiMode,
+        responseApi,
+        flagUseResponse,
+        flagUseResponseModels,
+        context = 'operation',
+      } = params;
+
+      const log = debug(`${this.logPrefix}:shouldUseResponsesAPI`);
+
+      // Priority 1: User explicitly set apiMode via switch
+      if (userApiMode === 'responses') {
+        log('using Responses API: explicit userApiMode=%s', userApiMode);
+        return true;
+      }
+
+      // Priority 2: userApiMode is explicitly set to something else
+      if (userApiMode !== undefined) {
+        log('using Chat Completions API: userApiMode=%s', userApiMode);
+        return false;
+      }
+
+      // Priority 3: Explicit responseApi flag
+      if (responseApi) {
+        log('using Responses API: explicit responseApi flag for %s', context);
+        return true;
+      }
+
+      // Priority 4: Factory/instance level useResponse flag
+      if (flagUseResponse) {
+        log('using Responses API: flagUseResponse=true for %s', context);
+        return true;
+      }
+
+      // Priority 5: Check if model matches useResponseModels patterns
+      if (model && flagUseResponseModels?.length) {
+        const matches = flagUseResponseModels.some((m: string | RegExp) =>
+          typeof m === 'string' ? model.includes(m) : (m as RegExp).test(model),
+        );
+        if (matches) {
+          log('using Responses API: model %s matches useResponseModels config', model);
+          return true;
+        }
+      }
+
+      // Priority 6: Check built-in responsesAPIModels
+      if (model && responsesAPIModels.has(model)) {
+        log('using Responses API: model %s in built-in responsesAPIModels', model);
+        return true;
+      }
+
+      log('using Chat Completions API for %s', context);
+      return false;
+    }
+
     async chat({ responseMode, ...payload }: ChatStreamPayload, options?: ChatMethodOptions) {
       try {
         const log = debug(`${this.logPrefix}:chat`);
@@ -212,41 +287,39 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
 
         log('chat called with model: %s, stream: %s', payload.model, payload.stream ?? true);
 
-        // 工厂级 Responses API 路由控制（支持实例覆盖）
+        let processedPayload: any = payload;
+        const userApiMode = (payload as any).apiMode as string | undefined;
         const modelId = (payload as any).model as string | undefined;
-        const shouldUseResponses = (() => {
-          const instanceChat = ((this._options as any).chatCompletion || {}) as {
-            useResponse?: boolean;
-            useResponseModels?: Array<string | RegExp>;
-          };
-          const flagUseResponse =
-            instanceChat.useResponse ?? (chatCompletion ? chatCompletion.useResponse : undefined);
-          const flagUseResponseModels =
-            instanceChat.useResponseModels ?? chatCompletion?.useResponseModels;
-
-          if (!chatCompletion && !instanceChat) return false;
-          if (flagUseResponse) return true;
-          if (!modelId || !flagUseResponseModels?.length) return false;
-          return flagUseResponseModels.some((m: string | RegExp) =>
-            typeof m === 'string' ? modelId.includes(m) : (m as RegExp).test(modelId),
-          );
-        })();
 
-        let processedPayload: any = payload;
+        const instanceChat = ((this._options as any).chatCompletion || {}) as {
+          useResponse?: boolean;
+          useResponseModels?: Array<string | RegExp>;
+        };
+        const flagUseResponse =
+          instanceChat.useResponse ?? (chatCompletion ? chatCompletion.useResponse : undefined);
+        const flagUseResponseModels =
+          instanceChat.useResponseModels ?? chatCompletion?.useResponseModels;
+
+        // Determine if should use Responses API
+        const shouldUseResponses = this.shouldUseResponsesAPI({
+          context: 'chat',
+          flagUseResponse,
+          flagUseResponseModels,
+          model: modelId,
+          userApiMode,
+        });
+
         if (shouldUseResponses) {
-          log('using Responses API mode');
           processedPayload = { ...payload, apiMode: 'responses' } as any;
-        } else {
-          log('using Chat Completions API mode');
         }
 
         // 再进行工厂级处理
         const postPayload = chatCompletion?.handlePayload
           ? chatCompletion.handlePayload(processedPayload, this._options)
           : ({
-              ...processedPayload,
-              stream: processedPayload.stream ?? true,
-            } as OpenAI.ChatCompletionCreateParamsStreaming);
+            ...processedPayload,
+            stream: processedPayload.stream ?? true,
+          } as OpenAI.ChatCompletionCreateParamsStreaming);
 
         if ((postPayload as any).apiMode === 'responses') {
           return this.handleResponseAPIMode(processedPayload, options);
@@ -312,13 +385,13 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
           return StreamingResponse(
             chatCompletion?.handleStream
               ? chatCompletion.handleStream(prod, {
-                  callbacks: streamOptions.callbacks,
-                  inputStartAt,
-                })
+                callbacks: streamOptions.callbacks,
+                inputStartAt,
+              })
               : OpenAIStream(prod, {
-                  ...streamOptions,
-                  inputStartAt,
-                }),
+                ...streamOptions,
+                inputStartAt,
+              }),
             {
               headers: options?.headers,
             },
@@ -342,9 +415,9 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
         return StreamingResponse(
           chatCompletion?.handleStream
             ? chatCompletion.handleStream(stream, {
-                callbacks: streamOptions.callbacks,
-                inputStartAt,
-              })
+              callbacks: streamOptions.callbacks,
+              inputStartAt,
+            })
             : OpenAIStream(stream, { ...streamOptions, enableStreaming: false, inputStartAt }),
           {
             headers: options?.headers,
@@ -500,47 +573,23 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
       }
 
       // Factory-level Responses API routing control (supports instance override)
-      const shouldUseResponses = (() => {
-        const instanceGenerateObject = ((this._options as any).generateObject || {}) as {
-          useResponse?: boolean;
-          useResponseModels?: Array<string | RegExp>;
-        };
-        const flagUseResponse =
-          instanceGenerateObject.useResponse ??
-          (generateObjectConfig ? generateObjectConfig.useResponse : undefined);
-        const flagUseResponseModels =
-          instanceGenerateObject.useResponseModels ?? generateObjectConfig?.useResponseModels;
-
-        if (responseApi) {
-          log('using Responses API due to explicit responseApi flag');
-          return true;
-        }
-
-        if (flagUseResponse) {
-          log('using Responses API due to useResponse flag');
-          return true;
-        }
-
-        // Use factory-configured model list if provided
-        if (model && flagUseResponseModels?.length) {
-          const matches = flagUseResponseModels.some((m: string | RegExp) =>
-            typeof m === 'string' ? model.includes(m) : (m as RegExp).test(model),
-          );
-          if (matches) {
-            log('using Responses API: model %s matches useResponseModels config', model);
-            return true;
-          }
-        }
-
-        // Default: use built-in responsesAPIModels
-        if (model && responsesAPIModels.has(model)) {
-          log('using Responses API: model %s in built-in responsesAPIModels', model);
-          return true;
-        }
-
-        log('using Chat Completions API for generateObject');
-        return false;
-      })();
+      const instanceGenerateObject = ((this._options as any).generateObject || {}) as {
+        useResponse?: boolean;
+        useResponseModels?: Array<string | RegExp>;
+      };
+      const flagUseResponse =
+        instanceGenerateObject.useResponse ??
+        (generateObjectConfig ? generateObjectConfig.useResponse : undefined);
+      const flagUseResponseModels =
+        instanceGenerateObject.useResponseModels ?? generateObjectConfig?.useResponseModels;
+
+      const shouldUseResponses = this.shouldUseResponsesAPI({
+        context: 'generateObject',
+        flagUseResponse,
+        flagUseResponseModels,
+        model,
+        responseApi,
+      });
 
       // Apply schema transformation if configured
       const processedSchema = generateObjectConfig?.handleSchema
@@ -790,11 +839,11 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
         ...res,
         ...(reasoning || reasoning_effort
           ? {
-              reasoning: {
-                ...reasoning,
-                ...(reasoning_effort && { effort: reasoning_effort }),
-              },
-            }
+            reasoning: {
+              ...reasoning,
+              ...(reasoning_effort && { effort: reasoning_effort }),
+            },
+          }
           : {}),
         input,
         ...(max_tokens && { max_output_tokens: max_tokens }),
@@ -885,47 +934,23 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
       );
 
       // Factory-level Responses API routing control (supports instance override)
-      const shouldUseResponses = (() => {
-        const instanceGenerateObject = ((this._options as any).generateObject || {}) as {
-          useResponse?: boolean;
-          useResponseModels?: Array<string | RegExp>;
-        };
-        const flagUseResponse =
-          instanceGenerateObject.useResponse ??
-          (generateObjectConfig ? generateObjectConfig.useResponse : undefined);
-        const flagUseResponseModels =
-          instanceGenerateObject.useResponseModels ?? generateObjectConfig?.useResponseModels;
-
-        if (responseApi) {
-          log('using Responses API due to explicit responseApi flag');
-          return true;
-        }
-
-        if (flagUseResponse) {
-          log('using Responses API due to useResponse flag');
-          return true;
-        }
-
-        // Use factory-configured model list if provided
-        if (model && flagUseResponseModels?.length) {
-          const matches = flagUseResponseModels.some((m: string | RegExp) =>
-            typeof m === 'string' ? model.includes(m) : (m as RegExp).test(model),
-          );
-          if (matches) {
-            log('using Responses API: model %s matches useResponseModels config', model);
-            return true;
-          }
-        }
-
-        // Default: use built-in responsesAPIModels
-        if (model && responsesAPIModels.has(model)) {
-          log('using Responses API: model %s in built-in responsesAPIModels', model);
-          return true;
-        }
-
-        log('using Chat Completions API for tool calling');
-        return false;
-      })();
+      const instanceGenerateObject = ((this._options as any).generateObject || {}) as {
+        useResponse?: boolean;
+        useResponseModels?: Array<string | RegExp>;
+      };
+      const flagUseResponse =
+        instanceGenerateObject.useResponse ??
+        (generateObjectConfig ? generateObjectConfig.useResponse : undefined);
+      const flagUseResponseModels =
+        instanceGenerateObject.useResponseModels ?? generateObjectConfig?.useResponseModels;
+
+      const shouldUseResponses = this.shouldUseResponsesAPI({
+        context: 'tool calling',
+        flagUseResponse,
+        flagUseResponseModels,
+        model,
+        responseApi,
+      });
 
       if (shouldUseResponses) {
         log('calling responses.create for tool calling');

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

@@ -5,7 +5,7 @@ import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { responsesAPIModels } from '../../const/models';
 import { ChatStreamPayload } from '../../types/chat';
 import * as modelParseModule from '../../utils/modelParse';
-import { LobeNewAPIAI, NewAPIModelCard, NewAPIPricing, handlePayload, params } from './index';
+import { LobeNewAPIAI, NewAPIModelCard, NewAPIPricing, params } from './index';
 
 // Mock external dependencies
 vi.mock('../../utils/modelParse');
@@ -701,78 +701,6 @@ describe('NewAPI Runtime - 100% Branch Coverage', () => {
     });
   });
 
-  describe('HandlePayload Function - Direct Testing', () => {
-    beforeEach(() => {
-      // Mock responsesAPIModels as a Set for testing
-      (responsesAPIModels as any).has = vi.fn((model: string) => model === 'o1-pro');
-    });
-
-    it('should add apiMode for models in responsesAPIModels set', () => {
-      (responsesAPIModels as any).has = vi.fn((model: string) => model === 'o1-pro');
-
-      const payload: ChatStreamPayload = {
-        model: 'o1-pro',
-        messages: [{ role: 'user', content: 'test' }],
-        temperature: 0.5,
-      };
-
-      const result = handlePayload(payload);
-      expect(result).toEqual({ ...payload, apiMode: 'responses' });
-    });
-
-    it('should add apiMode for gpt- models', () => {
-      (responsesAPIModels as any).has = vi.fn(() => false);
-
-      const payload: ChatStreamPayload = {
-        model: 'gpt-4o',
-        messages: [{ role: 'user', content: 'test' }],
-        temperature: 0.5,
-      };
-
-      const result = handlePayload(payload);
-      expect(result).toEqual({ ...payload, apiMode: 'responses' });
-    });
-
-    it('should add apiMode for o1 models', () => {
-      (responsesAPIModels as any).has = vi.fn(() => false);
-
-      const payload: ChatStreamPayload = {
-        model: 'o1-mini',
-        messages: [{ role: 'user', content: 'test' }],
-        temperature: 0.5,
-      };
-
-      const result = handlePayload(payload);
-      expect(result).toEqual({ ...payload, apiMode: 'responses' });
-    });
-
-    it('should add apiMode for o3 models', () => {
-      (responsesAPIModels as any).has = vi.fn(() => false);
-
-      const payload: ChatStreamPayload = {
-        model: 'o3-turbo',
-        messages: [{ role: 'user', content: 'test' }],
-        temperature: 0.5,
-      };
-
-      const result = handlePayload(payload);
-      expect(result).toEqual({ ...payload, apiMode: 'responses' });
-    });
-
-    it('should not modify payload for regular models', () => {
-      (responsesAPIModels as any).has = vi.fn(() => false);
-
-      const payload: ChatStreamPayload = {
-        model: 'claude-3-sonnet',
-        messages: [{ role: 'user', content: 'test' }],
-        temperature: 0.5,
-      };
-
-      const result = handlePayload(payload);
-      expect(result).toEqual(payload);
-    });
-  });
-
   describe('Routers Function - Direct Testing', () => {
     it('should generate routers with correct apiTypes', () => {
       const options = { apiKey: 'test', baseURL: 'https://api.newapi.com/v1' };
@@ -823,11 +751,11 @@ describe('NewAPI Runtime - 100% Branch Coverage', () => {
       expect(routers[3].options.baseURL).toBe('https://custom.com/v1');
     });
 
-    it('should configure openai router with handlePayload', () => {
+    it('should configure openai router with useResponseModels', () => {
       const options = { apiKey: 'test', baseURL: 'https://custom.com/v1' };
       const routers = params.routers(options);
 
-      expect((routers[3].options as any).chatCompletion?.handlePayload).toBe(handlePayload);
+      expect((routers[3].options as any).chatCompletion?.useResponseModels).toBeDefined();
     });
 
     it('should filter anthropic models for anthropic router', () => {

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

@@ -4,7 +4,6 @@ import urlJoin from 'url-join';
 import { responsesAPIModels } from '../../const/models';
 import { createRouterRuntime } from '../../core/RouterRuntime';
 import { CreateRouterRuntimeOptions } from '../../core/RouterRuntime/createRuntime';
-import { ChatStreamPayload } from '../../types/chat';
 import { detectModelProvider, processMultiProviderModelList } from '../../utils/modelParse';
 
 export interface NewAPIModelCard {
@@ -26,18 +25,6 @@ export interface NewAPIPricing {
   supported_endpoint_types?: string[];
 }
 
-export const handlePayload = (payload: ChatStreamPayload) => {
-  // Handle OpenAI responses API mode
-  if (
-    responsesAPIModels.has(payload.model) ||
-    payload.model.includes('gpt-') ||
-    /^o\d/.test(payload.model)
-  ) {
-    return { ...payload, apiMode: 'responses' };
-  }
-  return payload;
-};
-
 export const params = {
   debug: {
     chatCompletion: () => process.env.DEBUG_NEWAPI_CHAT_COMPLETION === '1',
@@ -178,7 +165,7 @@ export const params = {
           ...options,
           baseURL: urlJoin(userBaseURL, '/v1'),
           chatCompletion: {
-            handlePayload,
+            useResponseModels: [...Array.from(responsesAPIModels), /gpt-\d(?!\d)/, /^o\d/],
           },
         },
       },

package/packages/model-runtime/src/providers/openrouter/index.test.ts

@@ -1548,8 +1548,9 @@ describe('LobeOpenRouterAI - custom features', () => {
       const models = await params.models();
 
       const mixedModel = models.find((m) => m.id === 'mixed-free/model');
-      // Input or output is 0, so should be marked as free
-      expect(mixedModel?.displayName).toContain('(free)');
+      // Input or output is 0. Current behavior does not append '(free)' for mixed pricing,
+      // so assert the displayName equals the cleaned model name.
+      expect(mixedModel?.displayName).toBe('Mixed Free Model');
     });
 
     it('should handle very large pricing values', async () => {

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

@@ -99,7 +99,7 @@ export const params = {
       const cachedInputPrice = formatPrice(pricing.input_cache_read);
       const writeCacheInputPrice = formatPrice(pricing.input_cache_write);
 
-      const isFree = (inputPrice === 0 || outputPrice === 0) && !displayName.endsWith('(free)');
+      const isFree = inputPrice === 0 && outputPrice === 0 && !displayName.endsWith('(free)');
       if (isFree) {
         displayName += ' (free)';
       }

package/src/app/[variants]/(main)/settings/provider/features/CreateNewProvider/index.tsx

@@ -42,6 +42,15 @@ const CreateNewProvider = memo<CreateNewProviderProps>(({ onClose, open }) => {
         name: values.name || values.id,
       };
 
+      // 只为 openai 和 router (newapi) 类型的自定义 provider 添加 supportResponsesApi: true
+      const sdkType = values.settings?.sdkType;
+      if (sdkType === 'openai' || sdkType === 'router') {
+        finalValues.settings = {
+          ...finalValues.settings,
+          supportResponsesApi: true,
+        };
+      }
+
       await createNewAiProvider(finalValues);
       setLoading(false);
       navigate(`/settings?active=provider&provider=${values.id}`);
@@ -102,12 +111,16 @@ const CreateNewProvider = memo<CreateNewProviderProps>(({ onClose, open }) => {
     {
       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/app/[variants]/(main)/settings/provider/features/customProviderSdkOptions.ts

@@ -9,4 +9,5 @@ export const CUSTOM_PROVIDER_SDK_OPTIONS = [
   { label: 'Qwen', value: 'qwen' },
   { label: 'Volcengine', value: 'volcengine' },
   { label: 'Ollama', value: 'ollama' },
+  { label: 'New API', value: 'router' },
 ] satisfies { label: string; value: AiProviderSDKType }[];

package/src/config/modelProviders/aihubmix.ts

@@ -11,6 +11,7 @@ const AiHubMix: ModelProviderCard = {
   settings: {
     sdkType: 'router',
     showModelFetcher: true,
+    supportResponsesApi: true,
   },
   url: 'https://aihubmix.com?utm_source=lobehub',
 };

package/src/config/modelProviders/newapi.ts

@@ -13,6 +13,7 @@ const NewAPI: ModelProviderCard = {
     },
     sdkType: 'router',
     showModelFetcher: true,
+    supportResponsesApi: true,
   },
   url: 'https://github.com/Calcium-Ion/new-api',
 };

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

@@ -52,8 +52,10 @@ const errorHandlingLink: TRPCLink<LambdaRouter> = () => {
               }
 
               default: {
-                if (fetchErrorNotification)
+                console.error(err);
+                if (fetchErrorNotification && status) {
                   fetchErrorNotification.error({ errorMessage: err.message, status });
+                }
               }
             }
           }

package/src/locales/default/modelProvider.ts

@@ -298,7 +298,7 @@ export default {
       },
       helpDoc: '配置教程',
       responsesApi: {
-        desc: '采用 OpenAI 新一代请求格式规范，解锁思维链等进阶特性',
+        desc: '采用 OpenAI 新一代请求格式规范，解锁思维链等进阶特性 (仅 OpenAI 模型支持)',
         title: '使用 Responses API 规范',
       },
       waitingForMore: '更多模型正在 <1>计划接入</1> 中，敬请期待',