@vectorx/ai-sdk 0.0.0-beta-20251112071234

package/README.md

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

package/lib/agent/index.d.ts

@@ -0,0 +1,17 @@
+import type { GetAgentInfoResponse, GetConversationsResponse, GetHistoryMessagesParams, GetHistoryMessagesResponse, SendMessageInput } from "@vectorx/ai-types";
+import type { IAbstractRequest } from "@vectorx/ai-types";
+import type { IAgent, IAgentOptions } from "../model-type";
+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/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.d.ts

@@ -0,0 +1,16 @@
+import type { IAbstractRequest } from "@vectorx/ai-types";
+import { Agent } from "./agent";
+import { AiSdkEnv } from "./index";
+import type * as types from "./model-type";
+import * as models from "./models";
+import { TokenManager } from "./tokenManager";
+export declare class AI {
+    env: AiSdkEnv;
+    protected baseUrl: string;
+    protected request: IAbstractRequest;
+    tokenManager: TokenManager;
+    constructor(request: IAbstractRequest, baseUrl: string, env: AiSdkEnv);
+    createModel(model: models.ModelName | models.MultiModalModelName): models.ReActModel;
+    createAgent(options: types.IAgentOptions): Agent;
+    registerFunctionTool(functionTool: types.FunctionTool): void;
+}

package/lib/ai.js

@@ -0,0 +1,90 @@
+"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;
+    };
+})();
+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 tokenManager_1 = require("./tokenManager");
+class AI {
+    constructor(request, baseUrl, env) {
+        this.env = index_1.AiSdkEnv.Cloud;
+        this.baseUrl = baseUrl;
+        this.request = request;
+        this.env = env;
+        this.tokenManager = new tokenManager_1.TokenManager(this.request, this.baseUrl);
+    }
+    createModel(model) {
+        if (this.env === index_1.AiSdkEnv.MiniProgram) {
+            console.warn(`[${index_1.AiSdkEnv.MiniProgram}] is not supported for model creation`);
+            return null;
+        }
+        if (!models.isValidModel(model)) {
+            throw new Error(`[${model}] is not supported, please check the model name`);
+        }
+        switch (model) {
+            case models.MultiModalModelName.QwenImage:
+                return new models.ReActModel(new models.QwenImageModel(this.request, models.QwenImageModel.BASE_URL, this.tokenManager));
+            case models.MultiModalModelName.QwenImageEdit:
+                return new models.ReActModel(new models.QwenImageEditModel(this.request, models.QwenImageEditModel.BASE_URL, this.tokenManager));
+            case models.MultiModalModelName.WanxSketchToImageLite:
+                return new models.ReActModel(new models.WanxSketchToImageLiteModel(this.request, models.WanxSketchToImageLiteModel.BASE_URL, this.tokenManager));
+            case models.MultiModalModelName.QwenStyleRepaintV1:
+                return new models.ReActModel(new models.QwenStyleRepaintV1Model(this.request, models.QwenStyleRepaintV1Model.BASE_URL, this.tokenManager));
+            case models.MultiModalModelName.Qwen25T2iPreview:
+                return new models.ReActModel(new models.Qwen25T2iPreviewModel(this.request, models.Qwen25T2iPreviewModel.BASE_URL, this.tokenManager));
+            case models.MultiModalModelName.QwenVlMax:
+                return new models.ReActModel(new models.QwenVlMax(this.request, models.QwenVlMax.BASE_URL, model, this.tokenManager));
+            case models.MultiModalModelName.QwenDocTurbo:
+                return new models.ReActModel(new models.QwenDocTurbo(this.request, models.QwenDocTurbo.BASE_URL, model, this.tokenManager));
+            default:
+                return new models.ReActModel(new models.DefaultSimpleModel(this.request, this.baseUrl, model));
+        }
+    }
+    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.d.ts

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

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.d.ts

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

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.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/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.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/lib/eventsource_parser/types.js

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

package/lib/index.d.ts

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

package/lib/index.js

@@ -0,0 +1,56 @@
+"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 model_type_1 = require("./model-type");
+Object.defineProperty(exports, "IAgentEnv", { enumerable: true, get: function () { return model_type_1.IAgentEnv; } });
+const models = __importStar(require("./models"));
+exports.models = models;
+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("./model-type"), exports);
+__exportStar(require("./tokenManager"), exports);

package/lib/model-type.d.ts

@@ -0,0 +1,207 @@
+import type { GetAgentInfoResponse, GetConversationsResponse, GetHistoryMessagesParams, GetHistoryMessagesResponse, QueryTasksResponse, SendMessageInput, UploadFileInput, UploadFileResponse } from "@vectorx/ai-types";
+import type { ModelName } from "./models";
+export type { GetAgentInfoResponse, GetConversationsResponse, GetHistoryMessagesParams, GetHistoryMessagesResponse, SendMessageInput, QueryTasksResponse, UploadFileInput, UploadFileResponse, };
+export type DoGenerateOutput = BaseDoGenerateOutput;
+export type DoStreamOutput = AsyncIterableReadableStream<BaseDoStreamOutputChunk>;
+export type AsyncIterableReadableStream<T> = ReadableStream<T> & {
+    [Symbol.asyncIterator]: () => {
+        next(): Promise<IteratorResult<T>>;
+    };
+};
+export interface TextContent {
+    type: "text";
+    text: string;
+}
+export interface ImageUrlContent {
+    type: "image_url";
+    image_url: {
+        url: string;
+        detail?: "auto" | "low" | "high";
+    };
+}
+export interface DocUrlContent {
+    type: "doc_url";
+    doc_url: string[];
+    file_parsing_strategy?: "auto" | "text_only";
+}
+export interface VideoUrlContent {
+    type: "video_url";
+    video_url: {
+        url: string;
+    };
+}
+export interface AudioUrlContent {
+    type: "audio_url";
+    audio_url: {
+        url: string;
+    };
+}
+export interface VideoContent {
+    type: "video";
+    video: string[];
+}
+export interface AudioContent {
+    type: "audio";
+    audio: string[];
+}
+export type MultiModalContent = TextContent | ImageUrlContent | DocUrlContent | VideoUrlContent | AudioUrlContent | VideoContent | AudioContent;
+export type SupportedContentType = MultiModalContent["type"];
+export declare function filterContentByTypes<T extends SupportedContentType>(content: MultiModalContent[], supportedTypes: T[]): Extract<MultiModalContent, {
+    type: T;
+}>[];
+export declare function hasContentType(content: string | MultiModalContent[], type: SupportedContentType): boolean;
+export declare function extractContentByType<T extends SupportedContentType>(content: string | MultiModalContent[], type: T): Extract<MultiModalContent, {
+    type: T;
+}>[];
+export interface ModelRequestOptions {
+    async?: boolean;
+    model: ModelName | 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;
+    }>;
+    messages?: Array<{
+        role: string;
+        content: string | MultiModalContent[];
+    }>;
+    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;
+    parameters?: any;
+}
+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;
+    headers?: Record<string, string>;
+    method?: string;
+}
+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;
+    message?: string;
+    code: number;
+    created: number;
+    model: string;
+    choices: Choice[];
+    usage: Usage;
+}
+export type MessageType = "answer" | "image" | "video" | "async_task" | "function_call" | "function_call_response" | "knowledge_base_search" | "knowledge_base_search_response" | "error";
+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;
+    delta?: {
+        content?: string;
+        reasoning_content?: 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>;
+    queryTasks?(task_id?: string): Promise<QueryTasksResponse>;
+    uploadFile?(input: UploadFileInput): Promise<UploadFileResponse>;
+}
+export declare enum IAgentEnv {
+    Production = "production",
+    Development = "development"
+}
+export interface IAgentOptions {
+    agentId: string;
+    accessToken: string;
+    version?: string;
+    env: IAgentEnv;
+}