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

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

@@ -0,0 +1,85 @@
+type SystemMessage = {
+    role: 'system';
+    content: string;
+};
+type UserMessage = {
+    role: 'user';
+    content: string;
+};
+type AssistantMessage = {
+    role: 'assistant';
+    content?: string;
+    tool_calls?: Array<{
+        id: string;
+        type: string;
+        function?: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+};
+type ToolMessage = {
+    role: 'tool';
+    content: string;
+    tool_call_id: string;
+};
+type MoonshotMessage = SystemMessage | UserMessage | AssistantMessage | ToolMessage;
+export type MoonshotInputData = {
+    messages: Array<MoonshotMessage>;
+    model: string;
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    n?: number;
+    tools?: Array<{
+        type: string;
+        function: {
+            name: string;
+            description: string;
+            parameters: object;
+        };
+    }>;
+    presence_penalty?: number;
+    frequency_penalty?: number;
+    response_format?: object;
+    stop?: string | Array<string>;
+};
+export type MoonshotGenerateTextOutput = {
+    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 MoonshotStreamTextOutput = {
+    choices: Array<{
+        delta: {
+            content: string;
+            tool_calls?: Array<ToolCall>;
+            role: 'assistant';
+        };
+        finish_reason: string;
+    }>;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+};
+type ToolCall = {
+    id: string;
+    type: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+export {};

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

@@ -0,0 +1,10 @@
+import type { ModelReq, BaseChatModelInput, DoGenerateOutput, DoStreamOutput, SimpleChatModel, ReqOptions } from '../../type';
+export declare class YiSimpleModel 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/Yi/type.d.ts

@@ -0,0 +1,75 @@
+type SystemMessage = {
+    role: 'system';
+    content: string;
+};
+type UserMessage = {
+    role: 'user';
+    content: string;
+};
+type AssistantMessage = {
+    role: 'assistant';
+    content: string;
+} | {
+    role: 'assistant';
+    tool_calls: Array<ToolCall>;
+    content?: string;
+};
+type ToolMessage = {
+    role: 'tool';
+    content: string;
+    tool_call_id: string;
+};
+type YiMessage = SystemMessage | UserMessage | AssistantMessage | ToolMessage;
+export type YiInput = {
+    model: string;
+    messages: Array<YiMessage>;
+    temperature?: number;
+    top_p?: number;
+    tools?: Array<{
+        type: string;
+        function: {
+            name: string;
+            description: string;
+            parameters: object;
+        };
+    }>;
+};
+type ToolCall = {
+    id: string;
+    type: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+export type YiGenerateOutput = {
+    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 YiStreamOutput = {
+    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/ZhiPu/index.d.ts

@@ -0,0 +1,10 @@
+import type { ModelReq, BaseChatModelInput, SimpleChatModel, DoStreamOutput, DoGenerateOutput, ReqOptions } from '../../type';
+export declare class ZhiPuSimpleModel 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/ZhiPu/type.d.ts

@@ -0,0 +1,71 @@
+import { ChatModelMessage } from '../../type';
+type SystemMessage = {
+    role: 'system';
+    content: string;
+};
+type UserMessage = {
+    role: 'user';
+    content: string;
+};
+type AssistantMessage = {
+    role: 'assistant';
+    content?: string;
+    tool_calls?: Array<{
+        id: string;
+        type: string;
+        function?: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+};
+type ToolMessage = {
+    role: 'tool';
+    content: string;
+    tool_call_id: string;
+};
+type ZhiPuMessage = SystemMessage | UserMessage | AssistantMessage | ToolMessage;
+export type ZhiPuInputData = {
+    model: string;
+    messages: Array<ZhiPuMessage>;
+    request_id?: string;
+    do_sample?: boolean;
+    temperature?: number;
+    top_p?: number;
+    max_tokens?: number;
+    stop?: Array<string>;
+    tools?: Array<{
+        type: string;
+        function: {
+            name: string;
+            description: string;
+            parameters: object;
+        };
+    }>;
+    tool_choice?: 'auto';
+    user_id?: string;
+};
+export type ZhiPuGenerateTextOutput = {
+    choices?: Array<{
+        finish_reason?: 'stop' | 'tool_calls' | 'length' | 'sensitive' | 'network_error';
+        message?: ChatModelMessage;
+    }>;
+    usage?: {
+        completion_tokens: number;
+        prompt_tokens: number;
+        total_tokens: number;
+    };
+};
+export type ZhiPuStreamTextOutput = {
+    choices?: Array<{
+        index: number;
+        finish_reason?: 'stop' | 'tool_calls' | 'length' | 'sensitive' | 'network_error';
+        delta?: ChatModelMessage;
+    }>;
+    usage?: {
+        completion_tokens: number;
+        prompt_tokens: number;
+        total_tokens: number;
+    };
+};
+export {};

package/ai/dist/models/image-model.d.ts

@@ -0,0 +1,19 @@
+import type { ModelReq, HunyuanGenerateImageInput, HunyuanGenerateImageOutput, HunyuanARGenerateImageInput, HunyuanARGenerateImageOutput } from '../type';
+interface HunyuanImageGenerateFn {
+    (input: HunyuanARGenerateImageInput): Promise<HunyuanARGenerateImageOutput>;
+    (input: HunyuanGenerateImageInput): Promise<HunyuanGenerateImageOutput>;
+}
+type GenerateImageFn<TProvider> = TProvider extends 'hunyuan-image' ? HunyuanImageGenerateFn : (input: unknown) => Promise<unknown>;
+export declare class DefaultImageModel<TProvider extends string> {
+    private req;
+    baseUrl: string;
+    provider: TProvider;
+    defaultGenerateImageSubUrl: string;
+    generateImageSubUrlConfig: Record<string, Array<[RegExp, string]>>;
+    generateImage: GenerateImageFn<TProvider>;
+    constructor(req: ModelReq, baseUrl: string, provider: TProvider);
+    private generateImageImpl;
+    private getGenerateUrl;
+    private getGenerateImageSubUrl;
+}
+export {};

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

@@ -0,0 +1,26 @@
+import { ZhiPuSimpleModel } from './ZhiPu/index';
+import { HunYuanBetaSimpleModel } from './HunYuanBeta/index';
+import { HunYuanSimpleModel } from './HunYuan/index';
+import { ArkSimpleModel } from './Ark/index';
+import { DSSimpleModel } from './DashScope/index';
+import { YiSimpleModel } from './Yi/index';
+import { MoonshotSimpleModel } from './Moonshot/index';
+import { HunYuanExpSimpleModel } from './HunYuanExp/index';
+import { HunYuanOpenSimpleModel } from './HunYuanOpen/index';
+import { DeepSeekSimpleModel } from './DeepSeek';
+import { DefaultSimpleModel } from './Default';
+import { DefaultImageModel } from './image-model';
+export declare const MODELS: {
+    hunyuan: typeof HunYuanSimpleModel;
+    'hunyuan-beta': typeof HunYuanBetaSimpleModel;
+    ark: typeof ArkSimpleModel;
+    dashscope: typeof DSSimpleModel;
+    '01-ai': typeof YiSimpleModel;
+    moonshot: typeof MoonshotSimpleModel;
+    zhipu: typeof ZhiPuSimpleModel;
+    'hunyuan-exp': typeof HunYuanExpSimpleModel;
+    'hunyuan-open': typeof HunYuanOpenSimpleModel;
+    deepseek: typeof DeepSeekSimpleModel;
+};
+export { ZhiPuSimpleModel, HunYuanBetaSimpleModel, HunYuanSimpleModel, ArkSimpleModel, DSSimpleModel, YiSimpleModel, MoonshotSimpleModel, HunYuanExpSimpleModel, HunYuanOpenSimpleModel, DefaultSimpleModel, DefaultImageModel, };
+export { ReactModel, toolMap } from './model';

package/ai/dist/models/model.d.ts

@@ -0,0 +1,40 @@
+import { BaseChatModelInput, DoStreamOutput, SimpleChatModel, ToolCall, ChatModelMessage, AsyncIterableReadableStream, Usage, ModelTool, FunctionTool, ReqOptions } from '../type';
+type ReactModelInput = ReactProps & Omit<BaseChatModelInput, 'tools'> & {
+    tools?: Array<ModelTool | FunctionTool>;
+    topP?: number;
+    toolChoice?: 'none' | 'auto' | 'custom';
+};
+interface IOnStepFinish {
+    messages: Array<ChatModelMessage>;
+    text?: string;
+    toolCall?: ToolCall;
+    toolResult?: unknown;
+    finishReason?: string;
+    stepUsage?: Usage;
+    totalUsage?: Usage;
+}
+interface ReactProps {
+    maxSteps?: number;
+    onStepFinish?: (prop: IOnStepFinish) => unknown;
+    abortSignal?: AbortSignal;
+}
+export declare class ReactModel {
+    private model;
+    constructor(model: SimpleChatModel);
+    generateText(_input: ReactModelInput, options?: ReqOptions): Promise<{
+        text: string;
+        messages: Array<ChatModelMessage>;
+        usage: Usage;
+        rawResponses: Array<unknown>;
+        error?: any;
+    }>;
+    streamText(_input: ReactModelInput, options?: ReqOptions): Promise<{
+        dataStream: DoStreamOutput;
+        textStream: AsyncIterableReadableStream<string>;
+        messages: Promise<Array<ChatModelMessage>>;
+        usage: Promise<Usage>;
+        error?: any;
+    }>;
+}
+export declare const toolMap: Map<string, CallableFunction>;
+export {};

package/ai/dist/type.d.ts

@@ -0,0 +1,192 @@
+export declare abstract class SimpleChatModel {
+    abstract doGenerate(data: BaseChatModelInput, options?: ReqOptions): Promise<DoGenerateOutput>;
+    abstract doStream(data: BaseChatModelInput, options?: ReqOptions): Promise<DoStreamOutput>;
+}
+type RawResponse = {
+    rawResponse?: any;
+};
+export type DoGenerateOutput = BaseDoGenerateOutput & RawResponse;
+export type DoStreamOutput = AsyncIterableReadableStream<BaseDoStreamOutputChunk & RawResponse>;
+export type ChatModelConstructor = typeof SimpleChatModel;
+export type AsyncIterableReadableStream<T> = ReadableStream<T> & {
+    [Symbol.asyncIterator]: () => {
+        next(): Promise<IteratorResult<T>>;
+    };
+};
+export interface IModelReqInput {
+    url: string;
+    headers?: Record<string, string>;
+    data?: Object;
+    stream?: boolean;
+    timeout?: number;
+}
+export type ModelReq = <T extends IModelReqInput>(props: T) => T['stream'] extends true ? Promise<ReadableStream<Uint8Array>> : Promise<Object>;
+export interface IBotReqInput {
+    url: string;
+    method: string;
+    headers?: Record<string, string>;
+    data?: Object;
+    stream?: boolean;
+    timeout?: number;
+}
+export interface ReqOptions {
+    timeout?: number;
+}
+export type BotReq = <T extends IBotReqInput>(props: T) => T['stream'] extends true ? Promise<ReadableStream<Uint8Array>> : Promise<Object>;
+export type UserMessage = {
+    role: 'user';
+    content: string;
+};
+export type SystemMessage = {
+    role: 'system';
+    content: string;
+};
+export type AssistantMessage = PlainAssistantMessage | ToolCallAssistantMessage;
+export type PlainAssistantMessage = {
+    role: 'assistant';
+    content: string;
+};
+export type ToolCallAssistantMessage = {
+    role: 'assistant';
+    tool_calls: Array<ToolCall>;
+    content?: string;
+};
+export type ToolMessage = {
+    role: 'tool';
+    tool_call_id: string;
+    content: string;
+};
+export type ChatModelMessage = UserMessage | SystemMessage | AssistantMessage | ToolMessage;
+export type FunctionTool = {
+    name: string;
+    description: string;
+    fn: CallableFunction;
+    parameters: object;
+};
+export interface BaseChatModelInput {
+    model: string;
+    messages: Array<ChatModelMessage>;
+    temperature?: number;
+    top_p?: number;
+    tools?: Array<ModelTool>;
+    tool_choice?: 'none' | 'auto' | 'custom';
+}
+export type ModelTool = {
+    type: string;
+    function: ModelToolFunction;
+};
+export type ModelToolFunction = {
+    name: string;
+    description: string;
+    parameters: object;
+};
+export type ToolCall = {
+    id: string;
+    type: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+type FinishReason = 'tool_calls' | (string & {});
+export type Usage = {
+    completion_tokens: number;
+    prompt_tokens: number;
+    total_tokens: number;
+};
+export interface BaseDoGenerateOutput {
+    choices?: Array<{
+        finish_reason?: FinishReason;
+        message?: ChatModelMessage;
+    }>;
+    usage?: Usage;
+}
+export interface BaseDoStreamOutputChunk {
+    choices?: Array<{
+        finish_reason?: FinishReason;
+        delta?: ChatModelMessage;
+    }>;
+    usage?: Usage;
+}
+export interface ImageGenerateInput {
+    model: string;
+    prompt: string;
+    size?: string;
+    n?: number;
+    [key: string]: unknown;
+}
+export interface ImageEditInput {
+    model: string;
+    prompt: string;
+    size?: string;
+    n?: number;
+    [key: string]: unknown;
+}
+export interface HunyuanGenerateImageInput {
+    model: 'hunyuan-image';
+    prompt: string;
+    version?: 'v1.8.1' | 'v1.9' | (string & {});
+    size?: string;
+    negative_prompt?: string;
+    style?: '古风二次元风格' | '都市二次元风格' | '悬疑风格' | '校园风格' | '都市异能风格' | (string & {});
+    revise?: boolean;
+    n?: number;
+    footnote?: string;
+    seed?: number;
+}
+export interface HunyuanARGenerateImageInput {
+    model: 'HY-Image-3.0-Plus-4090-Tob-v1.0' | 'HY-Image-v3.0-I2I-ToB-v1.0.1' | 'hunyuan-image-v3.0-v1.0.4' | 'hunyuan-image-v3.0-v1.0.1' | 'hunyuan-image-v3.0-v1.0.5';
+    prompt: string;
+    size?: string;
+    seed?: number;
+    footnote?: string;
+    revise?: {
+        value: boolean;
+    };
+    enable_thinking?: {
+        value: boolean;
+    };
+    image_urls?: string[];
+    images?: string[];
+}
+export interface HunyuanARGenerateImageOutput {
+    id: string;
+    created: number;
+    data: Array<{
+        url: string;
+        revised_prompt?: string;
+    }>;
+}
+export type HunyuanEditImageInput = {
+    model: 'hunyuan-image' | (string & {});
+    prompt: string;
+    version?: string;
+    size?: string;
+    n?: number;
+    seed?: number;
+    footnote?: string;
+    image?: string;
+    image_url?: string;
+} & ({
+    mask: string;
+    mask_url?: never;
+} | {
+    mask?: never;
+    mask_url: string;
+});
+export interface HunyuanGenerateImageOutput {
+    id: string;
+    created: number;
+    data: Array<{
+        url: string;
+        revised_prompt?: string;
+    }>;
+}
+export interface HunyuanEditImageOutput {
+    id: string;
+    created: number;
+    data: Array<{
+        url: string;
+    }>;
+}
+export {};

package/ai/dist/utils.d.ts

@@ -0,0 +1,38 @@
+import { type ParsedEvent } from './eventsource_parser';
+import type { AsyncIterableReadableStream, ChatModelMessage, ToolCallAssistantMessage, ModelTool, FunctionTool } from './type';
+export declare const ReadableStream: {
+    new (underlyingSource: UnderlyingByteSource, strategy?: {
+        highWaterMark?: number;
+    }): ReadableStream<Uint8Array>;
+    new <R = any>(underlyingSource: UnderlyingDefaultSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
+    new <R_1 = any>(underlyingSource?: UnderlyingSource<R_1>, strategy?: QueuingStrategy<R_1>): ReadableStream<R_1>;
+    prototype: ReadableStream;
+};
+export declare const TransformStream: {
+    new <I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
+    prototype: TransformStream;
+};
+export declare const createEventSourceParserTransformStream: () => TransformStream<string, ParsedEvent>;
+export declare const toPolyfillReadable: (readable: any) => any;
+export declare class TextDecoderStream {
+    private handle;
+    private transform;
+    constructor(encoding?: string, options?: TextDecoderOptions);
+    get encoding(): string;
+    get fatal(): boolean;
+    get ignoreBOM(): boolean;
+    get readable(): ReadableStream<any>;
+    get writable(): WritableStream<any>;
+    get [Symbol.toStringTag](): string;
+}
+export declare function createAsyncIterable<T>(stream: ReadableStream<T>): AsyncIterableReadableStream<T>;
+export declare function intoStandardStream<T>(stream: ReadableStream<Uint8Array>): ReadableStream<T>;
+export declare function intoTextStream(stream: ReadableStream<Uint8Array>): AsyncIterableReadableStream<string>;
+export declare function readableStream2JsonObject(stream: ReadableStream): Promise<any>;
+export declare function createPromise<T = unknown>(): {
+    promise: Promise<T>;
+    res: (value: T | PromiseLike<T>) => void;
+    rej: (reason?: any) => void;
+};
+export declare function isToolCallAssistantMessage(message: ChatModelMessage): message is ToolCallAssistantMessage;
+export declare function functionToolToModelTool(tool: FunctionTool): ModelTool;

package/apis/dist/callApis.d.ts

@@ -0,0 +1,20 @@
+import { ICallApiOptions, KV } from '@cloudbase/js-sdk/types';
+import { ResponseObject, SDKRequestInterface } from '@cloudbase/adapter-interface';
+export declare function callApi(callApiOptions: ICallApiOptions, opts?: KV<any>): Promise<ResponseObject['data']>;
+declare type MethodType = 'request' | 'post' | 'get' | 'head' | 'patch' | 'delete' | 'put';
+export declare function generateCallApis(apiName: string): {
+    [method in MethodType]: typeof callApi;
+};
+export declare function generateApis(params?: {
+    env?: string;
+    request?: SDKRequestInterface;
+    gatewayOrigin?: string;
+    getAccessToken?: () => Promise<{
+        accessToken: string;
+    }>;
+}): {
+    [apiName: string]: {
+        [method in MethodType]: typeof callApi;
+    };
+};
+export {};

package/apis/dist/index.d.ts

@@ -1 +1,5 @@
-export * from '@cloudbase/apis';
+import type { ICloudbase } from '@cloudbase/js-sdk/types';
+import { generateApis } from './callApis';
+declare function registerApis(app: ICloudbase): void;
+export { generateApis, registerApis };
+export * from './type';

package/apis/dist/type.d.ts

@@ -0,0 +1,14 @@
+import { KV } from '@cloudbase/js-sdk/types';
+export interface IGenericError<T extends string, P = any> extends Error {
+    type: T;
+    payload: P;
+    generic: boolean;
+}
+export interface ICallApiOptions {
+    name?: string;
+    path?: string;
+    method?: string;
+    headers?: KV<any>;
+    body?: KV<any> | string;
+    token?: string;
+}

package/app/dist/constants/common.d.ts

@@ -0,0 +1,38 @@
+import { EndPointKey } from '@cloudbase/js-sdk/types';
+export declare function setSdkVersion(version: string): void;
+export declare function getSdkVersion(): string;
+export declare function setSdkName(name: string): void;
+export declare function getSdkName(): string;
+export declare const DATA_VERSION = "2020-01-10";
+interface EndPointInfo {
+    env: string;
+    endPointKey: EndPointKey;
+    region?: string;
+    baseUrl?: string;
+    protocol?: Protocol;
+}
+type Protocol = 'http' | 'https' | 'http:' | 'https:';
+export declare const DEFAULT_PROTOCOL: 'http:' | 'https:';
+export declare function setEndPointInfo(newInfo: EndPointInfo): void;
+export declare function getEndPointInfo(env: string, endPointKey: EndPointKey, region?: string): EndPointInfo;
+export interface ISetEndPointWithKey {
+    key: EndPointKey;
+    url?: string;
+    protocol?: 'http' | 'https';
+}
+export declare function setGatewayEndPointWithEnv(env: string, protocol?: Protocol, intl?: boolean): void;
+export declare function setRegionLevelEndpoint(env: string, region: string, protocol?: Protocol): void;
+export declare function getBaseEndPoint(env: string, endPointKey?: EndPointKey): string;
+export declare enum LOGINTYPE {
+    NULL = "NULL",
+    ANONYMOUS = "ANONYMOUS",
+    WECHAT = "WECHAT",
+    WECHAT_PUBLIC = "WECHAT-PUBLIC",
+    WECHAT_OPEN = "WECHAT-OPEN",
+    CUSTOM = "CUSTOM",
+    EMAIL = "EMAIL",
+    USERNAME = "USERNAME",
+    PHONE = "PHONE"
+}
+export declare const OAUTH2_LOGINTYPE_PREFIX = "OAUTH2";
+export {};