@vectorx/ai-sdk 0.1.0

package/README.md

@@ -0,0 +1 @@
+### 小程序/智能体 ai sdk 

package/lib/agent/index.js

@@ -0,0 +1,69 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Agent = exports.AiSdkEnv = void 0;
+var AiSdkEnv;
+(function (AiSdkEnv) {
+    AiSdkEnv["Cloud"] = "cloud";
+    AiSdkEnv["MiniProgram"] = "miniprogram";
+})(AiSdkEnv || (exports.AiSdkEnv = AiSdkEnv = {}));
+class Agent {
+    constructor(req, baseUrl, options) {
+        this.req = req;
+        this.baseUrl = baseUrl;
+        this.options = options;
+    }
+    sendMessage(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fetchHeaders = {
+                "Content-Type": "application/json",
+                Accept: "text/event-stream",
+            };
+            const response = yield this.req.fetch({
+                method: "post",
+                headers: Object.assign({}, fetchHeaders),
+                body: props,
+                url: `${this.baseUrl}/v1/aiagent/agents/${this.options.agentId}/send-message`,
+                stream: true,
+            });
+            return response;
+        });
+    }
+    getHistoryMessages(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.req.get({
+                method: "GET",
+                url: `${this.baseUrl}/v1/aiagent/agents/${this.options.agentId}/messages`,
+                data: props,
+            });
+            return response.data;
+        });
+    }
+    getAgentInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.req.get({
+                method: "GET",
+                url: `${this.baseUrl}/v1/aiagent/agents/${this.options.agentId}/info`,
+            });
+            return response.data;
+        });
+    }
+    getConversations() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.req.get({
+                method: "GET",
+                url: `${this.baseUrl}/v1/aiagent/agents/${this.options.agentId}/conversations`,
+            });
+            return response.data;
+        });
+    }
+}
+exports.Agent = Agent;

package/lib/ai.js

@@ -0,0 +1,94 @@
+"use strict";
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI = void 0;
+const agent_1 = require("./agent");
+const index_1 = require("./index");
+const models = __importStar(require("./models"));
+const utils_1 = require("./utils");
+class AI {
+    constructor(request, baseUrl, env) {
+        this.modelSubUrl = "conversation/chat";
+        this.modelRequest = (options) => __awaiter(this, void 0, void 0, function* () {
+            const fetchHeaders = {
+                "Content-Type": "application/json",
+            };
+            options.stream && Object.assign(fetchHeaders, { Accept: "text/event-stream" });
+            const { data: responseData, header } = (yield this.request.fetch({
+                method: "post",
+                headers: Object.assign({}, fetchHeaders),
+                body: JSON.stringify(options),
+                url: `${this.baseUrl}/${this.modelSubUrl}`,
+                stream: options.stream,
+            }));
+            return (0, utils_1.handleResponseData)(responseData, header);
+        });
+        this.baseUrl = baseUrl;
+        this.request = request;
+        this.env = env;
+    }
+    createModel(model) {
+        if (this.env === index_1.AiSdkEnv.MiniProgram) {
+            console.warn(`[${index_1.AiSdkEnv.MiniProgram}] is not supported for model creation`);
+            return null;
+        }
+        const simpleModel = new models.DefaultSimpleModel(this.modelRequest, model);
+        const reactModel = new models.ReactModel(simpleModel);
+        return reactModel;
+    }
+    createAgent(options) {
+        if (this.env === index_1.AiSdkEnv.Cloud) {
+            console.warn(`[${index_1.AiSdkEnv.Cloud}] is not supported for \`Agent\` creation !`);
+            return null;
+        }
+        return new agent_1.Agent(this.request, this.baseUrl, options);
+    }
+    registerFunctionTool(functionTool) {
+        if (models.toolMap.has(functionTool.name)) {
+            console.warn(`AI function tool ${functionTool.name} already exists and will be overwritten!`);
+        }
+        models.toolMap.set(functionTool.name, functionTool.fn);
+    }
+}
+exports.AI = AI;

package/lib/eventsource_parser/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParser = void 0;
+var parse_1 = require("./parse");
+Object.defineProperty(exports, "createParser", { enumerable: true, get: function () { return parse_1.createParser; } });

package/lib/eventsource_parser/parse.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParser = createParser;
+function createParser(onParse) {
+    let isFirstChunk;
+    let buffer;
+    let startingPosition;
+    let startingFieldLength;
+    let eventId;
+    let eventName;
+    let data;
+    reset();
+    return { feed, 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;
+        const { length } = buffer;
+        let position = 0;
+        let discardTrailingNewline = false;
+        while (position < length) {
+            if (discardTrailingNewline) {
+                if (buffer[position] === "\n") {
+                    position += 1;
+                }
+                discardTrailingNewline = false;
+            }
+            let lineLength = -1;
+            let fieldLength = startingFieldLength;
+            let character;
+            for (let 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;
+        }
+        const noValue = fieldLength < 0;
+        const field = lineBuffer.slice(index, index + (noValue ? lineLength : fieldLength));
+        let step = 0;
+        if (noValue) {
+            step = lineLength;
+        }
+        else if (lineBuffer[index + fieldLength + 1] === " ") {
+            step = fieldLength + 2;
+        }
+        else {
+            step = fieldLength + 1;
+        }
+        const position = index + step;
+        const valueLength = lineLength - step;
+        const value = lineBuffer.slice(position, position + valueLength).toString();
+        if (field === "data") {
+            data += value ? `${value}\n` : "\n";
+        }
+        else if (field === "event") {
+            eventName = value;
+        }
+        else if (field === "id" && !value.includes("\u0000")) {
+            eventId = value;
+        }
+        else if (field === "retry") {
+            const retry = Number.parseInt(value, 10);
+            if (!Number.isNaN(retry)) {
+                onParse({ type: "reconnect-interval", value: retry });
+            }
+        }
+    }
+}
+const BOM = [239, 187, 191];
+function hasBom(buffer) {
+    return BOM.every((charCode, index) => buffer.charCodeAt(index) === charCode);
+}

package/lib/eventsource_parser/stream.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSourceParserStream = void 0;
+const parse_1 = require("./parse");
+class EventSourceParserStream extends TransformStream {
+    constructor() {
+        let parser;
+        super({
+            start(controller) {
+                parser = (0, parse_1.createParser)((event) => {
+                    if (event.type === "event") {
+                        controller.enqueue(event);
+                    }
+                });
+            },
+            transform(chunk) {
+                parser.feed(chunk);
+            },
+        });
+    }
+}
+exports.EventSourceParserStream = EventSourceParserStream;

package/lib/eventsource_parser/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/index.js

@@ -0,0 +1,55 @@
+"use strict";
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IAgentEnv = exports.AiSdkEnv = exports.AI = exports.models = void 0;
+exports.createAi = createAi;
+const agent_1 = require("./agent");
+Object.defineProperty(exports, "AiSdkEnv", { enumerable: true, get: function () { return agent_1.AiSdkEnv; } });
+const ai_1 = require("./ai");
+Object.defineProperty(exports, "AI", { enumerable: true, get: function () { return ai_1.AI; } });
+const models = __importStar(require("./models"));
+exports.models = models;
+const types_1 = require("./types");
+Object.defineProperty(exports, "IAgentEnv", { enumerable: true, get: function () { return types_1.IAgentEnv; } });
+function createAi({ getBaseUrl, request, env = agent_1.AiSdkEnv.Cloud }) {
+    if (getBaseUrl == null || typeof getBaseUrl !== "function") {
+        throw new Error("`getBaseUrl` is required!");
+    }
+    return new ai_1.AI(request, getBaseUrl(), env);
+}
+__exportStar(require("./types"), exports);

package/lib/models/default.js

@@ -0,0 +1,51 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSimpleModel = exports.SimpleChatModel = void 0;
+const stream_1 = require("../stream");
+class SimpleChatModel {
+}
+exports.SimpleChatModel = SimpleChatModel;
+const defaultOptions = {
+    max_tokens: 1000,
+    temperature: 0.7,
+    top_p: 1,
+    frequency_penalty: 0,
+    presence_penalty: 0,
+    stream: true,
+    platform_tools: [],
+    knowledge_base: [],
+    enable_thinking: false,
+    enable_search: false,
+};
+class DefaultSimpleModel {
+    constructor(req, modelName) {
+        this.req = req;
+        this.modelName = modelName;
+    }
+    doGenerate(data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            data.model = this.modelName;
+            const res = yield this.req(Object.assign(Object.assign(Object.assign(Object.assign({}, defaultOptions), data), (options || {})), { stream: false }));
+            return Object.assign(Object.assign({}, res), { rawResponse: res });
+        });
+    }
+    doStream(data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            data.model = this.modelName;
+            const _stream = yield this.req(Object.assign(Object.assign(Object.assign(Object.assign({}, defaultOptions), data), (options || {})), { stream: true }));
+            const stream = (0, stream_1.toPolyfillReadable)(_stream);
+            const standardStream = (0, stream_1.intoStandardStream)(stream);
+            return (0, stream_1.createAsyncIterable)(standardStream);
+        });
+    }
+}
+exports.DefaultSimpleModel = DefaultSimpleModel;

package/lib/models/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolMap = exports.ReactModel = exports.DefaultSimpleModel = exports.modelName = exports.ModelName = void 0;
+const default_1 = require("./default");
+Object.defineProperty(exports, "DefaultSimpleModel", { enumerable: true, get: function () { return default_1.DefaultSimpleModel; } });
+const react_1 = require("./react");
+Object.defineProperty(exports, "ReactModel", { enumerable: true, get: function () { return react_1.ReactModel; } });
+var ModelName;
+(function (ModelName) {
+    ModelName["DeepSeekR1"] = "deepseek-r1";
+    ModelName["DeepSeekV3"] = "deepseek-v3";
+    ModelName["QwenMax"] = "qwen-max";
+    ModelName["QwenLong"] = "qwen-long";
+    ModelName["QwenPlus"] = "qwen-plus";
+    ModelName["QwenTurbo"] = "qwen-turbo";
+    ModelName["QwenVlOcr"] = "qwen-vl-ocr";
+    ModelName["Wanx21T2iTurbo"] = "wanx2.1-t2i-turbo";
+})(ModelName || (exports.ModelName = ModelName = {}));
+exports.modelName = {
+    [ModelName.DeepSeekR1]: "deepseek-r1",
+    [ModelName.DeepSeekV3]: "deepseek-v3",
+    [ModelName.QwenMax]: "qwen-max",
+    [ModelName.QwenLong]: "qwen-long",
+    [ModelName.QwenPlus]: "qwen-plus",
+    [ModelName.QwenTurbo]: "qwen-turbo",
+    [ModelName.QwenVlOcr]: "qwen-vl-ocr",
+};
+const toolMap = new Map();
+exports.toolMap = toolMap;

package/lib/models/model-types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleChatModel = void 0;
+class SimpleChatModel {
+}
+exports.SimpleChatModel = SimpleChatModel;

package/lib/models/react.js

@@ -0,0 +1,28 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactModel = void 0;
+class ReactModel {
+    constructor(model) {
+        this.model = model;
+    }
+    generateText(_input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.model.doGenerate(_input, options);
+        });
+    }
+    streamText(_input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.model.doStream(_input, options);
+        });
+    }
+}
+exports.ReactModel = ReactModel;

package/lib/stream.js

@@ -0,0 +1,138 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextDecoderStream = exports.toPolyfillReadable = exports.createEventSourceParserTransformStream = exports.TransformStream = exports.ReadableStream = void 0;
+exports.createAsyncIterable = createAsyncIterable;
+exports.intoStandardStream = intoStandardStream;
+exports.createPromise = createPromise;
+exports.isToolCallAssistantMessage = isToolCallAssistantMessage;
+exports.functionToolToModelTool = functionToolToModelTool;
+const web_streams_adapter_1 = require("@mattiasbuelens/web-streams-adapter");
+const text_encoding_shim_1 = require("text-encoding-shim");
+const web_streams_polyfill_1 = require("web-streams-polyfill");
+const eventsource_parser_1 = require("./eventsource_parser");
+exports.ReadableStream = web_streams_polyfill_1.ReadableStream;
+exports.TransformStream = web_streams_polyfill_1.TransformStream;
+const createEventSourceParserTransformStream = () => {
+    let parser;
+    return new exports.TransformStream({
+        start(controller) {
+            parser = (0, eventsource_parser_1.createParser)((event) => {
+                if (event.type === "event") {
+                    controller.enqueue(event);
+                }
+            });
+        },
+        transform(chunk) {
+            parser.feed(chunk);
+        },
+    });
+};
+exports.createEventSourceParserTransformStream = createEventSourceParserTransformStream;
+exports.toPolyfillReadable = (0, web_streams_adapter_1.createReadableStreamWrapper)(exports.ReadableStream);
+class TextDecoderStream {
+    constructor(encoding = "utf-8", options = {}) {
+        this.transform = new exports.TransformStream({
+            transform: (chunk, controller) => {
+                const value = this.handle.decode(new Uint8Array(chunk), { stream: true });
+                if (value) {
+                    controller.enqueue(value);
+                }
+            },
+            flush: (controller) => {
+                const value = this.handle.decode();
+                if (value) {
+                    controller.enqueue(value);
+                }
+                controller.terminate();
+            },
+        });
+        this.handle = new text_encoding_shim_1.TextDecoder(encoding, options);
+    }
+    get encoding() {
+        return this.handle.encoding;
+    }
+    get fatal() {
+        return this.handle.fatal;
+    }
+    get ignoreBOM() {
+        return this.handle.ignoreBOM;
+    }
+    get readable() {
+        return this.transform.readable;
+    }
+    get writable() {
+        return this.transform.writable;
+    }
+    get [Symbol.toStringTag]() {
+        return "TextDecoderStream";
+    }
+}
+exports.TextDecoderStream = TextDecoderStream;
+function createAsyncIterable(stream) {
+    const _stream = stream;
+    _stream[Symbol.asyncIterator] = () => {
+        const reader = stream.getReader();
+        return {
+            next() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const { done, value } = yield reader.read();
+                    return done ? { done: true, value: undefined } : { done: false, value };
+                });
+            },
+        };
+    };
+    return _stream;
+}
+function intoStandardStream(stream) {
+    return createAsyncIterable(stream
+        .pipeThrough(new TextDecoderStream())
+        .pipeThrough((0, exports.createEventSourceParserTransformStream)())
+        .pipeThrough(new exports.TransformStream({
+        transform(chunk, controller) {
+            try {
+                const 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();
+                }
+            }
+        },
+    })));
+}
+function createPromise() {
+    let res;
+    let rej;
+    const promise = new Promise((resolve, reject) => {
+        res = resolve;
+        rej = reject;
+    });
+    return { promise, res, rej };
+}
+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;
+}
+function functionToolToModelTool(tool) {
+    return {
+        type: "function",
+        function: {
+            description: tool.description,
+            name: tool.name,
+            parameters: tool.parameters,
+        },
+    };
+}

package/lib/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IAgentEnv = exports.SimpleChatModel = void 0;
+class SimpleChatModel {
+}
+exports.SimpleChatModel = SimpleChatModel;
+var IAgentEnv;
+(function (IAgentEnv) {
+    IAgentEnv["Production"] = "production";
+    IAgentEnv["Development"] = "development";
+})(IAgentEnv || (exports.IAgentEnv = IAgentEnv = {}));

package/lib/utils.js

@@ -0,0 +1,46 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleResponseData = handleResponseData;
+const GO_TO_AI_TEXT = "请检查调用方式，或前往云开发 AI+ 首页查看文档：https://tcb.cloud.tencent.com/dev#/ai";
+function handleResponseData(responseData, header) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        if (typeof responseData === "object" && responseData && "then" in responseData) {
+            const json = (yield responseData);
+            if (typeof json === "object" && json && "code" in json && json.code !== 0) {
+                throw new Error(`小红书 ModelRequest 请求出错，错误码：${json.code}，错误信息：${json.message}\n${GO_TO_AI_TEXT}\n${JSON.stringify(json, null, 2)}`);
+            }
+            return responseData;
+        }
+        if ((_b = (_a = header === null || header === void 0 ? void 0 : header.get) === null || _a === void 0 ? void 0 : _a.call(header, "content-type")) === null || _b === void 0 ? void 0 : _b.includes("application/json")) {
+            const json = yield readableStream2JsonObject(responseData);
+            if (typeof json === "object" && json && "code" in json && json.code !== 0) {
+                throw new Error(`小红书 ModelRequest 请求出错，错误码：${json.code}，错误信息：${json.message}\n${GO_TO_AI_TEXT}\n${JSON.stringify(json, null, 2)}`);
+            }
+        }
+        return responseData;
+    });
+}
+function readableStream2JsonObject(stream) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        let result = "";
+        while (true) {
+            const { done, value } = yield reader.read();
+            if (done)
+                break;
+            result += decoder.decode(value);
+        }
+        return JSON.parse(result);
+    });
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@vectorx/ai-sdk",
+  "version": "0.1.0",
+  "description": "Cloud AI SDK",
+  "main": "lib/index.js",
+  "types": "types/index.d.ts",
+  "sideEffects": false,
+  "files": [
+    "lib",
+    "types",
+    "README.md"
+  ],
+  "keywords": [
+    "ai",
+    "sdk",
+    "cloud",
+    "sdk"
+  ],
+  "author": "",
+  "license": "ISC",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@vectorx/ai-types": "0.1.0",
+    "@vectorx/agent-runtime": "0.1.0",
+    "@mattiasbuelens/web-streams-adapter": "^0.1.0",
+    "text-encoding-shim": "^1.0.5",
+    "web-streams-polyfill": "^4.1.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.24",
+    "@typescript-eslint/eslint-plugin": "^7.1.0",
+    "@typescript-eslint/parser": "^7.1.0",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "openai": "^4.103.0",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.3.3"
+  },
+  "scripts": {
+    "dev": "tsc -w",
+    "build": "rimraf lib types && tsc",
+    "lint": "eslint 'src/**/*.ts'",
+    "fix": "eslint 'src/**/*.ts' --fix"
+  },
+  "readme": "### 小程序/智能体 ai sdk "
+}

package/types/agent/index.d.ts

@@ -0,0 +1,17 @@
+import type { GetAgentInfoResponse, GetConversationsResponse, GetHistoryMessagesParams, GetHistoryMessagesResponse, SendMessageInput } from "@vectorx/agent-runtime";
+import type { IAbstractRequest } from "@vectorx/ai-types";
+import type { IAgent, IAgentOptions } from "../types";
+export declare enum AiSdkEnv {
+    Cloud = "cloud",
+    MiniProgram = "miniprogram"
+}
+export declare class Agent implements IAgent {
+    private readonly req;
+    private readonly baseUrl;
+    private readonly options;
+    constructor(req: IAbstractRequest, baseUrl: string, options: IAgentOptions);
+    sendMessage(props: SendMessageInput): Promise<any>;
+    getHistoryMessages(props: GetHistoryMessagesParams): Promise<GetHistoryMessagesResponse>;
+    getAgentInfo(): Promise<GetAgentInfoResponse>;
+    getConversations(): Promise<GetConversationsResponse>;
+}

package/types/ai.d.ts

@@ -0,0 +1,17 @@
+import type { IAbstractRequest } from "@vectorx/ai-types";
+import { Agent } from "./agent";
+import { AiSdkEnv } from "./index";
+import * as models from "./models";
+import type * as types from "./types";
+declare class AI {
+    baseUrl: string;
+    request: IAbstractRequest;
+    modelSubUrl: string;
+    env: AiSdkEnv;
+    constructor(request: IAbstractRequest, baseUrl: string, env: AiSdkEnv);
+    createModel(model: models.ModelName): models.ReactModel;
+    modelRequest: (options: types.ModelRequestOptions) => Promise<any>;
+    createAgent(options: types.IAgentOptions): Agent;
+    registerFunctionTool(functionTool: types.FunctionTool): void;
+}
+export { AI };

package/types/eventsource_parser/index.d.ts

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

package/types/eventsource_parser/parse.d.ts

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

package/types/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/types/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/types/index.d.ts

@@ -0,0 +1,13 @@
+import type { IAbstractRequest } from "@vectorx/ai-types";
+import { AiSdkEnv } from "./agent";
+import { AI } from "./ai";
+import * as models from "./models";
+import { IAgentEnv } from "./types";
+interface ICreateAi {
+    getBaseUrl: () => string;
+    request: IAbstractRequest;
+    env?: AiSdkEnv;
+}
+declare function createAi({ getBaseUrl, request, env }: ICreateAi): AI;
+export * from "./types";
+export { createAi, models, AI, AiSdkEnv, IAgentEnv };

package/types/models/default.d.ts

@@ -0,0 +1,13 @@
+import type { DoGenerateOutput, DoStreamOutput, ModelReq, ModelRequestOptions, ReqOptions } from "../types";
+import type { ModelName } from "./index";
+export declare abstract class SimpleChatModel {
+    abstract doGenerate(data: ModelRequestOptions, options?: ReqOptions): Promise<DoGenerateOutput>;
+    abstract doStream(data: ModelRequestOptions, options?: ReqOptions): Promise<DoStreamOutput>;
+}
+export declare class DefaultSimpleModel implements SimpleChatModel {
+    private req;
+    modelName: ModelName;
+    constructor(req: ModelReq, modelName: ModelName);
+    doGenerate(data: ModelRequestOptions, options?: ReqOptions): Promise<DoGenerateOutput>;
+    doStream(data: ModelRequestOptions, options?: ReqOptions): Promise<DoStreamOutput>;
+}

package/types/models/index.d.ts

@@ -0,0 +1,23 @@
+import { DefaultSimpleModel } from "./default";
+import { ReactModel } from "./react";
+export declare enum ModelName {
+    DeepSeekR1 = "deepseek-r1",
+    DeepSeekV3 = "deepseek-v3",
+    QwenMax = "qwen-max",
+    QwenLong = "qwen-long",
+    QwenPlus = "qwen-plus",
+    QwenTurbo = "qwen-turbo",
+    QwenVlOcr = "qwen-vl-ocr",
+    Wanx21T2iTurbo = "wanx2.1-t2i-turbo"
+}
+export declare const modelName: {
+    "deepseek-r1": string;
+    "deepseek-v3": string;
+    "qwen-max": string;
+    "qwen-long": string;
+    "qwen-plus": string;
+    "qwen-turbo": string;
+    "qwen-vl-ocr": string;
+};
+declare const toolMap: Map<string, Function>;
+export { DefaultSimpleModel, ReactModel, toolMap };

package/types/models/model-types.d.ts

@@ -0,0 +1,131 @@
+export declare abstract class SimpleChatModel {
+    abstract doGenerate(data: ModelRequestOptions, options?: ReqOptions): Promise<DoGenerateOutput>;
+    abstract doStream(data: ModelRequestOptions, options?: ReqOptions): Promise<DoStreamOutput>;
+}
+export interface ModelRequestOptions {
+    model: string;
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    n?: number;
+    conversation_id?: string;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    stream?: boolean;
+    platform_tools?: Array<{
+        plantform_tool_id: string;
+        payload: any;
+    }>;
+    historys?: Array<{
+        role: string;
+        content: string;
+    }>;
+    knowledge_base?: Array<{
+        knowledge_base_id: string;
+        search_mode?: "vector" | "full_text" | "hybrid";
+        limit?: number;
+        score_threshold?: number;
+    }>;
+    db_base?: any[];
+    enable_thinking?: boolean;
+    enable_search?: boolean;
+}
+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 IAgentReqInput {
+    url: string;
+    method: string;
+    headers?: Record<string, string>;
+    data?: Object;
+    stream?: boolean;
+    timeout?: number;
+}
+export interface ReqOptions {
+    timeout?: number;
+}
+export type AgentReq = <T extends IAgentReqInput>(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 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 {};

package/types/models/react.d.ts

@@ -0,0 +1,7 @@
+import type { DoGenerateOutput, DoStreamOutput, ModelRequestOptions, ReqOptions, SimpleChatModel } from "../types";
+export declare class ReactModel {
+    private model;
+    constructor(model: SimpleChatModel);
+    generateText(_input: ModelRequestOptions, options?: ReqOptions): Promise<DoGenerateOutput>;
+    streamText(_input: ModelRequestOptions, options?: ReqOptions): Promise<DoStreamOutput>;
+}

package/types/stream.d.ts

@@ -0,0 +1,54 @@
+import { type ParsedEvent } from "./eventsource_parser";
+import type { BaseDoGenerateOutput, BaseDoStreamOutputChunk, ChatModelMessage, ModelTool, SimpleChatModel, ToolCallAssistantMessage } from "./types";
+export type FunctionTool = {
+    name: string;
+    description: string;
+    fn: CallableFunction;
+    parameters: object;
+};
+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 declare const ReadableStream: {
+    prototype: ReadableStream;
+    new (underlyingSource: UnderlyingByteSource, strategy?: {
+        highWaterMark?: number;
+    }): ReadableStream<Uint8Array>;
+    new <R = any>(underlyingSource: UnderlyingDefaultSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
+    new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
+};
+export declare const TransformStream: {
+    prototype: TransformStream;
+    new <I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
+};
+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 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;
+export {};

package/types/types.d.ts

@@ -0,0 +1,159 @@
+import type { GetAgentInfoResponse, GetConversationsResponse, GetHistoryMessagesParams, GetHistoryMessagesResponse, SendMessageInput } from "@vectorx/agent-runtime";
+import type { ModelName } from "./models";
+export type { GetAgentInfoResponse, GetConversationsResponse, GetHistoryMessagesParams, GetHistoryMessagesResponse, SendMessageInput, };
+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 declare abstract class SimpleChatModel {
+    abstract doGenerate(data: ModelRequestOptions, options?: ReqOptions): Promise<DoGenerateOutput>;
+    abstract doStream(data: ModelRequestOptions, options?: ReqOptions): Promise<DoStreamOutput>;
+}
+export interface ModelRequestOptions {
+    model: ModelName;
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    n?: number;
+    conversation_id?: string;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    stream?: boolean;
+    platform_tools?: Array<{
+        plantform_tool_id: string;
+        payload: any;
+    }>;
+    messages?: Array<{
+        role: string;
+        content: string;
+    }>;
+    knowledge_base?: Array<{
+        knowledge_base_id: string;
+        search_mode?: "vector" | "full_text" | "hybrid";
+        limit?: number;
+        score_threshold?: number;
+    }>;
+    db_base?: any[];
+    enable_thinking?: boolean;
+    enable_search?: boolean;
+}
+export type ModelReq = <T extends ModelRequestOptions>(props: T) => T["stream"] extends true ? Promise<ReadableStream<Uint8Array>> : Promise<Object>;
+export interface IAgentReqInput {
+    url: string;
+    method: string;
+    headers?: Record<string, string>;
+    data?: Object;
+    stream?: boolean;
+    timeout?: number;
+}
+export interface ReqOptions {
+    timeout?: number;
+}
+export type AgentReq = <T extends IAgentReqInput>(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 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;
+    };
+};
+export interface BaseDoGenerateOutput extends ChatCompletion {
+}
+export interface BaseDoStreamOutputChunk extends ChatCompletion {
+}
+export interface ChatCompletion {
+    id: string;
+    log_id: string;
+    object: string;
+    error: string;
+    code: number;
+    created: number;
+    model: string;
+    choices: Choice[];
+    usage: Usage;
+}
+export type MessageType = "answer" | "function_call" | "function_call_response" | "knowledge_base_search" | "knowledge_base_search_response";
+export interface Choice {
+    index: number;
+    message: {
+        id: string;
+        role: string;
+        type: MessageType;
+        reasoning_content?: string;
+        content?: string;
+        knowledge_retrieval?: any[];
+        db_operations?: any[];
+        search_results?: any[];
+    };
+    finish_reason: string;
+}
+interface Usage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    knowledge_tokens: number;
+    reasoning_tokens: number;
+    total_tokens: number;
+}
+export interface IAgent {
+    sendMessage(input: SendMessageInput): Promise<any>;
+    getHistoryMessages?(input: GetHistoryMessagesParams): Promise<GetHistoryMessagesResponse>;
+    getAgentInfo?(): Promise<GetAgentInfoResponse>;
+    getConversations?(): Promise<GetConversationsResponse>;
+}
+export declare enum IAgentEnv {
+    Production = "production",
+    Development = "development"
+}
+export interface IAgentOptions {
+    agentId: string;
+    accessToken: string;
+    version?: string;
+    env: IAgentEnv;
+}

package/types/utils.d.ts

@@ -0,0 +1 @@
+export declare function handleResponseData(responseData: Promise<unknown> | ReadableStream<Uint8Array>, header?: Headers): Promise<unknown>;