@lobehub/lobehub 2.0.0-next.82 → 2.0.0-next.84

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

@@ -1007,78 +1007,122 @@ describe('LobeOpenAICompatibleFactory', () => {
     });
 
     describe('responses routing', () => {
-      it('should route to Responses API when chatCompletion.useResponse is true', async () => {
-        const LobeMockProviderUseResponses = createOpenAICompatibleRuntime({
-          baseURL: 'https://api.test.com/v1',
-          chatCompletion: {
-            useResponse: true,
-          },
-          provider: ModelProvider.OpenAI,
-        });
+      it(
+        'should route to Responses API when chatCompletion.useResponse is true',
+        async () => {
+          const LobeMockProviderUseResponses = createOpenAICompatibleRuntime({
+            baseURL: 'https://api.test.com/v1',
+            chatCompletion: {
+              useResponse: true,
+            },
+            provider: ModelProvider.OpenAI,
+          });
 
-        const inst = new LobeMockProviderUseResponses({ apiKey: 'test' });
+          const inst = new LobeMockProviderUseResponses({ apiKey: 'test' });
 
-        // mock responses.create to return a stream-like with tee
-        const prod = new ReadableStream();
-        const debug = new ReadableStream();
-        const mockResponsesCreate = vi
-          .spyOn(inst['client'].responses, 'create')
-          .mockResolvedValue({ tee: () => [prod, debug] } as any);
+          // Mock responses.create to return a proper stream-like object
+          const mockResponsesCreate = vi
+            .spyOn(inst['client'].responses, 'create')
+            .mockResolvedValue({
+              toReadableStream: () =>
+                new ReadableStream({
+                  start(controller) {
+                    controller.close();
+                  },
+                }),
+            } as any);
 
-        await inst.chat({
-          messages: [{ content: 'hi', role: 'user' }],
-          model: 'any-model',
-          temperature: 0,
-        });
+          // Mock getModelPricing to prevent async issues
+          vi.mock('../../utils/model', () => ({
+            getModelPricing: vi.fn().mockResolvedValue({}),
+          }));
 
-        expect(mockResponsesCreate).toHaveBeenCalled();
-      });
+          try {
+            await inst.chat({
+              messages: [{ content: 'hi', role: 'user' }],
+              model: 'any-model',
+              temperature: 0,
+            });
+          } catch (e) {
+            // Catch errors from incomplete mocking, we only care that responses.create was called
+          }
 
-      it('should route to Responses API when model matches useResponseModels', async () => {
-        const LobeMockProviderUseResponseModels = createOpenAICompatibleRuntime({
-          baseURL: 'https://api.test.com/v1',
-          chatCompletion: {
-            useResponseModels: ['special-model', /special-\w+/],
-          },
-          provider: ModelProvider.OpenAI,
-        });
-        const inst = new LobeMockProviderUseResponseModels({ apiKey: 'test' });
-        const spy = vi.spyOn(inst['client'].responses, 'create');
-        // Prevent hanging by mocking normal chat completion stream
-        vi.spyOn(inst['client'].chat.completions, 'create').mockResolvedValue(
-          new ReadableStream() as any,
-        );
+          expect(mockResponsesCreate).toHaveBeenCalled();
+        },
+        { timeout: 10000 },
+      );
 
-        // First invocation: model contains the string
-        spy.mockResolvedValueOnce({
-          tee: () => [new ReadableStream(), new ReadableStream()],
-        } as any);
-        await inst.chat({
-          messages: [{ content: 'hi', role: 'user' }],
-          model: 'prefix-special-model-suffix',
-          temperature: 0,
-        });
-        expect(spy).toHaveBeenCalledTimes(1);
+      it(
+        'should route to Responses API when model matches useResponseModels',
+        async () => {
+          const LobeMockProviderUseResponseModels = createOpenAICompatibleRuntime({
+            baseURL: 'https://api.test.com/v1',
+            chatCompletion: {
+              useResponseModels: ['special-model', /special-\w+/],
+            },
+            provider: ModelProvider.OpenAI,
+          });
+          const inst = new LobeMockProviderUseResponseModels({ apiKey: 'test' });
+          const spy = vi.spyOn(inst['client'].responses, 'create');
+          // Prevent hanging by mocking normal chat completion stream
+          vi.spyOn(inst['client'].chat.completions, 'create').mockResolvedValue(
+            new ReadableStream() as any,
+          );
 
-        // Second invocation: model matches the RegExp
-        spy.mockResolvedValueOnce({
-          tee: () => [new ReadableStream(), new ReadableStream()],
-        } as any);
-        await inst.chat({
-          messages: [{ content: 'hi', role: 'user' }],
-          model: 'special-xyz',
-          temperature: 0,
-        });
-        expect(spy).toHaveBeenCalledTimes(2);
+          // First invocation: model contains the string
+          spy.mockResolvedValueOnce({
+            toReadableStream: () =>
+              new ReadableStream({
+                start(controller) {
+                  controller.close();
+                },
+              }),
+          } as any);
+          try {
+            await inst.chat({
+              messages: [{ content: 'hi', role: 'user' }],
+              model: 'prefix-special-model-suffix',
+              temperature: 0,
+            });
+          } catch (e) {
+            // Catch errors from incomplete mocking
+          }
+          expect(spy).toHaveBeenCalledTimes(1);
 
-        // Third invocation: model does not match any useResponseModels patterns
-        await inst.chat({
-          messages: [{ content: 'hi', role: 'user' }],
-          model: 'unrelated-model',
-          temperature: 0,
-        });
-        expect(spy).toHaveBeenCalledTimes(2); // Ensure no additional calls were made
-      });
+          // Second invocation: model matches the RegExp
+          spy.mockResolvedValueOnce({
+            toReadableStream: () =>
+              new ReadableStream({
+                start(controller) {
+                  controller.close();
+                },
+              }),
+          } as any);
+          try {
+            await inst.chat({
+              messages: [{ content: 'hi', role: 'user' }],
+              model: 'special-xyz',
+              temperature: 0,
+            });
+          } catch (e) {
+            // Catch errors from incomplete mocking
+          }
+          expect(spy).toHaveBeenCalledTimes(2);
+
+          // Third invocation: model does not match any useResponseModels patterns
+          try {
+            await inst.chat({
+              messages: [{ content: 'hi', role: 'user' }],
+              model: 'unrelated-model',
+              temperature: 0,
+            });
+          } catch (e) {
+            // Catch errors
+          }
+          expect(spy).toHaveBeenCalledTimes(2); // Ensure no additional calls were made
+        },
+        { timeout: 10000 },
+      );
     });
 
     describe('DEBUG', () => {

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/],
           },
         },
       },