@lobehub/chat 1.23.0 → 1.24.0

package/src/features/Conversation/Error/APIKeyForm/SenseNova.tsx

@@ -0,0 +1,49 @@
+import { SenseNova } from '@lobehub/icons';
+import { Input } from 'antd';
+import { memo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { ModelProvider } from '@/libs/agent-runtime';
+import { useUserStore } from '@/store/user';
+import { keyVaultsConfigSelectors } from '@/store/user/selectors';
+
+import { FormAction } from '../style';
+
+const SenseNovaForm = memo(() => {
+  const { t } = useTranslation('modelProvider');
+
+  const [sensenovaAccessKeyID, sensenovaAccessKeySecret, setConfig] = useUserStore((s) => [
+    keyVaultsConfigSelectors.sensenovaConfig(s).sensenovaAccessKeyID,
+    keyVaultsConfigSelectors.sensenovaConfig(s).sensenovaAccessKeySecret,
+    s.updateKeyVaultConfig,
+  ]);
+
+  return (
+    <FormAction
+      avatar={<SenseNova color={SenseNova.colorPrimary} size={56} />}
+      description={t('sensenova.unlock.description')}
+      title={t('sensenova.unlock.title')}
+    >
+      <Input.Password
+        autoComplete={'new-password'}
+        onChange={(e) => {
+          setConfig(ModelProvider.SenseNova, { sensenovaAccessKeyID: e.target.value });
+        }}
+        placeholder={t('sensenova.sensenovaAccessKeyID.placeholder')}
+        type={'block'}
+        value={sensenovaAccessKeyID}
+      />
+      <Input.Password
+        autoComplete={'new-password'}
+        onChange={(e) => {
+          setConfig(ModelProvider.SenseNova, { sensenovaAccessKeySecret: e.target.value });
+        }}
+        placeholder={t('sensenova.sensenovaAccessKeySecret.placeholder')}
+        type={'block'}
+        value={sensenovaAccessKeySecret}
+      />
+    </FormAction>
+  );
+});
+
+export default SenseNovaForm;

package/src/features/Conversation/Error/APIKeyForm/index.tsx

@@ -10,6 +10,7 @@ import { GlobalLLMProviderKey } from '@/types/user/settings';
 
 import BedrockForm from './Bedrock';
 import ProviderApiKeyForm from './ProviderApiKeyForm';
+import SenseNovaForm from './SenseNova';
 import WenxinForm from './Wenxin';
 
 interface APIKeyFormProps {
@@ -66,6 +67,8 @@ const APIKeyForm = memo<APIKeyFormProps>(({ id, provider }) => {
     <Center gap={16} style={{ maxWidth: 300 }}>
       {provider === ModelProvider.Bedrock ? (
         <BedrockForm />
+      ) : provider === ModelProvider.SenseNova ? (
+        <SenseNovaForm />
       ) : provider === ModelProvider.Wenxin ? (
         <WenxinForm />
       ) : (

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

@@ -25,6 +25,7 @@ import { LobeOpenAI } from './openai';
 import { LobeOpenRouterAI } from './openrouter';
 import { LobePerplexityAI } from './perplexity';
 import { LobeQwenAI } from './qwen';
+import { LobeSenseNovaAI } from './sensenova';
 import { LobeSiliconCloudAI } from './siliconcloud';
 import { LobeSparkAI } from './spark';
 import { LobeStepfunAI } from './stepfun';
@@ -146,6 +147,7 @@ class AgentRuntime {
       openrouter: Partial<ClientOptions>;
       perplexity: Partial<ClientOptions>;
       qwen: Partial<ClientOptions>;
+      sensenova: Partial<ClientOptions>;
       siliconcloud: Partial<ClientOptions>;
       spark: Partial<ClientOptions>;
       stepfun: Partial<ClientOptions>;
@@ -314,6 +316,11 @@ class AgentRuntime {
         runtimeModel = new LobeHunyuanAI(params.hunyuan);
         break;
       }
+
+      case ModelProvider.SenseNova: {
+        runtimeModel = await LobeSenseNovaAI.fromAPIKey(params.sensenova);
+        break;
+      }
     }
 
     return new AgentRuntime(runtimeModel);

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

@@ -15,6 +15,7 @@ export { LobeOpenAI } from './openai';
 export { LobeOpenRouterAI } from './openrouter';
 export { LobePerplexityAI } from './perplexity';
 export { LobeQwenAI } from './qwen';
+export { LobeSenseNovaAI } from './sensenova';
 export { LobeTogetherAI } from './togetherai';
 export * from './types';
 export { AgentRuntimeError } from './utils/createError';

package/src/libs/agent-runtime/sensenova/authToken.test.ts

@@ -0,0 +1,18 @@
+// @vitest-environment node
+import { generateApiToken } from './authToken';
+
+describe('generateApiToken', () => {
+  it('should throw an error if no apiKey is provided', async () => {
+    await expect(generateApiToken()).rejects.toThrow('Invalid apiKey');
+  });
+
+  it('should throw an error if apiKey is invalid', async () => {
+    await expect(generateApiToken('invalid')).rejects.toThrow('Invalid apiKey');
+  });
+
+  it('should return a token if a valid apiKey is provided', async () => {
+    const apiKey = 'id:secret';
+    const token = await generateApiToken(apiKey);
+    expect(token).toBeDefined();
+  });
+});

package/src/libs/agent-runtime/sensenova/authToken.ts

@@ -0,0 +1,27 @@
+import { SignJWT } from 'jose';
+
+// https://console.sensecore.cn/help/docs/model-as-a-service/nova/overview/Authorization
+export const generateApiToken = async (apiKey?: string): Promise<string> => {
+  if (!apiKey) {
+    throw new Error('Invalid apiKey');
+  }
+
+  const [id, secret] = apiKey.split(':');
+  if (!id || !secret) {
+    throw new Error('Invalid apiKey');
+  }
+
+  const currentTime = Math.floor(Date.now() / 1000);
+
+  const payload = {
+    exp: currentTime + 1800,
+    iss: id,
+    nbf: currentTime - 5,
+  };
+
+  const jwt = await new SignJWT(payload)
+    .setProtectedHeader({ alg: 'HS256', typ: 'JWT' })
+    .sign(new TextEncoder().encode(secret));
+
+  return jwt;
+};

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

@@ -0,0 +1,321 @@
+// @vitest-environment node
+import { OpenAI } from 'openai';
+import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { ChatStreamCallbacks, LobeOpenAI } from '@/libs/agent-runtime';
+import * as debugStreamModule from '@/libs/agent-runtime/utils/debugStream';
+
+import * as authTokenModule from './authToken';
+import { LobeSenseNovaAI } from './index';
+
+const bizErrorType = 'ProviderBizError';
+const invalidErrorType = 'InvalidProviderAPIKey';
+
+// Mock相关依赖
+vi.mock('./authToken');
+
+describe('LobeSenseNovaAI', () => {
+  beforeEach(() => {
+    // Mock generateApiToken
+    vi.spyOn(authTokenModule, 'generateApiToken').mockResolvedValue('mocked_token');
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('fromAPIKey', () => {
+    it('should correctly initialize with an API key', async () => {
+      const lobeSenseNovaAI = await LobeSenseNovaAI.fromAPIKey({ apiKey: 'test_api_key' });
+      expect(lobeSenseNovaAI).toBeInstanceOf(LobeSenseNovaAI);
+      expect(lobeSenseNovaAI.baseURL).toEqual('https://api.sensenova.cn/compatible-mode/v1');
+    });
+
+    it('should throw an error if API key is invalid', async () => {
+      vi.spyOn(authTokenModule, 'generateApiToken').mockRejectedValue(new Error('Invalid API Key'));
+      try {
+        await LobeSenseNovaAI.fromAPIKey({ apiKey: 'asd' });
+      } catch (e) {
+        expect(e).toEqual({ errorType: invalidErrorType });
+      }
+    });
+  });
+
+  describe('chat', () => {
+    let instance: LobeSenseNovaAI;
+
+    beforeEach(async () => {
+      instance = await LobeSenseNovaAI.fromAPIKey({
+        apiKey: 'test_api_key',
+      });
+
+      // Mock chat.completions.create
+      vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
+        new ReadableStream() as any,
+      );
+    });
+
+    it('should return a StreamingTextResponse on successful API call', async () => {
+      const result = await instance.chat({
+        messages: [{ content: 'Hello', role: 'user' }],
+        model: 'SenseChat',
+        temperature: 0,
+      });
+      expect(result).toBeInstanceOf(Response);
+    });
+
+    it('should handle callback and headers correctly', async () => {
+      // 模拟 chat.completions.create 方法返回一个可读流
+      const mockCreateMethod = vi
+        .spyOn(instance['client'].chat.completions, 'create')
+        .mockResolvedValue(
+          new ReadableStream({
+            start(controller) {
+              controller.enqueue({
+                id: 'chatcmpl-8xDx5AETP8mESQN7UB30GxTN2H1SO',
+                object: 'chat.completion.chunk',
+                created: 1709125675,
+                model: 'gpt-3.5-turbo-0125',
+                system_fingerprint: 'fp_86156a94a0',
+                choices: [
+                  { index: 0, delta: { content: 'hello' }, logprobs: null, finish_reason: null },
+                ],
+              });
+              controller.close();
+            },
+          }) as any,
+        );
+
+      // 准备 callback 和 headers
+      const mockCallback: ChatStreamCallbacks = {
+        onStart: vi.fn(),
+        onToken: vi.fn(),
+      };
+      const mockHeaders = { 'Custom-Header': 'TestValue' };
+
+      // 执行测试
+      const result = await instance.chat(
+        {
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'SenseChat',
+          temperature: 0,
+        },
+        { callback: mockCallback, headers: mockHeaders },
+      );
+
+      // 验证 callback 被调用
+      await result.text(); // 确保流被消费
+
+      // 验证 headers 被正确传递
+      expect(result.headers.get('Custom-Header')).toEqual('TestValue');
+
+      // 清理
+      mockCreateMethod.mockRestore();
+    });
+
+    it('should transform messages correctly', async () => {
+      const spyOn = vi.spyOn(instance['client'].chat.completions, 'create');
+
+      await instance.chat({
+        frequency_penalty: 0,
+        messages: [
+          { content: 'Hello', role: 'user' },
+          { content: [{ type: 'text', text: 'Hello again' }], role: 'user' },
+        ],
+        model: 'SenseChat',
+        temperature: 0,
+        top_p: 1,
+      });
+
+      const calledWithParams = spyOn.mock.calls[0][0];
+
+      expect(calledWithParams.frequency_penalty).toBeUndefined(); // frequency_penalty 0 should be undefined
+      expect(calledWithParams.messages[1].content).toEqual([{ type: 'text', text: 'Hello again' }]);
+      expect(calledWithParams.temperature).toBeUndefined(); // temperature 0 should be undefined
+      expect(calledWithParams.top_p).toBeUndefined(); // top_p 1 should be undefined
+    });
+
+    describe('Error', () => {
+      it('should return SenseNovaAIBizError 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: 'SenseChat',
+            temperature: 0,
+          });
+        } catch (e) {
+          expect(e).toEqual({
+            endpoint: 'https://api.sensenova.cn/compatible-mode/v1',
+            error: {
+              error: { message: 'Bad Request' },
+              status: 400,
+            },
+            errorType: bizErrorType,
+            provider: 'sensenova',
+          });
+        }
+      });
+
+      it('should throw AgentRuntimeError with NoOpenAIAPIKey if no apiKey is provided', async () => {
+        try {
+          await LobeSenseNovaAI.fromAPIKey({ apiKey: '' });
+        } 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: 'SenseChat',
+            temperature: 0.2,
+          });
+        } catch (e) {
+          expect(e).toEqual({
+            endpoint: 'https://api.sensenova.cn/compatible-mode/v1',
+            error: {
+              cause: { message: 'api is undefined' },
+              stack: 'abc',
+            },
+            errorType: bizErrorType,
+            provider: 'sensenova',
+          });
+        }
+      });
+
+      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 = await LobeSenseNovaAI.fromAPIKey({
+          apiKey: 'test',
+
+          baseURL: 'https://abc.com/v2',
+        });
+
+        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
+
+        // Act
+        try {
+          await instance.chat({
+            messages: [{ content: 'Hello', role: 'user' }],
+            model: 'gpt-3.5-turbo',
+            temperature: 0,
+          });
+        } catch (e) {
+          expect(e).toEqual({
+            endpoint: 'https://***.com/v2',
+            error: {
+              cause: { message: 'api is undefined' },
+              stack: 'abc',
+            },
+            errorType: bizErrorType,
+            provider: 'sensenova',
+          });
+        }
+      });
+
+      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: 'SenseChat',
+            temperature: 0,
+          });
+        } catch (e) {
+          expect(e).toEqual({
+            endpoint: 'https://api.sensenova.cn/compatible-mode/v1',
+            errorType: 'AgentRuntimeError',
+            provider: 'sensenova',
+            error: {
+              name: genericError.name,
+              cause: genericError.cause,
+              message: genericError.message,
+              stack: genericError.stack,
+            },
+          });
+        }
+      });
+    });
+
+    describe('DEBUG', () => {
+      it('should call debugStream and return StreamingTextResponse when DEBUG_OPENAI_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_SENSENOVA_CHAT_COMPLETION;
+
+        // 模拟环境变量
+        process.env.DEBUG_SENSENOVA_CHAT_COMPLETION = '1';
+        vi.spyOn(debugStreamModule, 'debugStream').mockImplementation(() => Promise.resolve());
+
+        // 执行测试
+        // 运行你的测试函数，确保它会在条件满足时调用 debugStream
+        // 假设的测试函数调用，你可能需要根据实际情况调整
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'SenseChat',
+          temperature: 0,
+        });
+
+        // 验证 debugStream 被调用
+        expect(debugStreamModule.debugStream).toHaveBeenCalled();
+
+        // 恢复原始环境变量值
+        process.env.DEBUG_SENSENOVA_CHAT_COMPLETION = originalDebugValue;
+      });
+    });
+  });
+});

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

@@ -0,0 +1,98 @@
+import OpenAI, { ClientOptions } 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 { desensitizeUrl } from '../utils/desensitizeUrl';
+import { handleOpenAIError } from '../utils/handleOpenAIError';
+import { convertOpenAIMessages } from '../utils/openaiHelpers';
+import { StreamingResponse } from '../utils/response';
+import { OpenAIStream } from '../utils/streams';
+import { generateApiToken } from './authToken';
+
+const DEFAULT_BASE_URL = 'https://api.sensenova.cn/compatible-mode/v1';
+
+export class LobeSenseNovaAI implements LobeRuntimeAI {
+  private client: OpenAI;
+
+  baseURL: string;
+
+  constructor(oai: OpenAI) {
+    this.client = oai;
+    this.baseURL = this.client.baseURL;
+  }
+
+  static async fromAPIKey({ apiKey, baseURL = DEFAULT_BASE_URL, ...res }: ClientOptions = {}) {
+    const invalidSenseNovaAPIKey = AgentRuntimeError.createError(
+      AgentRuntimeErrorType.InvalidProviderAPIKey,
+    );
+
+    if (!apiKey) throw invalidSenseNovaAPIKey;
+
+    let token: string;
+
+    try {
+      token = await generateApiToken(apiKey);
+    } catch {
+      throw invalidSenseNovaAPIKey;
+    }
+    
+    const header = { Authorization: `Bearer ${token}` };
+
+    const llm = new OpenAI({ apiKey, baseURL, defaultHeaders: header, ...res });
+
+    return new LobeSenseNovaAI(llm);
+  }
+
+  async chat(payload: ChatStreamPayload, options?: ChatCompetitionOptions) {
+    try {
+      const params = await this.buildCompletionsParams(payload);
+
+      const response = await this.client.chat.completions.create(
+        params as unknown as OpenAI.ChatCompletionCreateParamsStreaming,
+      );
+
+      const [prod, debug] = response.tee();
+
+      if (process.env.DEBUG_SENSENOVA_CHAT_COMPLETION === '1') {
+        debugStream(debug.toReadableStream()).catch(console.error);
+      }
+
+      return StreamingResponse(OpenAIStream(prod), {
+        headers: options?.headers,
+      });
+    } catch (error) {
+      const { errorResult, RuntimeError } = handleOpenAIError(error);
+
+      const errorType = RuntimeError || AgentRuntimeErrorType.ProviderBizError;
+      let desensitizedEndpoint = this.baseURL;
+
+      if (this.baseURL !== DEFAULT_BASE_URL) {
+        desensitizedEndpoint = desensitizeUrl(this.baseURL);
+      }
+      throw AgentRuntimeError.chat({
+        endpoint: desensitizedEndpoint,
+        error: errorResult,
+        errorType,
+        provider: ModelProvider.SenseNova,
+      });
+    }
+  }
+
+  private async buildCompletionsParams(payload: ChatStreamPayload) {
+    const { frequency_penalty, messages, temperature, top_p, ...params } = payload;
+
+    return {
+      messages: await convertOpenAIMessages(messages as any),
+      ...params,
+      frequency_penalty: (frequency_penalty !== undefined && frequency_penalty > 0 && frequency_penalty <= 2) ? frequency_penalty : undefined,
+      stream: true,
+      temperature: (temperature !== undefined && temperature > 0 && temperature <= 2) ? temperature : undefined,
+      top_p: (top_p !== undefined && top_p > 0 && top_p < 1) ? top_p : undefined,
+    };
+  }
+}
+
+export default LobeSenseNovaAI;

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

@@ -44,6 +44,7 @@ export enum ModelProvider {
   OpenRouter = 'openrouter',
   Perplexity = 'perplexity',
   Qwen = 'qwen',
+  SenseNova = 'sensenova',
   SiliconCloud = 'siliconcloud',
   Spark = 'spark',
   Stepfun = 'stepfun',

package/src/locales/default/modelProvider.ts

@@ -122,6 +122,23 @@ export default {
       title: '下载指定的 Ollama 模型',
     },
   },
+  sensenova: {
+    sensenovaAccessKeyID: {
+      desc: '填入 SenseNova Access Key ID',
+      placeholder: 'SenseNova Access Key ID',
+      title: 'Access Key ID',
+    },
+    sensenovaAccessKeySecret: {
+      desc: '填入 SenseNova Access Key Secret',
+      placeholder: 'SenseNova Access Key Secret',
+      title: 'Access Key Secret',
+    },
+    unlock: {
+      description:
+        '输入你的 Access Key ID / Access Key Secret 即可开始会话。应用不会记录你的鉴权配置',
+      title: '使用自定义 SenseNova 鉴权信息',
+    },
+  },
   wenxin: {
     accessKey: {
       desc: '填入百度千帆平台的 Access Key',