@lobehub/chat 1.136.13 → 1.137.1

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

@@ -14,6 +14,7 @@ interface TesstProviderParams {
   provider: string;
   test?: {
     skipAPICall?: boolean;
+    skipErrorHandle?: boolean;
   };
 }
 
@@ -109,165 +110,167 @@ export const testProvider = ({
         });
       }
 
-      describe('Error', () => {
-        it('should return ProviderBizError with an openai error response when OpenAI.APIError is thrown', async () => {
-          // Arrange
-          const apiError = new OpenAI.APIError(
-            400,
-            {
-              error: {
-                message: 'Bad Request',
-              },
-              status: 400,
-            },
-            'Error message',
-            {},
-          );
-
-          vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
-
-          // Act
-          try {
-            await instance.chat({
-              messages: [{ content: 'Hello', role: 'user' }],
-              model: chatModel,
-              temperature: 0,
-            });
-          } catch (e) {
-            expect(e).toEqual({
-              endpoint: defaultBaseURL,
-              error: {
-                error: { message: 'Bad Request' },
+      if (!test.skipErrorHandle) {
+        describe('Error', () => {
+          it('should return ProviderBizError with an openai error response when OpenAI.APIError is thrown', async () => {
+            // Arrange
+            const apiError = new OpenAI.APIError(
+              400,
+              {
+                error: {
+                  message: 'Bad Request',
+                },
                 status: 400,
               },
-              errorType: bizErrorType,
-              provider,
-            });
-          }
-        });
-
-        it('should throw AgentRuntimeError with InvalidProviderAPIKey if no apiKey is provided', async () => {
-          try {
-            new Runtime({});
-          } catch (e) {
-            expect(e).toEqual({ errorType: invalidErrorType });
-          }
-        });
-
-        it('should return ProviderBizError with the cause when OpenAI.APIError is thrown with cause', async () => {
-          // Arrange
-          const errorInfo = {
-            cause: {
-              message: 'api is undefined',
-            },
-          };
-          const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
+              'Error message',
+              {},
+            );
+
+            vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
+
+            // Act
+            try {
+              await instance.chat({
+                messages: [{ content: 'Hello', role: 'user' }],
+                model: chatModel,
+                temperature: 0,
+              });
+            } catch (e) {
+              expect(e).toEqual({
+                endpoint: defaultBaseURL,
+                error: {
+                  error: { message: 'Bad Request' },
+                  status: 400,
+                },
+                errorType: bizErrorType,
+                provider,
+              });
+            }
+          });
 
-          vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
+          it('should throw AgentRuntimeError with InvalidProviderAPIKey if no apiKey is provided', async () => {
+            try {
+              new Runtime({});
+            } catch (e) {
+              expect(e).toEqual({ errorType: invalidErrorType });
+            }
+          });
 
-          // Act
-          try {
-            await instance.chat({
-              messages: [{ content: 'Hello', role: 'user' }],
-              model: chatModel,
-              temperature: 0,
-            });
-          } catch (e) {
-            expect(e).toEqual({
-              endpoint: defaultBaseURL,
-              error: {
-                cause: { message: 'api is undefined' },
+          it('should return ProviderBizError with the cause when OpenAI.APIError is thrown with cause', async () => {
+            // Arrange
+            const errorInfo = {
+              cause: {
+                message: 'api is undefined',
               },
-              errorType: bizErrorType,
-              provider,
-            });
-          }
-        });
-
-        it('should return ProviderBizError with an cause response with desensitize Url', async () => {
-          // Arrange
-          const errorInfo = {
-            cause: { message: 'api is undefined' },
-          };
-          const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
-
-          instance = new Runtime({
-            apiKey: 'test',
-
-            baseURL: 'https://api.abc.com/v1',
+            };
+            const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
+
+            vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
+
+            // Act
+            try {
+              await instance.chat({
+                messages: [{ content: 'Hello', role: 'user' }],
+                model: chatModel,
+                temperature: 0,
+              });
+            } catch (e) {
+              expect(e).toEqual({
+                endpoint: defaultBaseURL,
+                error: {
+                  cause: { message: 'api is undefined' },
+                },
+                errorType: bizErrorType,
+                provider,
+              });
+            }
           });
 
-          vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
-
-          // Act
-          try {
-            await instance.chat({
-              messages: [{ content: 'Hello', role: 'user' }],
-              model: chatModel,
-              temperature: 0,
-            });
-          } catch (e) {
-            expect(e).toEqual({
-              endpoint: 'https://api.***.com/v1',
-              error: {
-                cause: { message: 'api is undefined' },
-              },
-              errorType: bizErrorType,
-              provider,
-            });
-          }
-        });
+          it('should return ProviderBizError with an cause response with desensitize Url', async () => {
+            // Arrange
+            const errorInfo = {
+              cause: { message: 'api is undefined' },
+            };
+            const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
 
-        it(`should throw an InvalidAPIKey error type on 401 status code`, async () => {
-          // Mock the API call to simulate a 401 error
-          const error = new Error('Unauthorized') as any;
-          error.status = 401;
-          vi.mocked(instance['client'].chat.completions.create).mockRejectedValue(error);
+            instance = new Runtime({
+              apiKey: 'test',
 
-          try {
-            await instance.chat({
-              messages: [{ content: 'Hello', role: 'user' }],
-              model: chatModel,
-              temperature: 0,
-            });
-          } catch (e) {
-            // Expect the chat method to throw an error with InvalidHunyuanAPIKey
-            expect(e).toEqual({
-              endpoint: defaultBaseURL,
-              error: error,
-              errorType: invalidErrorType,
-              provider,
+              baseURL: 'https://api.abc.com/v1',
             });
-          }
-        });
 
-        it('should return AgentRuntimeError for non-OpenAI errors', async () => {
-          // Arrange
-          const genericError = new Error('Generic Error');
+            vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
+
+            // Act
+            try {
+              await instance.chat({
+                messages: [{ content: 'Hello', role: 'user' }],
+                model: chatModel,
+                temperature: 0,
+              });
+            } catch (e) {
+              expect(e).toEqual({
+                endpoint: 'https://api.***.com/v1',
+                error: {
+                  cause: { message: 'api is undefined' },
+                },
+                errorType: bizErrorType,
+                provider,
+              });
+            }
+          });
 
-          vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(genericError);
+          it(`should throw an InvalidAPIKey error type on 401 status code`, async () => {
+            // Mock the API call to simulate a 401 error
+            const error = new Error('Unauthorized') as any;
+            error.status = 401;
+            vi.mocked(instance['client'].chat.completions.create).mockRejectedValue(error);
+
+            try {
+              await instance.chat({
+                messages: [{ content: 'Hello', role: 'user' }],
+                model: chatModel,
+                temperature: 0,
+              });
+            } catch (e) {
+              // Expect the chat method to throw an error with InvalidHunyuanAPIKey
+              expect(e).toEqual({
+                endpoint: defaultBaseURL,
+                error: error,
+                errorType: invalidErrorType,
+                provider,
+              });
+            }
+          });
 
-          // Act
-          try {
-            await instance.chat({
-              messages: [{ content: 'Hello', role: 'user' }],
-              model: chatModel,
-              temperature: 0,
-            });
-          } catch (e) {
-            expect(e).toEqual({
-              endpoint: defaultBaseURL,
-              error: {
-                cause: genericError.cause,
-                message: genericError.message,
-                name: genericError.name,
-              },
-              errorType: 'AgentRuntimeError',
-              provider,
-            });
-          }
+          it('should return AgentRuntimeError for non-OpenAI errors', async () => {
+            // Arrange
+            const genericError = new Error('Generic Error');
+
+            vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(genericError);
+
+            // Act
+            try {
+              await instance.chat({
+                messages: [{ content: 'Hello', role: 'user' }],
+                model: chatModel,
+                temperature: 0,
+              });
+            } catch (e) {
+              expect(e).toEqual({
+                endpoint: defaultBaseURL,
+                error: {
+                  cause: genericError.cause,
+                  message: genericError.message,
+                  name: genericError.name,
+                },
+                errorType: 'AgentRuntimeError',
+                provider,
+              });
+            }
+          });
         });
-      });
+      }
 
       describe('DEBUG', () => {
         it(`should call debugStream and return StreamingTextResponse when ${chatDebugEnv} is 1`, async () => {

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

@@ -0,0 +1,60 @@
+// @vitest-environment node
+import { ModelProvider } from 'model-bank';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { testProvider } from '../../providerTestUtils';
+import { AgentRuntimeErrorType } from '../../types/error';
+import { Lobe302AI, params } from './index';
+
+testProvider({
+  Runtime: Lobe302AI,
+  provider: ModelProvider.Ai302,
+  defaultBaseURL: 'https://api.302.ai/v1',
+  chatDebugEnv: 'DEBUG_AI302_CHAT_COMPLETION',
+  chatModel: 'gpt-3.5-turbo',
+  invalidErrorType: 'InvalidProviderAPIKey',
+  bizErrorType: 'ProviderBizError',
+  test: {
+    skipAPICall: true,
+    skipErrorHandle: true,
+  },
+});
+
+describe('Lobe302AI - params', () => {
+  it('should have correct baseURL', () => {
+    expect(params.baseURL).toBe('https://api.302.ai/v1');
+    expect(params.provider).toBe(ModelProvider.Ai302);
+  });
+
+  describe('handleError', () => {
+    it('should handle 401 error as InvalidProviderAPIKey', () => {
+      const error = new Response('Unauthorized', { status: 401 });
+      const result = params.chatCompletion?.handleError?.(error);
+
+      expect(result?.errorType).toBe(AgentRuntimeErrorType.InvalidProviderAPIKey);
+      expect(result?.error).toBe(401);
+    });
+
+    it('should handle error with status property', () => {
+      const error = { status: 401, message: 'Unauthorized' };
+      const result = params.chatCompletion?.handleError?.(error);
+
+      expect(result?.errorType).toBe(AgentRuntimeErrorType.InvalidProviderAPIKey);
+    });
+
+    it('should return error for non-401 status', () => {
+      const error = new Response('Bad Request', { status: 400 });
+      const result = params.chatCompletion?.handleError?.(error);
+
+      expect(result?.error).toBe(error);
+      expect(result?.errorType).toBeUndefined();
+    });
+
+    it('should return error for generic errors', () => {
+      const error = new Error('Network error');
+      const result = params.chatCompletion?.handleError?.(error);
+
+      expect(result?.error).toBe(error);
+    });
+  });
+});

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

@@ -1,6 +1,9 @@
 import { ModelProvider } from 'model-bank';
 
-import { createOpenAICompatibleRuntime } from '../../core/openaiCompatibleFactory';
+import {
+  OpenAICompatibleFactoryOptions,
+  createOpenAICompatibleRuntime,
+} from '../../core/openaiCompatibleFactory';
 import { ChatCompletionErrorPayload } from '../../types';
 import { AgentRuntimeErrorType } from '../../types/error';
 import { processMultiProviderModelList } from '../../utils/modelParse';
@@ -9,7 +12,7 @@ export interface Ai302ModelCard {
   id: string;
 }
 
-export const Lobe302AI = createOpenAICompatibleRuntime({
+export const params = {
   baseURL: 'https://api.302.ai/v1',
   chatCompletion: {
     handleError: (error: any): Omit<ChatCompletionErrorPayload, 'provider'> | undefined => {
@@ -32,7 +35,7 @@ export const Lobe302AI = createOpenAICompatibleRuntime({
     },
   },
   debug: {
-    chatCompletion: () => process.env.DEBUG_SILICONCLOUD_CHAT_COMPLETION === '1',
+    chatCompletion: () => process.env.DEBUG_AI302_CHAT_COMPLETION === '1',
   },
   errorType: {
     bizError: AgentRuntimeErrorType.ProviderBizError,
@@ -45,4 +48,6 @@ export const Lobe302AI = createOpenAICompatibleRuntime({
     return processMultiProviderModelList(modelList, 'ai302');
   },
   provider: ModelProvider.Ai302,
-});
+} satisfies OpenAICompatibleFactoryOptions;
+
+export const Lobe302AI = createOpenAICompatibleRuntime(params);