doomiaichat 7.1.29 → 7.1.30

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 ;
-
-}

package/src/openaiproxy.ts

@@ -1,97 +0,0 @@
-import { ApiResult, OpenAIApiParameters, ProxyPatameters } from './declare';
-import OpenAIGpt from './openai';
-import axios  from 'axios';
-const ERROR_RESPONSE: string[] = ['[AUTHORIZATION NEEDED]', '[AUTHORIZATION ERROR]', '[BODY ERROR]','[REQUEST ERROR]']
-export default class OpenAIProxy extends OpenAIGpt {
-    protected readonly proxySetting: ProxyPatameters;
-    constructor(apiKey: string, proxyOption: ProxyPatameters, apiOption: OpenAIApiParameters = {}) {
-        super(apiKey, apiOption);
-        this.proxySetting = proxyOption;
-    }
-    /**
-     * 重写chatRequest方法
-     * @param chatText 
-     * @param callChatOption 
-     * @param axiosOption 
-     */
-    override async chatRequest(chatText: string | any[], _paramOption: any, axiosOption?: any): Promise<ApiResult> {
-        const opts: any = {
-            headers: {
-                'Content-Type': 'application/json',
-                'authorization': `Bearer ${this.apiKey}`
-            },
-            method: 'post',
-            url: this.proxySetting.serviceurl,
-            data: {
-                chatText,
-                option: _paramOption
-            },
-            ...axiosOption
-        }
-        const requestResult = await axios(opts);
-        return requestResult.data as ApiResult;
-    }
-    /**
-     * 重写chatRequestInStream方法
-     * @param chatText 
-     * @param callChatOption 
-     * @param attach 
-     * @param axiosOption 
-     */
-    override async chatRequestInStream(chatText:Array<any>, callChatOption: OpenAIApiParameters, attach?: any, axiosOption?: any): Promise<any> {
-        // const decoder = new TextDecoder();
-        //overContent,
-        let  streamText,requestid = Math.ceil(Math.random() * (new Date().getTime() * Math.random()) / 1000);
-        const opts:any = {
-            headers: {
-                'Content-Type': 'application/json',
-                'authorization': `Bearer ${this.apiKey}`
-            },
-            method: 'post',
-            url: this.proxySetting.serviceurl +'/stream',
-            data: {
-                messages:chatText,
-                option: callChatOption,
-                axiosOption
-            },
-            responseType: 'stream',
-        }
-        let unCompleteSegment:string = '';
-        axios(opts)
-        .then(res => {
-            res.data.on('data', (chunk:any) => { 
-                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 });
-                    }
-                    const fullData = (unCompleteSegment +streamText).split('*&$')
-                    unCompleteSegment = '';
-                    // console.log('fullData', fullData.length);
-                    for (const segment of fullData){
-                        if (!segment) continue;
-                        try {
-                            ////判断接收到的不是一个完整的JSON段了，则该段作为下一次的数据段
-                            if (!segment.endsWith('}')) {
-                                unCompleteSegment = segment;
-                                break;
-                            }
-                            const objData = Object.assign(JSON.parse(segment), attach);
-                            this.emit(objData.finish_reason?'chatdone':'chattext', objData);
-                        } catch (errParse) {
-                            
-                            break;
-                            //this.emit('chaterror', { successed: false, requestid, error: 'JSON parse stream message' + errParse });
-                        }
-                    }
-                    
-                }
-                return;
-            });
-            //res.data.on('end', () => { this.emit('chatdone', Object.assign(streamText, attach)); });
-        }).catch(err=>{
-            this.emit('requesterror', { successed: false, requestid, error: 'Axios Error : ' + err });
-        })
-    }
-}

package/src/stabilityai.ts

@@ -1,67 +0,0 @@
-import { request, AzureOpenAIPatameters, StabilityOption, StabilityResult } from "./declare";
-import GptBase from "./gptbase"
-export default class StabilityAI extends GptBase {
-    
-    protected readonly apiKey: string;
-    protected readonly apiSetting: AzureOpenAIPatameters
-    protected readonly apiOption:StabilityOption;
-    /**
-     * 
-     * @param apiKey 调用OpenAI 的key
-     * @param azureOption  用作accesstoken的缓存 
-     * @param apiOption  用作accesstoken的缓存 
-     */
-    constructor(apiKey: string, urlOption: AzureOpenAIPatameters, apiOption: StabilityOption = {}) {
-        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作画的接口
-     */
-    public async chatRequest(chatText: string, paramOption: StabilityOption, axiosOption: any = {}): Promise<StabilityResult> {
-        if (!chatText) return { successed: false, error: { errcode: 2, errmsg: '缺失聊天的内容' } };
-        axiosOption = Object.assign({}, axiosOption,{
-            headers:{
-                "Content-Type": "application/json",
-                "Accept": "application/json",
-                "Authorization": `Bearer ${this.apiKey}`
-            }
-        })
-        try {
-            let param = {
-                ...axiosOption,
-                method: "post",
-                url: `${this.apiSetting.endpoint}/v1/generation/${this.apiSetting.engine}/text-to-image`,
-                data: {
-                    text_prompts: [
-                        {
-                            text: chatText
-                        }
-                    ],
-                    cfg_scale: paramOption.cfg_scale || this.apiOption.cfg_scale || 7,
-                    clip_guidance_preset: paramOption.clip_guidance_preset || this.apiOption.clip_guidance_preset || "FAST_BLUE",
-                    height: paramOption.height || this.apiOption.height || 512,
-                    width: paramOption.width || this.apiOption.width || 512,
-                    samples: paramOption.samples || this.apiOption.samples || 1,
-                    steps: paramOption.steps || this.apiOption.steps || 30,
-                },
-                
-            };
-            const response:any = await request(param)
-            if (response.successed) {
-                let data = response.data;
-                return { successed: true, type: 'image', data: data.artifacts, };
-            }
-            return { successed: false, ...response.data };
-        } catch (error) {
-            console.log('result is error ', error)
-            return { successed: false, error };
-        }
-
-    }
-}

package/src/stabilityplusai.ts

@@ -1,77 +0,0 @@
-
-import { AzureOpenAIPatameters, StabilityOption, StabilityResult, request } from "./declare";
-import GptBase from "./gptbase";
-export default class StabilityPlusAI extends GptBase {
-    protected readonly apiKey: string;
-    // protected readonly apiSetting: AzureOpenAIPatameters
-    protected readonly apiOption: StabilityOption;
-    constructor(apiKey: string, _urlOption: AzureOpenAIPatameters, apiOption: StabilityOption = {}) {
-        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作画的接口
-     */
-    public async chatRequest(chatText: string, paramOption: StabilityOption, axiosOption: any = {}): Promise<StabilityResult> {
-        if (!chatText) return { successed: false, error: { errcode: 2, errmsg: '缺失聊天的内容' } };
-        axiosOption = Object.assign({}, axiosOption, {
-            headers: {
-                "Content-Type": "application/json",
-                "Accept": "application/json",
-            }
-        })
-        try {
-            const requestOption = {
-                ...axiosOption,
-                method: "POST",
-                data: {
-                    "enable_hr": false,
-                    "denoising_strength": paramOption.denoising_strength || this.apiOption.denoising_strength ||  0.5,
-                    "firstphase_width": 0,
-                    "firstphase_height": 0,
-                    "hr_scale": paramOption.hr_scale || this.apiOption.hr_scale || 2,
-                    "hr_upscaler": "string",
-                    "hr_second_pass_steps": 0,
-                    "hr_resize_x": 0,
-                    "hr_resize_y": 0,
-                    "prompt": chatText,
-                    "styles":["string"], //[paramOption.engine || this.apiSetting.engine || "bra_v5"], //["bra_v5"],   //模型
-                    "seed": paramOption.seed || this.apiOption.seed ||  -1,
-                    "subseed": -1,
-                    "subseed_strength": 0,
-                    "seed_resize_from_h": -1,
-                    "seed_resize_from_w": -1,
-                    "sampler_name": paramOption.sampler || this.apiOption.sampler || "Euler a", //"Euler",
-                    "batch_size": 1,
-                    "n_iter": paramOption.samples || this.apiOption.samples || 1,        //生成的数量
-                    "steps": paramOption.steps || this.apiOption.steps ||  20,
-                    "cfg_scale": paramOption.cfg_scale || this.apiOption.cfg_scale || 7,
-                    "width": paramOption.width || this.apiOption.width || 512, 
-                    "height": paramOption.height || this.apiOption.height || 512,
-                    "restore_faces": false,
-                    "tiling": false,
-                    "do_not_save_samples": false,
-                    "do_not_save_grid": false,
-                    "negative_prompt": paramOption.negative || ''
-                },
-                url: `${paramOption.endpoint}/sdapi/v1/txt2img`,
-            };
-            // console.log('stablity param', requestOption);
-            const response: any = await request(requestOption)
-            if (response.successed) {
-                return { successed: true, type: 'image', data: response.data.images, };
-            }
-            // console.log('response result ', response.data)
-            return { successed: false, ...response.data };
-        } catch (error) {
-            console.log('result is error ', error)
-            return { successed: false, error };
-        }
-
-    }
-}