@zhivex-ai/qwen 0.15.3 → 0.16.2

package/dist/index.js

@@ -1,9 +1,23 @@
+export { createQwenSDPExchange } from "./sdp-exchange.js";
+export { connectQwenWebRTC, connectQwenAOQ } from "./browser-realtime.js";
+import { createQwenTemporaryKeysClient } from "./temporary-keys.js";
+import { createQwenNativeTranscriptionModel, createQwenFileTranscriptionModel } from "./native-asr.js";
+export { createQwenWorldRTC } from "./world-rtc.js";
+import { createQwenImageTranslationModel, validateWan30, validateQwenImage30, validateHappyHorse, prepareViduVideo, validateViduImage } from "./cloud-media.js";
+import { createQwenWorldsClient } from "./worlds.js";
+import { QwenCloudSpeechModel, QwenCloudStreamingASRModel, isQwenCloudSpeech, isQwenCloudStreamingASR } from "./inference-audio.js";
+import { isQwenCloudRealtime, isQwenAudioRealtime, isQwenOmni38Realtime, mapQwenCloudRealtimeSession, validateQwenCloudAudioFrame, qwenCloudAudioEvent, extendQwenCloudRealtimeSession } from "./cloud-realtime.js";
+import { createQwenDecisionModel } from "./decision.js";
+import { assertQwenLanguageModel, isQwenTranslation, isQwenCharacter, isQwen38Open, validateQwenSpecializedText } from "./text-profiles.js";
+import { createQwenTextEmbeddingModel } from "./embeddings.js";
 import { createQwenVoicesClient } from "./voices.js";
 import { isLiveTranslate38, liveTranslateSession } from "./live-translate.js";
 import { thirdPartyProfile, thirdPartyCapabilities, validateThirdParty, thirdPartyReasoning } from "./third-party.js";
 import { toJSONSchema } from "zod";
 import { capabilities, embeddingCapabilities, imageGenerationCapabilities, realtimeCapabilities, speechCapabilities, transcriptionCapabilities, videoGenerationCapabilities, } from "./capabilities.js";
 import { imageInputToDataUrl, CallbackRealtimeSession, ConfigurationError, decodeBase64WithLimit, ProviderHTTPError, ProviderToolCallError, ValidationError, assertTrustedEndpoint, readBodyWithLimit, readErrorBodyWithLimit, readJsonWithLimit, resolveAudioResponseLimits, UnsupportedFeatureError, createProviderAdapter, hostedTool, openWebSocketConnection, isCallableToolDefinition, normalizeFinishReason, providerDataPart, streamSSE, toolResultPayload, toToolSet, withRetry, withResponseRetry, withTimeoutSignal } from "@zhivex-ai/core/provider";
+export const QWEN_CLOUD_BASE_URL = "https://maas.qwencloudapi.com/compatible-mode/v1";
+export const QWEN_DECISION_PREVIEW_BASE_URL = "https://trial.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1";
 export const QWEN_TOKEN_PLAN_BASE_URL = "https://token-plan.maas.qwencloudapi.com/compatible-mode/v1";
 const QWEN_TOKEN_PLAN_ORIGINS = new Set([
     new URL(QWEN_TOKEN_PLAN_BASE_URL).origin,
@@ -155,7 +169,7 @@ const stripResponsesRequestOptions = (providerOptions) => {
 };
 const modelFamily = (modelId) => {
     const normalized = modelId.toLowerCase();
-    return normalized.replace(/^(qwen3\.8-(?:max|flash))-\d{4}$/, "$1");
+    return normalized.replace(/^(qwen3\.8-(?:max|flash))-(?:\d{4}|\d{4}-\d{2}-\d{2})$/, "$1");
 };
 const isQwen38OmniFlash = (modelId) => modelId.toLowerCase() === "qwen3.8-omni-flash";
 const isQwen38Max = (modelId) => modelFamily(modelId) === "qwen3.8-max";
@@ -216,10 +230,11 @@ const supportsQwenVision = (modelId) => {
         model.includes("vision") ||
         isQwen38ProductionModel(modelId) ||
         isQwen38MaxPreview(modelId) ||
-        /^qwen3\.7-plus(?:$|-)/.test(model) ||
+        isQwen38Open(modelId) ||
+        /^qwen3\.7-(?:plus|flash)(?:$|-)/.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 supportsQwenTools = (modelId) => !isQwenTranslation(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) => {
@@ -241,8 +256,8 @@ const qwenLanguageCapabilities = (modelId) => {
         jsonMode: tools && !omni && !omni38 && !qwen38MaxPreview,
         toolChoice: tools,
         parallelToolCalls: qwen38Production && !omni38,
-        webSearch: tools && !omni,
-        files: supportsQwenFiles(modelId) || qwen38Production,
+        webSearch: tools && !omni || ["qwen-plus-character", "qwen-flash-character"].includes(modelId),
+        files: supportsQwenFiles(modelId) || qwen38Production || isQwen38Open(modelId),
         audioInput: supportsQwenAudioInput(modelId),
         reasoning,
         reasoningEfforts: qwen38Production
@@ -669,8 +684,10 @@ const hasMessagePart = (messages, type) => messages.some((message) => message.pa
 const hasVideoInput = (messages) => messages.some((message) => message.parts.some((part) => part.type === "file" && part.mediaType.toLowerCase().startsWith("video/")));
 const hasNonVideoFileInput = (messages) => messages.some((message) => message.parts.some((part) => part.type === "file" && !part.mediaType.toLowerCase().startsWith("video/")));
 const resolveApiMode = (modelId, requestedMode, input, providerOptions) => {
+    if (isQwenTranslation(modelId) || isQwenCharacter(modelId))
+        return "chat";
     const videoInput = hasVideoInput(input.messages);
-    if (videoInput && !isQwen38ProductionModel(modelId)) {
+    if (videoInput && !isQwen38ProductionModel(modelId) && !isQwen38Open(modelId)) {
         throw new UnsupportedFeatureError(`Qwen model "${modelId}" does not support video FilePart input through this adapter.`);
     }
     const omni38 = isQwen38OmniFlash(modelId);
@@ -910,12 +927,65 @@ class QwenResponseError extends Error {
         this.name = "QwenResponseError";
     }
 }
+// Never retain provider arguments or parser causes in diagnostics.
+const qwenResponsesToolCallError = (reason, usage, effectsPossible = false) => new ProviderToolCallError({
+    provider: "qwen", transport: "responses", diagnosticCode: "QWEN_RESPONSES_TOOL_CALL_INVALID",
+    reason, usage, effectsPossible, retryable: false
+});
+class QwenStreamEventError extends Error {
+    transport;
+    reason;
+    provider = "qwen";
+    diagnosticCode = "QWEN_SSE_EVENT_INVALID";
+    retryable = false;
+    constructor(transport, reason) {
+        super("Qwen stream event could not be parsed safely.");
+        this.transport = transport;
+        this.reason = reason;
+        this.name = "QwenStreamEventError";
+    }
+}
+const parseQwenStreamEvent = (data, transport) => {
+    let event;
+    try {
+        event = JSON.parse(data);
+    }
+    catch {
+        throw new QwenStreamEventError(transport, "invalid_json");
+    }
+    if (!event || typeof event !== "object" || Array.isArray(event) || (transport === "responses" && typeof event.type !== "string")) {
+        throw new QwenStreamEventError(transport, "invalid_event");
+    }
+    return event;
+};
+const parseQwenResponsesArguments = (raw, usage, effectsPossible = false) => {
+    const failure = (reason) => qwenResponsesToolCallError(reason, usage, effectsPossible);
+    if (typeof raw !== "string")
+        throw failure("incomplete_arguments");
+    if (!raw.trim())
+        throw failure("empty_arguments");
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw failure("invalid_json");
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw failure("invalid_json");
+    return value;
+};
 const parseResponsesAssistantMessage = (json, input) => {
     if (json.status === "failed" || json.error)
         throw new QwenResponseError();
     const parts = [];
     const seenIds = existingToolCallIds(input.messages);
     const fallbackGeneration = nextFallbackToolCallGeneration("responses", input, seenIds);
+    const usage = mapResponsesUsage(json.usage);
+    const effectsPossible = Object.values(input.tools ?? {}).some(tool => !isCallableToolDefinition(tool)) || (json.output ?? []).some((item) => parseResponsesProviderData(item) !== undefined);
+    if (json.status === "incomplete" && (json.output ?? []).some((item) => item?.type === "function_call")) {
+        throw qwenResponsesToolCallError("response_incomplete", usage, effectsPossible);
+    }
     for (const [index, item] of (json.output ?? []).entries()) {
         if (item?.type === "message") {
             for (const content of item.content ?? []) {
@@ -926,6 +996,9 @@ const parseResponsesAssistantMessage = (json, input) => {
             continue;
         }
         if (item?.type === "function_call") {
+            if (typeof item.name !== "string" || !item.name.trim()) {
+                throw qwenResponsesToolCallError("inconsistent_metadata", usage, effectsPossible);
+            }
             const providerCallId = qwenResponsesProviderCallId(item.call_id);
             const id = resolveToolCallId([item.call_id, item.id], fallbackToolCallId("responses", fallbackGeneration, index), seenIds);
             parts.push({
@@ -933,7 +1006,7 @@ const parseResponsesAssistantMessage = (json, input) => {
                 toolCall: {
                     id,
                     name: item.name,
-                    input: JSON.parse(item.arguments ?? "{}"),
+                    input: parseQwenResponsesArguments(item.arguments, usage, effectsPossible),
                     ...(providerCallId !== undefined && providerCallId !== id
                         ? { providerMetadata: { qwenResponsesCallId: providerCallId } }
                         : {})
@@ -974,7 +1047,24 @@ const streamResponses = async function* (response, input) {
     const toolBufferAliases = new Map();
     const seenIds = existingToolCallIds(input.messages);
     const fallbackGeneration = nextFallbackToolCallGeneration("responses", input, seenIds);
-    let sawToolCalls = false;
+    let terminal;
+    let effectsPossible = Object.values(input.tools ?? {}).some(tool => !isCallableToolDefinition(tool));
+    let invalidMetadata = false;
+    const mergeMetadata = (buffer, itemId, callId, name) => {
+        const nextItemId = qwenResponsesProviderCallId(itemId);
+        const nextCallId = qwenResponsesProviderCallId(callId);
+        const nextName = typeof name === "string" && name.trim() ? name : undefined;
+        if ((buffer.itemId !== undefined && nextItemId !== undefined && buffer.itemId !== nextItemId) ||
+            (buffer.providerCallId !== undefined && nextCallId !== undefined && buffer.providerCallId !== nextCallId) ||
+            (buffer.name && nextName !== undefined && buffer.name !== nextName) ||
+            (name !== undefined && typeof name !== "string"))
+            invalidMetadata = true;
+        buffer.itemId ??= nextItemId;
+        buffer.providerCallId ??= nextCallId;
+        buffer.name ||= nextName ?? "";
+        // A receipt ID may arrive after the item ID used as the initial fallback.
+        buffer.callId = stableToolCallId(callId) ?? buffer.callId;
+    };
     const bufferKey = (outputIndex, candidates, fallbackId) => {
         const stableIds = candidates
             .map(stableToolCallId)
@@ -993,31 +1083,11 @@ const streamResponses = async function* (response, input) {
         }
         return `fallback:${fallbackId}`;
     };
-    const emitToolCall = (key) => {
-        const toolCall = toolBuffers.get(key);
-        if (!toolCall || toolCall.emitted || !toolCall.name) {
-            return undefined;
-        }
-        toolCall.emitted = true;
-        sawToolCalls = true;
-        const id = resolveToolCallId([toolCall.callId], toolCall.fallbackId, seenIds);
-        return {
-            type: "tool-call",
-            toolCall: {
-                id,
-                name: toolCall.name,
-                input: JSON.parse(toolCall.args || "{}"),
-                ...(toolCall.providerCallId !== undefined && toolCall.providerCallId !== id
-                    ? { providerMetadata: { qwenResponsesCallId: toolCall.providerCallId } }
-                    : {})
-            }
-        };
-    };
     for await (const event of streamSSE(response)) {
         if (event.data === "[DONE]") {
-            return;
+            break;
         }
-        const json = JSON.parse(event.data);
+        const json = parseQwenStreamEvent(event.data, "responses");
         const type = json.type;
         if (type === "error" || type === "response.failed" || json.response?.status === "failed" || json.error) {
             throw new QwenResponseError();
@@ -1050,23 +1120,24 @@ const streamResponses = async function* (response, input) {
                     fallbackId,
                     name: item.name ?? "",
                     args: "",
-                    emitted: false
+                    done: false
                 };
-                existing.callId = stableToolCallId(item.call_id) ?? existing.callId;
-                existing.providerCallId = qwenResponsesProviderCallId(item.call_id) ?? existing.providerCallId;
-                existing.name ||= item.name ?? "";
+                if (item.arguments !== undefined && typeof item.arguments !== "string")
+                    invalidMetadata = true;
+                if (existing.done && typeof item.arguments === "string" && item.arguments !== existing.args)
+                    invalidMetadata = true;
+                mergeMetadata(existing, item.id ?? json.item_id, item.call_id, item.name);
                 if (typeof item.arguments === "string") {
                     existing.args = item.arguments;
                 }
                 toolBuffers.set(key, existing);
                 if (type === "response.output_item.done") {
-                    const emitted = emitToolCall(key);
-                    if (emitted) {
-                        yield emitted;
-                    }
+                    existing.done = true;
                 }
             }
             const providerData = parseResponsesProviderData(item);
+            if (providerData)
+                effectsPossible = true;
             if (providerData && type === "response.output_item.done") {
                 yield {
                     type: "provider-data",
@@ -1086,9 +1157,13 @@ const streamResponses = async function* (response, input) {
                 fallbackId,
                 name: "",
                 args: "",
-                emitted: false
+                done: false
             };
-            existing.providerCallId = qwenResponsesProviderCallId(json.call_id) ?? existing.providerCallId;
+            mergeMetadata(existing, json.item_id, json.call_id);
+            if (existing.done)
+                invalidMetadata = true;
+            if (typeof json.delta !== "string")
+                invalidMetadata = true;
             existing.args += typeof json.delta === "string" ? json.delta : "";
             toolBuffers.set(key, existing);
             continue;
@@ -1103,36 +1178,104 @@ const streamResponses = async function* (response, input) {
                 fallbackId,
                 name: "",
                 args: "",
-                emitted: false
+                done: false
             };
-            existing.providerCallId = qwenResponsesProviderCallId(json.call_id) ?? existing.providerCallId;
+            mergeMetadata(existing, json.item_id, json.call_id);
+            if (json.arguments !== undefined && typeof json.arguments !== "string")
+                invalidMetadata = true;
+            if (existing.done && typeof json.arguments === "string" && json.arguments !== existing.args)
+                invalidMetadata = true;
             if (typeof json.arguments === "string") {
                 existing.args = json.arguments;
             }
+            existing.done = true;
             toolBuffers.set(key, existing);
-            const emitted = emitToolCall(key);
-            if (emitted) {
-                yield emitted;
-            }
             continue;
         }
         if (type === "response.completed" || type === "response.incomplete") {
-            const responseData = json.response ?? {};
-            if (typeof responseData.id === "string") {
-                yield {
-                    type: "provider-data",
-                    provider: "qwen",
-                    data: { responseId: responseData.id }
-                };
+            if (terminal)
+                invalidMetadata = true;
+            terminal = json.response ?? {};
+            terminal = { ...terminal, status: type === "response.incomplete" ? "incomplete" : terminal.status };
+        }
+    }
+    // Some servers supply the final items only in the terminal snapshot. When
+    // both forms exist, neither may silently overwrite a contradictory call.
+    if (Array.isArray(terminal?.output)) {
+        const terminalKeys = new Set();
+        for (const [index, item] of terminal.output.entries()) {
+            if (parseResponsesProviderData(item))
+                effectsPossible = true;
+            if (item?.type !== "function_call")
+                continue;
+            const fallbackId = fallbackToolCallId("responses", fallbackGeneration, index);
+            const priorKey = [item.id, item.call_id]
+                .map(stableToolCallId)
+                .filter((id) => id !== undefined)
+                .map(id => toolBufferAliases.get(`id:${id}`) ?? `id:${id}`)
+                .find(key => toolBuffers.has(key));
+            const positionalKey = `output:${index}`;
+            const key = toolBuffers.has(positionalKey) ? positionalKey : priorKey ?? bufferKey(index, [item.id, item.call_id], fallbackId);
+            terminalKeys.add(key);
+            const existing = toolBuffers.get(key);
+            if (existing) {
+                if (existing.done && existing.args !== item.arguments)
+                    invalidMetadata = true;
+                mergeMetadata(existing, item.id, item.call_id, item.name);
             }
-            yield {
-                type: "finish",
-                finishReason: normalizeResponsesFinishReason(responseData.status, sawToolCalls),
-                providerFinishReason: responseData.status,
-                usage: mapResponsesUsage(responseData.usage)
-            };
+            if (item.arguments !== undefined && typeof item.arguments !== "string")
+                invalidMetadata = true;
+            toolBuffers.set(key, {
+                itemId: existing?.itemId ?? qwenResponsesProviderCallId(item.id),
+                callId: stableToolCallId(item.call_id) ?? existing?.callId ?? stableToolCallId(item.id),
+                providerCallId: qwenResponsesProviderCallId(item.call_id) ?? existing?.providerCallId,
+                fallbackId: existing?.fallbackId ?? fallbackId,
+                name: item.name,
+                args: typeof item.arguments === "string" ? item.arguments : "",
+                done: true
+            });
         }
-    }
+        if ([...toolBuffers.keys()].some(key => !terminalKeys.has(key)))
+            invalidMetadata = true;
+    }
+    // No callable event escapes until the full response batch has been checked.
+    // Text/provider events may already have been observed; hosted effects cannot be undone.
+    input.abortSignal?.throwIfAborted();
+    const usage = mapResponsesUsage(terminal?.usage);
+    const failure = (reason) => qwenResponsesToolCallError(reason, usage, effectsPossible);
+    if (!terminal)
+        throw failure("stream_truncated");
+    if (invalidMetadata)
+        throw failure("inconsistent_metadata");
+    if (toolBuffers.size && terminal.status !== "completed")
+        throw failure("response_incomplete");
+    const materialized = [];
+    for (const call of toolBuffers.values()) {
+        if (!call.done)
+            throw failure("incomplete_arguments");
+        if (typeof call.name !== "string" || !call.name.trim())
+            throw failure("inconsistent_metadata");
+        const args = parseQwenResponsesArguments(call.args, usage, effectsPossible);
+        const id = resolveToolCallId([call.callId], call.fallbackId, seenIds);
+        materialized.push({ type: "tool-call", toolCall: {
+                id, name: call.name, input: args,
+                ...(call.providerCallId !== undefined && call.providerCallId !== id
+                    ? { providerMetadata: { qwenResponsesCallId: call.providerCallId } } : {})
+            } });
+    }
+    for (const event of materialized) {
+        input.abortSignal?.throwIfAborted();
+        yield event;
+    }
+    if (typeof terminal.id === "string") {
+        yield { type: "provider-data", provider: "qwen", data: { responseId: terminal.id } };
+    }
+    yield {
+        type: "finish",
+        finishReason: normalizeResponsesFinishReason(terminal.status, materialized.length > 0),
+        providerFinishReason: terminal.status,
+        usage
+    };
 };
 class QwenLanguageModel {
     modelId;
@@ -1154,6 +1297,7 @@ class QwenLanguageModel {
         }
         const providerOptions = { ...(input.providerOptions ?? {}) };
         validateThirdParty(this.modelId, input, providerOptions);
+        validateQwenSpecializedText(this.modelId, input);
         validateQwenToolStream(this.modelId, providerOptions, false);
         if (isQwen38ReasoningModel(this.modelId)) {
             validateQwen38Request(this.modelId, input, providerOptions);
@@ -1254,6 +1398,7 @@ class QwenLanguageModel {
     async stream(input) {
         const providerOptions = { ...(input.providerOptions ?? {}) };
         validateThirdParty(this.modelId, input, providerOptions);
+        validateQwenSpecializedText(this.modelId, input);
         validateQwenToolStream(this.modelId, providerOptions, true);
         if (isQwen38ReasoningModel(this.modelId)) {
             validateQwen38Request(this.modelId, input, providerOptions);
@@ -1294,7 +1439,7 @@ class QwenLanguageModel {
             }), { ...input, abortSignal: signal }, "Qwen").catch((error) => { cleanup(); throw error; });
             return (async function* () {
                 try {
-                    yield* streamResponses(response, input);
+                    yield* streamResponses(response, { ...input, abortSignal: signal });
                 }
                 finally {
                     cleanup();
@@ -1325,11 +1470,13 @@ class QwenLanguageModel {
                 ...mapChatReasoning(this.modelId, input, providerOptions)
             })
         }), { ...input, abortSignal: signal }, "Qwen").catch((error) => { cleanup(); throw error; });
+        const cumulativeTranslation = /^(?:qwen-mt-plus|qwen-mt-turbo)$/.test(this.modelId);
         return (async function* () {
             try {
                 const toolBuffers = new Map();
                 const seenIds = existingToolCallIds(input.messages);
                 const fallbackGeneration = nextFallbackToolCallGeneration("chat", input, seenIds);
+                let translationText = "";
                 let lastFinishReason;
                 let lastUsage;
                 const failure = (reason) => new ProviderToolCallError({ provider: "qwen", transport: "chat", diagnosticCode: "QWEN_CHAT_TOOL_CALL_INVALID",
@@ -1338,7 +1485,7 @@ class QwenLanguageModel {
                     if (event.data === "[DONE]") {
                         break;
                     }
-                    const json = JSON.parse(event.data);
+                    const json = parseQwenStreamEvent(event.data, "chat");
                     if (json.error) {
                         if (json.usage)
                             lastUsage = json.usage;
@@ -1357,7 +1504,13 @@ class QwenLanguageModel {
                         };
                     }
                     if (delta?.content) {
-                        yield { type: "text-delta", textDelta: delta.content };
+                        const content = String(delta.content);
+                        if (cumulativeTranslation && !content.startsWith(translationText))
+                            throw new ValidationError("Qwen translation replaced already streamed text.");
+                        const textDelta = cumulativeTranslation ? content.slice(translationText.length) : content;
+                        translationText = content;
+                        if (textDelta)
+                            yield { type: "text-delta", textDelta };
                     }
                     for (const toolCall of delta?.tool_calls ?? []) {
                         const index = Number(toolCall.index ?? 0);
@@ -1418,52 +1571,6 @@ class QwenLanguageModel {
         })();
     }
 }
-class QwenEmbeddingModel {
-    modelId;
-    apiKey;
-    baseURL;
-    fetcher;
-    provider = "qwen";
-    capabilities = embeddingCapabilities;
-    constructor(modelId, apiKey, baseURL, fetcher) {
-        this.modelId = modelId;
-        this.apiKey = apiKey;
-        this.baseURL = baseURL;
-        this.fetcher = fetcher;
-    }
-    async embed(input) {
-        const { signal, cleanup } = withTimeoutSignal(input);
-        const values = input.values.map((value) => {
-            if (typeof value !== "string") {
-                throw new UnsupportedFeatureError('Provider "qwen" does not support multimodal embedding values.');
-            }
-            return value;
-        });
-        try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/embeddings`, {
-                method: "POST",
-                headers: jsonHeaders(this.apiKey),
-                signal,
-                body: JSON.stringify({
-                    model: this.modelId,
-                    input: values
-                })
-            }), input);
-            const json = await parseJson(response);
-            return {
-                embeddings: json.data.map((entry) => entry.embedding),
-                usage: {
-                    inputTokens: json.usage?.prompt_tokens,
-                    totalTokens: json.usage?.total_tokens
-                },
-                rawResponse: json
-            };
-        }
-        finally {
-            cleanup();
-        }
-    }
-}
 const toMultimodalEmbeddingContent = (value) => {
     if (typeof value === "string") {
         return { text: value };
@@ -1919,7 +2026,6 @@ class QwenImageGenerationModel {
         this.fetcher = fetcher;
     }
     async generateImage(input) {
-        const { signal, cleanup } = withTimeoutSignal(input);
         const providerOptions = { ...(input.providerOptions ?? {}) };
         delete providerOptions.endpoint;
         const nestedParameters = providerOptions.parameters && typeof providerOptions.parameters === "object"
@@ -1928,18 +2034,41 @@ class QwenImageGenerationModel {
         delete providerOptions.parameters;
         delete providerOptions.model;
         delete providerOptions.input;
-        const endpoint = `${this.taskBaseURL}/services/aigc/multimodal-generation/generation`;
-        const sizeFromAspectRatio = {
+        const vidu = this.modelId === "vidu/vidu-image_reference2image";
+        const endpoint = `${this.taskBaseURL}/services/aigc/${vidu ? "image-generation" : "multimodal-generation"}/generation`;
+        const sizeFromAspectRatio = vidu ? {
+            "1:1": "1024*1024", "16:9": "1920*1088", "9:16": "1088*1920", "4:3": "1024*768", "3:4": "768*1024"
+        } : {
             "1:1": "2048*2048",
             "16:9": "1664*928",
             "9:16": "928*1664",
             "4:3": "1472*1104",
             "3:4": "1104*1472"
         };
+        const parameters = { ...providerOptions, ...nestedParameters };
+        if (input.count !== undefined)
+            parameters.n = input.count;
+        if (input.size !== undefined)
+            parameters.size = input.size;
+        else if (input.aspectRatio) {
+            if (!sizeFromAspectRatio[input.aspectRatio])
+                throw new ConfigurationError("Unsupported image aspect ratio.");
+            parameters.size = sizeFromAspectRatio[input.aspectRatio];
+        }
+        if (input.negativePrompt !== undefined)
+            parameters.negative_prompt = input.negativePrompt;
+        if (/^qwen-image-3\.0(?:$|-)/.test(this.modelId))
+            validateQwenImage30(input, parameters);
+        if (vidu) {
+            parameters.n ??= 1;
+            validateViduImage(input, parameters);
+        }
+        const { signal, cleanup } = withTimeoutSignal(input);
         try {
             const response = await withRetry(() => this.fetcher(endpoint, {
                 method: "POST",
-                headers: jsonHeaders(this.apiKey),
+                headers: { ...jsonHeaders(this.apiKey), ...(vidu ? { "X-DashScope-Async": "enable" } : {}) },
+                redirect: "error",
                 signal,
                 body: JSON.stringify({
                     model: this.modelId,
@@ -1954,24 +2083,25 @@ class QwenImageGenerationModel {
                             }
                         ]
                     },
-                    parameters: {
-                        ...providerOptions,
-                        ...nestedParameters,
-                        n: input.count,
-                        size: input.size ?? (input.aspectRatio ? sizeFromAspectRatio[input.aspectRatio] : undefined),
-                        negative_prompt: input.negativePrompt
-                    }
+                    parameters
                 })
-            }), input);
+            }), { ...input, maxRetries: input.maxRetries ?? 0 });
             const json = await parseJson(response);
+            if (json.code || json.output?.task_status === "FAILED")
+                throw new ProviderHTTPError("Qwen media generation failed.", response.status, { responseBody: { code: json.code ?? json.output?.code } });
             const data = json.output?.choices?.flatMap((choice) => choice.message?.content ?? []) ??
                 json.output?.results ??
                 json.output?.images ??
                 json.data ??
                 [];
+            if (vidu && (typeof json.output?.task_id !== "string" || !json.output.task_id))
+                throw new ValidationError("Vidu image submission returned no task ID.");
+            if (/^qwen-image-3\.0(?:$|-)/.test(this.modelId) && (!Array.isArray(data) || !data.length))
+                throw new ValidationError("Qwen Image 3.0 returned no images.");
             return {
                 images: data.map((item) => normalizeGeneratedMedia(item, input.outputMimeType ?? "image/png")),
                 text: json.output?.text,
+                ...(vidu ? { operationName: json.output?.task_id } : {}),
                 rawResponse: json
             };
         }
@@ -1994,7 +2124,6 @@ class QwenVideoGenerationModel {
         this.fetcher = fetcher;
     }
     async generateVideo(input) {
-        const { signal, cleanup } = withTimeoutSignal(input);
         const providerOptions = { ...(input.providerOptions ?? {}) };
         delete providerOptions.endpoint;
         const nestedInput = providerOptions.input && typeof providerOptions.input === "object"
@@ -2006,38 +2135,60 @@ class QwenVideoGenerationModel {
         delete providerOptions.input;
         delete providerOptions.parameters;
         delete providerOptions.model;
-        const isWan27 = /^wan2\.7(?:$|-)/i.test(this.modelId);
+        const happyHorseEdit = /^happyhorse-.*-video-edit$/.test(this.modelId);
+        const media = input.image
+            ? happyHorseEdit
+                ? [...(Array.isArray(nestedInput.media) ? nestedInput.media : []), { type: "reference_image", url: mediaValue(input.image) }]
+                : [{ type: this.modelId.startsWith("vidu/") ? "image" : "first_frame", url: mediaValue(input.image) }]
+            : nestedInput.media;
+        let parameters = { ...providerOptions, ...nestedParameters };
+        if (input.aspectRatio !== undefined)
+            parameters.ratio = input.aspectRatio;
+        if (input.durationSeconds !== undefined)
+            parameters.duration = input.durationSeconds;
+        if (input.count !== undefined)
+            parameters.n = input.count;
+        if (input.outputStorageUri !== undefined)
+            parameters.output_storage_uri = input.outputStorageUri;
+        const usesMedia = /^(?:wan(?:2\.7|3\.0)(?:$|-)|happyhorse-|vidu\/)/i.test(this.modelId);
+        if (/^happyhorse-/.test(this.modelId))
+            validateHappyHorse(this.modelId, media, parameters);
+        if (/^wan3\.0-/.test(this.modelId))
+            validateWan30(media, parameters);
+        if (this.modelId.startsWith("vidu/"))
+            parameters = prepareViduVideo(this.modelId, media, parameters);
+        const { signal, cleanup } = withTimeoutSignal(input);
         try {
             const response = await withRetry(() => this.fetcher(`${this.taskBaseURL}/services/aigc/video-generation/video-synthesis`, {
                 method: "POST",
                 headers: { ...jsonHeaders(this.apiKey), "X-DashScope-Async": "enable" },
+                redirect: "error",
                 signal,
                 body: JSON.stringify({
                     model: this.modelId,
                     input: {
                         ...nestedInput,
                         prompt: input.prompt,
-                        negative_prompt: input.negativePrompt,
+                        negative_prompt: input.negativePrompt ?? nestedInput.negative_prompt,
                         ...(input.image
-                            ? isWan27
-                                ? { media: [{ type: "first_frame", url: mediaValue(input.image) }] }
+                            ? usesMedia
+                                ? { media }
                                 : { img_url: mediaValue(input.image) }
                             : {})
                     },
-                    parameters: {
-                        ...providerOptions,
-                        ...nestedParameters,
-                        ratio: input.aspectRatio,
-                        duration: input.durationSeconds,
-                        n: input.count,
-                        output_storage_uri: input.outputStorageUri
-                    }
+                    parameters
                 })
-            }), input);
+            }), { ...input, maxRetries: input.maxRetries ?? 0 });
             const json = await parseJson(response);
+            if (json.code || json.output?.task_status === "FAILED")
+                throw new ProviderHTTPError("Qwen media generation failed.", response.status, { responseBody: { code: json.code ?? json.output?.code } });
             const items = json.output?.results ??
                 json.output?.videos ??
                 (json.output?.video_url ? [{ url: json.output.video_url }] : []);
+            if (/^(?:wan3\.0-|happyhorse-|vidu\/)/.test(this.modelId) && !items.length &&
+                (typeof (json.output?.task_id ?? json.task_id) !== "string" || !(json.output?.task_id ?? json.task_id))) {
+                throw new ValidationError("Qwen video submission returned neither output nor a task ID.");
+            }
             return {
                 videos: items.map((item) => normalizeGeneratedMedia(item, "video/mp4")),
                 operationName: json.output?.task_id ?? json.task_id,
@@ -2270,6 +2421,12 @@ class QwenRealtimeModel {
     connectionFactory;
     provider = "qwen";
     get capabilities() {
+        if (isQwenCloudRealtime(this.modelId))
+            return {
+                ...realtimeCapabilities, vision: !isQwenAudioRealtime(this.modelId), webSearch: true,
+                agentCapabilities: { ...realtimeCapabilities.agentCapabilities, hostedWebSearch: true, remoteMcp: isQwenOmni38Realtime(this.modelId) },
+                realtime: { ...realtimeCapabilities.realtime, imageInput: !isQwenAudioRealtime(this.modelId) }
+            };
         if (!isLiveTranslate38(this.modelId))
             return realtimeCapabilities;
         return { ...realtimeCapabilities, tools: false, realtime: { ...realtimeCapabilities.realtime, tools: false } };
@@ -2282,9 +2439,14 @@ class QwenRealtimeModel {
     }
     async connect(config = {}, options) {
         const liveTranslate = isLiveTranslate38(this.modelId);
-        const mapSession = liveTranslate ? liveTranslateSession : mapRealtimeSession;
+        const cloudRealtime = isQwenCloudRealtime(this.modelId);
+        const mapSession = liveTranslate ? liveTranslateSession : cloudRealtime
+            ? (value) => mapQwenCloudRealtimeSession(this.modelId, value, mapRealtimeSession(value))
+            : mapRealtimeSession;
         mapSession(config);
         let audioSent = false;
+        let responseActive = false;
+        const pendingMcpApprovals = new Set();
         const imageTimes = [];
         const unsupported = () => { throw new UnsupportedFeatureError("LiveTranslate accepts streaming audio and images, not conversation commands."); };
         const url = appendQuery(this.realtimeURL, { model: this.modelId });
@@ -2297,15 +2459,35 @@ class QwenRealtimeModel {
             capabilities: this.capabilities,
             config,
             connection,
-            initializationTimeoutMs: liveTranslate ? (options?.timeoutMs ?? 15000) : undefined,
+            initializationTimeoutMs: liveTranslate || cloudRealtime ? (options?.timeoutMs ?? 15000) : undefined,
             callbacks: {
                 ...(liveTranslate ? {
                     isReadyPayload: (payload) => payload.type === "session.updated",
                     isCloseAcknowledgementPayload: (payload) => payload.type === "session.finished"
                 } : {}),
-                parseEvent: (payload) => parseRealtimeEvent(payload, () => `qwen-realtime-tool-${fallbackRealtimeToolCallIndex++}`, seenRealtimeToolCallIds, liveTranslate),
+                ...(cloudRealtime ? { isReadyPayload: (payload) => payload.type === "session.updated" } : {}),
+                parseEvent: (payload) => {
+                    if (payload.type === "response.created")
+                        responseActive = true;
+                    if (payload.type === "response.done")
+                        responseActive = false;
+                    const item = payload.item;
+                    if (cloudRealtime && payload.type === "conversation.item.created" && item?.type === "mcp_approval_request" && typeof item.id === "string")
+                        pendingMcpApprovals.add(item.id);
+                    return (cloudRealtime ? qwenCloudAudioEvent(payload, session.config) : undefined) ?? parseRealtimeEvent(payload, () => `qwen-realtime-tool-${fallbackRealtimeToolCallIndex++}`, seenRealtimeToolCallIds, liveTranslate || cloudRealtime);
+                },
                 buildInitialPayloads: (value) => [{ type: "session.update", session: mapSession(value) }],
                 buildAudioPayloads: (frame, sessionConfig) => {
+                    if (cloudRealtime) {
+                        validateQwenCloudAudioFrame(frame, sessionConfig);
+                        audioSent = true;
+                        const manual = sessionConfig.turnDetection === null;
+                        return [
+                            { type: "input_audio_buffer.append", audio: encodeRealtimeData(frame.data) },
+                            ...(frame.isFinal && manual ? [{ type: "input_audio_buffer.commit" }] : []),
+                            ...(frame.isFinal && manual && (sessionConfig.autoResponse ?? true) ? [{ type: "response.create" }] : [])
+                        ];
+                    }
                     if (liveTranslate) {
                         if (frame.mediaType !== "audio/pcm" || (frame.sampleRateHz !== undefined && frame.sampleRateHz !== 16000) || (frame.channels !== undefined && frame.channels !== 1))
                             throw new ConfigurationError("LiveTranslate input must be mono 16000 Hz PCM16.");
@@ -2323,6 +2505,8 @@ class QwenRealtimeModel {
                     ];
                 },
                 buildMediaPayloads: (frame) => {
+                    if (isQwenAudioRealtime(this.modelId))
+                        throw new UnsupportedFeatureError("Qwen Audio Realtime does not accept image or video frames.");
                     if (!/^image\/(jpeg|jpg)$/i.test(frame.mediaType)) {
                         throw new UnsupportedFeatureError("Qwen realtime media frames must be JPEG images.");
                     }
@@ -2348,13 +2532,25 @@ class QwenRealtimeModel {
                     { type: "conversation.item.create", item: { type: "function_call_output", call_id: result.toolCallId, output: JSON.stringify(result.isError ? result.error : result.output ?? null) } },
                     ...((sessionConfig.autoResponse ?? true) ? [{ type: "response.create" }] : [])
                 ],
-                buildUpdatePayloads: (value) => [{ type: "session.update", session: mapSession(value) }],
+                buildUpdatePayloads: (value) => {
+                    if (cloudRealtime && responseActive && JSON.stringify(value.providerOptions?.mcpServers) !== JSON.stringify(session.config.providerOptions?.mcpServers))
+                        throw new ConfigurationError("MCP configuration cannot change during an active response.");
+                    if (cloudRealtime && audioSent && (JSON.stringify(value.turnDetection) !== JSON.stringify(session.config.turnDetection) ||
+                        JSON.stringify(value.providerOptions?.audio) !== JSON.stringify(session.config.providerOptions?.audio) ||
+                        JSON.stringify(value.providerOptions?.video) !== JSON.stringify(session.config.providerOptions?.video) ||
+                        value.channels !== session.config.channels || value.inputSampleRateHz !== session.config.inputSampleRateHz ||
+                        value.outputSampleRateHz !== session.config.outputSampleRateHz || value.outputAudioMediaType !== session.config.outputAudioMediaType))
+                        throw new ConfigurationError("Qwen realtime audio/video formats and turn detection must be set before audio starts.");
+                    if (isQwenAudioRealtime(this.modelId) && value.voice !== session.config.voice)
+                        throw new ConfigurationError("Qwen Audio Realtime voice is fixed after the initial session update.");
+                    return [{ type: "session.update", session: mapSession(value) }];
+                },
                 buildInterruptPayloads: () => liveTranslate ? unsupported() : [{ type: "response.cancel" }],
                 buildClosePayloads: () => liveTranslate ? [{ type: "session.finish" }] : []
             }
         });
         await session.initialize();
-        return session;
+        return extendQwenCloudRealtimeSession(session, connection, pendingMcpApprovals);
     }
 }
 export const createQwen = (options = {}) => {
@@ -2378,7 +2574,7 @@ export const createQwen = (options = {}) => {
     }).toString().replace(/\/+$/, "");
     const realtimeURL = assertTrustedEndpoint(options.realtimeURL ??
         workspaceURLs?.realtimeURL ??
-        "wss://dashscope-intl.aliyuncs.com/api-ws/v1/realtime", {
+        `${new URL(baseURL).protocol === "https:" ? "wss:" : "ws:"}//${new URL(baseURL).host}/api-ws/v1/realtime`, {
         label: "Qwen realtimeURL",
         protocols: ["wss"],
         allowedHosts: options.realtimeURL
@@ -2386,6 +2582,13 @@ export const createQwen = (options = {}) => {
             : [new URL(baseURL).hostname, "dashscope-intl.aliyuncs.com"],
         allowUnsafe: options.allowUnsafeEndpoints
     }).toString();
+    const realtimeEndpoint = new URL(realtimeURL);
+    const inferenceURL = assertTrustedEndpoint(options.inferenceURL ??
+        (/\/realtime$/.test(realtimeEndpoint.pathname)
+            ? `${realtimeEndpoint.origin}${realtimeEndpoint.pathname.replace(/\/realtime$/, "/inference")}`
+            : `${realtimeEndpoint.origin}/api-ws/v1/inference`), {
+        label: "Qwen inferenceURL", protocols: ["wss"], allowedHosts: [new URL(baseURL).hostname], allowUnsafe: options.allowUnsafeEndpoints
+    }).toString();
     const fetcher = options.fetch ?? globalThis.fetch;
     const responseLimits = resolveAudioResponseLimits(options.responseLimits);
     const speechAudioMaxRedirects = options.speechAudioMaxRedirects ?? 3;
@@ -2395,13 +2598,28 @@ export const createQwen = (options = {}) => {
     return createProviderAdapter({
         name: "qwen",
         languageModel: (modelId) => {
+            assertQwenLanguageModel(modelId);
             if (isLiveTranslate38(modelId))
                 throw new UnsupportedFeatureError("Qwen 3.8 LiveTranslate requires realtimeModel(), not languageModel().");
             return 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, taskBaseURL, fetcher, responseLimits, options.speechAudioURLValidator, speechAudioMaxRedirects),
+        embeddingModel: (modelId) => createQwenTextEmbeddingModel(modelId, apiKey, baseURL, taskBaseURL, fetcher),
+        decisionModel: (modelId = "decision-model-preview") => createQwenDecisionModel(modelId, { apiKey, baseURL: options.decisionBaseURL ?? baseURL, fetch: fetcher, allowUnsafeEndpoints: options.allowUnsafeEndpoints }),
+        textEmbeddingModel: (modelId) => createQwenTextEmbeddingModel(modelId, apiKey, baseURL, taskBaseURL, fetcher),
+        fileTranscriptionModel: (modelId) => createQwenFileTranscriptionModel(modelId, { apiKey, taskBaseURL, fetch: fetcher, allowUnsafeEndpoints: options.allowUnsafeEndpoints }),
+        transcriptionModel: (modelId) => {
+            if (/filetrans/.test(modelId))
+                throw new UnsupportedFeatureError("Use fileTranscriptionModel() for asynchronous file transcription.");
+            if (modelId === "qwen-audio-3.0-asr-flash")
+                return createQwenNativeTranscriptionModel(modelId, { apiKey, taskBaseURL, fetch: fetcher, allowUnsafeEndpoints: options.allowUnsafeEndpoints });
+            return isQwenCloudStreamingASR(modelId)
+                ? new QwenCloudStreamingASRModel(modelId, apiKey, inferenceURL, options.realtimeConnectionFactory)
+                : new QwenTranscriptionModel(modelId, apiKey, baseURL, fetcher, responseLimits);
+        },
+        streamingASRModel: (modelId) => new QwenCloudStreamingASRModel(modelId, apiKey, inferenceURL, options.realtimeConnectionFactory),
+        speechModel: (modelId) => isQwenCloudSpeech(modelId)
+            ? new QwenCloudSpeechModel(modelId, apiKey, inferenceURL, options.realtimeConnectionFactory)
+            : 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),
@@ -2411,6 +2629,9 @@ export const createQwen = (options = {}) => {
         multimodalEmbeddingModel: (modelId) => new QwenMultimodalEmbeddingModelImpl(modelId, apiKey, taskBaseURL, fetcher),
         tasks: new QwenTasksClientImpl(apiKey, taskBaseURL, fetcher),
         voices: createQwenVoicesClient(apiKey, taskBaseURL, fetcher),
+        imageTranslationModel: (modelId = "qwen-mt-image-2.0") => createQwenImageTranslationModel(modelId, apiKey, taskBaseURL, fetcher),
+        worlds: (modelId) => createQwenWorldsClient(modelId, apiKey, taskBaseURL, fetcher),
+        temporaryKeys: createQwenTemporaryKeysClient(apiKey, taskBaseURL, fetcher),
         rawFetch: fetcher
     });
 };