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

package/node_modules/@cloudbase/ai/dist/cjs/eventsource_parser/parse.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParser = void 0;
+function createParser(onParse) {
+    var isFirstChunk;
+    var buffer;
+    var startingPosition;
+    var startingFieldLength;
+    var eventId;
+    var eventName;
+    var data;
+    reset();
+    return { feed: feed, reset: reset };
+    function reset() {
+        isFirstChunk = true;
+        buffer = '';
+        startingPosition = 0;
+        startingFieldLength = -1;
+        eventId = undefined;
+        eventName = undefined;
+        data = '';
+    }
+    function feed(chunk) {
+        buffer = buffer ? buffer + chunk : chunk;
+        if (isFirstChunk && hasBom(buffer)) {
+            buffer = buffer.slice(BOM.length);
+        }
+        isFirstChunk = false;
+        var length = buffer.length;
+        var position = 0;
+        var discardTrailingNewline = false;
+        while (position < length) {
+            if (discardTrailingNewline) {
+                if (buffer[position] === '\n') {
+                    position += 1;
+                }
+                discardTrailingNewline = false;
+            }
+            var lineLength = -1;
+            var fieldLength = startingFieldLength;
+            var character = void 0;
+            for (var index = startingPosition; lineLength < 0 && index < length; index++) {
+                character = buffer[index];
+                if (character === ':' && fieldLength < 0) {
+                    fieldLength = index - position;
+                }
+                else if (character === '\r') {
+                    discardTrailingNewline = true;
+                    lineLength = index - position;
+                }
+                else if (character === '\n') {
+                    lineLength = index - position;
+                }
+            }
+            if (lineLength < 0) {
+                startingPosition = length - position;
+                startingFieldLength = fieldLength;
+                break;
+            }
+            else {
+                startingPosition = 0;
+                startingFieldLength = -1;
+            }
+            parseEventStreamLine(buffer, position, fieldLength, lineLength);
+            position += lineLength + 1;
+        }
+        if (position === length) {
+            buffer = '';
+        }
+        else if (position > 0) {
+            buffer = buffer.slice(position);
+        }
+    }
+    function parseEventStreamLine(lineBuffer, index, fieldLength, lineLength) {
+        if (lineLength === 0) {
+            if (data.length > 0) {
+                onParse({
+                    type: 'event',
+                    id: eventId,
+                    event: eventName || undefined,
+                    data: data.slice(0, -1),
+                });
+                data = '';
+                eventId = undefined;
+            }
+            eventName = undefined;
+            return;
+        }
+        var noValue = fieldLength < 0;
+        var field = lineBuffer.slice(index, index + (noValue ? lineLength : fieldLength));
+        var step = 0;
+        if (noValue) {
+            step = lineLength;
+        }
+        else if (lineBuffer[index + fieldLength + 1] === ' ') {
+            step = fieldLength + 2;
+        }
+        else {
+            step = fieldLength + 1;
+        }
+        var position = index + step;
+        var valueLength = lineLength - step;
+        var value = lineBuffer.slice(position, position + valueLength).toString();
+        if (field === 'data') {
+            data += value ? "".concat(value, "\n") : '\n';
+        }
+        else if (field === 'event') {
+            eventName = value;
+        }
+        else if (field === 'id' && !value.includes('\u0000')) {
+            eventId = value;
+        }
+        else if (field === 'retry') {
+            var retry = parseInt(value, 10);
+            if (!Number.isNaN(retry)) {
+                onParse({ type: 'reconnect-interval', value: retry });
+            }
+        }
+    }
+}
+exports.createParser = createParser;
+var BOM = [239, 187, 191];
+function hasBom(buffer) {
+    return BOM.every(function (charCode, index) { return buffer.charCodeAt(index) === charCode; });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parse.js","sourceRoot":"","sources":["../../../src/eventsource_parser/parse.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * EventSource/Server-Sent Events parser\n * @see https://html.spec.whatwg.org/multipage/server-sent-events.html\n *\n * Based on code from the {@link https://github.com/EventSource/eventsource | EventSource module},\n * which is licensed under the MIT license. And copyrighted the EventSource GitHub organisation.\n */\nimport type { EventSourceParseCallback, EventSourceParser } from './types'\n\n/**\n * Creates a new EventSource parser.\n *\n * @param onParse - Callback to invoke when a new event is parsed, or a new reconnection interval\n *                  has been sent from the server\n *\n * @returns A new EventSource parser, with `parse` and `reset` methods.\n * @public\n */\nexport function createParser(onParse: EventSourceParseCallback): EventSourceParser {\n  // Processing state\n  let isFirstChunk: boolean\n  let buffer: string\n  let startingPosition: number\n  let startingFieldLength: number\n\n  // Event state\n  let eventId: string | undefined\n  let eventName: string | undefined\n  let data: string\n\n  reset()\n  return { feed, reset }\n\n  function reset(): void {\n    isFirstChunk = true\n    buffer = ''\n    startingPosition = 0\n    startingFieldLength = -1\n\n    eventId = undefined\n    eventName = undefined\n    data = ''\n  }\n\n  function feed(chunk: string): void {\n    buffer = buffer ? buffer + chunk : chunk\n\n    // Strip any UTF8 byte order mark (BOM) at the start of the stream.\n    // Note that we do not strip any non - UTF8 BOM, as eventsource streams are\n    // always decoded as UTF8 as per the specification.\n    if (isFirstChunk && hasBom(buffer)) {\n      buffer = buffer.slice(BOM.length)\n    }\n\n    isFirstChunk = false\n\n    // Set up chunk-specific processing state\n    const { length } = buffer\n    let position = 0\n    let discardTrailingNewline = false\n\n    // Read the current buffer byte by byte\n    while (position < length) {\n      // EventSource allows for carriage return + line feed, which means we\n      // need to ignore a linefeed character if the previous character was a\n      // carriage return\n      // @todo refactor to reduce nesting, consider checking previous byte?\n      // @todo but consider multiple chunks etc\n      if (discardTrailingNewline) {\n        if (buffer[position] === '\\n') {\n          position += 1\n        }\n        discardTrailingNewline = false\n      }\n\n      let lineLength = -1\n      let fieldLength = startingFieldLength\n      let character: string\n\n      for (let index = startingPosition; lineLength < 0 && index < length; index++) {\n        character = buffer[index]\n        if (character === ':' && fieldLength < 0) {\n          fieldLength = index - position\n        } else if (character === '\\r') {\n          discardTrailingNewline = true\n          lineLength = index - position\n        } else if (character === '\\n') {\n          lineLength = index - position\n        }\n      }\n\n      if (lineLength < 0) {\n        startingPosition = length - position\n        startingFieldLength = fieldLength\n        break\n      } else {\n        startingPosition = 0\n        startingFieldLength = -1\n      }\n\n      parseEventStreamLine(buffer, position, fieldLength, lineLength)\n\n      position += lineLength + 1\n    }\n\n    if (position === length) {\n      // If we consumed the entire buffer to read the event, reset the buffer\n      buffer = ''\n    } else if (position > 0) {\n      // If there are bytes left to process, set the buffer to the unprocessed\n      // portion of the buffer only\n      buffer = buffer.slice(position)\n    }\n  }\n\n  function parseEventStreamLine(lineBuffer: string, index: number, fieldLength: number, lineLength: number) {\n    if (lineLength === 0) {\n      // We reached the last line of this event\n      if (data.length > 0) {\n        onParse({\n          type: 'event',\n          id: eventId,\n          event: eventName || undefined,\n          data: data.slice(0, -1), // remove trailing newline\n        })\n\n        data = ''\n        eventId = undefined\n      }\n      eventName = undefined\n      return\n    }\n\n    const noValue = fieldLength < 0\n    const field = lineBuffer.slice(index, index + (noValue ? lineLength : fieldLength))\n    let step = 0\n\n    if (noValue) {\n      step = lineLength\n    } else if (lineBuffer[index + fieldLength + 1] === ' ') {\n      step = fieldLength + 2\n    } else {\n      step = fieldLength + 1\n    }\n\n    const position = index + step\n    const valueLength = lineLength - step\n    const value = lineBuffer.slice(position, position + valueLength).toString()\n\n    if (field === 'data') {\n      data += value ? `${value}\\n` : '\\n'\n    } else if (field === 'event') {\n      eventName = value\n    } else if (field === 'id' && !value.includes('\\u0000')) {\n      eventId = value\n    } else if (field === 'retry') {\n      const retry = parseInt(value, 10)\n      if (!Number.isNaN(retry)) {\n        onParse({ type: 'reconnect-interval', value: retry })\n      }\n    }\n  }\n}\n\nconst BOM = [239, 187, 191]\n\nfunction hasBom(buffer: string) {\n  return BOM.every((charCode: number, index: number) => buffer.charCodeAt(index) === charCode)\n}\n"]}

package/node_modules/@cloudbase/ai/dist/cjs/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/node_modules/@cloudbase/ai/dist/cjs/eventsource_parser/stream.js

@@ -0,0 +1,40 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSourceParserStream = void 0;
+var parse_1 = require("./parse");
+var EventSourceParserStream = (function (_super) {
+    __extends(EventSourceParserStream, _super);
+    function EventSourceParserStream() {
+        var parser;
+        return _super.call(this, {
+            start: function (controller) {
+                parser = (0, parse_1.createParser)(function (event) {
+                    if (event.type === 'event') {
+                        controller.enqueue(event);
+                    }
+                });
+            },
+            transform: function (chunk) {
+                parser.feed(chunk);
+            },
+        }) || this;
+    }
+    return EventSourceParserStream;
+}(TransformStream));
+exports.EventSourceParserStream = EventSourceParserStream;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyZWFtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2V2ZW50c291cmNlX3BhcnNlci9zdHJlYW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQ0EsaUNBQXNDO0FBY3RDO0lBQTZDLDJDQUFvQztJQUMvRTtRQUNFLElBQUksTUFBMEIsQ0FBQTtlQUU5QixrQkFBTTtZQUNKLEtBQUssWUFBQyxVQUFVO2dCQUNkLE1BQU0sR0FBRyxJQUFBLG9CQUFZLEVBQUMsVUFBQyxLQUFLO29CQUMxQixJQUFJLEtBQUssQ0FBQyxJQUFJLEtBQUssT0FBTyxFQUFFO3dCQUMxQixVQUFVLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFBO3FCQUMxQjtnQkFDSCxDQUFDLENBQUMsQ0FBQTtZQUNKLENBQUM7WUFDRCxTQUFTLFlBQUMsS0FBSztnQkFDYixNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFBO1lBQ3BCLENBQUM7U0FDRixDQUFDO0lBQ0osQ0FBQztJQUNILDhCQUFDO0FBQUQsQ0FBQyxBQWpCRCxDQUE2QyxlQUFlLEdBaUIzRDtBQWpCWSwwREFBdUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEV2ZW50U291cmNlUGFyc2VyLCBQYXJzZWRFdmVudCB9IGZyb20gJy4vdHlwZXMnXG5pbXBvcnQgeyBjcmVhdGVQYXJzZXIgfSBmcm9tICcuL3BhcnNlJ1xuXG4vKipcbiAqIEEgVHJhbnNmb3JtU3RyZWFtIHRoYXQgaW5nZXN0cyBhIHN0cmVhbSBvZiBzdHJpbmdzIGFuZCBwcm9kdWNlcyBhIHN0cmVhbSBvZiBQYXJzZWRFdmVudHMuXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYFxuICogY29uc3QgZXZlbnRTdHJlYW0gPVxuICogICByZXNwb25zZS5ib2R5XG4gKiAgICAgLnBpcGVUaHJvdWdoKG5ldyBUZXh0RGVjb2RlclN0cmVhbSgpKVxuICogICAgIC5waXBlVGhyb3VnaChuZXcgRXZlbnRTb3VyY2VQYXJzZXJTdHJlYW0oKSlcbiAqIGBgYFxuICogQHB1YmxpY1xuICovXG5leHBvcnQgY2xhc3MgRXZlbnRTb3VyY2VQYXJzZXJTdHJlYW0gZXh0ZW5kcyBUcmFuc2Zvcm1TdHJlYW08c3RyaW5nLCBQYXJzZWRFdmVudD4ge1xuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBsZXQgcGFyc2VyITogRXZlbnRTb3VyY2VQYXJzZXJcblxuICAgIHN1cGVyKHtcbiAgICAgIHN0YXJ0KGNvbnRyb2xsZXIpIHtcbiAgICAgICAgcGFyc2VyID0gY3JlYXRlUGFyc2VyKChldmVudCkgPT4ge1xuICAgICAgICAgIGlmIChldmVudC50eXBlID09PSAnZXZlbnQnKSB7XG4gICAgICAgICAgICBjb250cm9sbGVyLmVucXVldWUoZXZlbnQpXG4gICAgICAgICAgfVxuICAgICAgICB9KVxuICAgICAgfSxcbiAgICAgIHRyYW5zZm9ybShjaHVuaykge1xuICAgICAgICBwYXJzZXIuZmVlZChjaHVuaylcbiAgICAgIH0sXG4gICAgfSlcbiAgfVxufVxuXG5leHBvcnQgdHlwZSB7IFBhcnNlZEV2ZW50IH0gZnJvbSAnLi90eXBlcydcbiJdfQ==

package/node_modules/@cloudbase/ai/dist/cjs/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/node_modules/@cloudbase/ai/dist/cjs/eventsource_parser/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,40 @@
+import type { SDKRequestInterface } from '@cloudbase/adapter-interface';
+import type { ICloudbase, ICloudbaseConfig } from '@cloudbase/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;
+    env?: string;
+    getAccessToken?: () => Promise<{
+        accessToken: string;
+    }>;
+    handleReqInstance?: HandleRequestInstanceFunc;
+    i18n?: ICloudbaseConfig['i18n'];
+}
+declare function createAI({ env, baseUrl, 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';

package/node_modules/@cloudbase/ai/dist/cjs/index.js

@@ -0,0 +1,187 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utils = exports.registerAi = exports.models = exports.createAI = exports.createAi = exports.Bot = exports.AI = void 0;
+var AI_1 = require("./AI");
+Object.defineProperty(exports, "AI", { enumerable: true, get: function () { return AI_1.AI; } });
+var bot_1 = require("./bot");
+Object.defineProperty(exports, "Bot", { enumerable: true, get: function () { return bot_1.Bot; } });
+var models = __importStar(require("./models"));
+var utils = __importStar(require("./utils"));
+exports.utils = utils;
+var COMPONENT_NAME = 'ai';
+var MODELS = models.MODELS, restModels = __rest(models, ["MODELS"]);
+exports.models = restModels;
+var createRequestInstanceWithAccessTokenHeader = function (_a) {
+    var getAccessToken = _a.getAccessToken, req = _a.req;
+    var fetch = function (options) { return __awaiter(void 0, void 0, void 0, function () {
+        var token, _a, headers, restOptions, accessToken;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (typeof req.fetch !== 'function') {
+                        throw new Error('req.fetch is not a function');
+                    }
+                    token = options.token, _a = options.headers, headers = _a === void 0 ? {} : _a, restOptions = __rest(options, ["token", "headers"]);
+                    if (!(token != null)) return [3, 1];
+                    accessToken = token;
+                    return [3, 3];
+                case 1: return [4, getAccessToken()];
+                case 2:
+                    accessToken = (_b.sent()).accessToken;
+                    _b.label = 3;
+                case 3: return [2, req.fetch(__assign({ headers: __assign({ Authorization: "Bearer ".concat(accessToken) }, headers) }, restOptions))];
+            }
+        });
+    }); };
+    return {
+        download: req.download,
+        post: req.post,
+        upload: req.upload,
+        fetch: fetch,
+    };
+};
+function createAI(_a) {
+    var env = _a.env, baseUrl = _a.baseUrl, req = _a.req, getAccessToken = _a.getAccessToken, handleReqInstance = _a.handleReqInstance, i18n = _a.i18n;
+    var getBaseUrl = function () {
+        if (baseUrl != null) {
+            return baseUrl;
+        }
+        if (env == null) {
+            throw new Error('`env` is required when `baseUrl` is not provided!');
+        }
+        return "https://".concat(env, ".api.tcloudbasegateway.com/v1");
+    };
+    var getReq = function () {
+        if (handleReqInstance == null) {
+            if (getAccessToken == null) {
+                throw new Error('`getAccessToken` is required when `handleReqInstance` is not provided!');
+            }
+            return createRequestInstanceWithAccessTokenHeader({ req: req, getAccessToken: getAccessToken });
+        }
+        return handleReqInstance({ req: req });
+    };
+    return new AI_1.AI(getReq(), getBaseUrl(), i18n);
+}
+exports.createAI = createAI;
+var createAi = createAI;
+exports.createAi = createAi;
+function ai(options) {
+    var _this = this;
+    var _a;
+    var req = this.request;
+    if (req.fetch == null) {
+        throw new Error('cloudbase.request.fetch() unimplemented!');
+    }
+    var getUrlFromCloud = function () {
+        var _a = _this.getEndPointWithKey('GATEWAY'), BASE_URL = _a.BASE_URL, PROTOCOL = _a.PROTOCOL;
+        return "".concat(PROTOCOL).concat(BASE_URL);
+    };
+    var baseUrl = (_a = options === null || options === void 0 ? void 0 : options.baseUrl) !== null && _a !== void 0 ? _a : getUrlFromCloud();
+    return createAI({ req: req, baseUrl: baseUrl, handleReqInstance: function (_a) {
+            var req = _a.req;
+            return req;
+        }, i18n: this.config.i18n });
+}
+var component = {
+    name: COMPONENT_NAME,
+    entity: { ai: ai },
+};
+function registerAi(app) {
+    try {
+        app.registerComponent(component);
+    }
+    catch (e) {
+        console.warn(e);
+    }
+}
+exports.registerAi = registerAi;
+__exportStar(require("./type"), exports);
+try {
+    window.registerAi = registerAi;
+}
+catch (e) { }
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable eqeqeq */\nimport type { IFetchOptions, SDKRequestInterface } from '@cloudbase/adapter-interface'\nimport type { ICloudbase, ICloudbaseConfig } from '@cloudbase/types'\nimport type { ICloudbaseComponent } from '@cloudbase/types/component'\nimport { AI } from './AI'\nimport { Bot } from './bot'\nimport * as models from './models'\nimport * as utils from './utils'\n\nconst COMPONENT_NAME = 'ai'\n\nconst { MODELS, ...restModels } = models\n\ninterface IHandleRequestInstance {\n  req: SDKRequestInterface\n}\n\ntype HandleRequestInstanceFunc = (options: IHandleRequestInstance) => SDKRequestInterface\n\nconst createRequestInstanceWithAccessTokenHeader = ({\n  getAccessToken,\n  req,\n}: IHandleRequestInstance & { getAccessToken: () => Promise<{ accessToken: string }> }) => {\n  const fetch: typeof req.fetch = async (options: IFetchOptions & { token?: string }) => {\n    if (typeof req.fetch !== 'function') {\n      throw new Error('req.fetch is not a function')\n    }\n\n    const { token, headers = {}, ...restOptions } = options\n    let accessToken: string\n    if (token != null) {\n      accessToken = token\n    } else {\n      accessToken = (await getAccessToken()).accessToken\n    }\n\n    return req.fetch({\n      headers: {\n        Authorization: `Bearer ${accessToken}`,\n        ...headers,\n      },\n      ...restOptions,\n    })\n  }\n\n  return {\n    download: req.download,\n    post: req.post,\n    upload: req.upload,\n    fetch,\n  }\n}\n\ninterface AIInitOption {\n  baseUrl?: string\n}\n\ninterface ICreateAI {\n  req: SDKRequestInterface\n  baseUrl?: string\n  env?: string\n  getAccessToken?: () => Promise<{ accessToken: string }>\n  handleReqInstance?: HandleRequestInstanceFunc\n  i18n?: ICloudbaseConfig['i18n']\n}\n\n/**\n * 最简地创建一个接云开发网关服务的 `AI` 实例，请求时会自动带上鉴权请求头。\n * 只需要传入：\n *\n * - `getAccessToken`: 获取 accessToken 的函数\n * - `req`: 请求函数，一般从 adapter 上拿\n * - `env`: 云开发环境 ID\n *\n * 其他参数可按需传入覆盖函数逻辑。\n */\nfunction createAI({ env, baseUrl, req, getAccessToken, handleReqInstance, i18n }: ICreateAI) {\n  const getBaseUrl = () => {\n    if (baseUrl != null) {\n      return baseUrl\n    }\n    if (env == null) {\n      throw new Error('`env` is required when `baseUrl` is not provided!')\n    }\n    return `https://${env}.api.tcloudbasegateway.com/v1`\n  }\n\n  const getReq = () => {\n    if (handleReqInstance == null) {\n      if (getAccessToken == null) {\n        throw new Error('`getAccessToken` is required when `handleReqInstance` is not provided!')\n      }\n      return createRequestInstanceWithAccessTokenHeader({ req, getAccessToken })\n    }\n    return handleReqInstance({ req })\n  }\n\n  return new AI(getReq(), getBaseUrl(), i18n)\n}\n\n// 兼容\n/**\n * @deprecated use `createAI`\n */\nconst createAi = createAI\n\n/**\n * 创建 `AI` 实例。\n * 该函数挂载在 js sdk 的 Cloudbase 实例上。\n * 该函数调用了本模块暴露的 `createAI` 函数，但调用时通过传入参数做了逻辑覆盖：\n *\n * - 传入从 Cloudbase 实例上的中心的 `req`\n * - 传入从 Cloudbase 实例上拿到的 `baseUrl`\n * - 传入一个不处理 `req` 的 `handleReqInstance`，由于 `req` 是从 Cloudbase 实例上拿到的，这个中心的 `req` 已经可用了\n * - 不用传入 `env` 了，因为已经传了 `baseUrl`\n * - 不用传入 `getAccessToken` 了，因为传了 `handleReqInstance`\n */\nfunction ai(\n  this: ICloudbase & { getEndPointWithKey: (key: 'GATEWAY') => { BASE_URL: string; PROTOCOL: string } },\n  options?: AIInitOption,\n) {\n  const req = this.request\n\n  if (req.fetch == null) {\n    throw new Error('cloudbase.request.fetch() unimplemented!')\n  }\n\n  const getUrlFromCloud = () => {\n    const { BASE_URL, PROTOCOL } = this.getEndPointWithKey('GATEWAY')\n    return `${PROTOCOL}${BASE_URL}`\n  }\n\n  const baseUrl = options?.baseUrl ?? getUrlFromCloud()\n\n  return createAI({ req, baseUrl, handleReqInstance: ({ req }) => req, i18n: this.config.i18n })\n}\n\nconst component: ICloudbaseComponent = {\n  name: COMPONENT_NAME,\n  entity: { ai },\n}\n\nfunction registerAi(app: ICloudbase) {\n  try {\n    app.registerComponent(component)\n  } catch (e) {\n    console.warn(e)\n  }\n}\n\nexport { AI, Bot, createAi, createAI, restModels as models, registerAi, utils }\nexport * from './type'\n\ntry {\n  (window as any).registerAi = registerAi\n} catch (e) {}\n"]}

package/node_modules/@cloudbase/ai/dist/cjs/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/node_modules/@cloudbase/ai/dist/cjs/models/Ark/index.js

@@ -0,0 +1,130 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArkSimpleModel = void 0;
+var utils_1 = require("../../utils");
+function processInput(input) {
+    var messages = input.messages, model = input.model, temperature = input.temperature, tools = input.tools, top_p = input.top_p;
+    return __assign(__assign({}, input), { messages: messages, model: model, tools: tools, top_p: top_p, temperature: temperature });
+}
+var ArkSimpleModel = (function () {
+    function ArkSimpleModel(req, baseUrl, subUrl) {
+        this.req = req;
+        this.baseUrl = baseUrl;
+        this.subUrl = 'ark/api/v3/chat/completions';
+        if (subUrl != null) {
+            this.subUrl = subUrl;
+        }
+    }
+    Object.defineProperty(ArkSimpleModel.prototype, "url", {
+        get: function () {
+            return "".concat(this.baseUrl, "/").concat(this.subUrl);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ArkSimpleModel.prototype.doGenerate = function (data, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.req({
+                            url: this.url,
+                            data: __assign(__assign({}, processInput(data)), { stream: false }),
+                            stream: false,
+                            timeout: options === null || options === void 0 ? void 0 : options.timeout,
+                        })];
+                    case 1:
+                        res = (_a.sent());
+                        return [2, __assign(__assign({}, res), { rawResponse: res })];
+                }
+            });
+        });
+    };
+    ArkSimpleModel.prototype.doStream = function (data, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var isToolCall, _stream, stream, arkStream, streamWithRaw;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        isToolCall = null;
+                        return [4, this.req({
+                                url: this.url,
+                                data: __assign(__assign({}, processInput(data)), { stream: true }),
+                                stream: true,
+                                timeout: options === null || options === void 0 ? void 0 : options.timeout,
+                            })];
+                    case 1:
+                        _stream = _a.sent();
+                        stream = (0, utils_1.toPolyfillReadable)(_stream);
+                        arkStream = (0, utils_1.intoStandardStream)(stream);
+                        streamWithRaw = arkStream.pipeThrough(new utils_1.TransformStream({
+                            transform: function (chunk, controller) {
+                                var newChoices = chunk.choices.map(function (choice) {
+                                    var message = choice.delta;
+                                    if (isToolCall == null)
+                                        isToolCall = (0, utils_1.isToolCallAssistantMessage)(message);
+                                    if (isToolCall) {
+                                        return __assign(__assign({}, choice), { finish_reason: 'tool_calls', delta: message });
+                                    }
+                                    return choice;
+                                });
+                                var newChunk = __assign(__assign({}, chunk), { choices: newChoices });
+                                controller.enqueue(__assign(__assign({}, newChunk), { rawResponse: chunk }));
+                            },
+                        }));
+                        return [2, (0, utils_1.createAsyncIterable)(streamWithRaw)];
+                }
+            });
+        });
+    };
+    return ArkSimpleModel;
+}());
+exports.ArkSimpleModel = ArkSimpleModel;
+//# sourceMappingURL=data:application/json;base64,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