gitlab-ai-review 4.2.3 → 6.3.9

package/lib/ai-client.js

@@ -1,30 +1,75 @@
 /**
- * AI 客户端 - 基于 ARK API (豆包大模型)
- * 只负责调用 AI API，不处理业务逻辑
+ * AI 客户端 - 基于 LangChain ChatOpenAI (WPS LLM Proxy)
+ * 使用 @langchain/openai 实现
  */
 
-import OpenAI from 'openai';
+import { ChatOpenAI } from '@langchain/openai';
+import { HumanMessage, SystemMessage, AIMessage } from '@langchain/core/messages';
 
 /**
- * AI 客户端类 - 纯粹的 API 调用封装
+ * AI 客户端类 - 基于 LangChain ChatOpenAI
  */
 export class AIClient {
   constructor(config = {}) {
     const apiKey = config.apiKey || process.env.ARK_API_KEY;
-    const baseURL = config.baseURL || 'https://ark.cn-beijing.volces.com/api/v3';
-    const model = config.model || 'doubao-seed-1-6-251015';
+    const baseURL = config.baseURL || process.env.WPS_BASE_URL;
+    const model = config.model || '643045305/doubao/Doubao-Seed-1.6//public';
+    const userId = config.userId || process.env.WPS_USER_ID;
 
     if (!apiKey) {
       throw new Error('ARK_API_KEY 未配置');
     }
 
-    this.openai = new OpenAI({
-      apiKey,
-      baseURL,
-    });
+    if (!baseURL) {
+      throw new Error('WPS_BASE_URL 未配置');
+    }
+
+    if (!userId) {
+      throw new Error('WPS_USER_ID 未配置');
+    }
 
+    this.apiKey = apiKey;
+    this.baseURL = baseURL;
     this.model = model;
+    this.userId = userId;
     this.config = config;
+
+    // 创建 ChatOpenAI 实例
+    this.chatModel = new ChatOpenAI({
+      model: this.model,
+      temperature: config.temperature || 0.7,
+      openAIApiKey: this.apiKey,
+      configuration: {
+        baseURL: this.baseURL,
+        defaultHeaders: {
+          'X-WPS-User-ID': this.userId,
+          'X-Api-Key': this.apiKey,
+        },
+      },
+    });
+  }
+
+  /**
+   * 将消息数组转换为 LangChain 消息格式
+   * @param {Array|string} prompt - 消息数组或单个提示词
+   * @returns {Array} LangChain 消息数组
+   */
+  _convertToLangChainMessages(prompt) {
+    if (typeof prompt === 'string') {
+      return [new HumanMessage(prompt)];
+    }
+
+    return prompt.map((msg) => {
+      switch (msg.role) {
+        case 'system':
+          return new SystemMessage(msg.content);
+        case 'assistant':
+          return new AIMessage(msg.content);
+        case 'user':
+        default:
+          return new HumanMessage(msg.content);
+      }
+    });
   }
 
   /**
@@ -34,24 +79,39 @@ export class AIClient {
    * @returns {Promise<Object>} AI 响应
    */
   async sendMessage(prompt, options = {}) {
-    // 如果传入的是字符串，转换为消息数组
-    const messages = typeof prompt === 'string' 
-      ? [{ role: 'user', content: prompt }]
-      : prompt;
-
-    const completion = await this.openai.chat.completions.create({
-      messages,
-      model: options.model || this.model,
-      reasoning_effort: options.reasoningEffort || this.config.reasoningEffort || 'medium',
-      ...options,
-    });
+    try {
+      const messages = this._convertToLangChainMessages(prompt);
+
+      // 如果有特定选项，创建临时模型实例
+      let model = this.chatModel;
+      if (options.model || options.temperature !== undefined || options.seed !== undefined) {
+        model = new ChatOpenAI({
+          model: options.model || this.model,
+          temperature: options.temperature ?? 0.7,
+          openAIApiKey: this.apiKey,
+          configuration: {
+            baseURL: this.baseURL,
+            defaultHeaders: {
+              'X-WPS-User-ID': this.userId,
+              'X-Api-Key': this.apiKey,
+            },
+          },
+          modelKwargs: options.seed ? { seed: options.seed } : undefined,
+        });
+      }
 
-    return {
-      reasoning: completion.choices[0]?.message?.reasoning_content || '',
-      content: completion.choices[0]?.message?.content || '',
-      usage: completion.usage,
-      raw: completion,
-    };
+      const response = await model.invoke(messages);
+
+      return {
+        reasoning: response.additional_kwargs?.reasoning_content || '',
+        content: response.content || '',
+        usage: response.response_metadata?.usage || {},
+        raw: response,
+      };
+    } catch (error) {
+      console.error('AI 调用失败:', error);
+      throw error;
+    }
   }
 
   /**
@@ -62,59 +122,83 @@ export class AIClient {
    * @returns {Promise<Object>} 完整 AI 响应
    */
   async sendMessageStream(prompt, onChunk, options = {}) {
-    // 如果传入的是字符串，转换为消息数组
-    const messages = typeof prompt === 'string' 
-      ? [{ role: 'user', content: prompt }]
-      : prompt;
-
-    const stream = await this.openai.chat.completions.create({
-      messages,
-      model: options.model || this.model,
-      reasoning_effort: options.reasoningEffort || this.config.reasoningEffort || 'medium',
-      stream: true,
-      ...options,
-    });
+    try {
+      const messages = this._convertToLangChainMessages(prompt);
+
+      // 如果有特定选项，创建临时模型实例
+      let model = this.chatModel;
+      if (options.model || options.temperature !== undefined || options.seed !== undefined) {
+        model = new ChatOpenAI({
+          model: options.model || this.model,
+          temperature: options.temperature ?? 0.7,
+          openAIApiKey: this.apiKey,
+          configuration: {
+            baseURL: this.baseURL,
+            defaultHeaders: {
+              'X-WPS-User-ID': this.userId,
+              'X-Api-Key': this.apiKey,
+            },
+          },
+          modelKwargs: options.seed ? { seed: options.seed } : undefined,
+        });
+      }
+
+      let fullReasoning = '';
+      let fullContent = '';
 
-    let fullReasoning = '';
-    let fullContent = '';
+      // 使用流式调用
+      const stream = await model.stream(messages);
 
-    for await (const part of stream) {
-      const reasoning = part.choices[0]?.delta?.reasoning_content || '';
-      const content = part.choices[0]?.delta?.content || '';
+      for await (const chunk of stream) {
+        const reasoning = chunk.additional_kwargs?.reasoning_content || '';
+        const content = chunk.content || '';
 
-      fullReasoning += reasoning;
-      fullContent += content;
+        fullReasoning += reasoning;
+        fullContent += content;
 
-      if (onChunk) {
-        onChunk({ reasoning, content });
+        if (onChunk) {
+          onChunk({ reasoning, content });
+        }
       }
+
+      return {
+        reasoning: fullReasoning,
+        content: fullContent,
+      };
+    } catch (error) {
+      console.error('AI 流式调用失败:', error);
+      throw error;
     }
+  }
 
+  /**
+   * 获取当前配置
+   * @returns {Object} 配置对象
+   */
+  getConfig() {
     return {
-      reasoning: fullReasoning,
-      content: fullContent,
+      model: this.model,
+      baseURL: this.baseURL,
+      userId: this.userId,
+      ...this.config,
     };
   }
 
   /**
-   * 获取原始 OpenAI 客户端（高级用法）
-   * @returns {OpenAI} OpenAI 客户端实例
+   * 获取原始客户端（兼容性方法）
+   * @returns {AIClient} 返回自身
    */
   getClient() {
-    return this.openai;
+    return this;
   }
 
   /**
-   * 获取当前配置
-   * @returns {Object} 配置对象
+   * 获取 LangChain ChatOpenAI 实例
+   * @returns {ChatOpenAI} LangChain 模型实例
    */
-  getConfig() {
-    return {
-      model: this.model,
-      ...this.config,
-    };
+  getChatModel() {
+    return this.chatModel;
   }
 }
 
 export default AIClient;
-