@cloudbase/js-sdk 3.8.2-beta.1 → 3.8.2-beta.2

package/ai/dist/AI.d.ts

@@ -0,0 +1,29 @@
+import type { SDKRequestInterface } from '@cloudbase/adapter-interface';
+import { Bot } from './bot';
+import * as models from './models';
+import * as types from './type';
+import { ICloudbaseConfig } from '@cloudbase/js-sdk/types';
+declare class AI {
+    private req;
+    baseUrl: string;
+    bot: Bot;
+    i18n: ICloudbaseConfig['i18n'];
+    defaultHeaders: {
+        [x: string]: any;
+    };
+    private _getBaseUrl?;
+    get aiBaseUrl(): string;
+    get aiBotBaseUrl(): string;
+    constructor(req: SDKRequestInterface, baseUrl: string, i18n: ICloudbaseConfig['i18n'], getBaseUrl?: () => string);
+    handleResponseData(responseData: Promise<unknown> | ReadableStream<Uint8Array>, header?: Headers): Promise<unknown>;
+    createModel(model: string, options?: {
+        defaultModelSubUrl?: string;
+    }): models.ReactModel;
+    registerModel(name: string, model: types.ChatModelConstructor): void;
+    createImageModel<T extends 'hunyuan-image' | (string & {})>(provider: T): models.DefaultImageModel<T>;
+    modelRequest: types.ModelReq;
+    botRequest: types.BotReq;
+    registerFunctionTool(functionTool: types.FunctionTool): void;
+    private resolveUrl;
+}
+export { AI };

package/ai/dist/bot/index.d.ts

@@ -0,0 +1,41 @@
+import { type ParsedEvent } from '../eventsource_parser';
+import { BotReq, ReqOptions } from '../type';
+import { IBotCreateConversation, IBotDeleteConversation, IBotGetConversation, IBotGetTextToSpeechResult, IBotPreview, IBotSendMessage, IBotSpeechToText, IBotTextToSpeech, IBotUploadFiles, ICreateBot, IDeleteBot, IGenerateBot, IGenerateImage, IGetBot, IGetBotChatRecords, IGetBotFeedback, IGetBotList, IGetBotRecommendQuestions, ISendBotFeedback, IUpdateBot } from './types';
+export declare class Bot {
+    baseUrl: string;
+    req: BotReq;
+    constructor(req: BotReq, baseUrl: string);
+    list(props: IGetBotList, options?: ReqOptions): Promise<Object>;
+    create({ botInfo }: ICreateBot, options?: ReqOptions): Promise<Object>;
+    get({ botId }: IGetBot, options?: ReqOptions): Promise<Object>;
+    update({ botId, botInfo }: IUpdateBot, options?: ReqOptions): Promise<Object>;
+    delete({ botId }: IDeleteBot, options?: ReqOptions): Promise<Object>;
+    getChatRecords(props: IGetBotChatRecords, options?: ReqOptions): Promise<Object>;
+    sendFeedback({ userFeedback }: ISendBotFeedback, options?: ReqOptions): Promise<Object>;
+    getFeedback(props: IGetBotFeedback, options?: ReqOptions): Promise<Object>;
+    uploadFiles(props: IBotUploadFiles, options?: ReqOptions): Promise<Object>;
+    createConversation({ botId, ...rest }: IBotCreateConversation, options?: ReqOptions): Promise<Object>;
+    getConversation({ pageSize, pageNumber, botId, ...rest }: IBotGetConversation, options?: ReqOptions): Promise<Object>;
+    deleteConversation({ botId, conversationId, ...rest }: IBotDeleteConversation, options?: ReqOptions): Promise<Object>;
+    speechToText(props: IBotSpeechToText, options?: ReqOptions): Promise<Object>;
+    textToSpeech(props: IBotTextToSpeech, options?: ReqOptions): Promise<Object>;
+    getTextToSpeechResult(props: IBotGetTextToSpeechResult, options?: ReqOptions): Promise<Object>;
+    getRecommendQuestions(props: IGetBotRecommendQuestions, options?: ReqOptions): Promise<StreamResult>;
+    generateBot(props: IGenerateBot, options?: ReqOptions): Promise<StreamResult>;
+    getPreview(props: IBotPreview, options?: ReqOptions): Promise<StreamResult>;
+    generateImage(props: IGenerateImage, options?: ReqOptions): Promise<Object>;
+    sendMessage(props: IBotSendMessage, options?: ReqOptions): Promise<StreamResult>;
+    private join;
+}
+type BotEventStreamData = {
+    content: string;
+};
+declare class StreamResult {
+    private _eventSourceStream;
+    constructor(_stream: ReadableStream<Uint8Array>);
+    private get teeedStream();
+    get eventSourceStream(): import("../type").AsyncIterableReadableStream<ParsedEvent>;
+    get dataStream(): import("../type").AsyncIterableReadableStream<BotEventStreamData>;
+    get textStream(): import("../type").AsyncIterableReadableStream<string>;
+}
+export {};

package/ai/dist/bot/types.d.ts

@@ -0,0 +1,144 @@
+export interface IGetBotList {
+    name: string;
+    introduction: string;
+    information: string;
+    enable: boolean;
+    pageSize: number;
+    pageNumber: number;
+}
+export interface ICreateBot {
+    botInfo: BotInfo;
+}
+export interface IGetBot {
+    botId: string;
+}
+export interface IUpdateBot {
+    botId: string;
+    botInfo: BotInfo;
+}
+export interface IDeleteBot {
+    botId: string;
+}
+export interface IGetBotChatRecords {
+    botId: string;
+    sort: 'asc' | 'desc' | string;
+    pageSize: number;
+    pageNumber: number;
+}
+export interface ISendBotFeedback {
+    userFeedback: IUserFeedback;
+}
+export interface IGetBotFeedback {
+    botId: string;
+    type: 'upvote' | 'downvote' | string;
+    sender: string;
+    senderFilter: 'include' | 'exclude' | 'equal' | 'unequal' | 'prefix' | string;
+    minRating: number;
+    maxRating: number;
+    from: number;
+    to: number;
+    pageSize: number;
+    pageNumber: number;
+}
+export interface IGetBotRecommendQuestions {
+    botId: string;
+    name: string;
+    introduction: string;
+    agentSetting: string;
+    msg: string;
+    history: Array<{
+        role: string;
+        content: string;
+    }>;
+}
+export interface IGenerateBot {
+    simple: boolean;
+    prompt: string;
+}
+export interface IBotPreview {
+    name: string;
+    introduction: string;
+    agentSetting: string;
+    msg: string;
+    history: Array<{
+        role: string;
+        content: string;
+    }>;
+    knowledgeBase: Array<string>;
+}
+export interface IGenerateImage {
+    prompt: string;
+}
+export interface IBotSendMessage {
+    botId: string;
+    msg: string;
+    history: Array<{
+        role: string;
+        content: string;
+    }>;
+}
+export interface IBotUploadFiles {
+    botId: string;
+    fileList: Array<{
+        fileName: string;
+        fileId: string;
+        type: string;
+    }>;
+}
+export interface IBotCreateConversation {
+    botId: string;
+    title?: string;
+}
+export interface IBotGetConversation {
+    botId: string;
+    pageSize?: number;
+    pageNumber?: number;
+    isDefault?: boolean;
+}
+export interface IBotDeleteConversation {
+    botId: string;
+    conversationId: string;
+}
+export interface IBotSpeechToText {
+    botId: string;
+    engSerViceType: string;
+    voiceFormat: string;
+    url: string;
+    isPreview?: boolean;
+}
+export interface IBotTextToSpeech {
+    botId: string;
+    voiceType: number;
+    text: string;
+    isPreview?: boolean;
+}
+export interface IBotGetTextToSpeechResult {
+    botId: string;
+    taskId: string;
+    isPreview?: boolean;
+}
+export interface IUserFeedback {
+    recordId: string;
+    type: string;
+    botId: string;
+    comment: string;
+    rating: number;
+    tags: Array<string>;
+    input: string;
+    aiAnswer: string;
+}
+export interface BotInfo {
+    botId: string;
+    name: string;
+    introduction: string;
+    agentSetting: string;
+    welcomeMessage: string;
+    avatar: string;
+    background: string;
+    tags: Array<string>;
+    isNeedRecommend: boolean;
+    knowledgeBase: Array<string>;
+    type: string;
+    initQuestions: Array<string>;
+    enable: true;
+}

package/ai/dist/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class InvalidParamsError extends Error {
+    code: string;
+    field?: string;
+    constructor(message: string, field?: string);
+    toJSON(): {
+        code: string;
+        message: string;
+        field: string;
+    };
+}

package/ai/dist/eventsource_parser/index.d.ts

@@ -0,0 +1,2 @@
+export type { EventSourceParser, ParsedEvent, ReconnectInterval, ParseEvent, EventSourceParseCallback } from './types';
+export { createParser } from './parse';

package/ai/dist/eventsource_parser/parse.d.ts

@@ -0,0 +1,2 @@
+import type { EventSourceParseCallback, EventSourceParser } from './types';
+export declare function createParser(onParse: EventSourceParseCallback): EventSourceParser;

package/ai/dist/eventsource_parser/stream.d.ts

@@ -0,0 +1,5 @@
+import type { ParsedEvent } from './types';
+export declare class EventSourceParserStream extends TransformStream<string, ParsedEvent> {
+    constructor();
+}
+export type { ParsedEvent } from './types';

package/ai/dist/eventsource_parser/types.d.ts

@@ -0,0 +1,16 @@
+export interface EventSourceParser {
+    feed(chunk: string): void;
+    reset(): void;
+}
+export interface ParsedEvent {
+    type: 'event';
+    event?: string;
+    id?: string;
+    data: string;
+}
+export interface ReconnectInterval {
+    type: 'reconnect-interval';
+    value: number;
+}
+export type ParseEvent = ParsedEvent | ReconnectInterval;
+export type EventSourceParseCallback = (event: ParseEvent) => void;

package/ai/dist/index.d.ts

@@ -1 +1,42 @@
-export * from '@cloudbase/ai';
+import type { SDKRequestInterface } from '@cloudbase/adapter-interface';
+import type { ICloudbase, ICloudbaseConfig } from '@cloudbase/js-sdk/types';
+import { AI } from './AI';
+import { Bot } from './bot';
+import * as models from './models';
+import * as utils from './utils';
+declare const restModels: {
+    ZhiPuSimpleModel: typeof models.ZhiPuSimpleModel;
+    HunYuanBetaSimpleModel: typeof models.HunYuanBetaSimpleModel;
+    HunYuanSimpleModel: typeof models.HunYuanSimpleModel;
+    ArkSimpleModel: typeof models.ArkSimpleModel;
+    DSSimpleModel: typeof models.DSSimpleModel;
+    YiSimpleModel: typeof models.YiSimpleModel;
+    MoonshotSimpleModel: typeof models.MoonshotSimpleModel;
+    HunYuanExpSimpleModel: typeof models.HunYuanExpSimpleModel;
+    HunYuanOpenSimpleModel: typeof models.HunYuanOpenSimpleModel;
+    DefaultSimpleModel: typeof models.DefaultSimpleModel;
+    DefaultImageModel: typeof models.DefaultImageModel;
+    ReactModel: typeof models.ReactModel;
+    toolMap: Map<string, CallableFunction>;
+};
+interface IHandleRequestInstance {
+    req: SDKRequestInterface;
+}
+type HandleRequestInstanceFunc = (options: IHandleRequestInstance) => SDKRequestInterface;
+interface ICreateAI {
+    req: SDKRequestInterface;
+    baseUrl?: string;
+    getBaseUrl?: () => string;
+    env?: string;
+    getAccessToken?: () => Promise<{
+        accessToken: string;
+    }>;
+    handleReqInstance?: HandleRequestInstanceFunc;
+    i18n?: ICloudbaseConfig['i18n'];
+}
+declare function createAI({ env, baseUrl, getBaseUrl: getBaseUrlFunc, req, getAccessToken, handleReqInstance, i18n }: ICreateAI): AI;
+declare const createAi: typeof createAI;
+declare function registerAi(app: ICloudbase): void;
+export { AI, Bot, createAi, createAI, restModels as models, registerAi, utils };
+export * from './type';
+export * from './errors';

package/ai/dist/models/Ark/index.d.ts

@@ -0,0 +1,10 @@
+import type { ModelReq, BaseChatModelInput, SimpleChatModel, DoGenerateOutput, DoStreamOutput, ReqOptions } from '../../type';
+export declare class ArkSimpleModel implements SimpleChatModel {
+    private req;
+    baseUrl: string;
+    subUrl: string;
+    constructor(req: ModelReq, baseUrl: string, subUrl?: string);
+    private get url();
+    doGenerate(data: BaseChatModelInput, options?: ReqOptions): Promise<DoGenerateOutput>;
+    doStream(data: BaseChatModelInput, options?: ReqOptions): Promise<DoStreamOutput>;
+}

package/ai/dist/models/Ark/type.d.ts

@@ -0,0 +1,71 @@
+type UserMessage = {
+    role: 'user';
+    content: string;
+};
+type SystemMessage = {
+    role: 'system';
+    content: string;
+};
+type ToolMessage = {
+    role: 'tool';
+    content: string;
+    tool_call_id: string;
+};
+type AssistantMessage = {
+    role: 'assistant';
+    content: string;
+} | {
+    role: 'assistant';
+    tool_calls: Array<ToolCall>;
+    content?: string;
+};
+type ToolCall = {
+    id: string;
+    type: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+type ArkMessage = UserMessage | SystemMessage | AssistantMessage | ToolMessage;
+export type ArkInputData = {
+    model: string;
+    messages: Array<ArkMessage>;
+    max_tokens?: number;
+    stop?: string | Array<string>;
+    frequency_penalty?: number;
+    temperature?: number;
+    top_p?: number;
+    tools?: Array<Tool>;
+};
+type Tool = {
+    type: string;
+    function: {
+        name: string;
+        description?: string;
+        parameters?: object;
+    };
+};
+export type ArkGenerateTextOutput = {
+    choices?: Array<{
+        finish_reason: string;
+        message?: AssistantMessage;
+    }>;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+};
+export type ArkStreamTextOutput = {
+    choices?: Array<{
+        finish_reason: string;
+        delta: AssistantMessage;
+    }>;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+};
+export {};

package/ai/dist/models/DashScope/index.d.ts

@@ -0,0 +1,10 @@
+import type { ModelReq, BaseChatModelInput, DoGenerateOutput, DoStreamOutput, SimpleChatModel, ReqOptions } from '../../type';
+export declare class DSSimpleModel implements SimpleChatModel {
+    private req;
+    baseUrl: string;
+    subUrl: string;
+    constructor(req: ModelReq, baseUrl: string, subUrl?: string);
+    private get url();
+    doGenerate(data: BaseChatModelInput, options?: ReqOptions): Promise<DoGenerateOutput>;
+    doStream(data: BaseChatModelInput, options?: ReqOptions): Promise<DoStreamOutput>;
+}

package/ai/dist/models/DashScope/type.d.ts

@@ -0,0 +1,74 @@
+export type DSInput = {
+    model: string;
+    messages: Array<Message>;
+    temperature?: number;
+    top_p?: number;
+    tools?: Array<{
+        type: string;
+        function: {
+            name: string;
+            description: string;
+            parameters: object;
+        };
+    }>;
+};
+type Message = SystemMessage | UserMessage | AssistantMessage | ToolMessage;
+type SystemMessage = {
+    content: string;
+    role: 'system';
+};
+type UserMessage = {
+    content: string;
+    role: 'user';
+};
+type ToolMessage = {
+    content: string;
+    role: 'tool';
+};
+type AssistantMessage = {
+    role: 'assistant';
+    content: string;
+} | {
+    role: 'assistant';
+    tool_calls: Array<ToolCall>;
+    content?: string;
+};
+type ToolCall = {
+    id: string;
+    type: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+export type DSGenerateOutput = {
+    choices: Array<{
+        finish_reason: string;
+        message: {
+            content: string;
+            role: 'assistant';
+            tool_calls?: Array<ToolCall>;
+        };
+    }>;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+};
+export type DSStreamOutput = {
+    choices: Array<{
+        delta: {
+            content: string;
+            tool_calls?: Array<ToolCall>;
+            role?: 'assistant';
+        };
+        finish_reason: string;
+    }>;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+};
+export {};

package/ai/dist/models/DeepSeek/index.d.ts

@@ -0,0 +1,10 @@
+import type { ModelReq, BaseChatModelInput, SimpleChatModel, DoStreamOutput, DoGenerateOutput, ReqOptions } from '../../type';
+export declare class DeepSeekSimpleModel implements SimpleChatModel {
+    private req;
+    baseUrl: string;
+    subUrl: string;
+    constructor(req: ModelReq, baseUrl: string, subUrl?: string);
+    private get url();
+    doGenerate(data: BaseChatModelInput, options?: ReqOptions): Promise<DoGenerateOutput>;
+    doStream(data: BaseChatModelInput, options?: ReqOptions): Promise<DoStreamOutput>;
+}

package/ai/dist/models/Default/index.d.ts

@@ -0,0 +1,10 @@
+import type { ModelReq, BaseChatModelInput, SimpleChatModel, DoStreamOutput, DoGenerateOutput } from '../../type';
+export declare class DefaultSimpleModel implements SimpleChatModel {
+    private req;
+    baseUrl: string;
+    subUrl: string;
+    constructor(req: ModelReq, baseUrl: string, subUrl?: string);
+    private get url();
+    doGenerate(data: BaseChatModelInput): Promise<DoGenerateOutput>;
+    doStream(data: BaseChatModelInput): Promise<DoStreamOutput>;
+}

package/ai/dist/models/HunYuan/index.d.ts

@@ -0,0 +1,10 @@
+import type { ModelReq, BaseChatModelInput, DoStreamOutput, SimpleChatModel, DoGenerateOutput, ReqOptions } from '../../type';
+export declare class HunYuanSimpleModel implements SimpleChatModel {
+    private req;
+    baseUrl: string;
+    subUrl: string;
+    constructor(req: ModelReq, baseUrl: string, subUrl?: string);
+    private get url();
+    doGenerate(data: BaseChatModelInput, options?: ReqOptions): Promise<DoGenerateOutput>;
+    doStream(data: BaseChatModelInput, options?: ReqOptions): Promise<DoStreamOutput>;
+}

package/ai/dist/models/HunYuan/type.d.ts

@@ -0,0 +1,74 @@
+type HunYuanUserMessage = {
+    role: 'user';
+    content: string;
+};
+type HunYuanSystemMessage = {
+    role: 'system';
+    content: string;
+};
+type HunYuanToolMessage = {
+    role: 'tool';
+    content: string;
+    tool_call_id: string;
+};
+type HunYuanAssistantMessage = {
+    role: 'assistant';
+    content: string;
+} | {
+    role: 'assistant';
+    tool_calls: Array<HunYuanToolCall>;
+    content?: string;
+};
+type HunYuanToolCall = {
+    id: string;
+    type: 'function';
+    function: HunYuanToolCallFunction;
+};
+type HunYuanToolCallFunction = {
+    name: string;
+    arguments: string;
+};
+export type HunYuanMessage = HunYuanUserMessage | HunYuanSystemMessage | HunYuanToolMessage | HunYuanAssistantMessage;
+type HunYuanTool = {
+    type: 'function';
+    function: HunYuanToolFunction;
+};
+type HunYuanToolFunction = {
+    name: string;
+    parameters: object;
+    description?: string;
+};
+export type HunYuanInputData = {
+    model: (string & {}) | 'hunyuan-lite' | 'hunyuan-standard' | 'hunyuan-standard-256K' | 'hunyuan-pro' | 'hunyuan-code' | 'hunyuan-role' | 'hunyuan-functioncall' | 'hunyuan-vision';
+    messages: Array<HunYuanMessage>;
+    stream_moderation?: boolean;
+    top_p?: number;
+    temperature?: number;
+    enable_enhancement?: boolean;
+    tools?: Array<HunYuanTool>;
+    tool_choice?: 'none' | 'auto' | 'custom';
+    custom_tool?: HunYuanTool;
+    search_info?: boolean;
+};
+type Usage = {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+};
+export type HunYuanGenerateTextOutput = {
+    choices?: Array<GenerateChoice>;
+    usage?: Usage;
+};
+type GenerateChoice = {
+    finish_reason?: string;
+    message: HunYuanMessage;
+};
+type StreamChoice = {
+    finish_reason?: string;
+    delta: HunYuanAssistantMessage;
+};
+export type HunYuanStreamTextOutput = {
+    choices?: Array<StreamChoice>;
+    usage?: Usage;
+};
+export {};

package/ai/dist/models/HunYuan/util.d.ts

@@ -0,0 +1,4 @@
+import { HunYuanInputData } from './type';
+import { BaseChatModelInput } from '../../type';
+export declare function processInput(input: BaseChatModelInput): HunYuanInputData;
+export declare function titleCaseToSnakeCase(obj: unknown): any;

package/ai/dist/models/HunYuanBeta/index.d.ts

@@ -0,0 +1,10 @@
+import type { ModelReq, BaseChatModelInput, SimpleChatModel, DoStreamOutput, DoGenerateOutput, ReqOptions } from '../../type';
+export declare class HunYuanBetaSimpleModel implements SimpleChatModel {
+    private req;
+    baseUrl: string;
+    subUrl: string;
+    constructor(req: ModelReq, baseUrl: string, subUrl?: string);
+    private get url();
+    doGenerate(data: BaseChatModelInput, options?: ReqOptions): Promise<DoGenerateOutput>;
+    doStream(data: BaseChatModelInput, options?: ReqOptions): Promise<DoStreamOutput>;
+}

package/ai/dist/models/HunYuanExp/index.d.ts

@@ -0,0 +1,10 @@
+import type { ModelReq, BaseChatModelInput, SimpleChatModel, DoStreamOutput, DoGenerateOutput } from '../../type';
+export declare class HunYuanExpSimpleModel implements SimpleChatModel {
+    private req;
+    baseUrl: string;
+    subUrl: string;
+    constructor(req: ModelReq, baseUrl: string, subUrl?: string);
+    private get url();
+    doGenerate(data: BaseChatModelInput): Promise<DoGenerateOutput>;
+    doStream(data: BaseChatModelInput): Promise<DoStreamOutput>;
+}

package/ai/dist/models/HunYuanOpen/index.d.ts

@@ -0,0 +1,10 @@
+import type { ModelReq, BaseChatModelInput, SimpleChatModel, DoStreamOutput, DoGenerateOutput, ReqOptions } from '../../type';
+export declare class HunYuanOpenSimpleModel implements SimpleChatModel {
+    private req;
+    baseUrl: string;
+    subUrl: string;
+    constructor(req: ModelReq, baseUrl: string, subUrl?: string);
+    private get url();
+    doGenerate(data: BaseChatModelInput, options?: ReqOptions): Promise<DoGenerateOutput>;
+    doStream(data: BaseChatModelInput, options?: ReqOptions): Promise<DoStreamOutput>;
+}

package/ai/dist/models/Moonshot/index.d.ts

@@ -0,0 +1,10 @@
+import type { ModelReq, DoGenerateOutput, DoStreamOutput, SimpleChatModel, BaseChatModelInput, ReqOptions } from '../../type';
+export declare class MoonshotSimpleModel implements SimpleChatModel {
+    private req;
+    baseUrl: string;
+    subUrl: string;
+    constructor(req: ModelReq, baseUrl: string, subUrl?: string);
+    private get url();
+    doGenerate(data: BaseChatModelInput, options?: ReqOptions): Promise<DoGenerateOutput>;
+    doStream(data: BaseChatModelInput, options?: ReqOptions): Promise<DoStreamOutput>;
+}