doomiaichat 5.1.0 → 6.0.0

package/dist/openaiproxy.js

@@ -0,0 +1,102 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const openai_1 = __importDefault(require("./openai"));
+const axios_1 = __importDefault(require("axios"));
+const ERROR_RESPONSE = ['[AUTHORIZATION NEEDED]', '[AUTHORIZATION ERROR]', '[BODY ERROR]', '[REQUEST ERROR]'];
+class OpenAIProxy extends openai_1.default {
+    constructor(apiKey, proxyOption, apiOption = {}) {
+        super(apiKey, apiOption);
+        this.proxySetting = proxyOption;
+    }
+    /**
+     * 重写chatRequest方法
+     * @param chatText
+     * @param callChatOption
+     * @param axiosOption
+     */
+    chatRequest(chatText, _paramOption, axiosOption) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const opts = Object.assign({ headers: {
+                    'Content-Type': 'application/json',
+                    'authorization': `Bearer ${this.apiKey}`
+                }, method: 'post', url: this.proxySetting.serviceurl, data: {
+                    chatText,
+                    option: _paramOption
+                } }, axiosOption);
+            const requestResult = yield (0, axios_1.default)(opts);
+            return requestResult.data;
+        });
+    }
+    /**
+     * 重写chatRequestInStream方法
+     * @param chatText
+     * @param callChatOption
+     * @param attach
+     * @param axiosOption
+     */
+    chatRequestInStream(chatText, callChatOption, attach, axiosOption) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // const decoder = new TextDecoder();
+            //overContent,
+            let streamText, requestid = Math.ceil(Math.random() * (new Date().getTime() * Math.random()) / 1000);
+            const opts = {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'authorization': `Bearer ${this.apiKey}`
+                },
+                method: 'post',
+                url: this.proxySetting.serviceurl + '/stream',
+                data: {
+                    messages: chatText,
+                    option: callChatOption,
+                    axiosOption
+                },
+                responseType: 'stream',
+            };
+            (0, axios_1.default)(opts)
+                .then(res => {
+                res.data.on('data', (chunk) => {
+                    streamText = chunk.toString(); //decoder.decode(chunk);
+                    if (streamText) {
+                        ///请求的响应发生了错误
+                        if (ERROR_RESPONSE.includes(streamText)) {
+                            return this.emit('requesterror', { successed: false, requestid, error: 'Request Remote OpenAI Error : ' + streamText });
+                        }
+                        ///已经全部结束了
+                        if (streamText === '[END]') {
+                            return this.emit('chatdone', streamText || {});
+                        }
+                        else {
+                            ///持续的文字输出中
+                            try {
+                                //streamText = JSON.parse(streamText);
+                                // overContent = JSON.parse(streamText);
+                                return this.emit('chattext', Object.assign(streamText, attach));
+                            }
+                            catch (errParse) {
+                                return this.emit('chaterror', { successed: false, requestid, error: 'JSON parse stream message', streamText });
+                            }
+                        }
+                    }
+                    return;
+                });
+                //res.data.on('end', () => { this.emit('chatdone', Object.assign(streamText, attach)); });
+            }).catch(err => {
+                this.emit('requesterror', { successed: false, requestid, error: 'Axios Error : ' + err });
+            });
+        });
+    }
+}
+exports.default = OpenAIProxy;

package/dist/stabilityai.d.ts

@@ -1,4 +1,4 @@
-import { ApiResult, AzureOpenAIPatameters } from "./declare";
+import { AzureOpenAIPatameters, StabilityOption, StabilityResult } from "./declare";
 import GptBase from "./gptbase";
 export default class StabilityAI extends GptBase {
     protected readonly apiKey: string;
@@ -16,22 +16,3 @@ export default class StabilityAI extends GptBase {
      */
     chatRequest(chatText: string, paramOption: StabilityOption, axiosOption?: any): Promise<StabilityResult>;
 }
-export interface StabilityOption {
-    'cfg_scale'?: number;
-    'clip_guidance_preset'?: string;
-    'height'?: number;
-    'width'?: number;
-    'samples'?: number;
-    'seed'?: number;
-    'steps'?: number;
-    'sampler'?: string;
-    'negative'?: string;
-    'engine'?: string;
-    'endpoint'?: string;
-    'denoising_strength'?: number;
-    'hr_scale'?: number;
-}
-export interface StabilityResult extends ApiResult {
-    'data'?: any;
-    'type'?: string;
-}

package/dist/stabilityplusai.d.ts

@@ -1,5 +1,9 @@
-import StabilityAI, { StabilityOption, StabilityResult } from "./stabilityai";
-export default class StabilityPlusAI extends StabilityAI {
+import { AzureOpenAIPatameters, StabilityOption, StabilityResult } from "./declare";
+import GptBase from "./gptbase";
+export default class StabilityPlusAI extends GptBase {
+    protected readonly apiKey: string;
+    protected readonly apiOption: StabilityOption;
+    constructor(apiKey: string, _urlOption: AzureOpenAIPatameters, apiOption?: StabilityOption);
     /**
      * 请求Stable作画的接口
      */

package/dist/stabilityplusai.js

@@ -13,8 +13,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const declare_1 = require("./declare");
-const stabilityai_1 = __importDefault(require("./stabilityai"));
-class StabilityPlusAI extends stabilityai_1.default {
+const gptbase_1 = __importDefault(require("./gptbase"));
+class StabilityPlusAI extends gptbase_1.default {
+    constructor(apiKey, _urlOption, apiOption = {}) {
+        super();
+        this.apiKey = apiKey;
+        // this.apiSetting = urlOption;
+        this.apiOption = apiOption;
+        // if (!this.apiSetting.endpoint.toLowerCase().startsWith('http')) {
+        //     this.apiSetting.endpoint = 'https://' + this.apiSetting.endpoint;
+        // }
+    }
     /**
      * 请求Stable作画的接口
      */
@@ -29,7 +38,7 @@ class StabilityPlusAI extends stabilityai_1.default {
                 }
             });
             try {
-                let param = Object.assign(Object.assign({}, axiosOption), { method: "post", url: `${paramOption.endpoint || this.apiSetting.endpoint}/sdapi/v1/txt2img`, data: {
+                const requestOption = Object.assign(Object.assign({}, axiosOption), { method: "POST", data: {
                         "enable_hr": false,
                         "denoising_strength": paramOption.denoising_strength || this.apiOption.denoising_strength || 0.5,
                         "firstphase_width": 0,
@@ -57,23 +66,14 @@ class StabilityPlusAI extends stabilityai_1.default {
                         "tiling": false,
                         "do_not_save_samples": false,
                         "do_not_save_grid": false,
-                        "negative_prompt": paramOption.negative || '',
-                        // "eta": 0,
-                        // "s_churn": 0,
-                        // "s_tmax": 0,
-                        // "s_tmin": 0,
-                        // "s_noise": 1,
-                        // "script_args": [],
-                        // "sampler_index": paramOption.sampler || this.apiOption.sampler || "Euler", //"Euler",
-                        // "send_images": true,
-                        // "save_images": false,
-                        // "alwayson_scripts": {}
-                    } });
-                const response = yield (0, declare_1.request)(param);
+                        "negative_prompt": paramOption.negative || ''
+                    }, url: `${paramOption.endpoint}/sdapi/v1/txt2img` });
+                // console.log('stablity param', requestOption);
+                const response = yield (0, declare_1.request)(requestOption);
                 if (response.successed) {
                     return { successed: true, type: 'image', data: response.data.images, };
                 }
-                console.log('response result ', response.data);
+                // console.log('response result ', response.data)
                 return Object.assign({ successed: false }, response.data);
             }
             catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doomiaichat",
-  "version": "5.1.0",
+  "version": "6.0.0",
   "description": "Doomisoft OpenAI",
   "main": "dist/index.js",
   "scripts": {
@@ -12,11 +12,12 @@
   "author": "Stephen.Shen",
   "license": "ISC",
   "devDependencies": {
-    "@types/node": "^18.15.11",
+    "@types/node": "^18.19.1",
     "typescript": "^4.9.5"
   },
   "dependencies": {
+    "@azure/openai": "^1.0.0-beta.10",
     "axios": "^1.3.4",
-    "azure-openai": "^0.9.4"
+    "openai": "^4.24.1"
   }
 }

package/src/azureai.ts

@@ -1,8 +1,11 @@
-import { Configuration, OpenAIApi } from "azure-openai";
-import { AzureOpenAIPatameters, EmbeddingResult, OpenAIApiParameters, request } from "./declare";
-// import { Configuration, OpenAIApi, ChatCompletionRequestMessage } from "azure-openai"
-import OpenAIGpt from "./openai"
-export default class AzureAI extends OpenAIGpt {
+/**
+ * 微软AZure OpenAI
+ */
+import OpenAIBase from "./openaibase"
+import { AzureOpenAIPatameters, ChatReponse, EmbeddingResult, OpenAIApiParameters, request } from "./declare";
+import { OpenAIClient, AzureKeyCredential, ChatCompletionsNamedToolSelection } from "@azure/openai";
+export default class AzureAI extends OpenAIBase<OpenAIClient> {
+
     protected readonly azureSetting: AzureOpenAIPatameters;
     constructor(apiKey: string, azureOption: AzureOpenAIPatameters, apiOption: OpenAIApiParameters = {}) {
         super(apiKey, apiOption);
@@ -14,20 +17,9 @@ export default class AzureAI extends OpenAIGpt {
     /**
      * 初始化OpenAI 的聊天对象Api
      */
-    override createOpenAI(apiKey: string): OpenAIApi {
-        return new OpenAIApi(new Configuration({ apiKey,
-            azure:{
-                apiKey,
-                endpoint: this.azureSetting.endpoint,
-                deploymentName: this.azureSetting.engine
-            } }))
+    createOpenAI(apiKey: string): OpenAIClient {
+        return new OpenAIClient(this.azureSetting.endpoint, new AzureKeyCredential(apiKey));
     }
-    /**
-     * ZAure OpenAI 最新的URL地址
-     */
-    // get BaseUrl(): string {
-    //     return `${this.azureSetting.endpoint}/openai/deployments/${this.azureSetting.engine}/chat/completions?api-version=${this.azureSetting.version || '2023-03-15-preview'}`
-    // }
 
     get EmbeddingUrl(): string {
         return `${this.azureSetting.endpoint}/openai/deployments/${this.embeddingmodel || 'openai-embedding-ada-002'}/embeddings?api-version=2022-12-01`
@@ -56,7 +48,7 @@ export default class AzureAI extends OpenAIGpt {
                 url: this.EmbeddingUrl
             };
             const response = await request(param)
-            if (response.data) {
+            if (response.successed && response.data) {
                 return { successed: true, embedding: response.data.data[0].embedding };
             }
             return { successed: false, ...response.data };
@@ -64,4 +56,91 @@ export default class AzureAI extends OpenAIGpt {
             return { successed: false, error };
         }
     }
+
+    /**
+     * 非流式聊天请求
+     * @param _chatText 
+     * @param _paramOption 
+     * @param _axiosOption 
+     */
+    public async chatRequest(chatText: string | Array<any>, callChatOption: OpenAIApiParameters, _axiosOption: any = {}): Promise<ChatReponse> {
+        if (!chatText) return { successed: false, error: { errcode: 2, errmsg: '缺失聊天的内容' } };
+        if (!this.aiApi) this.aiApi = this.createOpenAI(this.apiKey);
+
+        let message: Array<any> = typeof (chatText) == 'string' ?
+            [{ role: 'user', content: chatText }] : chatText;
+        try {
+            const response: any = await this.aiApi.getChatCompletions(
+                callChatOption?.model || this.chatModel,
+                message,
+                {
+                    temperature: Number(callChatOption?.temperature || this.temperature),
+                    maxTokens: Number(callChatOption?.maxtoken || this.maxtoken),
+                    topP: Number(callChatOption?.top_p || this.top_p),
+                    presencePenalty: Number(callChatOption?.presence_penalty || this.presence_penalty),
+                    frequencyPenalty: Number(callChatOption?.frequency_penalty || this.frequency_penalty),
+                    n: Number(callChatOption?.replyCounts || 1) || 1,
+                    tools: callChatOption.tools,
+                    toolChoice: (callChatOption.tool_choice || 'none') as ChatCompletionsNamedToolSelection,
+                });
+            const { promptTokens: prompt_tokens, completionTokens: completion_tokens, totalTokens: total_tokens } = response.usage
+            let rebuildChoice = [];
+            for (const msg of response.choices) {
+                ///, contentFilterResults: content_filter 
+                const { index, finishReason: finish_reason, message } = msg
+                rebuildChoice.push({ index, finish_reason, message })
+            }
+            return { successed: true, message: rebuildChoice, usage: { prompt_tokens, completion_tokens, total_tokens } };
+
+        } catch (error) {
+            console.log('result is error ', error)
+            return { successed: false, error };
+        }
+
+    }
+
+    /**
+     * 流式的聊天模式
+     * @param chatText 
+     * @param _paramOption 
+     * @param axiosOption 
+     */
+    override async chatRequestInStream(chatText: string | Array<any>, callChatOption: OpenAIApiParameters, attach?: any, axiosOption?: any): Promise<any> {
+        if (!chatText) this.emit('chaterror', { successed: false, error: 'no text in chat' });
+        if (!this.aiApi) {
+            this.aiApi = this.createOpenAI(this.apiKey);
+        }
+        let message: Array<any> = typeof (chatText) == 'string' ?[{ role: 'user', content: chatText }] : chatText;
+        axiosOption = Object.assign({}, axiosOption || { timeout: 60000 })
+        let requestid = Math.ceil(Math.random() * (new Date().getTime() * Math.random()) / 1000);
+        try {
+            const response: any = await this.aiApi.streamChatCompletions(
+                callChatOption?.model || this.chatModel,
+                message,
+                {
+                    temperature: Number(callChatOption?.temperature || this.temperature),
+                    maxTokens: Number(callChatOption?.maxtoken || this.maxtoken),
+                    topP: Number(callChatOption?.top_p || this.top_p),
+                    presencePenalty: Number(callChatOption?.presence_penalty || this.presence_penalty),
+                    frequencyPenalty: Number(callChatOption?.frequency_penalty || this.frequency_penalty),
+                    n: Number(callChatOption?.replyCounts || 1) || 1
+                });
+            let replytext: string[] = [];
+            for await (const event of response) {
+                for (const choice of event.choices) {
+                    const { finishReason: finishreason, index } = choice;
+                    const content = choice.delta?.content;
+                    if (!content) continue;
+                    replytext.push(content);
+                    let output = { successed: true, requestid, segment: content, text: replytext.join(''), finish_reason: finishreason, index };//, usage };
+                    if (attach) output = Object.assign({}, output, attach);
+                    this.emit(finishreason ? 'chatdone' : 'chattext', output)
+                }
+            }
+            return { successed: true, requestid }
+        } catch (error) {
+            this.emit('requesterror', { successed: false, requestid, error: 'call axios faied ' + error });
+            return { successed: false, requestid }
+        }
+    }
 }

package/src/declare.ts

@@ -38,15 +38,24 @@ export interface OpenAIApiParameters {
     'presence_penalty'?: number;
     'frequency_penalty'?: number;
     'replyCounts'?: number;  ///返回多少答案
+    'tools'?:Array<any>,
+    'tool_choice'?: string
 }
 /**
  * Azure 上的OpenAI的链接参数
  */
-export interface AzureOpenAIPatameters{
-    'endpoint':string;  ///端点
-    'engine':string;    ///GPT部署的项目名称
+export interface ProxyPatameters{
+    'serviceurl':string;  ///端点
+}
+
+/**
+ * OpenAI Proxy 链接参数
+ */
+export interface AzureOpenAIPatameters {
+    'endpoint': string;  ///端点
+    'engine': string;    ///GPT部署的项目名称
     'embedding'?: string;  ///向量引擎项目名称
-    'version'?:string;   ///Api 版本
+    'version'?: string;   ///Api 版本
 }
 
 /**
@@ -101,4 +110,26 @@ export interface CacheProvider {
      */
     delete(key: string): void;
 
+}
+
+
+export interface StabilityOption {
+    'cfg_scale'?: number,
+    'clip_guidance_preset'?: string,
+    'height'?: number,
+    'width'?: number,
+    'samples'?: number,
+    'seed'?: number,
+    'steps'?: number,
+    'sampler'?: string,
+    'negative'?: string,
+    'engine'?: string,
+    'endpoint'?: string
+    'denoising_strength'?: number,
+    'hr_scale'?: number
+}
+
+export interface StabilityResult extends ApiResult {
+    'data'?: any;
+    'type'?: string;
 }

package/src/gptprovider.ts

@@ -3,6 +3,7 @@
 * 语音转文字服务商工厂
 */
 import OpenAIGpt from './openai';
+import OpenAIProxt from './openaiproxy';
 import AzureAI from './azureai'
 import StabilityAI from './stabilityai'
 import StabilityPlusAI from './stabilityplusai'
@@ -13,6 +14,7 @@ import GptBase from './gptbase';
  */
 export const GptProviderEnum = {
     OPENAI: 'openai',
+    OPENAIPROXY:'openaiproxy',
     MICROSOFT: 'microsoft',
     BAIDU: 'baidu',
     GOOGLE:'google',
@@ -28,10 +30,12 @@ export type GptProviderEnum = typeof GptProviderEnum[keyof typeof GptProviderEnu
  * @returns 
  */
 export function createGpt(provider: GptProviderEnum, apikey: string|ApiCredential, setting: any): GptBase | null {
-    let { model, maxtoken, temperature, endpoint, engine, version, embedding, top_p, presence_penalty, frequency_penalty } = setting || {};
+    let { model, maxtoken, temperature, serviceurl,endpoint, engine, version, embedding, top_p, presence_penalty, frequency_penalty } = setting || {};
     switch (provider) {
         case GptProviderEnum.OPENAI: 
             return new OpenAIGpt(apikey + '', { model, maxtoken, temperature, embedding, top_p, presence_penalty, frequency_penalty });
+        case GptProviderEnum.OPENAIPROXY:
+            return new OpenAIProxt(apikey + '', { serviceurl}, { model, maxtoken, temperature, embedding, top_p, presence_penalty, frequency_penalty });
         case GptProviderEnum.MICROSOFT: 
             return new AzureAI(apikey + '', { endpoint, engine, version }, { model, maxtoken, temperature, embedding, top_p, presence_penalty, frequency_penalty }, );
         case GptProviderEnum.BAIDU: