@zhivex-ai/qwen 0.7.8 → 0.8.1

package/dist/index.js

@@ -1,12 +1,12 @@
 import { toJSONSchema } from "zod";
-import { CallbackRealtimeSession, ConfigurationError, decodeBase64WithLimit, ProviderHTTPError, readBodyWithLimit, readErrorBodyWithLimit, readJsonWithLimit, resolveAudioResponseLimits, UnsupportedFeatureError, createProviderAdapter, hostedTool, openWebSocketConnection, isCallableToolDefinition, normalizeFinishReason, providerDataPart, streamSSE, withRetry, withTimeoutSignal } from "@zhivex-ai/core";
+import { CallbackRealtimeSession, ConfigurationError, decodeBase64WithLimit, ProviderHTTPError, readBodyWithLimit, readErrorBodyWithLimit, readJsonWithLimit, resolveAudioResponseLimits, UnsupportedFeatureError, createProviderAdapter, hostedTool, openWebSocketConnection, isCallableToolDefinition, normalizeFinishReason, providerDataPart, streamSSE, toToolSet, withRetry, withTimeoutSignal } from "@zhivex-ai/core";
 const capabilities = {
     streaming: true,
     tools: true,
     structuredOutput: true,
     jsonMode: true,
     toolChoice: true,
-    parallelToolCalls: true,
+    parallelToolCalls: false,
     vision: true,
     files: false,
     audioInput: false,
@@ -57,6 +57,173 @@ const qwenTaskBaseURLFrom = (baseURL) => {
     const url = new URL(baseURL);
     return `${url.protocol}//${url.host}/api/v1`;
 };
+const QWEN_REGION_HOSTS = {
+    singapore: "ap-southeast-1.maas.aliyuncs.com",
+    beijing: "cn-beijing.maas.aliyuncs.com",
+    "hong-kong": "cn-hongkong.maas.aliyuncs.com",
+    tokyo: "ap-northeast-1.maas.aliyuncs.com",
+    frankfurt: "eu-central-1.maas.aliyuncs.com",
+    virginia: "dashscope-us.aliyuncs.com"
+};
+const qwenWorkspaceURLs = (workspaceId, region) => {
+    const origin = region === "virginia"
+        ? `https://${QWEN_REGION_HOSTS[region]}`
+        : `https://${workspaceId}.${QWEN_REGION_HOSTS[region]}`;
+    return {
+        baseURL: `${origin}/compatible-mode/v1`,
+        taskBaseURL: `${origin}/api/v1`,
+        realtimeURL: `${origin.replace(/^https:/, "wss:")}/api-ws/v1/realtime`
+    };
+};
+const QWEN_REALTIME_QUEUE_LIMIT = 256;
+const nodeWebSocketDataToText = (data) => {
+    if (Array.isArray(data)) {
+        return Buffer.concat(data).toString("utf8");
+    }
+    if (data instanceof ArrayBuffer) {
+        return Buffer.from(data).toString("utf8");
+    }
+    return Buffer.from(data).toString("utf8");
+};
+const openQwenRealtimeConnection = async (url, headers, options) => {
+    if (typeof process === "undefined" || !process.versions?.node) {
+        return openWebSocketConnection(url, headers, options);
+    }
+    if (options?.signal?.aborted) {
+        throw new Error("Qwen realtime connection aborted.");
+    }
+    const { default: WebSocket } = await import("ws");
+    const socket = options?.subprotocols?.length
+        ? new WebSocket(url, options.subprotocols, { headers })
+        : new WebSocket(url, { headers });
+    await new Promise((resolve, reject) => {
+        let finished = false;
+        const finish = (callback) => {
+            if (finished) {
+                return;
+            }
+            finished = true;
+            if (timer) {
+                clearTimeout(timer);
+            }
+            options?.signal?.removeEventListener("abort", onAbort);
+            socket.off("open", onOpen);
+            socket.off("error", onError);
+            callback();
+        };
+        const onOpen = () => finish(resolve);
+        const onError = (error) => finish(() => reject(error));
+        const onAbort = () => {
+            socket.close();
+            finish(() => reject(new Error("Qwen realtime connection aborted.")));
+        };
+        const timer = options?.timeoutMs
+            ? setTimeout(() => {
+                socket.close();
+                finish(() => reject(new Error(`Qwen realtime connection timed out after ${options.timeoutMs}ms.`)));
+            }, options.timeoutMs)
+            : undefined;
+        socket.once("open", onOpen);
+        socket.once("error", onError);
+        options?.signal?.addEventListener("abort", onAbort, { once: true });
+    });
+    const queue = [];
+    const readers = [];
+    let closed = false;
+    let connectionError;
+    const rejectReaders = (error) => {
+        for (const reader of readers.splice(0)) {
+            reader.reject(error);
+        }
+    };
+    const closeReaders = () => {
+        for (const reader of readers.splice(0)) {
+            reader.resolve(undefined);
+        }
+    };
+    socket.on("message", (data) => {
+        const text = nodeWebSocketDataToText(data);
+        const reader = readers.shift();
+        if (reader) {
+            try {
+                reader.resolve(JSON.parse(text));
+            }
+            catch (error) {
+                reader.reject(error);
+            }
+            return;
+        }
+        if (queue.length >= QWEN_REALTIME_QUEUE_LIMIT) {
+            connectionError = new Error(`Qwen realtime receive buffer exceeded ${QWEN_REALTIME_QUEUE_LIMIT} messages.`);
+            connectionError.name = "StreamBufferOverflowError";
+            socket.close();
+            return;
+        }
+        queue.push(text);
+    });
+    socket.on("error", (error) => {
+        connectionError = error;
+        rejectReaders(error);
+    });
+    socket.on("close", () => {
+        closed = true;
+        if (connectionError) {
+            rejectReaders(connectionError);
+        }
+        else {
+            closeReaders();
+        }
+    });
+    const connection = {
+        async sendJson(payload) {
+            if (connectionError) {
+                throw connectionError;
+            }
+            if (closed) {
+                throw new Error("Qwen realtime connection is closed.");
+            }
+            await new Promise((resolve, reject) => {
+                socket.send(JSON.stringify(payload), (error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        },
+        async recvJson() {
+            if (connectionError) {
+                throw connectionError;
+            }
+            if (queue.length > 0) {
+                return JSON.parse(queue.shift());
+            }
+            if (closed) {
+                return undefined;
+            }
+            return new Promise((resolve, reject) => readers.push({ resolve, reject }));
+        },
+        async close() {
+            if (closed) {
+                return;
+            }
+            await new Promise((resolve) => {
+                const timer = setTimeout(() => {
+                    socket.terminate();
+                    resolve();
+                }, 1_000);
+                socket.once("close", () => {
+                    clearTimeout(timer);
+                    resolve();
+                });
+                socket.close();
+            });
+        }
+    };
+    return connection;
+};
 const toUint8Array = async (data) => {
     if (data instanceof Uint8Array) {
         return data;
@@ -70,6 +237,24 @@ const toUint8Array = async (data) => {
     return Uint8Array.from(Buffer.from(String(data), "base64"));
 };
 const toBase64 = async (data) => typeof data === "string" ? data : Buffer.from(await toUint8Array(data)).toString("base64");
+const toDataURL = (data, mediaType) => {
+    if (typeof data === "string" && (/^data:/i.test(data) || /^https?:\/\//i.test(data))) {
+        return data;
+    }
+    const encoded = typeof data === "string"
+        ? data
+        : Buffer.from(data instanceof Uint8Array ? data : new Uint8Array(data)).toString("base64");
+    return `data:${mediaType};base64,${encoded}`;
+};
+const mediaValue = (input) => {
+    if (input.uri) {
+        return input.uri;
+    }
+    if (input.data === undefined) {
+        throw new ConfigurationError("Qwen media input requires either uri or data.");
+    }
+    return toDataURL(input.data, input.mediaType);
+};
 const createFile = async (data, mediaType, filename) => {
     const bytes = await toUint8Array(data);
     return new File([bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)], filename, { type: mediaType });
@@ -83,6 +268,50 @@ const appendQuery = (url, query) => {
     }
     return parsed.toString();
 };
+const encodeQwenResourceId = (value, resource) => {
+    if (!value || value === "." || value === ".." || /[\\/?#\s]/.test(value)) {
+        throw new ConfigurationError(`Qwen ${resource} ID must be a non-empty opaque identifier without path separators.`);
+    }
+    return encodeURIComponent(value);
+};
+const isQwenOmniLanguageModel = (modelId) => /^qwen3(?:\.5)?-omni-(?:plus|flash)(?:$|-)/i.test(modelId);
+const isOfficialQwenSpeechAudioURL = (url) => !url.username &&
+    !url.password &&
+    /(?:^|\.)oss(?:-[a-z0-9-]+)?\.aliyuncs\.com$/i.test(url.hostname);
+const parseQwenSpeechAudioURL = async (value, validator) => {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new ProviderHTTPError("Qwen speech response contained an invalid audio download URL.", 502);
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new ProviderHTTPError("Qwen speech audio downloads require an HTTP(S) URL.", 502);
+    }
+    const allowed = validator ? await validator(url) : isOfficialQwenSpeechAudioURL(url);
+    if (!allowed) {
+        throw new ProviderHTTPError("Qwen speech response contained an audio download URL rejected by the configured safety policy.", 502);
+    }
+    return url;
+};
+const downloadQwenSpeechAudio = async (initialURL, fetcher, signal, validator, maxRedirects) => {
+    let url = await parseQwenSpeechAudioURL(initialURL, validator);
+    for (let redirects = 0;; redirects += 1) {
+        const response = await fetcher(url, { method: "GET", redirect: "manual", signal });
+        if (![301, 302, 303, 307, 308].includes(response.status)) {
+            return response;
+        }
+        if (redirects >= maxRedirects) {
+            throw new ProviderHTTPError(`Qwen speech audio download exceeded ${maxRedirects} redirects.`, 502);
+        }
+        const location = response.headers.get("location");
+        if (!location) {
+            throw new ProviderHTTPError("Qwen speech audio redirect did not include a Location header.", 502);
+        }
+        url = await parseQwenSpeechAudioURL(new URL(location, url).toString(), validator);
+    }
+};
 const providerHeaders = (apiKey, providerOptions) => {
     const headers = jsonHeaders(apiKey);
     const sessionCache = providerOptions?.["x-dashscope-session-cache"];
@@ -96,26 +325,69 @@ const stripHeaderOptions = (providerOptions) => {
     delete next["x-dashscope-session-cache"];
     return next;
 };
+const stripResponsesRequestOptions = (providerOptions) => {
+    const next = stripHeaderOptions(providerOptions);
+    for (const key of [
+        "model",
+        "input",
+        "stream",
+        "tools",
+        "tool_choice",
+        "temperature",
+        "reasoning",
+        "previous_response_id",
+        "max_output_tokens",
+        "response_format"
+    ]) {
+        delete next[key];
+    }
+    return next;
+};
 const modelFamily = (modelId) => modelId.toLowerCase();
-const supportsQwenReasoning = (modelId) => /^(qwen-(plus|turbo|max|flash)|qwq|qwen3|qwen3\.)/i.test(modelId);
+const supportsQwenReasoning = (modelId) => !isQwenOmniLanguageModel(modelId) &&
+    supportsQwenTools(modelId) &&
+    /^(qwen-(plus|turbo|max|flash)|qwq|qwen3|qwen3\.)/i.test(modelId);
 const supportsQwenVision = (modelId) => {
     const model = modelFamily(modelId);
     return (model.includes("vl") ||
         model.includes("omni") ||
+        model.includes("ocr") ||
         model.includes("vision") ||
-        /^qwen3\.7-plus(?:$|-)/.test(model));
+        /^qwen3\.7-plus(?:$|-)/.test(model) ||
+        /^qwen3\.6-flash(?:$|-)/.test(model));
+};
+const supportsQwenTools = (modelId) => !/(embedding|rerank|asr|tts|image|realtime|ocr|translation|character|long-context)/.test(modelFamily(modelId));
+const supportsQwenFiles = (modelId) => /^qwen3\.5-ocr(?:$|-)/.test(modelFamily(modelId));
+const supportsQwenAudioInput = (modelId) => /(omni|audio|asr)/.test(modelFamily(modelId));
+const qwenLanguageCapabilities = (modelId) => {
+    const tools = supportsQwenTools(modelId);
+    const omni = isQwenOmniLanguageModel(modelId);
+    const reasoning = supportsQwenReasoning(modelId);
+    return {
+        ...capabilities,
+        vision: supportsQwenVision(modelId),
+        tools,
+        structuredOutput: tools && !omni,
+        jsonMode: tools && !omni,
+        toolChoice: tools,
+        parallelToolCalls: false,
+        webSearch: tools && !omni,
+        files: supportsQwenFiles(modelId),
+        audioInput: supportsQwenAudioInput(modelId),
+        reasoning,
+        reasoningEfforts: reasoning ? ["none", "minimal", "low", "medium", "high"] : undefined,
+        agentCapabilities: {
+            ...capabilities.agentCapabilities,
+            supportTier: tools && !omni ? "tier-b" : "tier-c",
+            toolChoiceNone: tools,
+            hostedWebSearch: tools && !omni,
+            hostedFileSearch: tools && !omni,
+            remoteMcp: tools && !omni,
+            codeExecution: tools && !omni,
+            webExtraction: tools && !omni
+        }
+    };
 };
-const supportsQwenTools = (modelId) => !modelFamily(modelId).includes("embedding");
-const qwenLanguageCapabilities = (modelId) => ({
-    ...capabilities,
-    vision: supportsQwenVision(modelId),
-    tools: supportsQwenTools(modelId),
-    structuredOutput: supportsQwenTools(modelId),
-    jsonMode: supportsQwenTools(modelId),
-    toolChoice: supportsQwenTools(modelId),
-    parallelToolCalls: supportsQwenTools(modelId),
-    reasoning: supportsQwenReasoning(modelId)
-});
 const transcriptionCapabilities = {
     ...embeddingCapabilities,
     audioInput: true
@@ -176,23 +448,25 @@ const parseJson = async (response, options = {}) => {
         : response.json();
 };
 const mapContentParts = (message) => {
-    const textParts = message.parts.filter((part) => part.type === "text");
-    const imageParts = message.parts.filter((part) => part.type === "image");
-    if (!imageParts.length) {
-        return textParts.map((part) => part.text).join("");
+    const hasMedia = message.parts.some((part) => part.type === "image" || part.type === "audio");
+    if (!hasMedia) {
+        return message.parts
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("");
     }
-    return [
-        ...textParts.map((part) => ({
-            type: "text",
-            text: part.text
-        })),
-        ...imageParts.map((part) => ({
-            type: "image_url",
-            image_url: {
-                url: part.image
-            }
-        }))
-    ];
+    return message.parts.flatMap((part) => {
+        if (part.type === "text") {
+            return [{ type: "text", text: part.text }];
+        }
+        if (part.type === "image") {
+            return [{ type: "image_url", image_url: { url: part.image } }];
+        }
+        if (part.type === "audio") {
+            return [{ type: "input_audio", input_audio: { data: toDataURL(part.data, part.mediaType) } }];
+        }
+        return [];
+    });
 };
 const mapMessages = (messages) => messages.map((message) => {
     if (message.role === "tool") {
@@ -264,7 +538,7 @@ const mapResponsesTools = (tools) => tools
         };
     })
     : undefined;
-const mapToolChoice = (toolChoice) => {
+const mapChatToolChoice = (toolChoice) => {
     if (!toolChoice) {
         return undefined;
     }
@@ -278,21 +552,48 @@ const mapToolChoice = (toolChoice) => {
         }
     };
 };
-const mapStructuredOutput = (input) => {
-    if (!input.structuredOutput || input.structuredOutput.mode !== "native") {
+const mapResponsesToolChoice = (toolChoice, tools) => {
+    if (!toolChoice) {
         return undefined;
     }
-    return {
-        type: "json_schema",
-        json_schema: {
-            name: input.structuredOutput.name ?? "response",
-            strict: true,
-            schema: toJSONSchema(input.structuredOutput.schema)
+    if (typeof toolChoice === "string") {
+        if (toolChoice === "required" && Object.keys(tools ?? {}).length !== 1) {
+            throw new UnsupportedFeatureError('Qwen Responses supports toolChoice "required" only when exactly one tool is provided.');
         }
+        return toolChoice;
+    }
+    return {
+        type: "allowed_tools",
+        mode: "required",
+        tools: [{ type: "function", name: toolChoice.toolName }]
     };
 };
+const mapStructuredOutput = (input) => {
+    if (!input.structuredOutput || input.structuredOutput.mode !== "native") {
+        return undefined;
+    }
+    return { type: "json_object" };
+};
+const withStructuredOutputMessages = (input) => {
+    if (!input.structuredOutput || input.structuredOutput.mode !== "native") {
+        return input.messages;
+    }
+    const schema = JSON.stringify(toJSONSchema(input.structuredOutput.schema));
+    return [
+        {
+            role: "system",
+            parts: [
+                {
+                    type: "text",
+                    text: `Return only valid JSON matching this JSON Schema: ${schema}`
+                }
+            ]
+        },
+        ...input.messages
+    ];
+};
 const hasPreservedReasoning = (messages) => messages.some((message) => message.role === "assistant" && reasoningContentFromMessage(message));
-const mapReasoning = (input) => {
+const mapChatReasoning = (input) => {
     if (!input.reasoning) {
         return undefined;
     }
@@ -304,6 +605,63 @@ const mapReasoning = (input) => {
         ...(hasPreservedReasoning(input.messages) ? { preserve_thinking: true } : {})
     };
 };
+const mapResponsesReasoning = (input) => {
+    const effort = input.reasoning?.effort;
+    if (!effort) {
+        return undefined;
+    }
+    return {
+        reasoning: {
+            effort: effort === "low" ? "minimal" : effort
+        }
+    };
+};
+const mapResponsesUsage = (usage) => usage
+    ? {
+        inputTokens: usage.input_tokens,
+        cachedInputTokens: usage.input_tokens_details?.cached_tokens,
+        outputTokens: usage.output_tokens,
+        reasoningTokens: usage.output_tokens_details?.reasoning_tokens,
+        totalTokens: usage.total_tokens
+    }
+    : undefined;
+const mapChatUsage = (usage) => usage
+    ? {
+        inputTokens: usage.prompt_tokens,
+        cachedInputTokens: usage.prompt_tokens_details?.cached_tokens ?? usage.input_tokens_details?.cached_tokens,
+        outputTokens: usage.completion_tokens,
+        reasoningTokens: usage.completion_tokens_details?.reasoning_tokens ?? usage.output_tokens_details?.reasoning_tokens,
+        totalTokens: usage.total_tokens
+    }
+    : undefined;
+const hasHostedTools = (tools) => Object.values(tools ?? {}).some((tool) => !isCallableToolDefinition(tool));
+const hasMessagePart = (messages, type) => messages.some((message) => message.parts.some((part) => part.type === type));
+const resolveApiMode = (modelId, requestedMode, input) => {
+    const needsChat = input.maxTokens !== undefined ||
+        input.reasoning?.budgetTokens !== undefined ||
+        input.structuredOutput?.mode === "native" ||
+        hasMessagePart(input.messages, "audio");
+    const needsResponses = hasHostedTools(input.tools) || hasMessagePart(input.messages, "file");
+    if (needsChat && needsResponses) {
+        throw new UnsupportedFeatureError("Qwen cannot combine Responses-only hosted/file inputs with Chat-only maxTokens, audio, reasoning budgets, or structured output.");
+    }
+    if (isQwenOmniLanguageModel(modelId)) {
+        if (requestedMode === "responses" || needsResponses) {
+            throw new UnsupportedFeatureError("Qwen Omni uses streaming Chat Completions and does not support Responses hosted tools or file inputs.");
+        }
+        return "chat";
+    }
+    if (requestedMode === "responses" && needsChat) {
+        throw new UnsupportedFeatureError('Qwen Responses does not process maxTokens, audio input, reasoning budgets, or native structured output; use apiMode "chat" or "auto".');
+    }
+    if (requestedMode === "chat" && needsResponses) {
+        throw new UnsupportedFeatureError('Qwen Chat Completions does not support Responses hosted tools or OCR file inputs.');
+    }
+    if (requestedMode === "responses" || requestedMode === "chat") {
+        return requestedMode;
+    }
+    return needsChat ? "chat" : "responses";
+};
 const parseAssistantMessage = (message) => ({
     role: "assistant",
     parts: [
@@ -366,6 +724,16 @@ const toResponsesInput = (messages) => {
                 case "image":
                     content.push({ type: "input_image", image_url: part.image });
                     break;
+                case "file":
+                    if (!/^https?:\/\//i.test(part.data)) {
+                        throw new UnsupportedFeatureError("Qwen Responses file input requires a public HTTP(S) file URL; DashScope Files IDs are reserved for batch jobs.");
+                    }
+                    content.push({
+                        type: "input_file",
+                        file_url: part.data,
+                        ...(part.filename ? { filename: part.filename } : {})
+                    });
+                    break;
                 case "tool-call":
                     if (message.role === "assistant") {
                         input.push({
@@ -376,6 +744,15 @@ const toResponsesInput = (messages) => {
                         });
                     }
                     break;
+                case "provider-data":
+                    if (message.role === "assistant" &&
+                        part.provider === "qwen" &&
+                        part.data &&
+                        typeof part.data === "object" &&
+                        typeof part.data.type === "string") {
+                        input.push(part.data);
+                    }
+                    break;
             }
         }
         if (content.length) {
@@ -553,17 +930,18 @@ const streamResponses = async function* (response) {
         }
         if (type === "response.completed" || type === "response.failed" || type === "response.incomplete") {
             const responseData = json.response ?? {};
+            if (typeof responseData.id === "string") {
+                yield {
+                    type: "provider-data",
+                    provider: "qwen",
+                    data: { responseId: responseData.id }
+                };
+            }
             yield {
                 type: "finish",
                 finishReason: normalizeResponsesFinishReason(responseData.status, sawToolCalls),
                 providerFinishReason: responseData.status,
-                usage: responseData.usage
-                    ? {
-                        inputTokens: responseData.usage.input_tokens,
-                        outputTokens: responseData.usage.output_tokens,
-                        totalTokens: responseData.usage.total_tokens
-                    }
-                    : undefined
+                usage: mapResponsesUsage(responseData.usage)
             };
         }
     }
@@ -583,14 +961,17 @@ class QwenLanguageModel {
         this.capabilities = qwenLanguageCapabilities(modelId);
     }
     async generate(input) {
+        if (isQwenOmniLanguageModel(this.modelId)) {
+            throw new UnsupportedFeatureError(`Qwen Omni model "${this.modelId}" is streaming-only. Use streamText() instead of generateText().`);
+        }
         const { signal, cleanup } = withTimeoutSignal(input);
         const providerOptions = { ...(input.providerOptions ?? {}) };
-        const apiMode = providerOptions.apiMode ?? "responses";
+        const apiMode = resolveApiMode(this.modelId, providerOptions.apiMode ?? "auto", input);
         delete providerOptions.apiMode;
         try {
             if (apiMode === "responses") {
                 const previousResponse = getProviderResponseId(input.messages);
-                const responseProviderOptions = stripHeaderOptions(providerOptions);
+                const responseProviderOptions = stripResponsesRequestOptions(providerOptions);
                 const messages = previousResponse && previousResponse.index < input.messages.length - 1
                     ? input.messages.slice(previousResponse.index + 1)
                     : input.messages;
@@ -603,12 +984,10 @@ class QwenLanguageModel {
                         model: this.modelId,
                         ...(previousResponse ? { previous_response_id: previousResponse.responseId } : {}),
                         ...(messages.length ? { input: toResponsesInput(messages) } : {}),
-                        ...(input.structuredOutput?.mode === "native" ? { response_format: mapStructuredOutput(input) } : {}),
                         tools: mapResponsesTools(input.tools),
-                        tool_choice: mapToolChoice(input.toolChoice),
+                        tool_choice: mapResponsesToolChoice(input.toolChoice, input.tools),
                         temperature: input.temperature,
-                        max_output_tokens: input.maxTokens,
-                        ...mapReasoning(input),
+                        ...mapResponsesReasoning(input),
                         stream: false
                     })
                 }), input);
@@ -623,29 +1002,25 @@ class QwenLanguageModel {
                         .join(""),
                     finishReason: normalizeResponsesFinishReason(json.status, hasToolCalls),
                     providerFinishReason: json.status,
-                    usage: {
-                        inputTokens: json.usage?.input_tokens,
-                        outputTokens: json.usage?.output_tokens,
-                        totalTokens: json.usage?.total_tokens
-                    },
+                    usage: mapResponsesUsage(json.usage),
                     rawResponse: json
                 };
             }
             const response = await withRetry(() => this.fetcher(`${this.baseURL}/chat/completions`, {
                 method: "POST",
-                headers: jsonHeaders(this.apiKey),
+                headers: providerHeaders(this.apiKey, providerOptions),
                 signal,
                 body: JSON.stringify({
-                    ...providerOptions,
+                    ...stripHeaderOptions(providerOptions),
                     model: this.modelId,
-                    messages: mapMessages(input.messages),
+                    messages: mapMessages(withStructuredOutputMessages(input)),
                     tools: mapChatTools(input.tools),
-                    tool_choice: mapToolChoice(input.toolChoice),
+                    tool_choice: mapChatToolChoice(input.toolChoice),
                     response_format: mapStructuredOutput(input),
                     temperature: input.temperature,
                     max_tokens: input.maxTokens,
                     stream: false,
-                    ...mapReasoning(input)
+                    ...mapChatReasoning(input)
                 })
             }), input);
             const json = await parseJson(response);
@@ -660,11 +1035,7 @@ class QwenLanguageModel {
                     .join(""),
                 finishReason: normalizeFinishReason(choice?.finish_reason),
                 providerFinishReason: choice?.finish_reason,
-                usage: {
-                    inputTokens: json.usage?.prompt_tokens,
-                    outputTokens: json.usage?.completion_tokens,
-                    totalTokens: json.usage?.total_tokens
-                },
+                usage: mapChatUsage(json.usage),
                 rawResponse: json
             };
         }
@@ -675,10 +1046,14 @@ class QwenLanguageModel {
     async stream(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
         const providerOptions = { ...(input.providerOptions ?? {}) };
-        const apiMode = providerOptions.apiMode ?? "responses";
+        const apiMode = resolveApiMode(this.modelId, providerOptions.apiMode ?? "auto", input);
         delete providerOptions.apiMode;
         if (apiMode === "responses") {
-            const responseProviderOptions = stripHeaderOptions(providerOptions);
+            const previousResponse = getProviderResponseId(input.messages);
+            const responseProviderOptions = stripResponsesRequestOptions(providerOptions);
+            const messages = previousResponse && previousResponse.index < input.messages.length - 1
+                ? input.messages.slice(previousResponse.index + 1)
+                : input.messages;
             const response = await withRetry(() => this.fetcher(`${this.baseURL}/responses`, {
                 method: "POST",
                 headers: providerHeaders(this.apiKey, providerOptions),
@@ -686,13 +1061,12 @@ class QwenLanguageModel {
                 body: JSON.stringify({
                     ...responseProviderOptions,
                     model: this.modelId,
-                    input: toResponsesInput(input.messages),
-                    ...(input.structuredOutput?.mode === "native" ? { response_format: mapStructuredOutput(input) } : {}),
+                    ...(previousResponse ? { previous_response_id: previousResponse.responseId } : {}),
+                    ...(messages.length ? { input: toResponsesInput(messages) } : {}),
                     tools: mapResponsesTools(input.tools),
-                    tool_choice: mapToolChoice(input.toolChoice),
+                    tool_choice: mapResponsesToolChoice(input.toolChoice, input.tools),
                     temperature: input.temperature,
-                    max_output_tokens: input.maxTokens,
-                    ...mapReasoning(input),
+                    ...mapResponsesReasoning(input),
                     stream: true
                 })
             }), input);
@@ -707,20 +1081,21 @@ class QwenLanguageModel {
         }
         const response = await withRetry(() => this.fetcher(`${this.baseURL}/chat/completions`, {
             method: "POST",
-            headers: jsonHeaders(this.apiKey),
+            headers: providerHeaders(this.apiKey, providerOptions),
             signal,
             body: JSON.stringify({
-                ...providerOptions,
+                ...stripHeaderOptions(providerOptions),
                 model: this.modelId,
-                messages: mapMessages(input.messages),
+                modalities: isQwenOmniLanguageModel(this.modelId) ? providerOptions.modalities ?? ["text"] : undefined,
+                messages: mapMessages(withStructuredOutputMessages(input)),
                 tools: mapChatTools(input.tools),
-                tool_choice: mapToolChoice(input.toolChoice),
+                tool_choice: mapChatToolChoice(input.toolChoice),
                 response_format: mapStructuredOutput(input),
                 temperature: input.temperature,
                 max_tokens: input.maxTokens,
                 stream: true,
                 stream_options: { include_usage: true },
-                ...mapReasoning(input)
+                ...mapChatReasoning(input)
             })
         }), input);
         return (async function* () {
@@ -747,37 +1122,40 @@ class QwenLanguageModel {
                         yield { type: "text-delta", textDelta: delta.content };
                     }
                     for (const toolCall of delta?.tool_calls ?? []) {
-                        const id = toolCall.id ?? `${toolCall.index}`;
-                        const existing = toolBuffers.get(id) ?? {
+                        const index = Number(toolCall.index ?? 0);
+                        const existing = toolBuffers.get(index) ?? {
+                            id: toolCall.id ?? `${index}`,
                             name: toolCall.function?.name ?? "",
-                            args: ""
+                            args: "",
+                            emitted: false
                         };
+                        existing.id = toolCall.id ?? existing.id;
                         existing.name ||= toolCall.function?.name ?? "";
                         existing.args += toolCall.function?.arguments ?? "";
-                        toolBuffers.set(id, existing);
-                        if (choice?.finish_reason === "tool_calls") {
-                            yield {
-                                type: "tool-call",
-                                toolCall: {
-                                    id,
-                                    name: existing.name,
-                                    input: JSON.parse(existing.args || "{}")
-                                }
-                            };
-                        }
+                        toolBuffers.set(index, existing);
                     }
                     if (choice?.finish_reason) {
+                        if (choice.finish_reason === "tool_calls") {
+                            for (const toolCall of toolBuffers.values()) {
+                                if (toolCall.emitted) {
+                                    continue;
+                                }
+                                toolCall.emitted = true;
+                                yield {
+                                    type: "tool-call",
+                                    toolCall: {
+                                        id: toolCall.id,
+                                        name: toolCall.name,
+                                        input: JSON.parse(toolCall.args || "{}")
+                                    }
+                                };
+                            }
+                        }
                         yield {
                             type: "finish",
                             finishReason: normalizeFinishReason(choice.finish_reason),
                             providerFinishReason: choice.finish_reason,
-                            usage: json.usage
-                                ? {
-                                    inputTokens: json.usage.prompt_tokens,
-                                    outputTokens: json.usage.completion_tokens,
-                                    totalTokens: json.usage.total_tokens
-                                }
-                                : undefined
+                            usage: mapChatUsage(json.usage)
                         };
                     }
                 }
@@ -834,6 +1212,67 @@ class QwenEmbeddingModel {
         }
     }
 }
+const toMultimodalEmbeddingContent = (value) => {
+    if (typeof value === "string") {
+        return { text: value };
+    }
+    if (value.mediaType.startsWith("image/")) {
+        return { image: mediaValue(value) };
+    }
+    if (value.mediaType.startsWith("video/")) {
+        if (!value.uri) {
+            throw new UnsupportedFeatureError("Qwen multimodal embedding requires a public URL for video input.");
+        }
+        return { video: value.uri };
+    }
+    throw new UnsupportedFeatureError(`Qwen multimodal embedding supports text, image, and video inputs, not "${value.mediaType}".`);
+};
+class QwenMultimodalEmbeddingModelImpl {
+    modelId;
+    apiKey;
+    taskBaseURL;
+    fetcher;
+    provider = "qwen";
+    capabilities = {
+        ...embeddingCapabilities,
+        vision: true
+    };
+    constructor(modelId, apiKey, taskBaseURL, fetcher) {
+        this.modelId = modelId;
+        this.apiKey = apiKey;
+        this.taskBaseURL = taskBaseURL;
+        this.fetcher = fetcher;
+    }
+    async embed(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(`${this.taskBaseURL}/services/embeddings/multimodal-embedding/multimodal-embedding`, {
+                method: "POST",
+                headers: jsonHeaders(this.apiKey),
+                signal,
+                body: JSON.stringify({
+                    model: this.modelId,
+                    input: { contents: input.values.map(toMultimodalEmbeddingContent) },
+                    ...(input.providerOptions && Object.keys(input.providerOptions).length
+                        ? { parameters: input.providerOptions }
+                        : {})
+                })
+            }), input);
+            const json = await parseJson(response);
+            return {
+                embeddings: (json.output?.embeddings ?? []).map((entry) => entry.embedding),
+                usage: {
+                    inputTokens: json.usage?.input_tokens,
+                    totalTokens: json.usage?.total_tokens
+                },
+                rawResponse: json
+            };
+        }
+        finally {
+            cleanup();
+        }
+    }
+}
 const normalizeUploadedFile = (json) => ({
     name: json.id ?? json.name ?? json.file_id ?? "",
     uri: json.url ?? json.uri,
@@ -844,14 +1283,6 @@ const normalizeUploadedFile = (json) => ({
     rawResponse: json,
     providerMetadata: json
 });
-const normalizeFileSearchStore = (json) => ({
-    name: json.id ?? json.name ?? "",
-    displayName: json.name ?? json.display_name ?? json.displayName,
-    createTime: json.created_at ? String(json.created_at) : json.createTime,
-    updateTime: json.updated_at ? String(json.updated_at) : json.updateTime,
-    rawResponse: json,
-    providerMetadata: json
-});
 const normalizeBatchJob = (json) => ({
     name: json.id ?? json.name ?? "",
     model: json.model,
@@ -863,10 +1294,13 @@ const normalizeBatchJob = (json) => ({
     providerMetadata: json
 });
 const normalizeOperation = (json) => ({
-    name: json.task_id ?? json.id ?? json.name ?? "",
+    name: json.output?.task_id ?? json.task_id ?? json.id ?? json.name ?? "",
     done: json.output?.task_status ? ["SUCCEEDED", "FAILED", "CANCELED"].includes(json.output.task_status) : json.done,
     response: json.output ?? json.response,
-    error: json.error,
+    error: json.error ??
+        (json.output?.task_status === "FAILED"
+            ? { message: json.output?.message ?? "Qwen task failed.", code: json.output?.code }
+            : undefined),
     metadata: json.usage ?? json.metadata,
     rawResponse: json
 });
@@ -900,7 +1334,8 @@ class QwenFilesClient {
     async get(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/files/${input.name}`, { method: "GET", headers: jsonHeaders(this.apiKey), signal }), input);
+            const fileId = encodeQwenResourceId(input.name, "file");
+            const response = await withRetry(() => this.fetcher(`${this.baseURL}/files/${fileId}`, { method: "GET", headers: jsonHeaders(this.apiKey), signal }), input);
             return normalizeUploadedFile(await parseJson(response));
         }
         finally {
@@ -925,88 +1360,8 @@ class QwenFilesClient {
     async delete(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/files/${input.name}`, { method: "DELETE", headers: jsonHeaders(this.apiKey), signal }), input);
-            const json = await parseJson(response);
-            return { name: input.name, rawResponse: json };
-        }
-        finally {
-            cleanup();
-        }
-    }
-}
-class QwenFileSearchStoresClient {
-    apiKey;
-    baseURL;
-    fetcher;
-    constructor(apiKey, baseURL, fetcher) {
-        this.apiKey = apiKey;
-        this.baseURL = baseURL;
-        this.fetcher = fetcher;
-    }
-    async create(input = {}) {
-        const { signal, cleanup } = withTimeoutSignal(input);
-        try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/file_search_stores`, {
-                method: "POST",
-                headers: jsonHeaders(this.apiKey),
-                signal,
-                body: JSON.stringify({ ...input.providerOptions, name: input.displayName })
-            }), input);
-            return normalizeFileSearchStore(await parseJson(response));
-        }
-        finally {
-            cleanup();
-        }
-    }
-    async upload(input) {
-        const files = new QwenFilesClient(this.apiKey, this.baseURL, this.fetcher);
-        const file = await files.upload(input);
-        return this.importFile({ ...input, fileName: file.name });
-    }
-    async importFile(input) {
-        const { signal, cleanup } = withTimeoutSignal(input);
-        try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/file_search_stores/${input.storeName}/files`, {
-                method: "POST",
-                headers: jsonHeaders(this.apiKey),
-                signal,
-                body: JSON.stringify({ ...input.providerOptions, file_id: input.fileName })
-            }), input);
-            return normalizeOperation(await parseJson(response));
-        }
-        finally {
-            cleanup();
-        }
-    }
-    async get(input) {
-        const { signal, cleanup } = withTimeoutSignal(input);
-        try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/file_search_stores/${input.name}`, { method: "GET", headers: jsonHeaders(this.apiKey), signal }), input);
-            return normalizeFileSearchStore(await parseJson(response));
-        }
-        finally {
-            cleanup();
-        }
-    }
-    async list(input = {}) {
-        const { signal, cleanup } = withTimeoutSignal(input);
-        try {
-            const response = await withRetry(() => this.fetcher(appendQuery(`${this.baseURL}/file_search_stores`, { limit: input.pageSize, after: input.pageToken }), { method: "GET", headers: jsonHeaders(this.apiKey), signal }), input);
-            const json = await parseJson(response);
-            return {
-                stores: (json.data ?? json.file_search_stores ?? json.fileSearchStores ?? []).map(normalizeFileSearchStore),
-                nextPageToken: json.next ?? json.nextPageToken,
-                rawResponse: json
-            };
-        }
-        finally {
-            cleanup();
-        }
-    }
-    async delete(input) {
-        const { signal, cleanup } = withTimeoutSignal(input);
-        try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/file_search_stores/${input.name}`, { method: "DELETE", headers: jsonHeaders(this.apiKey), signal }), input);
+            const fileId = encodeQwenResourceId(input.name, "file");
+            const response = await withRetry(() => this.fetcher(`${this.baseURL}/files/${fileId}`, { method: "DELETE", headers: jsonHeaders(this.apiKey), signal }), input);
             const json = await parseJson(response);
             return { name: input.name, rawResponse: json };
         }
@@ -1025,6 +1380,9 @@ class QwenBatchesClient {
         this.fetcher = fetcher;
     }
     async create(input) {
+        if (!input.fileName) {
+            throw new ConfigurationError("Qwen batch creation requires a JSONL fileName uploaded with purpose \"batch\".");
+        }
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
             const response = await withRetry(() => this.fetcher(`${this.baseURL}/batches`, {
@@ -1036,9 +1394,7 @@ class QwenBatchesClient {
                     input_file_id: input.fileName,
                     endpoint: input.providerOptions?.endpoint ?? "/v1/chat/completions",
                     completion_window: input.providerOptions?.completion_window ?? "24h",
-                    metadata: input.displayName ? { displayName: input.displayName } : undefined,
-                    model: input.modelId,
-                    requests: input.requests
+                    metadata: input.displayName ? { displayName: input.displayName } : undefined
                 })
             }), input);
             return normalizeBatchJob(await parseJson(response));
@@ -1050,7 +1406,8 @@ class QwenBatchesClient {
     async get(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/batches/${input.name}`, { method: "GET", headers: jsonHeaders(this.apiKey), signal }), input);
+            const batchId = encodeQwenResourceId(input.name, "batch");
+            const response = await withRetry(() => this.fetcher(`${this.baseURL}/batches/${batchId}`, { method: "GET", headers: jsonHeaders(this.apiKey), signal }), input);
             return normalizeBatchJob(await parseJson(response));
         }
         finally {
@@ -1071,7 +1428,8 @@ class QwenBatchesClient {
     async cancel(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/batches/${input.name}/cancel`, { method: "POST", headers: jsonHeaders(this.apiKey), signal }), input);
+            const batchId = encodeQwenResourceId(input.name, "batch");
+            const response = await withRetry(() => this.fetcher(`${this.baseURL}/batches/${batchId}/cancel`, { method: "POST", headers: jsonHeaders(this.apiKey), signal }), input);
             return normalizeBatchJob(await parseJson(response));
         }
         finally {
@@ -1081,7 +1439,8 @@ class QwenBatchesClient {
     async delete(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/batches/${input.name}`, { method: "DELETE", headers: jsonHeaders(this.apiKey), signal }), input);
+            const batchId = encodeQwenResourceId(input.name, "batch");
+            const response = await withRetry(() => this.fetcher(`${this.baseURL}/batches/${batchId}`, { method: "DELETE", headers: jsonHeaders(this.apiKey), signal }), input);
             const json = await parseJson(response);
             return { name: input.name, rawResponse: json };
         }
@@ -1106,29 +1465,59 @@ class QwenTranscriptionModel {
         this.responseLimits = responseLimits;
     }
     async transcribe(input) {
+        if (input.prompt) {
+            throw new UnsupportedFeatureError("Qwen3-ASR-Flash does not expose the common transcription prompt field; use providerOptions for documented asr_options.");
+        }
         const { signal, cleanup, abort } = withTimeoutSignal(input);
-        const form = new FormData();
-        for (const [key, value] of Object.entries(input.providerOptions ?? {})) {
-            if (["model", "file", "prompt", "language"].includes(key)) {
-                continue;
-            }
-            form.set(key, typeof value === "string" ? value : JSON.stringify(value));
-        }
-        form.set("model", this.modelId);
-        form.set("file", await createFile(input.audio.data, input.audio.mediaType, input.audio.filename ?? "audio"));
-        if (input.prompt)
-            form.set("prompt", input.prompt);
-        if (input.language)
-            form.set("language", input.language);
+        const providerOptions = { ...(input.providerOptions ?? {}) };
+        const nestedOptions = providerOptions.asr_options && typeof providerOptions.asr_options === "object"
+            ? providerOptions.asr_options
+            : {};
+        delete providerOptions.asr_options;
+        delete providerOptions.model;
+        delete providerOptions.messages;
+        delete providerOptions.stream;
         try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/audio/transcriptions`, { method: "POST", headers: { authorization: `Bearer ${this.apiKey}` }, signal, body: form }), input);
+            const response = await withRetry(() => this.fetcher(`${this.baseURL}/chat/completions`, {
+                method: "POST",
+                headers: jsonHeaders(this.apiKey),
+                signal,
+                body: JSON.stringify({
+                    model: this.modelId,
+                    messages: [
+                        {
+                            role: "user",
+                            content: [
+                                {
+                                    type: "input_audio",
+                                    input_audio: {
+                                        data: toDataURL(input.audio.data, input.audio.mediaType)
+                                    }
+                                }
+                            ]
+                        }
+                    ],
+                    stream: false,
+                    asr_options: {
+                        ...providerOptions,
+                        ...nestedOptions,
+                        ...(input.language ? { language: input.language } : {})
+                    }
+                })
+            }), input);
             const json = await parseJson(response, {
                 maxBytes: this.responseLimits.transcriptionBytes,
                 errorBodyBytes: this.responseLimits.errorBodyBytes,
-                endpoint: "audio/transcriptions",
+                endpoint: "chat/completions",
                 abort
             });
-            return { text: json.text ?? json.output?.text ?? "", rawResponse: json };
+            const content = json.choices?.[0]?.message?.content;
+            const text = Array.isArray(content)
+                ? content.map((part) => part?.text ?? "").join("")
+                : typeof content === "string"
+                    ? content
+                    : "";
+            return { text, rawResponse: json };
         }
         finally {
             cleanup();
@@ -1138,73 +1527,106 @@ class QwenTranscriptionModel {
 class QwenSpeechModel {
     modelId;
     apiKey;
-    baseURL;
+    taskBaseURL;
     fetcher;
     responseLimits;
+    speechAudioURLValidator;
+    speechAudioMaxRedirects;
     provider = "qwen";
     capabilities = speechCapabilities;
-    constructor(modelId, apiKey, baseURL, fetcher, responseLimits = resolveAudioResponseLimits()) {
+    constructor(modelId, apiKey, taskBaseURL, fetcher, responseLimits = resolveAudioResponseLimits(), speechAudioURLValidator, speechAudioMaxRedirects = 3) {
         this.modelId = modelId;
         this.apiKey = apiKey;
-        this.baseURL = baseURL;
+        this.taskBaseURL = taskBaseURL;
         this.fetcher = fetcher;
         this.responseLimits = responseLimits;
+        this.speechAudioURLValidator = speechAudioURLValidator;
+        this.speechAudioMaxRedirects = speechAudioMaxRedirects;
     }
     async generateSpeech(input) {
         const { signal, cleanup, abort } = withTimeoutSignal(input);
+        const providerOptions = { ...(input.providerOptions ?? {}) };
+        const nestedInput = providerOptions.input && typeof providerOptions.input === "object"
+            ? providerOptions.input
+            : {};
+        const parameters = providerOptions.parameters && typeof providerOptions.parameters === "object"
+            ? providerOptions.parameters
+            : undefined;
+        delete providerOptions.input;
+        delete providerOptions.parameters;
+        delete providerOptions.model;
         try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/audio/speech`, {
+            const response = await withRetry(() => this.fetcher(`${this.taskBaseURL}/services/aigc/multimodal-generation/generation`, {
                 method: "POST",
                 headers: jsonHeaders(this.apiKey),
                 signal,
-                body: JSON.stringify({ ...input.providerOptions, model: this.modelId, input: input.input, voice: input.voice ?? "Chelsie" })
+                body: JSON.stringify({
+                    model: this.modelId,
+                    input: {
+                        ...providerOptions,
+                        ...nestedInput,
+                        text: input.input,
+                        voice: input.voice ?? "Cherry"
+                    },
+                    ...(parameters ? { parameters } : {})
+                })
             }), input);
-            if (response.headers.get("content-type")?.includes("application/json")) {
-                const json = await parseJson(response, {
-                    maxBytes: this.responseLimits.speechJsonBytes,
-                    errorBodyBytes: this.responseLimits.errorBodyBytes,
-                    endpoint: "audio/speech",
-                    abort
-                });
-                const audio = json.audio?.data ?? json.output?.audio?.data ?? "";
+            const json = await parseJson(response, {
+                maxBytes: this.responseLimits.speechJsonBytes,
+                errorBodyBytes: this.responseLimits.errorBodyBytes,
+                endpoint: "multimodal-generation/generation",
+                abort
+            });
+            const audio = json.audio?.data ?? json.output?.audio?.data;
+            const audioURL = json.audio?.url ?? json.output?.audio?.url;
+            const rawResponse = {
+                ...json,
+                ...(json.audio && typeof json.audio === "object"
+                    ? { audio: { ...json.audio, data: undefined, data_omitted: audio ? true : undefined } }
+                    : {}),
+                ...(json.output && typeof json.output === "object"
+                    ? {
+                        output: {
+                            ...json.output,
+                            ...(json.output.audio && typeof json.output.audio === "object"
+                                ? { audio: { ...json.output.audio, data: undefined, data_omitted: audio ? true : undefined } }
+                                : {})
+                        }
+                    }
+                    : {})
+            };
+            if (audio) {
                 const decodedAudio = decodeBase64WithLimit(String(audio), {
                     maxBytes: this.responseLimits.speechBytes,
                     provider: "qwen",
-                    endpoint: "audio/speech",
+                    endpoint: "multimodal-generation/generation",
                     abort
                 });
-                const rawResponse = {
-                    ...json,
-                    ...(json.audio && typeof json.audio === "object"
-                        ? { audio: { ...json.audio, data: undefined, data_omitted: true } }
-                        : {}),
-                    ...(json.output && typeof json.output === "object"
-                        ? {
-                            output: {
-                                ...json.output,
-                                ...(json.output.audio && typeof json.output.audio === "object"
-                                    ? { audio: { ...json.output.audio, data: undefined, data_omitted: true } }
-                                    : {})
-                            }
-                        }
-                        : {})
+                return {
+                    audio: decodedAudio,
+                    mediaType: json.audio?.media_type ?? json.output?.audio?.media_type ?? "audio/pcm",
+                    rawResponse
                 };
-                return { audio: decodedAudio, mediaType: json.audio?.media_type ?? json.output?.audio?.media_type ?? "audio/mpeg", rawResponse };
             }
-            if (!response.ok) {
-                const body = await readErrorBodyWithLimit(response, this.responseLimits.errorBodyBytes);
-                throw new ProviderHTTPError(`Qwen request failed with status ${response.status}.`, response.status, {
+            if (typeof audioURL !== "string" || !/^https?:\/\//i.test(audioURL)) {
+                throw new ProviderHTTPError("Qwen speech response did not contain audio data or a downloadable audio URL.", 502);
+            }
+            const audioResponse = await withRetry(() => downloadQwenSpeechAudio(audioURL, this.fetcher, signal, this.speechAudioURLValidator, this.speechAudioMaxRedirects), input);
+            if (!audioResponse.ok) {
+                const body = await readErrorBodyWithLimit(audioResponse, this.responseLimits.errorBodyBytes);
+                throw new ProviderHTTPError(`Qwen audio download failed with status ${audioResponse.status}.`, audioResponse.status, {
                     responseBody: body
                 });
             }
             return {
-                audio: await readBodyWithLimit(response, {
+                audio: await readBodyWithLimit(audioResponse, {
                     maxBytes: this.responseLimits.speechBytes,
                     provider: "qwen",
-                    endpoint: "audio/speech",
+                    endpoint: "speech-audio-download",
                     abort
                 }),
-                mediaType: response.headers.get("content-type") ?? "audio/mpeg"
+                mediaType: audioResponse.headers.get("content-type") ?? json.output?.audio?.media_type ?? "audio/wav",
+                rawResponse
             };
         }
         finally {
@@ -1213,7 +1635,7 @@ class QwenSpeechModel {
     }
 }
 const normalizeGeneratedMedia = (item, fallbackMimeType) => ({
-    uri: item.url ?? item.uri,
+    uri: item.url ?? item.uri ?? item.image ?? item.video_url,
     data: item.b64_json || item.base64 ? Uint8Array.from(Buffer.from(item.b64_json ?? item.base64, "base64")) : undefined,
     mediaType: item.mime_type ?? item.mediaType ?? fallbackMimeType,
     text: item.revised_prompt ?? item.text,
@@ -1222,15 +1644,13 @@ const normalizeGeneratedMedia = (item, fallbackMimeType) => ({
 class QwenImageGenerationModel {
     modelId;
     apiKey;
-    baseURL;
     taskBaseURL;
     fetcher;
     provider = "qwen";
     capabilities = imageGenerationCapabilities;
-    constructor(modelId, apiKey, baseURL, taskBaseURL, fetcher) {
+    constructor(modelId, apiKey, taskBaseURL, fetcher) {
         this.modelId = modelId;
         this.apiKey = apiKey;
-        this.baseURL = baseURL;
         this.taskBaseURL = taskBaseURL;
         this.fetcher = fetcher;
     }
@@ -1238,25 +1658,53 @@ class QwenImageGenerationModel {
         const { signal, cleanup } = withTimeoutSignal(input);
         const providerOptions = { ...(input.providerOptions ?? {}) };
         delete providerOptions.endpoint;
-        const endpoint = `${this.baseURL}/images/generations`;
+        const nestedParameters = providerOptions.parameters && typeof providerOptions.parameters === "object"
+            ? providerOptions.parameters
+            : {};
+        delete providerOptions.parameters;
+        delete providerOptions.model;
+        delete providerOptions.input;
+        const endpoint = `${this.taskBaseURL}/services/aigc/multimodal-generation/generation`;
+        const sizeFromAspectRatio = {
+            "1:1": "2048*2048",
+            "16:9": "1664*928",
+            "9:16": "928*1664",
+            "4:3": "1472*1104",
+            "3:4": "1104*1472"
+        };
         try {
             const response = await withRetry(() => this.fetcher(endpoint, {
                 method: "POST",
                 headers: jsonHeaders(this.apiKey),
                 signal,
                 body: JSON.stringify({
-                    ...providerOptions,
                     model: this.modelId,
-                    prompt: input.prompt,
-                    n: input.count,
-                    size: input.size,
-                    negative_prompt: input.negativePrompt,
-                    response_format: providerOptions.response_format,
-                    input_image: input.images?.[0]?.uri
+                    input: {
+                        messages: [
+                            {
+                                role: "user",
+                                content: [
+                                    ...(input.images ?? []).map((image) => ({ image: mediaValue(image) })),
+                                    { text: input.prompt }
+                                ]
+                            }
+                        ]
+                    },
+                    parameters: {
+                        ...providerOptions,
+                        ...nestedParameters,
+                        n: input.count,
+                        size: input.size ?? (input.aspectRatio ? sizeFromAspectRatio[input.aspectRatio] : undefined),
+                        negative_prompt: input.negativePrompt
+                    }
                 })
             }), input);
             const json = await parseJson(response);
-            const data = json.data ?? json.output?.results ?? json.output?.images ?? [];
+            const data = json.output?.choices?.flatMap((choice) => choice.message?.content ?? []) ??
+                json.output?.results ??
+                json.output?.images ??
+                json.data ??
+                [];
             return {
                 images: data.map((item) => normalizeGeneratedMedia(item, input.outputMimeType ?? "image/png")),
                 text: json.output?.text,
@@ -1283,20 +1731,49 @@ class QwenVideoGenerationModel {
     }
     async generateVideo(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
+        const providerOptions = { ...(input.providerOptions ?? {}) };
+        delete providerOptions.endpoint;
+        const nestedInput = providerOptions.input && typeof providerOptions.input === "object"
+            ? providerOptions.input
+            : {};
+        const nestedParameters = providerOptions.parameters && typeof providerOptions.parameters === "object"
+            ? providerOptions.parameters
+            : {};
+        delete providerOptions.input;
+        delete providerOptions.parameters;
+        delete providerOptions.model;
+        const isWan27 = /^wan2\.7(?:$|-)/i.test(this.modelId);
         try {
-            const response = await withRetry(() => this.fetcher(`${this.taskBaseURL}/services/aigc/video-generation/generation`, {
+            const response = await withRetry(() => this.fetcher(`${this.taskBaseURL}/services/aigc/video-generation/video-synthesis`, {
                 method: "POST",
                 headers: { ...jsonHeaders(this.apiKey), "X-DashScope-Async": "enable" },
                 signal,
                 body: JSON.stringify({
-                    ...input.providerOptions,
                     model: this.modelId,
-                    input: { prompt: input.prompt, img_url: input.image?.uri, negative_prompt: input.negativePrompt },
-                    parameters: { size: input.aspectRatio, duration: input.durationSeconds, n: input.count, output_storage_uri: input.outputStorageUri }
+                    input: {
+                        ...nestedInput,
+                        prompt: input.prompt,
+                        negative_prompt: input.negativePrompt,
+                        ...(input.image
+                            ? isWan27
+                                ? { media: [{ type: "first_frame", url: mediaValue(input.image) }] }
+                                : { img_url: mediaValue(input.image) }
+                            : {})
+                    },
+                    parameters: {
+                        ...providerOptions,
+                        ...nestedParameters,
+                        ratio: input.aspectRatio,
+                        duration: input.durationSeconds,
+                        n: input.count,
+                        output_storage_uri: input.outputStorageUri
+                    }
                 })
             }), input);
             const json = await parseJson(response);
-            const items = json.output?.results ?? json.output?.videos ?? [];
+            const items = json.output?.results ??
+                json.output?.videos ??
+                (json.output?.video_url ? [{ url: json.output.video_url }] : []);
             return {
                 videos: items.map((item) => normalizeGeneratedMedia(item, "video/mp4")),
                 operationName: json.output?.task_id ?? json.task_id,
@@ -1311,23 +1788,47 @@ class QwenVideoGenerationModel {
 class QwenRerankModelImpl {
     modelId;
     apiKey;
-    baseURL;
+    taskBaseURL;
     fetcher;
     provider = "qwen";
-    constructor(modelId, apiKey, baseURL, fetcher) {
+    constructor(modelId, apiKey, taskBaseURL, fetcher) {
         this.modelId = modelId;
         this.apiKey = apiKey;
-        this.baseURL = baseURL;
+        this.taskBaseURL = taskBaseURL;
         this.fetcher = fetcher;
     }
     async rerank(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
+        const isTextRerank = /^qwen3-rerank(?:$|-)/i.test(this.modelId);
+        if (isTextRerank &&
+            (typeof input.query !== "string" || input.documents.some((document) => typeof document !== "string"))) {
+            throw new UnsupportedFeatureError("qwen3-rerank accepts text queries and text documents only.");
+        }
+        const toRerankContent = (value) => {
+            if (typeof value === "string") {
+                return /^qwen3-vl-rerank(?:$|-)/i.test(this.modelId) ? { text: value } : value;
+            }
+            return toMultimodalEmbeddingContent(value);
+        };
         try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/rerank`, {
+            const response = await withRetry(() => this.fetcher(`${this.taskBaseURL}/services/rerank/text-rerank/text-rerank`, {
                 method: "POST",
                 headers: jsonHeaders(this.apiKey),
                 signal,
-                body: JSON.stringify({ ...input.providerOptions, model: this.modelId, query: input.query, documents: input.documents, top_n: input.topN })
+                body: JSON.stringify({
+                    model: this.modelId,
+                    input: {
+                        query: isTextRerank ? input.query : toRerankContent(input.query),
+                        documents: isTextRerank
+                            ? input.documents
+                            : input.documents.map(toRerankContent)
+                    },
+                    parameters: {
+                        return_documents: true,
+                        ...input.providerOptions,
+                        top_n: input.topN
+                    }
+                })
             }), input);
             const json = await parseJson(response);
             return {
@@ -1357,7 +1858,8 @@ class QwenTasksClientImpl {
     async get(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(`${this.taskBaseURL}/tasks/${input.name}`, { method: "GET", headers: jsonHeaders(this.apiKey), signal }), input);
+            const taskId = encodeQwenResourceId(input.name, "task");
+            const response = await withRetry(() => this.fetcher(`${this.taskBaseURL}/tasks/${taskId}`, { method: "GET", headers: jsonHeaders(this.apiKey), signal }), input);
             return normalizeOperation(await parseJson(response));
         }
         finally {
@@ -1367,7 +1869,8 @@ class QwenTasksClientImpl {
     async cancel(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(`${this.taskBaseURL}/tasks/${input.name}/cancel`, { method: "POST", headers: jsonHeaders(this.apiKey), signal }), input);
+            const taskId = encodeQwenResourceId(input.name, "task");
+            const response = await withRetry(() => this.fetcher(`${this.taskBaseURL}/tasks/${taskId}/cancel`, { method: "POST", headers: jsonHeaders(this.apiKey), signal }), input);
             return normalizeOperation(await parseJson(response));
         }
         finally {
@@ -1377,23 +1880,103 @@ class QwenTasksClientImpl {
 }
 const parseRealtimeEvent = (payload) => {
     const type = String(payload.type ?? "");
-    if (type.includes("text.delta") && typeof payload.delta === "string") {
-        return [{ type: "realtime-text-delta", textDelta: payload.delta, providerMetadata: payload }];
-    }
-    if (type.includes("audio.delta") && typeof payload.delta === "string") {
-        return [{ type: "realtime-audio-output", audio: Uint8Array.from(Buffer.from(payload.delta, "base64")), mediaType: "audio/pcm", providerMetadata: payload }];
+    const metadata = payload;
+    const itemId = typeof payload.item_id === "string" ? payload.item_id : undefined;
+    const responseId = typeof payload.response_id === "string" ? payload.response_id : undefined;
+    if (type === "response.text.delta" && typeof payload.delta === "string") {
+        return [{ type: "realtime-text-delta", textDelta: payload.delta, itemId, responseId, providerMetadata: metadata }];
+    }
+    if (type === "response.audio.delta" && typeof payload.delta === "string") {
+        return [{
+                type: "realtime-audio-output",
+                audio: Uint8Array.from(Buffer.from(payload.delta, "base64")),
+                mediaType: "audio/pcm",
+                sampleRateHz: 24_000,
+                channels: 1,
+                itemId,
+                responseId,
+                providerMetadata: metadata
+            }];
+    }
+    if (type === "response.audio_transcript.delta" && typeof payload.delta === "string") {
+        return [{ type: "realtime-transcript", text: payload.delta, role: "assistant", isFinal: false, itemId, responseId, providerMetadata: metadata }];
+    }
+    if (type === "response.audio_transcript.done" && typeof payload.transcript === "string") {
+        return [{ type: "realtime-transcript", text: payload.transcript, role: "assistant", isFinal: true, itemId, responseId, providerMetadata: metadata }];
+    }
+    if (type === "conversation.item.input_audio_transcription.delta") {
+        const text = `${typeof payload.text === "string" ? payload.text : ""}${typeof payload.stash === "string" ? payload.stash : ""}`;
+        return [{ type: "realtime-transcript", text, role: "user", isFinal: false, itemId, providerMetadata: metadata }];
+    }
+    if (type === "conversation.item.input_audio_transcription.completed" && typeof payload.transcript === "string") {
+        return [{ type: "realtime-transcript", text: payload.transcript, role: "user", isFinal: true, itemId, providerMetadata: metadata }];
+    }
+    if (type === "response.function_call_arguments.done") {
+        return [{
+                type: "realtime-tool-call",
+                toolCall: {
+                    id: String(payload.call_id ?? payload.item_id ?? "qwen-tool-call"),
+                    name: String(payload.name ?? ""),
+                    input: JSON.parse(typeof payload.arguments === "string" ? payload.arguments : "{}")
+                }
+            }];
     }
-    if (type.includes("transcript") && typeof payload.text === "string") {
-        return [{ type: "realtime-transcript", text: payload.text, role: type.includes("input") ? "user" : "assistant", isFinal: type.includes("done"), providerMetadata: payload }];
+    if (type === "response.done") {
+        const response = payload.response;
+        return [{ type: "realtime-response-complete", reason: typeof response?.status === "string" ? response.status : undefined, providerMetadata: metadata }];
     }
-    if (type.includes("completed") || type.includes("done")) {
-        return [{ type: "realtime-response-complete", providerMetadata: payload }];
+    if (type === "session.finished") {
+        return [{ type: "realtime-end", reason: "finished", providerMetadata: metadata }];
     }
-    if (type.includes("error")) {
-        return [{ type: "realtime-error", message: String(payload.error ?? payload.message ?? "Qwen realtime error"), providerMetadata: payload }];
+    if (type === "error" || type.endsWith(".failed")) {
+        const error = payload.error;
+        return [{
+                type: "realtime-error",
+                message: String(error?.message ?? payload.message ?? "Qwen realtime error"),
+                providerMetadata: metadata
+            }];
     }
     return [];
 };
+const mapRealtimeTools = (config) => {
+    const tools = toToolSet(config.tools);
+    if (!tools) {
+        return undefined;
+    }
+    return Object.values(tools).map((tool) => {
+        if (!isCallableToolDefinition(tool)) {
+            throw new UnsupportedFeatureError("Qwen realtime supports callable function tools only.");
+        }
+        return {
+            type: "function",
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: toJSONSchema(tool.schema)
+            }
+        };
+    });
+};
+const mapRealtimeSession = (config) => ({
+    ...(config.providerOptions ?? {}),
+    instructions: config.instructions,
+    voice: config.voice,
+    input_audio_format: "pcm",
+    output_audio_format: "pcm",
+    turn_detection: config.turnDetection,
+    input_audio_transcription: typeof config.inputAudioTranscription === "object"
+        ? config.inputAudioTranscription
+        : config.inputAudioTranscription
+            ? {}
+            : undefined,
+    tools: mapRealtimeTools(config)
+});
+const encodeRealtimeData = (data) => {
+    if (typeof data === "string") {
+        return data.startsWith("data:") ? data.slice(data.indexOf(",") + 1) : data;
+    }
+    return Buffer.from(data instanceof Uint8Array ? data : new Uint8Array(data)).toString("base64");
+};
 class QwenRealtimeModel {
     modelId;
     apiKey;
@@ -1409,7 +1992,7 @@ class QwenRealtimeModel {
     }
     async connect(config = {}, options) {
         const url = appendQuery(this.realtimeURL, { model: this.modelId });
-        const connection = await (this.connectionFactory ?? openWebSocketConnection)(url, { authorization: `Bearer ${this.apiKey}` }, options);
+        const connection = await (this.connectionFactory ?? openQwenRealtimeConnection)(url, { authorization: `Bearer ${this.apiKey}` }, options);
         const session = new CallbackRealtimeSession({
             provider: this.provider,
             modelId: this.modelId,
@@ -1418,13 +2001,21 @@ class QwenRealtimeModel {
             connection,
             callbacks: {
                 parseEvent: parseRealtimeEvent,
-                buildInitialPayloads: (value) => [{ type: "session.update", session: { instructions: value.instructions, voice: value.voice, ...value.providerOptions } }],
-                buildAudioPayloads: (frame) => [{ type: "input_audio_buffer.append", audio: typeof frame.data === "string" ? frame.data : Buffer.from(frame.data).toString("base64") }],
-                buildMediaPayloads: (frame) => [{ type: "input_media.append", media_type: frame.mediaType, data: typeof frame.data === "string" ? frame.data : Buffer.from(frame.data).toString("base64") }],
+                buildInitialPayloads: (value) => [{ type: "session.update", session: mapRealtimeSession(value) }],
+                buildAudioPayloads: (frame) => [{ type: "input_audio_buffer.append", audio: encodeRealtimeData(frame.data) }],
+                buildMediaPayloads: (frame) => {
+                    if (!/^image\/(jpeg|jpg)$/i.test(frame.mediaType)) {
+                        throw new UnsupportedFeatureError("Qwen realtime media frames must be JPEG images.");
+                    }
+                    return [{ type: "input_image_buffer.append", image: encodeRealtimeData(frame.data) }];
+                },
                 buildTextPayloads: (text) => [{ type: "conversation.item.create", item: { type: "message", role: "user", content: [{ type: "input_text", text }] } }, { type: "response.create" }],
-                buildToolResultPayloads: (result) => [{ type: "conversation.item.create", item: { type: "function_call_output", call_id: result.toolCallId, output: JSON.stringify(result.isError ? result.error : result.output ?? null) } }],
-                buildUpdatePayloads: (value) => [{ type: "session.update", session: { instructions: value.instructions, voice: value.voice, ...value.providerOptions } }],
-                buildClosePayloads: () => [{ type: "session.close" }]
+                buildToolResultPayloads: (result) => [
+                    { type: "conversation.item.create", item: { type: "function_call_output", call_id: result.toolCallId, output: JSON.stringify(result.isError ? result.error : result.output ?? null) } },
+                    { type: "response.create" }
+                ],
+                buildUpdatePayloads: (value) => [{ type: "session.update", session: mapRealtimeSession(value) }],
+                buildClosePayloads: () => []
             }
         });
         await session.initialize();
@@ -1436,25 +2027,33 @@ export const createQwen = (options = {}) => {
     if (!apiKey) {
         throw new ConfigurationError("Missing Qwen API key.");
     }
-    const baseURL = options.baseURL ?? "https://dashscope-intl.aliyuncs.com/compatible-mode/v1";
-    const taskBaseURL = options.taskBaseURL ?? qwenTaskBaseURLFrom(baseURL);
-    const realtimeURL = options.realtimeURL ?? "wss://dashscope-intl.aliyuncs.com/compatible-mode/v1/realtime";
+    const workspaceURLs = options.workspaceId
+        ? qwenWorkspaceURLs(options.workspaceId, options.region ?? "singapore")
+        : undefined;
+    const baseURL = options.baseURL ?? workspaceURLs?.baseURL ?? "https://dashscope-intl.aliyuncs.com/compatible-mode/v1";
+    const taskBaseURL = options.taskBaseURL ?? workspaceURLs?.taskBaseURL ?? qwenTaskBaseURLFrom(baseURL);
+    const realtimeURL = options.realtimeURL ??
+        workspaceURLs?.realtimeURL ??
+        "wss://dashscope-intl.aliyuncs.com/api-ws/v1/realtime";
     const fetcher = options.fetch ?? globalThis.fetch;
     const responseLimits = resolveAudioResponseLimits(options.responseLimits);
+    const speechAudioMaxRedirects = options.speechAudioMaxRedirects ?? 3;
+    if (!Number.isInteger(speechAudioMaxRedirects) || speechAudioMaxRedirects < 0 || speechAudioMaxRedirects > 10) {
+        throw new ConfigurationError("Qwen speechAudioMaxRedirects must be an integer between 0 and 10.");
+    }
     return createProviderAdapter({
         name: "qwen",
         languageModel: (modelId) => new QwenLanguageModel(modelId, apiKey, baseURL, fetcher),
         embeddingModel: (modelId) => new QwenEmbeddingModel(modelId, apiKey, baseURL, fetcher),
         transcriptionModel: (modelId) => new QwenTranscriptionModel(modelId, apiKey, baseURL, fetcher, responseLimits),
-        speechModel: (modelId) => new QwenSpeechModel(modelId, apiKey, baseURL, fetcher, responseLimits),
-        imageGenerationModel: (modelId) => new QwenImageGenerationModel(modelId, apiKey, baseURL, taskBaseURL, fetcher),
+        speechModel: (modelId) => new QwenSpeechModel(modelId, apiKey, taskBaseURL, fetcher, responseLimits, options.speechAudioURLValidator, speechAudioMaxRedirects),
+        imageGenerationModel: (modelId) => new QwenImageGenerationModel(modelId, apiKey, taskBaseURL, fetcher),
         videoGenerationModel: (modelId) => new QwenVideoGenerationModel(modelId, apiKey, taskBaseURL, fetcher),
         realtimeModel: (modelId) => new QwenRealtimeModel(modelId, apiKey, realtimeURL, options.realtimeConnectionFactory),
         files: new QwenFilesClient(apiKey, baseURL, fetcher),
-        fileSearchStores: new QwenFileSearchStoresClient(apiKey, baseURL, fetcher),
         batches: new QwenBatchesClient(apiKey, baseURL, fetcher),
-        rerankModel: (modelId) => new QwenRerankModelImpl(modelId, apiKey, baseURL, fetcher),
-        multimodalEmbeddingModel: (modelId) => new QwenEmbeddingModel(modelId, apiKey, baseURL, fetcher),
+        rerankModel: (modelId) => new QwenRerankModelImpl(modelId, apiKey, taskBaseURL, fetcher),
+        multimodalEmbeddingModel: (modelId) => new QwenMultimodalEmbeddingModelImpl(modelId, apiKey, taskBaseURL, fetcher),
         tasks: new QwenTasksClientImpl(apiKey, taskBaseURL, fetcher),
         rawFetch: fetcher
     });