@lobehub/chat 1.57.0 → 1.58.0

package/src/features/AgentSetting/StoreUpdater.tsx

@@ -7,12 +7,14 @@ import { AgentSettingsInstance, useAgentSettings } from './hooks/useAgentSetting
 import { State, useStoreApi } from './store';
 
 export interface StoreUpdaterProps
-  extends Partial<Pick<State, 'onMetaChange' | 'onConfigChange' | 'meta' | 'config' | 'id'>> {
+  extends Partial<
+    Pick<State, 'onMetaChange' | 'onConfigChange' | 'meta' | 'config' | 'id' | 'loading'>
+  > {
   instanceRef?: ForwardedRef<AgentSettingsInstance> | null;
 }
 
 const StoreUpdater = memo<StoreUpdaterProps>(
-  ({ onConfigChange, instanceRef, id, onMetaChange, meta, config }) => {
+  ({ onConfigChange, instanceRef, id, onMetaChange, meta, config, loading }) => {
     const storeApi = useStoreApi();
     const useStoreUpdater = createStoreUpdater(storeApi);
 
@@ -20,6 +22,7 @@ const StoreUpdater = memo<StoreUpdaterProps>(
     useStoreUpdater('config', config);
     useStoreUpdater('onConfigChange', onConfigChange);
     useStoreUpdater('onMetaChange', onMetaChange);
+    useStoreUpdater('loading', loading);
     useStoreUpdater('id', id);
 
     const instance = useAgentSettings();

package/src/features/AgentSetting/index.tsx

@@ -1,3 +1,3 @@
 export { AgentSettings } from './AgentSettings';
-export { AgentSettingsStore } from './AgentSettingsStore';
+export { AgentSettingsProvider } from './AgentSettingsProvider';
 export type { AgentSettingsInstance } from './hooks/useAgentSettings';

package/src/features/AgentSetting/store/initialState.ts

@@ -7,8 +7,9 @@ export interface State {
   autocompleteLoading: SessionLoadingState;
   config: LobeAgentConfig;
   id?: string;
-  meta: MetaData;
+  loading?: boolean;
 
+  meta: MetaData;
   onConfigChange?: (config: LobeAgentConfig) => void;
   onMetaChange?: (meta: MetaData) => void;
 }

package/src/hooks/useInterceptingRoutes.test.ts

@@ -43,7 +43,7 @@ describe('useOpenChatSettings', () => {
     vi.mocked(useSessionStore).mockReturnValue('123');
     vi.mocked(useIsMobile).mockReturnValue(true);
     const { result } = renderHook(() => useOpenChatSettings(ChatSettingsTabs.Meta));
-    expect(result.current()).toBe('/chat/settings');
+    expect(result.current()).toBe('/chat/settings?session=123');
   });
 
   it('should handle desktop route for chat settings with session and tab', () => {

package/src/hooks/useInterceptingRoutes.ts

@@ -20,7 +20,7 @@ export const useOpenChatSettings = (tab: ChatSettingsTabs = ChatSettingsTabs.Met
       return () => router.push(urlJoin('/settings', SettingsTabs.Agent));
     }
 
-    if (isMobile) return () => router.push('/chat/settings');
+    if (isMobile) return () => router.push('/chat/settings', { query: { session: activeId } });
 
     return () => {
       useAgentStore.setState({ showAgentSetting: true });

package/src/layout/GlobalProvider/StoreInitialization.tsx

@@ -32,7 +32,7 @@ const StoreInitialization = memo(() => {
 
   const useInitSystemStatus = useGlobalStore((s) => s.useInitSystemStatus);
 
-  const useInitAgentStore = useAgentStore((s) => s.useInitAgentStore);
+  const useInitAgentStore = useAgentStore((s) => s.useInitInboxAgentStore);
   const useInitAiProviderKeyVaults = useAiInfraStore((s) => s.useFetchAiProviderRuntimeState);
 
   // init the system preference

package/src/libs/agent-runtime/AgentRuntime.ts

@@ -7,6 +7,7 @@ import { LobeAi21AI } from './ai21';
 import { LobeAi360AI } from './ai360';
 import { LobeAnthropicAI } from './anthropic';
 import { LobeAzureOpenAI } from './azureOpenai';
+import { LobeAzureAI } from './azureai';
 import { LobeBaichuanAI } from './baichuan';
 import { LobeBedrockAI, LobeBedrockAIParams } from './bedrock';
 import { LobeCloudflareAI, LobeCloudflareParams } from './cloudflare';
@@ -141,6 +142,7 @@ class AgentRuntime {
       ai360: Partial<ClientOptions>;
       anthropic: Partial<ClientOptions>;
       azure: { apiKey?: string; apiVersion?: string; baseURL?: string };
+      azureai: { apiKey?: string; apiVersion?: string; baseURL?: string };
       baichuan: Partial<ClientOptions>;
       bedrock: Partial<LobeBedrockAIParams>;
       cloudflare: Partial<LobeCloudflareParams>;
@@ -201,6 +203,11 @@ class AgentRuntime {
         break;
       }
 
+      case ModelProvider.AzureAI: {
+        runtimeModel = new LobeAzureAI(params.azureai);
+        break;
+      }
+
       case ModelProvider.ZhiPu: {
         runtimeModel = new LobeZhipuAI(params.zhipu);
         break;
@@ -307,7 +314,7 @@ class AgentRuntime {
       }
 
       case ModelProvider.Novita: {
-        runtimeModel = new LobeNovitaAI(params.novita ?? {});
+        runtimeModel = new LobeNovitaAI(params.novita);
         break;
       }
 
@@ -317,7 +324,7 @@ class AgentRuntime {
       }
 
       case ModelProvider.Baichuan: {
-        runtimeModel = new LobeBaichuanAI(params.baichuan ?? {});
+        runtimeModel = new LobeBaichuanAI(params.baichuan);
         break;
       }
 
@@ -327,12 +334,12 @@ class AgentRuntime {
       }
 
       case ModelProvider.Ai360: {
-        runtimeModel = new LobeAi360AI(params.ai360 ?? {});
+        runtimeModel = new LobeAi360AI(params.ai360);
         break;
       }
 
       case ModelProvider.SiliconCloud: {
-        runtimeModel = new LobeSiliconCloudAI(params.siliconcloud ?? {});
+        runtimeModel = new LobeSiliconCloudAI(params.siliconcloud);
         break;
       }
 
@@ -372,12 +379,12 @@ class AgentRuntime {
       }
 
       case ModelProvider.Jina: {
-        runtimeModel = new LobeJinaAI(params.jina ?? {});
+        runtimeModel = new LobeJinaAI(params.jina);
         break;
       }
 
       case ModelProvider.Cloudflare: {
-        runtimeModel = new LobeCloudflareAI(params.cloudflare ?? {});
+        runtimeModel = new LobeCloudflareAI(params.cloudflare);
         break;
       }
 

package/src/libs/agent-runtime/azureai/index.ts

@@ -0,0 +1,109 @@
+import createClient, { ModelClient } from '@azure-rest/ai-inference';
+import { AzureKeyCredential } from '@azure/core-auth';
+import OpenAI from 'openai';
+
+import { LobeRuntimeAI } from '../BaseAI';
+import { AgentRuntimeErrorType } from '../error';
+import { ChatCompetitionOptions, ChatStreamPayload, ModelProvider } from '../types';
+import { AgentRuntimeError } from '../utils/createError';
+import { debugStream } from '../utils/debugStream';
+import { transformResponseToStream } from '../utils/openaiCompatibleFactory';
+import { StreamingResponse } from '../utils/response';
+import { OpenAIStream, createSSEDataExtractor } from '../utils/streams';
+
+export class LobeAzureAI implements LobeRuntimeAI {
+  client: ModelClient;
+
+  constructor(params?: { apiKey?: string; apiVersion?: string; baseURL?: string }) {
+    if (!params?.apiKey || !params?.baseURL)
+      throw AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidProviderAPIKey);
+
+    this.client = createClient(params?.baseURL, new AzureKeyCredential(params?.apiKey));
+
+    this.baseURL = params?.baseURL;
+  }
+
+  baseURL: string;
+
+  async chat(payload: ChatStreamPayload, options?: ChatCompetitionOptions) {
+    const { messages, model, ...params } = payload;
+    // o1 series models on Azure OpenAI does not support streaming currently
+    const enableStreaming = model.includes('o1') ? false : (params.stream ?? true);
+    try {
+      const response = this.client.path('/chat/completions').post({
+        body: {
+          messages: messages as OpenAI.ChatCompletionMessageParam[],
+          model,
+          ...params,
+          stream: enableStreaming,
+          tool_choice: params.tools ? 'auto' : undefined,
+        },
+      });
+
+      if (enableStreaming) {
+        const stream = await response.asBrowserStream();
+
+        const [prod, debug] = stream.body!.tee();
+
+        if (process.env.DEBUG_AZURE_AI_CHAT_COMPLETION === '1') {
+          debugStream(debug).catch(console.error);
+        }
+
+        return StreamingResponse(
+          OpenAIStream(prod.pipeThrough(createSSEDataExtractor()), {
+            callbacks: options?.callback,
+          }),
+          {
+            headers: options?.headers,
+          },
+        );
+      } else {
+        const res = await response;
+
+        // the azure AI inference response is openai compatible
+        const stream = transformResponseToStream(res.body as OpenAI.ChatCompletion);
+        return StreamingResponse(OpenAIStream(stream, { callbacks: options?.callback }), {
+          headers: options?.headers,
+        });
+      }
+    } catch (e) {
+      let error = e as { [key: string]: any; code: string; message: string };
+
+      if (error.code) {
+        switch (error.code) {
+          case 'DeploymentNotFound': {
+            error = { ...error, deployId: model };
+          }
+        }
+      } else {
+        error = {
+          cause: error.cause,
+          message: error.message,
+          name: error.name,
+        } as any;
+      }
+
+      const errorType = error.code
+        ? AgentRuntimeErrorType.ProviderBizError
+        : AgentRuntimeErrorType.AgentRuntimeError;
+
+      throw AgentRuntimeError.chat({
+        endpoint: this.maskSensitiveUrl(this.baseURL),
+        error,
+        errorType,
+        provider: ModelProvider.Azure,
+      });
+    }
+  }
+
+  private maskSensitiveUrl = (url: string) => {
+    // 使用正则表达式匹配 'https://' 后面和 '.azure.com/' 前面的内容
+    const regex = /^(https:\/\/)([^.]+)(\.azure\.com\/.*)$/;
+
+    // 使用替换函数
+    return url.replace(regex, (match, protocol, subdomain, rest) => {
+      // 将子域名替换为 '***'
+      return `${protocol}***${rest}`;
+    });
+  };
+}

package/src/libs/agent-runtime/baichuan/index.test.ts

@@ -1,255 +1,13 @@
 // @vitest-environment node
-import OpenAI from 'openai';
-import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ModelProvider } from '@/libs/agent-runtime';
 
-import {
-  ChatStreamCallbacks,
-  LobeOpenAICompatibleRuntime,
-  ModelProvider,
-} from '@/libs/agent-runtime';
-
-import * as debugStreamModule from '../utils/debugStream';
+import { testProvider } from '../providerTestUtils';
 import { LobeBaichuanAI } from './index';
 
-const provider = ModelProvider.Baichuan;
-const defaultBaseURL = 'https://api.baichuan-ai.com/v1';
-
-const bizErrorType = 'ProviderBizError';
-const invalidErrorType = 'InvalidProviderAPIKey';
-
-// Mock the console.error to avoid polluting test output
-vi.spyOn(console, 'error').mockImplementation(() => {});
-
-let instance: LobeOpenAICompatibleRuntime;
-
-beforeEach(() => {
-  instance = new LobeBaichuanAI({ apiKey: 'test' });
-
-  // 使用 vi.spyOn 来模拟 chat.completions.create 方法
-  vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
-    new ReadableStream() as any,
-  );
-});
-
-afterEach(() => {
-  vi.clearAllMocks();
-});
-
-describe('LobeBaichuanAI', () => {
-  describe('init', () => {
-    it('should correctly initialize with an API key', async () => {
-      const instance = new LobeBaichuanAI({ apiKey: 'test_api_key' });
-      expect(instance).toBeInstanceOf(LobeBaichuanAI);
-      expect(instance.baseURL).toEqual(defaultBaseURL);
-    });
-  });
-
-  describe('chat', () => {
-    describe('Error', () => {
-      it('should return OpenAIBizError with an openai error response when OpenAI.APIError is thrown', async () => {
-        // Arrange
-        const apiError = new OpenAI.APIError(
-          400,
-          {
-            status: 400,
-            error: {
-              message: 'Bad Request',
-            },
-          },
-          'Error message',
-          {},
-        );
-
-        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
-
-        // Act
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'Baichuan4',
-            temperature: 0,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: defaultBaseURL,
-            error: {
-              error: { message: 'Bad Request' },
-              status: 400,
-            },
-            errorType: bizErrorType,
-            provider,
-          });
-        }
-      });
-
-      it('should throw AgentRuntimeError with NoOpenAIAPIKey if no apiKey is provided', async () => {
-        try {
-          new LobeBaichuanAI({});
-        } catch (e) {
-          expect(e).toEqual({ errorType: invalidErrorType });
-        }
-      });
-
-      it('should return OpenAIBizError with the cause when OpenAI.APIError is thrown with cause', async () => {
-        // Arrange
-        const errorInfo = {
-          stack: 'abc',
-          cause: {
-            message: 'api is undefined',
-          },
-        };
-        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: 'Baichuan4',
-            temperature: 0,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: defaultBaseURL,
-            error: {
-              cause: { message: 'api is undefined' },
-              stack: 'abc',
-            },
-            errorType: bizErrorType,
-            provider,
-          });
-        }
-      });
-
-      it('should return OpenAIBizError with an cause response with desensitize Url', async () => {
-        // Arrange
-        const errorInfo = {
-          stack: 'abc',
-          cause: { message: 'api is undefined' },
-        };
-        const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
-
-        instance = new LobeBaichuanAI({
-          apiKey: 'test',
-
-          baseURL: 'https://api.abc.com/v1',
-        });
-
-        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
-
-        // Act
-        try {
-          await instance.chat({
-            messages: [{ content: 'Hello', role: 'user' }],
-            model: 'Baichuan4',
-            temperature: 0,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: 'https://api.***.com/v1',
-            error: {
-              cause: { message: 'api is undefined' },
-              stack: 'abc',
-            },
-            errorType: bizErrorType,
-            provider,
-          });
-        }
-      });
-
-      it('should throw an InvalidBaichuanAPIKey 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: 'Baichuan4',
-            temperature: 0,
-          });
-        } catch (e) {
-          // Expect the chat method to throw an error with InvalidBaichuanAPIKey
-          expect(e).toEqual({
-            endpoint: defaultBaseURL,
-            error: new Error('Unauthorized'),
-            errorType: invalidErrorType,
-            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: 'Baichuan4',
-            temperature: 0,
-          });
-        } catch (e) {
-          expect(e).toEqual({
-            endpoint: defaultBaseURL,
-            errorType: 'AgentRuntimeError',
-            provider,
-            error: {
-              name: genericError.name,
-              cause: genericError.cause,
-              message: genericError.message,
-              stack: genericError.stack,
-            },
-          });
-        }
-      });
-    });
-
-    describe('DEBUG', () => {
-      it('should call debugStream and return StreamingTextResponse when DEBUG_BAICHUAN_CHAT_COMPLETION is 1', async () => {
-        // Arrange
-        const mockProdStream = new ReadableStream() as any; // 模拟的 prod 流
-        const mockDebugStream = new ReadableStream({
-          start(controller) {
-            controller.enqueue('Debug stream content');
-            controller.close();
-          },
-        }) as any;
-        mockDebugStream.toReadableStream = () => mockDebugStream; // 添加 toReadableStream 方法
-
-        // 模拟 chat.completions.create 返回值，包括模拟的 tee 方法
-        (instance['client'].chat.completions.create as Mock).mockResolvedValue({
-          tee: () => [mockProdStream, { toReadableStream: () => mockDebugStream }],
-        });
-
-        // 保存原始环境变量值
-        const originalDebugValue = process.env.DEBUG_BAICHUAN_CHAT_COMPLETION;
-
-        // 模拟环境变量
-        process.env.DEBUG_BAICHUAN_CHAT_COMPLETION = '1';
-        vi.spyOn(debugStreamModule, 'debugStream').mockImplementation(() => Promise.resolve());
-
-        // 执行测试
-        // 运行你的测试函数，确保它会在条件满足时调用 debugStream
-        // 假设的测试函数调用，你可能需要根据实际情况调整
-        await instance.chat({
-          messages: [{ content: 'Hello', role: 'user' }],
-          model: 'Baichuan4',
-          stream: true,
-          temperature: 0,
-        });
-
-        // 验证 debugStream 被调用
-        expect(debugStreamModule.debugStream).toHaveBeenCalled();
-
-        // 恢复原始环境变量值
-        process.env.DEBUG_BAICHUAN_CHAT_COMPLETION = originalDebugValue;
-      });
-    });
-  });
+testProvider({
+  Runtime: LobeBaichuanAI,
+  provider: ModelProvider.Baichuan,
+  defaultBaseURL: 'https://api.baichuan-ai.com/v1',
+  chatDebugEnv: 'DEBUG_BAICHUAN_CHAT_COMPLETION',
+  chatModel: 'hunyuan-lite',
 });

package/src/libs/agent-runtime/cloudflare/index.ts

@@ -1,3 +1,5 @@
+import { ChatModelCard } from '@/types/llm';
+
 import { LobeRuntimeAI } from '../BaseAI';
 import { AgentRuntimeErrorType } from '../error';
 import { ChatCompetitionOptions, ChatStreamPayload, ModelProvider } from '../types';
@@ -12,8 +14,6 @@ import { debugStream } from '../utils/debugStream';
 import { StreamingResponse } from '../utils/response';
 import { createCallbacksTransformer } from '../utils/streams';
 
-import { ChatModelCard } from '@/types/llm';
-
 export interface CloudflareModelCard {
   description: string;
   name: string;
@@ -34,7 +34,7 @@ export class LobeCloudflareAI implements LobeRuntimeAI {
   accountID: string;
   apiKey?: string;
 
-  constructor({ apiKey, baseURLOrAccountID }: LobeCloudflareParams) {
+  constructor({ apiKey, baseURLOrAccountID }: LobeCloudflareParams = {}) {
     if (!baseURLOrAccountID) {
       throw AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidProviderAPIKey);
     }
@@ -128,30 +128,34 @@ export class LobeCloudflareAI implements LobeRuntimeAI {
 
     return modelList
       .map((model) => {
-        const knownModel = LOBE_DEFAULT_MODEL_LIST.find((m) => model.name.toLowerCase() === m.id.toLowerCase());
+        const knownModel = LOBE_DEFAULT_MODEL_LIST.find(
+          (m) => model.name.toLowerCase() === m.id.toLowerCase(),
+        );
 
         return {
           contextWindowTokens: model.properties?.max_total_tokens
             ? Number(model.properties.max_total_tokens)
-            : knownModel?.contextWindowTokens ?? undefined,
-          displayName: knownModel?.displayName ?? (model.properties?.["beta"] === "true" ? `${model.name} (Beta)` : undefined),
+            : (knownModel?.contextWindowTokens ?? undefined),
+          displayName:
+            knownModel?.displayName ??
+            (model.properties?.['beta'] === 'true' ? `${model.name} (Beta)` : undefined),
           enabled: knownModel?.enabled || false,
           functionCall:
-            model.description.toLowerCase().includes('function call')
-            || model.properties?.["function_calling"] === "true"
-            || knownModel?.abilities?.functionCall
-            || false,
+            model.description.toLowerCase().includes('function call') ||
+            model.properties?.['function_calling'] === 'true' ||
+            knownModel?.abilities?.functionCall ||
+            false,
           id: model.name,
           reasoning:
-            model.name.toLowerCase().includes('deepseek-r1')
-            || knownModel?.abilities?.reasoning
-            || false,
+            model.name.toLowerCase().includes('deepseek-r1') ||
+            knownModel?.abilities?.reasoning ||
+            false,
           vision:
-            model.name.toLowerCase().includes('vision')
-            || model.task?.name.toLowerCase().includes('image-to-text')
-            || model.description.toLowerCase().includes('vision')
-            || knownModel?.abilities?.vision
-            || false,
+            model.name.toLowerCase().includes('vision') ||
+            model.task?.name.toLowerCase().includes('image-to-text') ||
+            model.description.toLowerCase().includes('vision') ||
+            knownModel?.abilities?.vision ||
+            false,
         };
       })
       .filter(Boolean) as ChatModelCard[];

package/src/libs/agent-runtime/index.ts

@@ -1,5 +1,6 @@
 export { default as AgentRuntime } from './AgentRuntime';
 export { LobeAnthropicAI } from './anthropic';
+export { LobeAzureAI } from './azureai';
 export { LobeAzureOpenAI } from './azureOpenai';
 export * from './BaseAI';
 export { LobeBedrockAI } from './bedrock';

package/src/libs/agent-runtime/types/type.ts

@@ -26,6 +26,7 @@ export enum ModelProvider {
   Ai360 = 'ai360',
   Anthropic = 'anthropic',
   Azure = 'azure',
+  AzureAI = 'azureai',
   Baichuan = 'baichuan',
   Bedrock = 'bedrock',
   Cloudflare = 'cloudflare',