@zhivex-ai/qwen 0.16.1 → 0.16.3

package/dist/index.js

@@ -1,3 +1,5 @@
+import { qwenSearchUsage } from "./search-usage.js";
+import { createAnnotationCollector } from "./annotations.js";
 export { createQwenSDPExchange } from "./sdp-exchange.js";
 export { connectQwenWebRTC, connectQwenAOQ } from "./browser-realtime.js";
 import { createQwenTemporaryKeysClient } from "./temporary-keys.js";
@@ -683,7 +685,37 @@ const hasHostedTools = (tools) => Object.values(tools ?? {}).some((tool) => !isC
 const hasMessagePart = (messages, type) => messages.some((message) => message.parts.some((part) => part.type === type));
 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/")));
+// Only documented Responses families may send a bounded output request.
+const responsesOutputLimitFamilies = new Set([
+    "qwen3.8-max", "qwen3.8-flash", "qwen3.8-omni-flash", "qwen3.8-2.4t-a95b", "qwen3.8-27b",
+    "qwen3.7-max", "qwen3.7-max-preview", "qwen3.7-plus", "qwen3.7-flash",
+    "qwen3.6-plus", "qwen3.6-flash", "qwen3.6-35b-a3b", "qwen3-max",
+    "qwen3.5-plus", "qwen3.5-flash", "qwen3.5-397b-a17b", "qwen3.5-122b-a10b", "qwen3.5-27b", "qwen3.5-35b-a3b"
+]);
+const supportsResponsesOutputLimit = (modelId) => responsesOutputLimitFamilies.has(modelId.toLowerCase().replace(/-\d{4}(?:-\d{2}-\d{2})?$/, "")) ||
+    thirdPartyProfile(modelId)?.responses === true;
+const responsesOutputLimit = (modelId, input, options) => {
+    const value = input.maxTokens ?? options.max_output_tokens;
+    if (input.maxTokens !== undefined && options.max_output_tokens !== undefined && input.maxTokens !== options.max_output_tokens) {
+        throw new ConfigurationError("Qwen maxTokens and max_output_tokens must agree.");
+    }
+    if (value === undefined)
+        return undefined;
+    if (!supportsResponsesOutputLimit(modelId))
+        throw new UnsupportedFeatureError(`Qwen Responses output limits are not supported for model "${modelId}".`);
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 16) {
+        throw new ConfigurationError("Qwen Responses maxTokens/max_output_tokens must be a safe integer of at least 16.");
+    }
+    return value;
+};
 const resolveApiMode = (modelId, requestedMode, input, providerOptions) => {
+    if (providerOptions.max_tool_calls !== undefined)
+        throw new UnsupportedFeatureError("Qwen max_tool_calls is not verified as an effective hosted-tool limit.");
+    for (const tool of Object.values(input.tools ?? {})) {
+        if (!isCallableToolDefinition(tool) && tool.type === "web_search" && tool.config && typeof tool.config === "object" &&
+            ("max_tool_calls" in tool.config || "max_uses" in tool.config))
+            throw new UnsupportedFeatureError("Qwen web_search tool-call limits are not verified on Responses.");
+    }
     if (isQwenTranslation(modelId) || isQwenCharacter(modelId))
         return "chat";
     const videoInput = hasVideoInput(input.messages);
@@ -700,15 +732,16 @@ const resolveApiMode = (modelId, requestedMode, input, providerOptions) => {
         throw new UnsupportedFeatureError('QwenCloud glm-5.2 callable tools require apiMode "chat" or "auto" because Responses function continuation is unavailable.');
     }
     const needsChat = glmCallableTools ||
-        input.maxTokens !== undefined ||
+        (input.maxTokens !== undefined && (!supportsResponsesOutputLimit(modelId) ||
+            (requestedMode === "auto" && !hasHostedTools(input.tools) && !hasNonVideoFileInput(input.messages) && providerOptions.max_output_tokens === undefined))) ||
         input.reasoning?.budgetTokens !== undefined ||
         providerOptions.thinking_budget !== undefined ||
         providerOptions.tool_stream === true ||
         input.structuredOutput?.mode === "native" ||
         (!omni38 && (hasMessagePart(input.messages, "audio") || videoInput));
-    const needsResponses = hasHostedTools(input.tools) || hasNonVideoFileInput(input.messages);
+    const needsResponses = hasHostedTools(input.tools) || hasNonVideoFileInput(input.messages) || providerOptions.max_output_tokens !== undefined;
     if (needsChat && needsResponses) {
-        throw new UnsupportedFeatureError("Qwen cannot combine Responses-only hosted/file inputs with Chat-only maxTokens, audio, video, reasoning budgets, structured output, or tool streaming.");
+        throw new UnsupportedFeatureError("Qwen cannot combine Responses-only hosted/file inputs with Chat-only options (including maxTokens on unsupported models), audio, video, reasoning budgets, structured output, or tool streaming.");
     }
     if (isQwenOmniLanguageModel(modelId)) {
         if (requestedMode === "responses" || needsResponses) {
@@ -895,7 +928,8 @@ const toResponsesInput = (messages, format, modelId) => {
                         part.provider === "qwen" &&
                         part.data &&
                         typeof part.data === "object" &&
-                        typeof part.data.type === "string") {
+                        typeof part.data.type === "string" &&
+                        !["response.annotations", "hosted-tool-usage"].includes(String(part.data.type))) {
                         input.push(part.data);
                     }
                     break;
@@ -927,15 +961,72 @@ 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);
+    }
+    const collectAnnotations = createAnnotationCollector();
     for (const [index, item] of (json.output ?? []).entries()) {
         if (item?.type === "message") {
-            for (const content of item.content ?? []) {
+            for (const [contentIndex, content] of (item.content ?? []).entries()) {
+                const data = collectAnnotations(content, index, contentIndex, item.id);
+                if (data)
+                    parts.push(providerDataPart("qwen", data));
                 if (typeof content?.text === "string" && content.text) {
                     parts.push({ type: "text", text: content.text });
                 }
@@ -943,6 +1034,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({
@@ -950,7 +1044,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 } }
                         : {})
@@ -981,17 +1075,41 @@ const normalizeResponsesFinishReason = (status, hasToolCalls) => {
     if (status === "completed") {
         return "stop";
     }
+    if (status === "incomplete")
+        return "length";
     if (status === "failed") {
         return "error";
     }
     return normalizeFinishReason(status);
 };
 const streamResponses = async function* (response, input) {
+    const attemptId = globalThis.crypto.randomUUID();
+    const searchEnabled = Object.values(input.tools ?? {}).some(t => !isCallableToolDefinition(t) && t.type === "web_search");
+    if (searchEnabled)
+        yield { type: "provider-data", provider: "qwen", data: qwenSearchUsage(attemptId) };
+    const collectAnnotations = createAnnotationCollector();
     const toolBuffers = new Map();
     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)
@@ -1010,31 +1128,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();
@@ -1055,8 +1153,23 @@ const streamResponses = async function* (response, input) {
             };
             continue;
         }
+        input.abortSignal?.throwIfAborted();
+        if (type === "response.content_part.done") {
+            const data = collectAnnotations(json.part, json.output_index, json.content_index, json.item_id);
+            if (data)
+                yield { type: "provider-data", provider: "qwen", data };
+            continue;
+        }
         if (type === "response.output_item.added" || type === "response.output_item.done") {
             const item = json.item;
+            if (type === "response.output_item.done" && item?.type === "message" && Array.isArray(item.content)) {
+                for (const [contentIndex, part] of item.content.entries()) {
+                    input.abortSignal?.throwIfAborted();
+                    const data = collectAnnotations(part, json.output_index, contentIndex, item.id);
+                    if (data)
+                        yield { type: "provider-data", provider: "qwen", data };
+                }
+            }
             if (item?.type === "function_call") {
                 const outputIndex = json.output_index ?? toolBuffers.size;
                 const fallbackId = fallbackToolCallId("responses", fallbackGeneration, outputIndex);
@@ -1067,23 +1180,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",
@@ -1103,9 +1217,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;
@@ -1120,36 +1238,115 @@ 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 }
-                };
+            const next = { ...(json.response ?? {}), status: type === "response.incomplete" ? "incomplete" : json.response?.status };
+            if (terminal && JSON.stringify(terminal) !== JSON.stringify(next))
+                invalidMetadata = true;
+            terminal = next;
+        }
+    }
+    // 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()) {
+            input.abortSignal?.throwIfAborted();
+            if (item?.type === "message" && Array.isArray(item.content)) {
+                for (const [contentIndex, part] of item.content.entries()) {
+                    input.abortSignal?.throwIfAborted();
+                    const data = collectAnnotations(part, index, contentIndex, item.id);
+                    if (data)
+                        yield { type: "provider-data", provider: "qwen", data };
+                }
             }
-            yield {
-                type: "finish",
-                finishReason: normalizeResponsesFinishReason(responseData.status, sawToolCalls),
-                providerFinishReason: responseData.status,
-                usage: mapResponsesUsage(responseData.usage)
-            };
+            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);
+            }
+            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 (searchEnabled || terminal.usage?.x_tools?.web_search !== undefined)
+        yield { type: "provider-data", provider: "qwen", data: qwenSearchUsage(attemptId, terminal) };
+    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;
@@ -1163,7 +1360,7 @@ class QwenLanguageModel {
         this.apiKey = apiKey;
         this.baseURL = baseURL;
         this.fetcher = fetcher;
-        this.capabilities = { ...qwenLanguageCapabilities(modelId), toolHistory: thirdPartyProfile(modelId)?.thinkingOnly || isQwen38MaxPreview(modelId) || /thinking|qwq/i.test(modelId) ? undefined : "json" };
+        this.capabilities = { ...qwenLanguageCapabilities(modelId), hostedTools: qwenLanguageCapabilities(modelId).webSearch ? [{ route: "responses", tool: "web_search", limit: "unverified", metering: "provider-counter" }] : [], toolHistory: thirdPartyProfile(modelId)?.thinkingOnly || isQwen38MaxPreview(modelId) || /thinking|qwq/i.test(modelId) ? undefined : "json" };
     }
     async generate(input) {
         if (isQwenOmniLanguageModel(this.modelId)) {
@@ -1184,6 +1381,7 @@ class QwenLanguageModel {
         }
         const apiMode = resolveApiMode(this.modelId, providerOptions.apiMode ?? "auto", input, providerOptions);
         delete providerOptions.apiMode;
+        const outputLimit = apiMode === "responses" ? responsesOutputLimit(this.modelId, input, providerOptions) : undefined;
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
             if (apiMode === "responses") {
@@ -1201,6 +1399,7 @@ class QwenLanguageModel {
                     signal,
                     body: JSON.stringify({
                         ...responseProviderOptions,
+                        max_output_tokens: outputLimit,
                         model: this.modelId,
                         ...(previousResponse ? { previous_response_id: previousResponse.responseId } : {}),
                         ...(messages.length ? { input: toResponsesInput(messages, input.toolResultFormat, this.modelId) } : {}),
@@ -1213,6 +1412,9 @@ class QwenLanguageModel {
                 }), { ...input, abortSignal: signal }, "Qwen");
                 const json = await parseJson(response);
                 const assistantMessage = parseResponsesAssistantMessage(json, input);
+                if (Object.values(input.tools ?? {}).some(t => !isCallableToolDefinition(t) && t.type === "web_search") || json.usage?.x_tools?.web_search !== undefined) {
+                    assistantMessage.parts.push(providerDataPart("qwen", qwenSearchUsage(globalThis.crypto.randomUUID(), json)));
+                }
                 const hasToolCalls = assistantMessage.parts.some((part) => part.type === "tool-call");
                 return {
                     messages: [assistantMessage],
@@ -1285,6 +1487,7 @@ class QwenLanguageModel {
         }
         const apiMode = resolveApiMode(this.modelId, providerOptions.apiMode ?? "auto", input, providerOptions);
         delete providerOptions.apiMode;
+        const outputLimit = apiMode === "responses" ? responsesOutputLimit(this.modelId, input, providerOptions) : undefined;
         const { signal, cleanup } = withTimeoutSignal(input);
         if (apiMode === "responses") {
             const previousResponse = getProviderResponseId(input.messages);
@@ -1301,6 +1504,7 @@ class QwenLanguageModel {
                 signal,
                 body: JSON.stringify({
                     ...responseProviderOptions,
+                    max_output_tokens: outputLimit,
                     model: this.modelId,
                     ...(previousResponse ? { previous_response_id: previousResponse.responseId } : {}),
                     ...(messages.length ? { input: toResponsesInput(messages, input.toolResultFormat, this.modelId) } : {}),
@@ -1313,7 +1517,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();
@@ -1359,7 +1563,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;