@cloudbase/js-sdk 3.3.14-beta.3 → 3.3.14-beta.4

package/node_modules/@cloudbase/ai/dist/cjs/type.d.ts

@@ -0,0 +1,190 @@
+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: 'hunyuan-image-v3.0-v1.0.4' | 'hunyuan-image-v3.0-v1.0.1';
+    prompt: string;
+    size?: string;
+    seed?: number;
+    footnote?: string;
+    revise?: {
+        value: boolean;
+    };
+    enable_thinking?: {
+        value: boolean;
+    };
+}
+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/node_modules/@cloudbase/ai/dist/cjs/type.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleChatModel = void 0;
+var SimpleChatModel = (function () {
+    function SimpleChatModel() {
+    }
+    return SimpleChatModel;
+}());
+exports.SimpleChatModel = SimpleChatModel;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type.js","sourceRoot":"","sources":["../../src/type.ts"],"names":[],"mappings":";;;AAAA;IAAA;IAIA,CAAC;IAAD,sBAAC;AAAD,CAAC,AAJD,IAIC;AAJqB,0CAAe","sourcesContent":["export abstract class SimpleChatModel {\n  public abstract doGenerate(data: BaseChatModelInput, options?: ReqOptions): Promise<DoGenerateOutput>\n\n  public abstract doStream(data: BaseChatModelInput, options?: ReqOptions): Promise<DoStreamOutput>\n}\n\ntype RawResponse = { rawResponse?: any }\n\nexport type DoGenerateOutput = BaseDoGenerateOutput & RawResponse\n\nexport type DoStreamOutput = AsyncIterableReadableStream<BaseDoStreamOutputChunk & RawResponse>\n\nexport type ChatModelConstructor = typeof SimpleChatModel\n\nexport type AsyncIterableReadableStream<T> = ReadableStream<T> & {\n  [Symbol.asyncIterator]: () => { next(): Promise<IteratorResult<T>> }\n}\n\nexport interface IModelReqInput {\n  url: string\n  headers?: Record<string, string>\n  data?: Object\n  stream?: boolean\n  timeout?: number\n}\n\nexport type ModelReq = <T extends IModelReqInput>(\n  props: T,\n) => T['stream'] extends true ? Promise<ReadableStream<Uint8Array>> : Promise<Object>\n\nexport interface IBotReqInput {\n  url: string\n  method: string\n  headers?: Record<string, string>\n  data?: Object\n  stream?: boolean\n  timeout?: number\n}\n\nexport interface ReqOptions {\n  timeout?: number\n}\n\nexport type BotReq = <T extends IBotReqInput>(\n  props: T,\n) => T['stream'] extends true ? Promise<ReadableStream<Uint8Array>> : Promise<Object>\n\nexport type UserMessage = {\n  role: 'user'\n  content: string\n}\n\nexport type SystemMessage = {\n  role: 'system'\n  content: string\n}\n\nexport type AssistantMessage = PlainAssistantMessage | ToolCallAssistantMessage\n\nexport type PlainAssistantMessage = {\n  role: 'assistant'\n  content: string\n}\n\nexport type ToolCallAssistantMessage = {\n  role: 'assistant'\n  tool_calls: Array<ToolCall>\n  content?: string\n}\n\nexport type ToolMessage = {\n  role: 'tool'\n  tool_call_id: string\n  content: string\n}\n\nexport type ChatModelMessage = UserMessage | SystemMessage | AssistantMessage | ToolMessage\n\nexport type FunctionTool = {\n  name: string\n  description: string\n  fn: CallableFunction\n  parameters: object\n}\n\n// #region 大模型标准输入类型\nexport interface BaseChatModelInput {\n  model: string\n  messages: Array<ChatModelMessage>\n  temperature?: number\n  top_p?: number\n  tools?: Array<ModelTool>\n  tool_choice?: 'none' | 'auto' | 'custom'\n}\n\n/**\n * 给 LLM 发请求时要传的工具\n */\nexport type ModelTool = {\n  type: string\n  function: ModelToolFunction\n}\n\n/**\n * 给 LLM 发请求时要传的工具函数\n */\nexport type ModelToolFunction = {\n  name: string\n  description: string\n  /**\n   * 描述函数参数的 JSON Schema\n   */\n  parameters: object\n}\n// #endregion\n\n// #region 大模型标准响应类型\nexport type ToolCall = {\n  id: string\n  type: string\n  function: { name: string; arguments: string }\n}\n\ntype FinishReason = 'tool_calls' | (string & {})\n\nexport type Usage = {\n  completion_tokens: number\n  prompt_tokens: number\n  total_tokens: number\n}\n\nexport interface BaseDoGenerateOutput {\n  choices?: Array<{\n    finish_reason?: FinishReason\n    message?: ChatModelMessage\n  }>\n  usage?: Usage\n}\n\nexport interface BaseDoStreamOutputChunk {\n  choices?: Array<{\n    finish_reason?: FinishReason\n    delta?: ChatModelMessage\n  }>\n  usage?: Usage\n}\n// #endregion\n\n// #region Image Model Types\n/**\n * 图片生成输入参数\n */\nexport interface ImageGenerateInput {\n  model: string // 模型名称，例如 'hunyuan-image'、'dall-e-3'\n  prompt: string // 用于描述要生成的图片内容\n  size?: string // 尺寸\n  n?: number // 张数\n  [key: string]: unknown // 允许额外的厂商特定参数\n}\n\n/**\n * 图片编辑输入参数\n */\nexport interface ImageEditInput {\n  model: string\n  prompt: string\n  size?: string // 尺寸\n  n?: number // 张数\n  [key: string]: unknown // 允许额外的厂商特定参数\n}\n\nexport interface HunyuanGenerateImageInput {\n  model: 'hunyuan-image'\n  /** 用来生成图像的文本描述 */\n  prompt: string\n  /**\n   * 模型版本，支持 v1.8.1 和 v1.9，默认版本 v1.8.1\n   * - v1.8.1: 采用二阶段模型支持文生图任务，针对图像细节、稳定性等要求高的任务较为合适\n   * - v1.9: 采用模型矩阵能力支持文生图任务，后端由人像、游戏、通用模型，以及各类功能插件组成，灵活适配多种文生图任务\n   */\n  version?: 'v1.8.1' | 'v1.9' | (string & {})\n  /**\n   * 图片尺寸，默认 \"1024x1024\"\n   * v1.9 仅支持以下几个尺寸：\n   * - 1024x1024\n   * - 1024x768, 1152x864\n   * - 768x1024, 864x1152\n   * - 1280x768 (16:9)\n   * - 768x1280 (9:16)\n   * - 1280x720 (16:9)\n   * - 720x1280 (9:16)\n   *\n   * 支持用户自定义尺寸，但输入尺寸只支持 768-1280 之间且为 64 的倍数的数字\n   */\n  size?: string\n  /**\n   * 仅 v1.9 支持，负向词\n   * 如果不传则使用各个模型内部的默认负向词\n   */\n  negative_prompt?: string\n  /**\n   * 仅 v1.9 支持，可指定风格：\n   * - 古风二次元风格\n   * - 都市二次元风格\n   * - 悬疑风格\n   * - 校园风格\n   * - 都市异能风格\n   */\n  style?: '古风二次元风格' | '都市二次元风格' | '悬疑风格' | '校园风格' | '都市异能风格' | (string & {})\n  /**\n   * 为 true 时对 prompt 进行改写，实际生成的图片会使用改写后的 prompt 进行生成\n   * 多数场景可提升生成的图片效果，默认为 true\n   */\n  revise?: boolean\n  /**\n   * 生成图片个数，默认为 1\n   * 目前只支持生成一张，固定为 1，传其他的值会报错\n   */\n  n?: number\n  /**\n   * 业务自定义水印内容\n   * 限制 16 个字符长度（不区分中英文），生成在图片右下角\n   */\n  footnote?: string\n  /**\n   * 生成种子，仅当生成图片数为 1 时生效\n   * 范围 [1, 4294967295]，不传时默认随机\n   */\n  seed?: number\n}\n\nexport interface HunyuanARGenerateImageInput {\n  /** 模型名称：hunyuan-image-v3.0-v1.0.4（推荐）或 hunyuan-image-v3.0-v1.0.1 */\n  model: 'hunyuan-image-v3.0-v1.0.4' | 'hunyuan-image-v3.0-v1.0.1'\n  /** 生成图片使用的文本，不超过 8192 字符 */\n  prompt: string\n  /**\n   * 图片尺寸，格式 \"${宽}x${高}\"，默认 \"1024x1024\"\n   * hunyuan-image-v3.0-v1.0.4：宽高 [512, 2048]，面积不超过 1024x1024\n   * hunyuan-image-v3.0-v1.0.1：支持固定尺寸列表\n   */\n  size?: string\n  /** 生成种子，仅当生成图片数为 1 时生效，范围 [1, 4294967295] */\n  seed?: number\n  /** 业务自定义水印内容，限制 16 字符，生成在图片右下角 */\n  footnote?: string\n  /** 是否对 prompt 改写，默认开启。改写会增加约 30s 耗时 */\n  revise?: { value: boolean }\n  /** 改写是否开启 thinking 模式，默认开启。开启后效果提升但耗时增加（最大 60s） */\n  enable_thinking?: { value: boolean }\n}\n\nexport interface HunyuanARGenerateImageOutput {\n  /** 此次请求的 id */\n  id: string\n  /** unix 时间戳 */\n  created: number\n  /** 返回的图片生成内容 */\n  data: Array<{\n    /** 生成的图片 url，有效期 24 小时 */\n    url: string\n    /** 改写后的 prompt */\n    revised_prompt?: string\n  }>\n}\n\nexport type HunyuanEditImageInput = {\n  /** 模型名称，本期为 hunyuan-image，即为商品图编辑场景 */\n  model: 'hunyuan-image' | (string & {})\n  /** 编辑的文本描述 */\n  prompt: string\n  /** 模型版本 */\n  version?: string\n  /**\n   * 图片尺寸，默认 \"800x800\"\n   * 支持用户自定义尺寸，但输入尺寸只支持 512-1280 之间\n   * 目前只支持 1:1、16:9、9:16 三个尺寸\n   */\n  size?: string\n  /**\n   * 生成图片个数，默认为 1\n   * 目前只支持生成一张，固定为 1，传其他的值会报错\n   */\n  n?: number\n  /**\n   * beta 参数，随机种子\n   * 范围 [1, 4294967295]，不传时默认随机\n   */\n  seed?: number\n  /**\n   * 业务自定义角标内容\n   * 限制 16 个字符长度（不区分中英文）\n   */\n  footnote?: string\n  /**\n   * 图 base64 编码，大小不超过 6M\n   * 支持 jpg/jpeg 格式，和 image_url 二选一\n   * 长短边比例要求 2:1 内\n   */\n  image?: string\n  /**\n   * 图片 url\n   * 长短边比例要求 2:1 内，和 image 二选一\n   */\n  image_url?: string\n} & (\n  | {\n    mask: string\n    mask_url?: never\n  }\n  | {\n    mask?: never\n    mask_url: string\n  }\n)\n\n/**\n * 混元图片生成输出\n */\nexport interface HunyuanGenerateImageOutput {\n  /** 此次请求的 id */\n  id: string\n  /** unix 时间戳 */\n  created: number\n  /** 返回的图片生成内容 */\n  data: Array<{\n    /** 生成的图片 url，有效期为 24 小时 */\n    url: string\n    /** 原 prompt 改写后的文本。若 revise 为 false，则为原 prompt */\n    revised_prompt?: string\n  }>\n}\n\n/**\n * 混元图片编辑输出\n */\nexport interface HunyuanEditImageOutput {\n  /** 此次请求的 id */\n  id: string\n  /** unix 时间戳 */\n  created: number\n  /** 返回的图片生成内容 */\n  data: Array<{\n    /** 生成的图片 url，有效期为 24 小时 */\n    url: string\n  }>\n}\n\n// #endregion\n"]}

package/node_modules/@cloudbase/ai/dist/cjs/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: import("@mattiasbuelens/web-streams-adapter").ReadableStreamWrapper;
+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/node_modules/@cloudbase/ai/dist/cjs/utils.js

@@ -0,0 +1,263 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionToolToModelTool = exports.isToolCallAssistantMessage = exports.createPromise = exports.readableStream2JsonObject = exports.intoTextStream = exports.intoStandardStream = exports.createAsyncIterable = exports.TextDecoderStream = exports.toPolyfillReadable = exports.createEventSourceParserTransformStream = exports.TransformStream = exports.ReadableStream = void 0;
+var web_streams_polyfill_1 = require("web-streams-polyfill");
+var web_streams_adapter_1 = require("@mattiasbuelens/web-streams-adapter");
+var eventsource_parser_1 = require("./eventsource_parser");
+var text_encoding_shim_1 = require("text-encoding-shim");
+exports.ReadableStream = web_streams_polyfill_1.ReadableStream;
+exports.TransformStream = web_streams_polyfill_1.TransformStream;
+var createEventSourceParserTransformStream = function () {
+    var parser;
+    return new exports.TransformStream({
+        start: function (controller) {
+            parser = (0, eventsource_parser_1.createParser)(function (event) {
+                if (event.type === 'event') {
+                    controller.enqueue(event);
+                }
+            });
+        },
+        transform: function (chunk) {
+            parser.feed(chunk);
+        },
+    });
+};
+exports.createEventSourceParserTransformStream = createEventSourceParserTransformStream;
+exports.toPolyfillReadable = (0, web_streams_adapter_1.createReadableStreamWrapper)(exports.ReadableStream);
+var TextDecoderStream = (function () {
+    function TextDecoderStream(encoding, options) {
+        if (encoding === void 0) { encoding = 'utf-8'; }
+        if (options === void 0) { options = {}; }
+        var _this = this;
+        this.transform = new exports.TransformStream({
+            transform: function (chunk, controller) {
+                var value = _this.handle.decode(new Uint8Array(chunk), { stream: true });
+                if (value) {
+                    controller.enqueue(value);
+                }
+            },
+            flush: function (controller) {
+                var value = _this.handle.decode();
+                if (value) {
+                    controller.enqueue(value);
+                }
+                controller.terminate();
+            },
+        });
+        this.handle = new text_encoding_shim_1.TextDecoder(encoding, options);
+    }
+    Object.defineProperty(TextDecoderStream.prototype, "encoding", {
+        get: function () {
+            return this.handle.encoding;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextDecoderStream.prototype, "fatal", {
+        get: function () {
+            return this.handle.fatal;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextDecoderStream.prototype, "ignoreBOM", {
+        get: function () {
+            return this.handle.ignoreBOM;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextDecoderStream.prototype, "readable", {
+        get: function () {
+            return this.transform.readable;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextDecoderStream.prototype, "writable", {
+        get: function () {
+            return this.transform.writable;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextDecoderStream.prototype, Symbol.toStringTag, {
+        get: function () {
+            return 'TextDecoderStream';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return TextDecoderStream;
+}());
+exports.TextDecoderStream = TextDecoderStream;
+function createAsyncIterable(stream) {
+    var _stream = stream;
+    _stream[Symbol.asyncIterator] = function () {
+        var reader = stream.getReader();
+        return {
+            next: function () {
+                return __awaiter(this, void 0, void 0, function () {
+                    var _a, done, value;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0: return [4, reader.read()];
+                            case 1:
+                                _a = _b.sent(), done = _a.done, value = _a.value;
+                                return [2, done ? { done: true, value: undefined } : { done: false, value: value }];
+                        }
+                    });
+                });
+            },
+        };
+    };
+    return _stream;
+}
+exports.createAsyncIterable = createAsyncIterable;
+function intoStandardStream(stream) {
+    return createAsyncIterable(stream
+        .pipeThrough(new TextDecoderStream())
+        .pipeThrough((0, exports.createEventSourceParserTransformStream)())
+        .pipeThrough(new exports.TransformStream({
+        transform: function (chunk, controller) {
+            try {
+                var data = JSON.parse(chunk.data);
+                controller.enqueue(data);
+            }
+            catch (e) {
+                if (chunk.data !== '[DONE]') {
+                    console.warn('Error when transforming event source data to json', e, chunk);
+                }
+                else {
+                    controller.terminate();
+                }
+            }
+        },
+    })));
+}
+exports.intoStandardStream = intoStandardStream;
+function intoTextStream(stream) {
+    return createAsyncIterable((0, exports.toPolyfillReadable)(stream).pipeThrough(new TextDecoderStream()));
+}
+exports.intoTextStream = intoTextStream;
+function readableStream2JsonObject(stream) {
+    var _a, e_1, _b, _c;
+    return __awaiter(this, void 0, void 0, function () {
+        var s, total, _d, s_1, s_1_1, chunk, e_1_1;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    s = intoTextStream(stream);
+                    total = '';
+                    _e.label = 1;
+                case 1:
+                    _e.trys.push([1, 6, 7, 12]);
+                    _d = true, s_1 = __asyncValues(s);
+                    _e.label = 2;
+                case 2: return [4, s_1.next()];
+                case 3:
+                    if (!(s_1_1 = _e.sent(), _a = s_1_1.done, !_a)) return [3, 5];
+                    _c = s_1_1.value;
+                    _d = false;
+                    try {
+                        chunk = _c;
+                        total += chunk;
+                    }
+                    finally {
+                        _d = true;
+                    }
+                    _e.label = 4;
+                case 4: return [3, 2];
+                case 5: return [3, 12];
+                case 6:
+                    e_1_1 = _e.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3, 12];
+                case 7:
+                    _e.trys.push([7, , 10, 11]);
+                    if (!(!_d && !_a && (_b = s_1.return))) return [3, 9];
+                    return [4, _b.call(s_1)];
+                case 8:
+                    _e.sent();
+                    _e.label = 9;
+                case 9: return [3, 11];
+                case 10:
+                    if (e_1) throw e_1.error;
+                    return [7];
+                case 11: return [7];
+                case 12: return [2, JSON.parse(total)];
+            }
+        });
+    });
+}
+exports.readableStream2JsonObject = readableStream2JsonObject;
+function createPromise() {
+    var res;
+    var rej;
+    var promise = new Promise(function (resolve, reject) {
+        res = resolve;
+        rej = reject;
+    });
+    return { promise: promise, res: res, rej: rej };
+}
+exports.createPromise = createPromise;
+function isToolCallAssistantMessage(message) {
+    var _a;
+    return message.role === 'assistant' && 'tool_calls' in message && ((_a = message.tool_calls) === null || _a === void 0 ? void 0 : _a[0]) != null;
+}
+exports.isToolCallAssistantMessage = isToolCallAssistantMessage;
+function functionToolToModelTool(tool) {
+    return {
+        type: 'function',
+        function: {
+            description: tool.description,
+            name: tool.name,
+            parameters: tool.parameters,
+        },
+    };
+}
+exports.functionToolToModelTool = functionToolToModelTool;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { TransformStream as _TransformStream, ReadableStream as _ReadableStream } from 'web-streams-polyfill'\nimport { createReadableStreamWrapper } from '@mattiasbuelens/web-streams-adapter'\nimport { createParser, type EventSourceParser, type ParsedEvent } from './eventsource_parser'\nimport type {\n  AsyncIterableReadableStream,\n  ChatModelMessage,\n  ToolCallAssistantMessage,\n  ModelTool,\n  FunctionTool,\n} from './type'\nimport { TextDecoder } from 'text-encoding-shim'\n\nexport const ReadableStream = _ReadableStream as {\n  prototype: ReadableStream\n\n  new (\n    underlyingSource: UnderlyingByteSource,\n    strategy?: {\n      highWaterMark?: number\n    },\n  ): ReadableStream<Uint8Array>\n  new <R = any>(underlyingSource: UnderlyingDefaultSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>\n  new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>\n}\n\nexport const TransformStream = _TransformStream as {\n  prototype: TransformStream\n\n  new <I = any, O = any>(\n    transformer?: Transformer<I, O>,\n    writableStrategy?: QueuingStrategy<I>,\n    readableStrategy?: QueuingStrategy<O>,\n  ): TransformStream<I, O>\n}\n\nexport const createEventSourceParserTransformStream = () => {\n  let parser!: EventSourceParser\n\n  return new TransformStream<string, ParsedEvent>({\n    start(controller) {\n      parser = createParser((event) => {\n        if (event.type === 'event') {\n          controller.enqueue(event)\n        }\n      })\n    },\n    transform(chunk) {\n      parser.feed(chunk)\n    },\n  })\n}\n\nexport const toPolyfillReadable = createReadableStreamWrapper(ReadableStream)\n\nexport class TextDecoderStream {\n  private handle: TextDecoder\n\n  private transform = new TransformStream({\n    transform: (chunk, controller) => {\n      const value = this.handle.decode(new Uint8Array(chunk), { stream: true })\n\n      if (value) {\n        controller.enqueue(value)\n      }\n    },\n    flush: (controller) => {\n      const value = this.handle.decode()\n      if (value) {\n        controller.enqueue(value)\n      }\n\n      controller.terminate()\n    },\n  })\n\n  constructor(encoding = 'utf-8', options: TextDecoderOptions = {}) {\n    this.handle = new TextDecoder(encoding, options)\n  }\n\n  get encoding() {\n    return this.handle.encoding\n  }\n\n  get fatal() {\n    return this.handle.fatal\n  }\n\n  get ignoreBOM() {\n    return this.handle.ignoreBOM\n  }\n\n  get readable() {\n    return this.transform.readable\n  }\n\n  get writable() {\n    return this.transform.writable\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'TextDecoderStream'\n  }\n}\n\nexport function createAsyncIterable<T>(stream: ReadableStream<T>) {\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  const _stream = stream as AsyncIterableReadableStream<T>\n  (_stream as any)[Symbol.asyncIterator] = () => {\n    const reader = stream.getReader()\n    return {\n      async next(): Promise<IteratorResult<T>> {\n        const { done, value } = await reader.read()\n        return done ? { done: true, value: undefined } : { done: false, value }\n      },\n    }\n  }\n  return _stream\n}\n\n/**\n * 将 SSE 二进制流转换为 T 类型的流\n */\nexport function intoStandardStream<T>(stream: ReadableStream<Uint8Array>): ReadableStream<T> {\n  return createAsyncIterable(stream\n    .pipeThrough(new TextDecoderStream())\n    .pipeThrough(createEventSourceParserTransformStream())\n    .pipeThrough(new TransformStream<ParsedEvent, T>({\n      transform(chunk, controller) {\n        try {\n          const data = JSON.parse(chunk.data) as T\n          controller.enqueue(data)\n        } catch (e) {\n          if (chunk.data !== '[DONE]') {\n            console.warn('Error when transforming event source data to json', e, chunk)\n          } else {\n            controller.terminate()\n          }\n        }\n      },\n    }),),)\n}\n\n/**\n * 将 SSE 二进制流转换为字符串流\n */\nexport function intoTextStream(stream: ReadableStream<Uint8Array>): AsyncIterableReadableStream<string> {\n  return createAsyncIterable((toPolyfillReadable(stream) as typeof stream).pipeThrough(new TextDecoderStream()))\n}\n\nexport async function readableStream2JsonObject(stream: ReadableStream) {\n  const s = intoTextStream(stream)\n  let total = ''\n  for await (const chunk of s) {\n    total += chunk\n  }\n  return JSON.parse(total)\n}\n\nexport function createPromise<T = unknown>() {\n  let res: (value: T | PromiseLike<T>) => void\n  let rej: (reason?: any) => void\n  const promise = new Promise<T>((resolve, reject) => {\n    res = resolve\n    rej = reject\n  })\n  return { promise, res, rej }\n}\n\nexport function isToolCallAssistantMessage(message: ChatModelMessage): message is ToolCallAssistantMessage {\n  // eslint-disable-next-line eqeqeq\n  return message.role === 'assistant' && 'tool_calls' in message && message.tool_calls?.[0] != null\n}\n\nexport function functionToolToModelTool(tool: FunctionTool): ModelTool {\n  return {\n    type: 'function',\n    function: {\n      description: tool.description,\n      name: tool.name,\n      parameters: tool.parameters,\n    },\n  }\n}\n"]}

package/node_modules/@cloudbase/ai/dist/esm/AI.d.ts

@@ -0,0 +1,27 @@
+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/types';
+declare class AI {
+    private req;
+    baseUrl: string;
+    aiBaseUrl: string;
+    aiBotBaseUrl: string;
+    bot: Bot;
+    i18n: ICloudbaseConfig['i18n'];
+    defaultHeaders: {
+        [x: string]: any;
+    };
+    constructor(req: SDKRequestInterface, baseUrl: string, i18n: ICloudbaseConfig['i18n']);
+    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;
+}
+export { AI };