doomiaichat 7.1.29 → 7.1.31

package/src/declare.ts

@@ -1,152 +0,0 @@
-
-import { EmbeddingItem } from '@azure/openai';
-import axios from 'axios';
-
-export interface ApiResult {
-    /**
-     * return the result of api called
-     * @type {boolean}
-     */
-    'successed': boolean
-    /**
-     * The error info 
-     * @type {any}
-     * @memberof ChatReponse
-     */
-    'error'?: any;
-}
-/**
- * Api封装后的返回结果
- */
-export interface ChatReponse extends ApiResult {
-
-    /**
-     * The name of the user in a multi-user chat
-     * @type {Array<any>}
-     * @memberof ChatReponse
-     */
-    'message'?: Array<any>;
-    'usage'?: any;
-}
-/**
- * 调用OpenAI Api的参数约定
- */
-export interface OpenAIApiParameters {
-    'embedding'?: string,       ///模型引擎，兼容Azure
-    'model'?: string,      ///模型名称
-    'maxtoken'?: number;    ///返回的最大token
-    'temperature'?: number;
-    'top_p'?: number;
-    'presence_penalty'?: number;
-    'frequency_penalty'?: number;
-    'replyCounts'?: number;  ///返回多少答案
-    'tools'?: Array<any>,
-    'tool_choice'?: string,
-    'enableToolCall'?: number ///是否允许调用toolfunction
-}
-/**
- * Azure 上的OpenAI的链接参数
- */
-export interface ProxyPatameters {
-    'serviceurl': string;  ///端点
-}
-
-/**
- * OpenAI Proxy 链接参数
- */
-export interface AzureOpenAIPatameters {
-    'endpoint': string;  ///端点
-    'engine': string;    ///GPT部署的项目名称
-    'embedding'?: string;  ///向量引擎项目名称
-    'version'?: string;   ///Api 版本
-}
-
-/**
- * 调用OpenAI Api的向量约定
- */
-export interface EmbeddingResult extends ApiResult {
-    'embedding'?: EmbeddingItem[],
-}
-/**
- * 远程请求的返回
- */
-export interface RpcResult extends ApiResult {
-    'data'?: any;
-}
-
-/**
- * Axios远程请求封装
- * @param opts 
- * @returns 
- */
-export async function request(opts: any = {}): Promise<RpcResult> {
-    if (!opts.data) opts.data = opts.body;
-    try {
-        let result = await axios(opts);
-        return { successed: true, data: result.data }
-    } catch (err) {
-        return { successed: false, error: err, data: err }
-    }
-}
-/**
- * 
- * @param opts 
- * @returns 
- */
-export function requestStream(opts: any = {},processChunkData:Function) {
-    if (!opts.data) opts.data = opts.body;
-    axios(opts)
-    .then((res: any) => {
-        res.data.on('data', (chunk: any) => {
-            processChunkData(chunk);
-        });
-    })
-}
-
-
-/**
- * 数据缓存提供者接口
- */
-export interface CacheProvider {
-    /**
-     * 缓存数据
-     * @param key 数据的键名称
-     * @param value 数据的键值
-     */
-    set(key: string, value: string | object, exp?: number): void;
-    /**
-     * 从缓存中读取数据
-     * @param key 数据的键名称
-     */
-    get(key: string): Promise<string | null>;
-
-
-    /**
-     * 删除缓存信息
-     * @param key 数据的键名称
-     */
-    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/deepseek.ts

@@ -1,11 +0,0 @@
-import OpenAI from 'openai';
-import OpenAIGpt from './openai';
-export default class DeepSeek extends OpenAIGpt{
-    override createOpenAI(apiKey: string): OpenAI {
-        return new OpenAI({ 
-            baseURL: 'https://api.deepseek.com',
-            apiKey 
-        })
-    }
-
-}

package/src/doubaoai.ts

@@ -1,129 +0,0 @@
-/**
- * 火山方舟-豆包大模型引擎
- */
-import { request, requestStream } from "./declare";
-import GptBase from "./gptbase"
-export default class DouBaoAI extends GptBase {
-    protected apiKey: string;
-    protected apiOption: any = {}
-    /**
-     * 构造函数
-     */
-    constructor(apiKey: string, apiOption: any = {}) {
-        super();
-        this.apiKey = apiKey;
-        this.apiOption = apiOption;
-    }
-    /**
-     * 请求接口
-     */
-    public async chatRequest(chatText: string | Array<any>, callChatOption: any, axiosOption: any = {}): Promise<any> {
-        if (!chatText) return { successed: false, error: { errcode: 2, errmsg: '缺失聊天的内容' } };
-        const callParams = this.assembleApiParams(chatText, false, callChatOption, axiosOption);
-        try {
-            const response = await request(callParams)
-            if (response.successed && !response.data.code)  return { successed: true, message: response.data.choices, usage: response.data.usage }
-            return { successed: false, ...response.data };
-        } catch (error) {
-            console.log('result is error ', error)
-            return { successed: false, error };
-        }
-    }
-    /**
-     * 组装最后的调用参数
-     * @param callChatOption 
-     * @returns 
-     */
-    private assembleApiParams(chatText: string | Array<any>, streamCall: boolean = false, callChatOption: any, axiosOption: any = {}): any {
-        let messages: Array<any> = typeof (chatText) == 'string' ? [{ role: 'user', content: chatText }] : chatText;
-        let params: any = {};
-        if (callChatOption?.temperature || this.apiOption.temperature) params.temperature = Number(callChatOption?.temperature || this.apiOption.temperature);
-        params.max_tokens = Number(callChatOption?.maxtoken || this.apiOption.maxtoken);
-        if (callChatOption?.top_p || this.apiOption.top_p) params.top_p = Number(callChatOption?.top_p || this.apiOption.top_p);
-        if (callChatOption?.presence_penalty || this.apiOption.presence_penalty) params.presence_penalty = Number(callChatOption?.presence_penalty || this.apiOption.presence_penalty);
-        if (callChatOption?.frequency_penalty || this.apiOption.frequency_penalty) params.frequency_penalty = Number(callChatOption?.frequency_penalty || this.apiOption.frequency_penalty);
-        if (callChatOption?.top_logprobs || this.apiOption.top_logprobs) {
-            params.logprobs = true;
-            params.top_logprobs = Number(callChatOption?.top_logprobs || this.apiOption.top_logprobs);
-        }
-        params.tools = (callChatOption?.enableToolCall === 1 && callChatOption?.tools) ? callChatOption.tools : undefined;
-        params.tool_choice = callChatOption?.enableToolCall === 1 ? 'auto' : undefined;
-        const axiosParams = {
-            ...axiosOption,
-            method: "post",
-            headers: {
-                'Content-Type': 'application/json',
-                'authorization': `Bearer ${this.apiKey}`
-            },
-            data: {
-                model: callChatOption?.model || this.apiOption.model,
-                ...params,
-                messages,
-                stream: streamCall
-            },
-            url: 'https://ark.cn-beijing.volces.com/api/v3/chat/completions'
-        };
-        if (streamCall) axiosParams.responseType = 'stream';
-        return axiosParams;
-    }
-    /**
-     * 流式的聊天模式
-     * @param chatText 
-     * @param _paramOption 
-     * @param axiosOption 
-     */
-    override async chatRequestInStream(chatText: string | Array<any>, callChatOption: any, attach?: any, axiosOption?: any): Promise<any> {
-        if (!chatText) this.emit('chaterror', { successed: false, error: 'no text in chat' });
-        axiosOption = Object.assign({}, axiosOption || { timeout: 10000 })
-        const callParams = this.assembleApiParams(chatText, true, callChatOption, axiosOption);
-        let requestid = Math.ceil(Math.random() * (new Date().getTime() * Math.random()) / 1000), replytext: string[] = [];
-        try {
-            requestStream(callParams, (chunk: any) => {
-                let streamText = chunk.toString().replace('[DONE]', '').replace(/[\r\n]+/gm, '')
-                this.processChunkData(streamText.split(/data: /), requestid, replytext, attach)
-            })
-            return { successed: true, requestid }
-        } catch (error) {
-            this.emit('requesterror', { successed: false, requestid, error: 'call axios faied ' + error });
-            return { successed: false, requestid }
-        }
-    }
-    /**
-     * 处理每次流式返回的对话片段
-     * @param chunks 
-     * @param requestid 
-     * @param replytext 
-     * @param attach 
-     */
-    processChunkData(chunks: string[], requestid: Number, replytext: string[], attach: any) {
-        let has_tool_calls = 0, currentIndex, previous_index = -1, tool_calls: any[] = [];// 使用数组来存储工具调用
-        for (const splitString of chunks) {
-            if (!splitString) continue;
-            const chunk = JSON.parse(splitString);
-            const [choice] = chunk.choices,
-                { finish_reason: finishreason, index, usage } = choice,
-                { content, tool_calls: toolCalls } = choice.delta;
-            if (toolCalls && toolCalls.length) {
-                currentIndex = toolCalls[0].index;
-                has_tool_calls = 1;
-                if (currentIndex !== previous_index) {
-                    tool_calls.push({
-                        id: toolCalls[0].id,
-                        type: 'function',
-                        function: {
-                            name: toolCalls[0].function.name,
-                            arguments: toolCalls[0].function.arguments
-                        }
-                    });
-                    // 更新previousIndex以供下次比较
-                    previous_index = currentIndex;
-                } else {
-                    tool_calls[previous_index].function.arguments += toolCalls[0].function.arguments
-                }
-            } else replytext.push(content);
-            let output = { successed: true, requestid, segment: content, text: replytext.join(''), finish_reason: finishreason, index, usage, has_tool_calls: has_tool_calls, tool_calls: tool_calls };
-            if (attach) output = Object.assign({}, output, attach);
-            this.emit(finishreason ? 'chatdone' : 'chattext', output)
-        }
-    }
-}

package/src/gptbase.ts

@@ -1,52 +0,0 @@
-import { EventEmitter } from "events"
-import { ApiResult } from './declare'
-
-export default abstract class GptBase extends EventEmitter {
-    /**
-     * 构造函数
-     */
-    constructor() {
-        super();
-    }
-    /**
-     * 获得文字的向量
-     * @param text 
-     */
-    getTextEmbedding(_text: string, _axiosOption: any):any {return null;}
-    /**
-     * 自由聊天模式
-     * @param chatText 
-     * @param _paramOption 
-     * @param axiosOption 
-     */
-    abstract chatRequest(chatText: string | Array<any>, _paramOption: any, axiosOption?: any): Promise<ApiResult>;
-
-    /**
-     * 创建一个会话主题id
-     * @returns 
-     */
-    async createCoversation(_client?:any):Promise<string|null> {
-        return null;
-    }
-
-    /**
-     * 设置智能体的变量
-     * @returns 
-     */
-    async setVariables(_params: any):Promise<ApiResult> {
-        return { successed: true };
-    }
-    /**
-     * 获取智能体的变量
-     * @returns 
-     */
-    async getVariables(_params: any): Promise<any> { return {successed: false}}
-    /**
-     * 流式的聊天模式
-     * @param chatText 
-     * @param _paramOption 
-     * @param axiosOption 
-     */
-    chatRequestInStream(_chatText: string | Array<any>, _paramOption: any, _attach?: any, _axiosOption?: any): any { return null; }
-    }
-

package/src/gptprovider.ts

@@ -1,74 +0,0 @@
-//ts check
-/**
-* 语音转文字服务商工厂
-*/
-import OpenAIGpt from './openai';
-import DeepSeek from './deepseek';
-import CorzBot from './corzbot'
-import OpenAIProxt from './openaiproxy';
-import AzureAI from './azureai'
-import StabilityAI from './stabilityai'
-import StabilityPlusAI from './stabilityplusai'
-import BaiduWenXinAI, { ApiCredential } from './baiduai'
-import AIMiddlePlatform  from './aimp';
-import DouBaoAI from './doubaoai'
-import GptBase from './gptbase';
-import { CorzAuthorization } from './corzauthorization'
-// 扣子的身份认证应用
-const corzAuth: Map<string, CorzAuthorization> = new Map();
-/**
- * OpenAI/NLP 的服务提供商 OpenAI,微软，百度文心(待接入)，google(待接入)
- */
-export const GptProviderEnum = {
-    OPENAI: 'openai',
-    OPENAIPROXY:'openaiproxy',
-    MICROSOFT: 'microsoft',
-    AIMP: 'aimp',   ///AI 中台业务
-    COZE:'coze',
-    BAIDU: 'baidu',
-    DOUBAO:'doubao',
-    DEEPSEEK:'deepseek',
-    GOOGLE:'google',
-    STABILITY:'stability',
-    STABILITY2: 'stability2',
-} as const;
-export type GptProviderEnum = typeof GptProviderEnum[keyof typeof GptProviderEnum];
-/**
- * 根据类型创建不同的TTS引擎对象
- * @param {*} provider 
- * @param {*} apikey 
- * @param {*} setting 
- * @returns 
- */
-export function createGpt(provider: GptProviderEnum, apikey: string|ApiCredential, setting: any): GptBase | null {
-    let { model,agentid, 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.DEEPSEEK:
-            return new DeepSeek(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:
-            let cred: ApiCredential = typeof (apikey) === 'string' ? { apikey, securitykey: apikey } : apikey;
-            return new BaiduWenXinAI(cred);
-        case GptProviderEnum.AIMP:
-            return new AIMiddlePlatform(apikey+'',{ endpoint,agentid });
-        case GptProviderEnum.COZE:
-            let authorizationProvider  = corzAuth.get(apikey + '');  
-            if (!authorizationProvider) {
-                authorizationProvider = new CorzAuthorization(apikey + '',setting);
-                corzAuth.set(apikey + '', authorizationProvider);
-            }
-            return new CorzBot(authorizationProvider!, setting);
-        case GptProviderEnum.DOUBAO:
-            return new DouBaoAI(apikey + '', { model, maxtoken, temperature, top_p, presence_penalty, frequency_penalty })
-        case GptProviderEnum.STABILITY:
-            return new StabilityAI(apikey + '', { endpoint, engine }, setting);
-        case GptProviderEnum.STABILITY2:
-            return new StabilityPlusAI(apikey + '', { endpoint, engine }, setting);
-        default: return null;
-    }
-};

package/src/index.ts

@@ -1,2 +0,0 @@
-export * as GptFactory from "./gptprovider";
-export * as GptBase from "./gptbase";

package/src/openai.ts

@@ -1,136 +0,0 @@
-// import { Configuration, OpenAIApi, ChatCompletionRequestMessage } from "azure-openai"
-/**
- * OpenAI 
- */
-import OpenAIBase from "./openaibase"
-import { OpenAIApiParameters, ChatReponse, EmbeddingResult } from './declare'
-import OpenAI from "openai";
-// import { ChatCompletionToolChoiceOption } from "openai/resources";
-export default class OpenAIGpt extends OpenAIBase<OpenAI> {
-    /**
-     * 初始化OpenAI 的聊天对象Api
-     */
-    createOpenAI(apiKey: string): OpenAI {
-        return new OpenAI({ apiKey })
-    }
-
-    /**
-     * 获得文字的向量
-     * @param text 
-     */
-    override async getTextEmbedding(text: string|string[], axiosOption: any): Promise<EmbeddingResult> {
-        if (!text) return { successed: false, error: { errcode: 2, errmsg: 'content required' } };
-        if (!this.aiApi) {
-            this.aiApi = this.createOpenAI(this.apiKey);
-        }
-        try {
-            const response: any = await this.aiApi.embeddings.create({
-                model: this.embeddingmodel,
-                input: text,
-            }, axiosOption);
-            return { successed: true, embedding: response.data.data};//[0].embedding };
-        } catch (error) {
-            return { successed: false, error };
-        }
-    }
-    /**
-     * 向OpenAI发送一个聊天请求
-     * @param {*} chatText 
-     */
-    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.createChatCompletion({
-            const response: any = await this.aiApi.chat.completions.create(
-            {
-                model:callChatOption?.model || this.chatModel,
-                messages:message,
-                temperature: Number(callChatOption?.temperature || this.temperature),
-                max_tokens: Number(callChatOption?.maxtoken || this.maxtoken),
-                top_p: Number(callChatOption?.top_p || this.top_p), 
-                presence_penalty: Number(callChatOption?.presence_penalty || this.presence_penalty), 
-                frequency_penalty: Number(callChatOption?.frequency_penalty || this.frequency_penalty), 
-                n: Number(callChatOption?.replyCounts || 1) || 1,
-                // tools: (callChatOption?.enableToolCall === 1 && callChatOption?.tools) ? callChatOption.tools : undefined,
-                // tool_choice: callChatOption?.enableToolCall === 1 ? 'auto' : undefined,
-            }, axiosOption);
-            // console.log('response.data', response)
-            return { successed: true, message: response.choices, usage: response.usage };
-        } 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.chat.completions.create(
-                {
-                    model: callChatOption?.model || this.chatModel,
-                    messages: message,
-                    temperature: Number(callChatOption?.temperature || this.temperature),
-                    max_tokens: Number(callChatOption?.maxtoken || this.maxtoken),
-                    top_p: Number(callChatOption?.top_p || this.top_p),
-                    presence_penalty: Number(callChatOption?.presence_penalty || this.presence_penalty),
-                    frequency_penalty: Number(callChatOption?.frequency_penalty || this.frequency_penalty),
-                    n: Number(callChatOption?.replyCounts || 1) || 1,
-                    tools: (callChatOption?.enableToolCall === 1 && callChatOption?.tools) ? callChatOption.tools : undefined,
-                    tool_choice: callChatOption?.enableToolCall === 1 ? 'auto' : undefined,
-                    stream:true
-                }, axiosOption);
-            let replytext: string[] = [];
-            let has_tool_calls = 0, currentIndex, previous_index = -1, tool_calls: any[] = [];// 使用数组来存储工具调用
-            for await (const chunk of response) {
-                const [choice] = chunk.choices,
-                    { finish_reason:finishreason, index, usage } = choice,
-                    { content, tool_calls:toolCalls } = choice.delta;
-                if (toolCalls && toolCalls.length) {
-                    currentIndex = toolCalls[0].index;
-                    has_tool_calls = 1;
-                    // 检查index是否发生变化
-                    //console.log('currentIndex,previous_index', currentIndex, previous_index)
-                    if (currentIndex !== previous_index) {
-                        tool_calls.push({
-                            id: toolCalls[0].id,
-                            type: 'function',
-                            function: {
-                                name: toolCalls[0].function.name,
-                                arguments: toolCalls[0].function.arguments
-                            }
-                        });
-                        // 更新previousIndex以供下次比较
-                        previous_index = currentIndex;
-                    } else {
-                        tool_calls[previous_index].function.arguments += toolCalls[0].function.arguments
-                    }
-                } else {
-                    replytext.push(content);
-                }
-                let output = { successed: true, requestid, segment: content, text: replytext.join(''), finish_reason: finishreason, index, usage, has_tool_calls: has_tool_calls, tool_calls: tool_calls };
-                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/openaibase.ts

@@ -1,30 +0,0 @@
-// import { Configuration, OpenAIApi, ChatCompletionRequestMessage } from "azure-openai"
-import { OpenAIApiParameters } from "./declare";
-import GptBase from "./gptbase"
-export default abstract class OpenAIBase<T> extends GptBase {
-    protected readonly apiKey: string;
-    protected readonly chatModel: string;
-    protected readonly maxtoken: number;
-    protected readonly top_p: number;
-    protected readonly presence_penalty: number;
-    protected readonly frequency_penalty: number;
-    protected readonly temperature: number;
-    protected readonly embeddingmodel: string;
-    protected aiApi: T | undefined;//OpenAIApi | undefined;
-    constructor(apiKey: string, apiOption: OpenAIApiParameters = {}) {
-        super();
-        this.apiKey = apiKey;
-        this.chatModel = apiOption.model || 'gpt-3.5-turbo';
-        this.maxtoken = apiOption.maxtoken || 2048;
-        this.top_p = apiOption.top_p || 0.95;
-        this.temperature = apiOption.temperature || 0.9;
-        this.presence_penalty = apiOption.presence_penalty || 0;
-        this.frequency_penalty = apiOption.frequency_penalty || 0;
-        this.embeddingmodel = apiOption.embedding || 'text-embedding-ada-002';
-    }
-    /**
-     * 初始化OpenAI 的聊天对象Api
-     */
-    abstract createOpenAI(apiKey: string): T ;
-
-}