@vectorx/ai-sdk 0.1.3 → 0.4.0

package/{types → lib}/agent/index.d.ts

@@ -1,6 +1,6 @@
-import type { GetAgentInfoResponse, GetConversationsResponse, GetHistoryMessagesParams, GetHistoryMessagesResponse, SendMessageInput } from "@vectorx/agent-runtime";
+import type { GetAgentInfoResponse, GetConversationsResponse, GetHistoryMessagesParams, GetHistoryMessagesResponse, SendMessageInput } from "@vectorx/ai-types";
 import type { IAbstractRequest } from "@vectorx/ai-types";
-import type { IAgent, IAgentOptions } from "../types";
+import type { IAgent, IAgentOptions } from "../model-type";
 export declare enum AiSdkEnv {
     Cloud = "cloud",
     MiniProgram = "miniprogram"

package/{types → lib}/ai.d.ts

@@ -1,17 +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 type * as types from "./types";
-declare class AI {
-    baseUrl: string;
-    request: IAbstractRequest;
-    modelSubUrl: string;
+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.ReactModel;
-    modelRequest: (options: types.ModelRequestOptions) => Promise<any>;
+    createModel(model: models.ModelName | models.MultiModalModelName): models.ReActModel;
     createAgent(options: types.IAgentOptions): Agent;
     registerFunctionTool(functionTool: types.FunctionTool): void;
 }
-export { AI };

package/lib/ai.js

@@ -32,50 +32,42 @@ var __importStar = (this && this.__importStar) || (function () {
         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");
+const tokenManager_1 = require("./tokenManager");
 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.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;
         }
-        const simpleModel = new models.DefaultSimpleModel(this.modelRequest, model);
-        const reactModel = new models.ReactModel(simpleModel);
-        return reactModel;
+        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.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.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) {

package/{types → lib}/index.d.ts

@@ -1,13 +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";
-import { IAgentEnv } from "./types";
 interface ICreateAi {
     getBaseUrl: () => string;
     request: IAbstractRequest;
     env?: AiSdkEnv;
 }
 declare function createAi({ getBaseUrl, request, env }: ICreateAi): AI;
-export * from "./types";
+export * from "./model-type";
+export * from "./tokenManager";
 export { createAi, models, AI, AiSdkEnv, IAgentEnv };

package/lib/index.js

@@ -42,14 +42,15 @@ 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;
-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);
+__exportStar(require("./model-type"), exports);
+__exportStar(require("./tokenManager"), exports);

package/{types/types.d.ts → lib/model-type.d.ts}

@@ -1,23 +1,61 @@
-import type { GetAgentInfoResponse, GetConversationsResponse, GetHistoryMessagesParams, GetHistoryMessagesResponse, SendMessageInput } from "@vectorx/agent-runtime";
+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, };
-type RawResponse = {
-    rawResponse?: any;
-};
-export type DoGenerateOutput = BaseDoGenerateOutput & RawResponse;
-export type DoStreamOutput = AsyncIterableReadableStream<BaseDoStreamOutputChunk & RawResponse>;
-export type ChatModelConstructor = typeof SimpleChatModel;
+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 declare abstract class SimpleChatModel {
-    abstract doGenerate(data: ModelRequestOptions, options?: ReqOptions): Promise<DoGenerateOutput>;
-    abstract doStream(data: ModelRequestOptions, options?: ReqOptions): Promise<DoStreamOutput>;
+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 {
-    model: ModelName;
+    async?: boolean;
+    model: ModelName | string;
     max_tokens?: number;
     temperature?: number;
     top_p?: number;
@@ -32,7 +70,7 @@ export interface ModelRequestOptions {
     }>;
     messages?: Array<{
         role: string;
-        content: string;
+        content: string | MultiModalContent[];
     }>;
     knowledge_base?: Array<{
         knowledge_base_id: string;
@@ -43,6 +81,7 @@ export interface ModelRequestOptions {
     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 {
@@ -55,6 +94,8 @@ export interface IAgentReqInput {
 }
 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 = {
@@ -113,13 +154,14 @@ export interface ChatCompletion {
     log_id: string;
     object: string;
     error: string;
+    message?: 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 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: {
@@ -133,6 +175,10 @@ export interface Choice {
         search_results?: any[];
     };
     finish_reason: string;
+    delta?: {
+        content?: string;
+        reasoning_content?: string;
+    };
 }
 interface Usage {
     prompt_tokens: number;
@@ -146,6 +192,8 @@ export interface IAgent {
     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",

package/lib/model-type.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IAgentEnv = void 0;
+exports.filterContentByTypes = filterContentByTypes;
+exports.hasContentType = hasContentType;
+exports.extractContentByType = extractContentByType;
+function filterContentByTypes(content, supportedTypes) {
+    return content.filter((item) => supportedTypes.includes(item.type));
+}
+function hasContentType(content, type) {
+    if (typeof content === "string")
+        return false;
+    return content.some((item) => item.type === type);
+}
+function extractContentByType(content, type) {
+    if (typeof content === "string")
+        return [];
+    return content.filter((item) => item.type === type);
+}
+var IAgentEnv;
+(function (IAgentEnv) {
+    IAgentEnv["Production"] = "production";
+    IAgentEnv["Development"] = "development";
+})(IAgentEnv || (exports.IAgentEnv = IAgentEnv = {}));

package/lib/models/Chat.d.ts

@@ -0,0 +1,14 @@
+import type { IAbstractRequest } from "@vectorx/ai-types";
+import { DoGenerateOutput, DoStreamOutput, ModelRequestOptions, ReqOptions } from "../model-type";
+import { TokenManager } from "../tokenManager";
+export declare abstract class SimpleChatModel {
+    protected req: IAbstractRequest;
+    protected baseUrl: string;
+    protected subUrl: string;
+    protected tokenManager?: TokenManager;
+    constructor(req: IAbstractRequest, baseUrl: string, subUrl: string, tokenManager?: TokenManager);
+    abstract doGenerate(data: ModelRequestOptions, options?: ReqOptions): Promise<DoGenerateOutput>;
+    abstract doStream(data: ModelRequestOptions, options?: ReqOptions): Promise<DoStreamOutput>;
+    protected getValidToken(): Promise<string>;
+    protected createAuthHeaders(additionalHeaders?: Record<string, string>): Promise<Record<string, string>>;
+}

package/lib/models/Chat.js

@@ -0,0 +1,36 @@
+"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.SimpleChatModel = void 0;
+class SimpleChatModel {
+    constructor(req, baseUrl, subUrl, tokenManager) {
+        this.req = req;
+        this.baseUrl = baseUrl;
+        this.subUrl = subUrl;
+        if (tokenManager)
+            this.tokenManager = tokenManager;
+    }
+    getValidToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.tokenManager) {
+                throw new Error("TokenManager is not set");
+            }
+            return yield this.tokenManager.getValidToken();
+        });
+    }
+    createAuthHeaders() {
+        return __awaiter(this, arguments, void 0, function* (additionalHeaders = {}) {
+            const token = yield this.getValidToken();
+            return Object.assign({ "Content-Type": "application/json", Authorization: `Bearer ${token}` }, additionalHeaders);
+        });
+    }
+}
+exports.SimpleChatModel = SimpleChatModel;

package/lib/models/Default/index.d.ts

@@ -0,0 +1,11 @@
+import type { IAbstractRequest } from "@vectorx/ai-types";
+import type { DoGenerateOutput, DoStreamOutput, ModelRequestOptions, ReqOptions } from "../../model-type";
+import { SimpleChatModel } from "../Chat";
+import type { ModelName } from "../index";
+export declare class DefaultSimpleModel extends SimpleChatModel {
+    modelName: ModelName;
+    constructor(req: IAbstractRequest, baseUrl: string, modelName: ModelName);
+    protected modelRequest(data: ModelRequestOptions, options?: ReqOptions): Promise<ReadableStream<Uint8Array> | Promise<unknown>>;
+    doGenerate(data: ModelRequestOptions, options?: ReqOptions): Promise<DoGenerateOutput>;
+    doStream(data: ModelRequestOptions, options?: ReqOptions): Promise<DoStreamOutput>;
+}

package/lib/models/{default.js → Default/index.js}

@@ -9,11 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultSimpleModel = exports.SimpleChatModel = void 0;
-const stream_1 = require("../stream");
-class SimpleChatModel {
-}
-exports.SimpleChatModel = SimpleChatModel;
+exports.DefaultSimpleModel = void 0;
+const stream_1 = require("../../stream");
+const utils_1 = require("../../utils");
+const Chat_1 = require("../Chat");
 const defaultOptions = {
     max_tokens: 1000,
     temperature: 0.7,
@@ -26,22 +25,40 @@ const defaultOptions = {
     enable_thinking: false,
     enable_search: false,
 };
-class DefaultSimpleModel {
-    constructor(req, modelName) {
-        this.req = req;
+class DefaultSimpleModel extends Chat_1.SimpleChatModel {
+    constructor(req, baseUrl, modelName) {
+        super(req, baseUrl, "conversation/chat");
         this.modelName = modelName;
     }
+    modelRequest(data_1) {
+        return __awaiter(this, arguments, void 0, function* (data, options = {
+            timeout: 30 * 1000,
+        }) {
+            const fetchHeaders = Object.assign({ "Content-Type": "application/json" }, ((options === null || options === void 0 ? void 0 : options.headers) || {}));
+            data.stream && Object.assign(fetchHeaders, { Accept: "text/event-stream" });
+            const { data: responseData, header } = (yield this.req.fetch({
+                url: `${this.baseUrl}/${this.subUrl}`,
+                headers: Object.assign({}, fetchHeaders),
+                body: JSON.stringify(data),
+                method: "post",
+                stream: Boolean(data.stream),
+            }));
+            return (0, utils_1.handleResponseData)(responseData, header);
+        });
+    }
     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 });
+            const payload = Object.assign(Object.assign(Object.assign({}, defaultOptions), data), { stream: false });
+            const res = yield this.modelRequest(payload, options);
+            return 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 payload = Object.assign(Object.assign(Object.assign({}, defaultOptions), data), { stream: true });
+            const _stream = (yield this.modelRequest(payload, options));
             const stream = (0, stream_1.toPolyfillReadable)(_stream);
             const standardStream = (0, stream_1.intoStandardStream)(stream);
             return (0, stream_1.createAsyncIterable)(standardStream);

package/lib/models/QwenDocTurbo/index.d.ts

@@ -0,0 +1,84 @@
+import type { IAbstractRequest } from "@vectorx/ai-types";
+import type { DoGenerateOutput, DoStreamOutput, DocUrlContent, ModelRequestOptions, ReqOptions, TextContent } from "../../model-type";
+import type { TokenManager } from "../../tokenManager";
+import { SimpleChatModel } from "../Chat";
+import type { MultiModalModelName } from "../index";
+export interface QwenDocTurboMessage {
+    role: "system" | "user" | "assistant";
+    content: string | Array<TextContent | DocUrlContent>;
+}
+export interface QwenDocTurboParameters {
+    temperature?: number;
+    top_p?: number;
+    max_tokens?: number;
+    n?: number;
+    stream?: boolean;
+    stop?: string | string[];
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    user?: string;
+    stream_options?: {
+        include_usage?: boolean;
+    };
+    response_format?: {
+        type: "text" | "json_object";
+    };
+    tools?: Array<object>;
+    tool_choice?: string | object;
+    parallel_tool_calls?: boolean;
+}
+export interface QwenDocTurboAPIInput {
+    model: string;
+    input: {
+        messages: QwenDocTurboMessage[];
+    };
+    parameters?: QwenDocTurboParameters;
+}
+export interface QwenDocTurboResponse {
+    request_id?: string;
+    output?: {
+        text?: string;
+        choices?: Array<{
+            finish_reason: string;
+            message: {
+                role: string;
+                content: string;
+            };
+        }>;
+    };
+    usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+        total_tokens?: number;
+    };
+}
+export interface QwenDocTurboStreamChunk {
+    request_id?: string;
+    output?: {
+        text?: string;
+        choices?: Array<{
+            finish_reason: string;
+            message: {
+                role?: string;
+                content?: string;
+            };
+        }>;
+    };
+    usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+        total_tokens?: number;
+    };
+}
+export declare class QwenDocTurbo extends SimpleChatModel {
+    static BASE_URL: string;
+    static SUB_URL: string;
+    modelName: MultiModalModelName;
+    constructor(req: IAbstractRequest, baseUrl: string, modelName: MultiModalModelName, tokenManager: TokenManager);
+    protected modelRequest(data: QwenDocTurboAPIInput, options?: ReqOptions): Promise<ReadableStream<Uint8Array> | Promise<unknown>>;
+    protected normalizeResponse(response: QwenDocTurboResponse): DoGenerateOutput;
+    doGenerate(data: ModelRequestOptions, options?: ReqOptions): Promise<DoGenerateOutput>;
+    doStream(data: ModelRequestOptions, options?: ReqOptions): Promise<DoStreamOutput>;
+    private normalizeStreamChunks;
+    private convertToQwenDocTurboRequestOptions;
+}