@vectorx/ai-sdk 0.0.0-beta-20251112071234

package/lib/models/QwenDocTurbo/adapters/OpenAICompat.d.ts

@@ -0,0 +1,24 @@
+import type { IAbstractRequest } from "@vectorx/ai-types";
+import type { BaseDoStreamOutputChunk, DoGenerateOutput, ModelRequestOptions, ReqOptions } from "../../../model-type";
+import type { TokenManager } from "../../../tokenManager";
+import type { QwenDocTurboApi } from "../types";
+import type { OpenAICompatibleAPIInput, OpenAICompatibleResponse } from "../types";
+export declare class OpenAICompatApi implements QwenDocTurboApi {
+    private req;
+    private baseUrl;
+    private subUrl;
+    private modelName;
+    private tokenManager?;
+    constructor(ctx: {
+        req: IAbstractRequest;
+        baseUrl: string;
+        subUrl: string;
+        modelName: string;
+        tokenManager?: TokenManager;
+    });
+    private createAuthHeaders;
+    buildPayload(data: ModelRequestOptions, stream: boolean): OpenAICompatibleAPIInput;
+    request(payload: OpenAICompatibleAPIInput, options?: ReqOptions): Promise<ReadableStream<Uint8Array> | unknown>;
+    normalizeResponse(response: OpenAICompatibleResponse): DoGenerateOutput;
+    normalizeStream(_stream: ReadableStream<Uint8Array>): ReadableStream<BaseDoStreamOutputChunk>;
+}

package/lib/models/QwenDocTurbo/adapters/OpenAICompat.js

@@ -0,0 +1,143 @@
+"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.OpenAICompatApi = void 0;
+const stream_1 = require("../../../stream");
+const utils_1 = require("../../../utils");
+class OpenAICompatApi {
+    constructor(ctx) {
+        this.req = ctx.req;
+        this.baseUrl = ctx.baseUrl;
+        this.subUrl = ctx.subUrl;
+        this.modelName = ctx.modelName;
+        this.tokenManager = ctx.tokenManager;
+    }
+    createAuthHeaders() {
+        return __awaiter(this, arguments, void 0, function* (additionalHeaders = {}) {
+            if (!this.tokenManager)
+                throw new Error("TokenManager is not set");
+            const token = yield this.tokenManager.getValidToken();
+            return Object.assign({ "Content-Type": "application/json", Authorization: `Bearer ${token}` }, additionalHeaders);
+        });
+    }
+    buildPayload(data, stream) {
+        const messages = (data.messages || []).map((msg) => {
+            const role = msg.role;
+            let contentStr = "";
+            if (typeof msg.content === "string")
+                contentStr = msg.content;
+            else if (Array.isArray(msg.content)) {
+                contentStr = msg.content
+                    .map((c) => ((c === null || c === void 0 ? void 0 : c.type) === "text" ? c.text : ""))
+                    .filter(Boolean)
+                    .join("\n");
+            }
+            return { role, content: contentStr };
+        });
+        return {
+            model: this.modelName,
+            messages,
+            stream,
+            stream_options: stream ? { include_usage: true } : undefined,
+        };
+    }
+    request(payload, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const headers = yield this.createAuthHeaders(options === null || options === void 0 ? void 0 : options.headers);
+            const response = (yield this.req.fetch({
+                method: "post",
+                headers: Object.assign({}, headers),
+                body: JSON.stringify(payload),
+                url: `${this.baseUrl}/${this.subUrl}`,
+                stream: (_a = payload.stream) !== null && _a !== void 0 ? _a : false,
+            }));
+            const { data, header } = response;
+            return (0, utils_1.handleResponseData)(data, header);
+        });
+    }
+    normalizeResponse(response) {
+        var _a, _b, _c, _d, _e;
+        const choice = (_a = response.choices) === null || _a === void 0 ? void 0 : _a[0];
+        const requestId = response.id || "";
+        const created = response.created || Math.floor(Date.now() / 1000);
+        const content = ((_b = choice === null || choice === void 0 ? void 0 : choice.message) === null || _b === void 0 ? void 0 : _b.content) || "";
+        return {
+            id: requestId,
+            object: "chat.completion",
+            created,
+            model: this.modelName,
+            log_id: requestId,
+            error: "",
+            code: 0,
+            choices: [
+                {
+                    index: 0,
+                    message: { id: requestId, role: "assistant", type: "answer", content, reasoning_content: "" },
+                    finish_reason: (choice === null || choice === void 0 ? void 0 : choice.finish_reason) || "stop",
+                },
+            ],
+            usage: {
+                prompt_tokens: ((_c = response.usage) === null || _c === void 0 ? void 0 : _c.prompt_tokens) || 0,
+                completion_tokens: ((_d = response.usage) === null || _d === void 0 ? void 0 : _d.completion_tokens) || 0,
+                knowledge_tokens: 0,
+                reasoning_tokens: 0,
+                total_tokens: ((_e = response.usage) === null || _e === void 0 ? void 0 : _e.total_tokens) || 0,
+            },
+        };
+    }
+    normalizeStream(_stream) {
+        const modelName = this.modelName;
+        const stream = (0, stream_1.toPolyfillReadable)(_stream);
+        const raw = (0, stream_1.intoStandardStream)(stream);
+        return raw.pipeThrough(new stream_1.TransformStream({
+            transform(chunk, controller) {
+                var _a, _b, _c, _d, _e;
+                const requestId = chunk.id || "";
+                const created = chunk.created || Math.floor(Date.now() / 1000);
+                const choice = (_a = chunk.choices) === null || _a === void 0 ? void 0 : _a[0];
+                const deltaContent = ((_b = choice === null || choice === void 0 ? void 0 : choice.delta) === null || _b === void 0 ? void 0 : _b.content) || "";
+                if (!deltaContent && !(choice === null || choice === void 0 ? void 0 : choice.finish_reason))
+                    return;
+                controller.enqueue({
+                    id: requestId,
+                    object: "chat.completion.chunk",
+                    created,
+                    model: modelName,
+                    log_id: requestId,
+                    error: "",
+                    code: 0,
+                    choices: [
+                        {
+                            index: (choice === null || choice === void 0 ? void 0 : choice.index) || 0,
+                            message: {
+                                id: requestId,
+                                role: "assistant",
+                                type: "answer",
+                                content: deltaContent,
+                                reasoning_content: "",
+                            },
+                            finish_reason: (choice === null || choice === void 0 ? void 0 : choice.finish_reason) || null,
+                        },
+                    ],
+                    usage: {
+                        prompt_tokens: ((_c = chunk.usage) === null || _c === void 0 ? void 0 : _c.prompt_tokens) || 0,
+                        completion_tokens: ((_d = chunk.usage) === null || _d === void 0 ? void 0 : _d.completion_tokens) || 0,
+                        knowledge_tokens: 0,
+                        reasoning_tokens: 0,
+                        total_tokens: ((_e = chunk.usage) === null || _e === void 0 ? void 0 : _e.total_tokens) || 0,
+                    },
+                });
+            },
+        }));
+    }
+}
+exports.OpenAICompatApi = OpenAICompatApi;

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

@@ -0,0 +1,16 @@
+import type { IAbstractRequest } from "@vectorx/ai-types";
+import type { DoGenerateOutput, DoStreamOutput, ModelRequestOptions, ReqOptions } from "../../model-type";
+import type { TokenManager } from "../../tokenManager";
+import { SimpleChatModel } from "../Chat";
+import type { MultiModalModelName } from "../index";
+export declare class QwenDocTurbo extends SimpleChatModel {
+    static BASE_URL: string;
+    static SUB_URL: string;
+    static OPENAI_COMPATIBLE_SUB_URL: string;
+    modelName: MultiModalModelName;
+    constructor(req: IAbstractRequest, baseUrl: string, modelName: MultiModalModelName, tokenManager: TokenManager);
+    private hasFileIdProtocol;
+    private createApi;
+    doGenerate(data: ModelRequestOptions, options?: ReqOptions): Promise<DoGenerateOutput>;
+    doStream(data: ModelRequestOptions, options?: ReqOptions): Promise<DoStreamOutput>;
+}

package/lib/models/QwenDocTurbo/index.js

@@ -0,0 +1,86 @@
+"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.QwenDocTurbo = void 0;
+const stream_1 = require("../../stream");
+const Chat_1 = require("../Chat");
+const DashScope_1 = require("./adapters/DashScope");
+const OpenAICompat_1 = require("./adapters/OpenAICompat");
+class QwenDocTurbo extends Chat_1.SimpleChatModel {
+    constructor(req, baseUrl, modelName, tokenManager) {
+        super(req, baseUrl, QwenDocTurbo.SUB_URL, tokenManager);
+        this.modelName = modelName;
+    }
+    hasFileIdProtocol(messages) {
+        if (!messages)
+            return false;
+        return messages.some((msg) => {
+            if (msg.role !== "system")
+                return false;
+            const content = msg.content;
+            if (typeof content === "string") {
+                return content.includes("fileid://");
+            }
+            if (Array.isArray(content)) {
+                return content.some((c) => {
+                    if (c.type === "text" && typeof c.text === "string") {
+                        return c.text.includes("fileid://");
+                    }
+                    return false;
+                });
+            }
+            return false;
+        });
+    }
+    createApi(hasFileId) {
+        if (hasFileId) {
+            return new OpenAICompat_1.OpenAICompatApi({
+                req: this.req,
+                baseUrl: this.baseUrl,
+                subUrl: QwenDocTurbo.OPENAI_COMPATIBLE_SUB_URL,
+                modelName: this.modelName,
+                tokenManager: this.tokenManager,
+            });
+        }
+        return new DashScope_1.DashScopeApi({
+            req: this.req,
+            baseUrl: this.baseUrl,
+            subUrl: QwenDocTurbo.SUB_URL,
+            modelName: this.modelName,
+            tokenManager: this.tokenManager,
+        });
+    }
+    doGenerate(data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasFileId = this.hasFileIdProtocol(data.messages);
+            const api = this.createApi(hasFileId);
+            const payload = api.buildPayload(data, false);
+            console.log("==== api ====", payload, options);
+            const res = yield api.request(payload, options);
+            console.log("==== res ====", JSON.stringify(res, null, 2));
+            return api.normalizeResponse(res);
+        });
+    }
+    doStream(data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasFileId = this.hasFileIdProtocol(data.messages);
+            const api = this.createApi(hasFileId);
+            const payload = api.buildPayload(data, true);
+            const _stream = (yield api.request(payload, options));
+            const normalized = api.normalizeStream(_stream);
+            return (0, stream_1.createAsyncIterable)(normalized);
+        });
+    }
+}
+exports.QwenDocTurbo = QwenDocTurbo;
+QwenDocTurbo.BASE_URL = "https://dashscope.aliyuncs.com";
+QwenDocTurbo.SUB_URL = "api/v1/services/aigc/text-generation/generation";
+QwenDocTurbo.OPENAI_COMPATIBLE_SUB_URL = "compatible-mode/v1/chat/completions";

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

@@ -0,0 +1,124 @@
+import type { DocUrlContent, TextContent } from "../../model-type";
+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;
+    incremental_output?: 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 interface OpenAICompatibleAPIInput {
+    model: string;
+    messages: Array<{
+        role: "system" | "user" | "assistant";
+        content: string;
+    }>;
+    stream?: boolean;
+    stream_options?: {
+        include_usage?: boolean;
+    };
+}
+export interface OpenAICompatibleResponse {
+    id?: string;
+    object?: string;
+    created?: number;
+    model?: string;
+    choices?: Array<{
+        index?: number;
+        message?: {
+            role?: string;
+            content?: string;
+        };
+        finish_reason?: string | null;
+    }>;
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+    };
+}
+export interface OpenAICompatibleStreamChunk {
+    id?: string;
+    object?: string;
+    created?: number;
+    model?: string;
+    choices?: Array<{
+        index?: number;
+        delta?: {
+            role?: string;
+            content?: string;
+        };
+        finish_reason?: string | null;
+    }>;
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+    };
+}
+export interface QwenDocTurboApi {
+    buildPayload(data: any, stream: boolean): unknown;
+    request(payload: unknown, options?: any): Promise<ReadableStream<Uint8Array> | unknown>;
+    normalizeResponse(res: unknown): any;
+    normalizeStream(stream: ReadableStream<Uint8Array>): ReadableStream<any>;
+}

package/lib/models/QwenDocTurbo/types.js

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

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

@@ -0,0 +1,81 @@
+import type { IAbstractRequest } from "@vectorx/ai-types";
+import type { DoGenerateOutput, DoStreamOutput, ModelRequestOptions, ReqOptions } from "../../model-type";
+import { TokenManager } from "../../tokenManager";
+import { SimpleChatModel } from "../Chat";
+export interface QwenImageParameters {
+    negative_prompt?: string;
+    size?: "1664*928" | "1472*1140" | "1328*1328" | "1140*1472" | "928*1664" | string;
+    n?: 1;
+    prompt_extend?: boolean;
+    watermark?: boolean;
+}
+export interface QwenImageAPIInput {
+    model: string;
+    input: {
+        messages?: Array<{
+            role: "user";
+            content: Array<{
+                text: string;
+            }>;
+        }>;
+        prompt?: string;
+    };
+    parameters?: QwenImageParameters;
+}
+export type QwenImageRequestOptions = QwenImageAPIInput & {
+    parameters?: QwenImageParameters;
+};
+export type QwenImageContentItem = {
+    image?: string;
+    url?: string;
+    image_url?: string | {
+        url: string;
+    };
+    b64_json?: string;
+    [key: string]: any;
+};
+export interface QwenImageAPIResponse {
+    async?: boolean;
+    output: {
+        choices?: Array<{
+            finish_reason: string;
+            message: {
+                role: "assistant" | "user";
+                content: QwenImageContentItem[];
+            };
+        }>;
+        task_status?: string;
+        task_id?: string;
+        task_metric?: {
+            TOTAL: number;
+            FAILED: number;
+            SUCCEEDED: number;
+        };
+    };
+    usage?: {
+        width?: number;
+        height?: number;
+        image_count?: number;
+    };
+    request_id?: string;
+    id?: string;
+    model?: string;
+    created?: number;
+    object?: string;
+    code?: number;
+    error?: string;
+}
+export declare class QwenImageModel extends SimpleChatModel {
+    static BASE_URL: string;
+    static SUB_SYNTHESIS_URL: string;
+    static SUB_GENERATION_URL: string;
+    modelName: string;
+    constructor(req: IAbstractRequest, baseUrl: string, tokenManager: TokenManager);
+    protected normalizeStandardImageCompletion(res: QwenImageAPIResponse, fallbackModel: string): DoGenerateOutput;
+    protected coverModelRequestToQwenInput(data: ModelRequestOptions & {
+        parameters?: QwenImageParameters;
+    }): QwenImageRequestOptions;
+    protected modelRequest(data: QwenImageRequestOptions, options?: ReqOptions): Promise<ReadableStream<Uint8Array> | Promise<unknown>>;
+    doGenerate(data: ModelRequestOptions, options?: ReqOptions): Promise<DoGenerateOutput>;
+    doStream(data: ModelRequestOptions, options?: ReqOptions): Promise<DoStreamOutput>;
+}