@jsonstudio/rcc 0.90.814 → 0.90.876

package/dist/providers/core/runtime/qwenchat-http-provider-helpers.js

@@ -1,7 +1,8 @@
 import { createHash, createHmac, randomBytes, randomUUID } from 'node:crypto';
+import { isIP } from 'node:net';
 import { PassThrough } from 'node:stream';
-import { processChatResponseTools } from '@jsonstudio/llms/conversion';
 import { applyStandardToolTextRequestTransform } from './standard-tool-text-request-transform.js';
+import { applyStandardToolTextHarvestToChatPayload } from './standard-tool-text-harvest.js';
 export const DEFAULT_QWENCHAT_BASE_URL = 'https://chat.qwen.ai';
 export const DEFAULT_QWENCHAT_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36';
 export const DEFAULT_QWENCHAT_ACCEPT_LANGUAGE = 'zh-CN,zh;q=0.9,en;q=0.8';
@@ -9,6 +10,8 @@ export const DEFAULT_QWENCHAT_COMPLETION_ENDPOINT = '/api/v2/chat/completions';
 export const DEFAULT_QWENCHAT_CHAT_CREATE_ENDPOINT = '/api/v2/chats/new';
 const BAXIA_VERSION = '2.5.36';
 const BAXIA_CACHE_TTL_MS = 4 * 60 * 1000;
+const DEFAULT_ATTACHMENT_FETCH_TIMEOUT_MS = 15_000;
+const DEFAULT_ATTACHMENT_MAX_BYTES = 20 * 1024 * 1024;
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
@@ -26,6 +29,214 @@ function normalizeInputString(value) {
     }
     return trimmed;
 }
+function clampInteger(value, fallback, min, max) {
+    const parsed = typeof value === 'number' && Number.isFinite(value)
+        ? Math.trunc(value)
+        : Number.parseInt(normalizeInputString(value), 10);
+    if (!Number.isFinite(parsed)) {
+        return fallback;
+    }
+    return Math.min(max, Math.max(min, parsed));
+}
+function readBooleanEnv(keys, fallback) {
+    for (const key of keys) {
+        const raw = normalizeInputString(process.env[key]);
+        if (!raw) {
+            continue;
+        }
+        const normalized = raw.trim().toLowerCase();
+        if (['1', 'true', 'yes', 'on'].includes(normalized)) {
+            return true;
+        }
+        if (['0', 'false', 'no', 'off'].includes(normalized)) {
+            return false;
+        }
+    }
+    return fallback;
+}
+function parseImageSizeToQwenRatio(size) {
+    const text = normalizeInputString(size);
+    if (!text) {
+        return '1:1';
+    }
+    const ratioMatch = text.match(/^(\d{1,2}):(\d{1,2})$/);
+    if (ratioMatch) {
+        const w = Number.parseInt(ratioMatch[1], 10);
+        const h = Number.parseInt(ratioMatch[2], 10);
+        if (Number.isFinite(w) && Number.isFinite(h) && w > 0 && h > 0) {
+            const ratio = `${w}:${h}`;
+            if (['1:1', '16:9', '9:16', '4:3', '3:4'].includes(ratio)) {
+                return ratio;
+            }
+        }
+    }
+    const sizeMatch = text.toLowerCase().match(/^(\d{2,5})\s*x\s*(\d{2,5})$/);
+    if (!sizeMatch) {
+        return '1:1';
+    }
+    const width = Number.parseInt(sizeMatch[1], 10);
+    const height = Number.parseInt(sizeMatch[2], 10);
+    if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+        return '1:1';
+    }
+    const ratio = width / height;
+    const candidates = [
+        { key: '1:1', ratio: 1 },
+        { key: '16:9', ratio: 16 / 9 },
+        { key: '9:16', ratio: 9 / 16 },
+        { key: '4:3', ratio: 4 / 3 },
+        { key: '3:4', ratio: 3 / 4 }
+    ];
+    let best = candidates[0];
+    let bestDiff = Number.POSITIVE_INFINITY;
+    for (const candidate of candidates) {
+        const diff = Math.abs(ratio - candidate.ratio);
+        if (diff < bestDiff) {
+            best = candidate;
+            bestDiff = diff;
+        }
+    }
+    return best.key;
+}
+function parseQwenImageGenerationOptions(metadata) {
+    const node = metadata && isRecord(metadata.qwenImageGeneration)
+        ? metadata.qwenImageGeneration
+        : undefined;
+    const enabled = metadata?.qwenImageGeneration === true
+        || metadata?.imageGeneration === true
+        || normalizeInputString(metadata?.generationMode).toLowerCase() === 'image'
+        || Boolean(node);
+    const count = clampInteger(node?.n ?? metadata?.n, 1, 1, 10);
+    const sizeRatio = parseImageSizeToQwenRatio(node?.size ?? metadata?.size);
+    const responseFormatRaw = normalizeInputString(node?.responseFormat ?? node?.response_format ?? metadata?.response_format).toLowerCase();
+    const responseFormat = responseFormatRaw === 'b64_json' ? 'b64_json' : 'url';
+    return {
+        enabled,
+        count,
+        sizeRatio,
+        responseFormat
+    };
+}
+function readPositiveIntegerEnv(keys, fallback, min = 1, max = Number.MAX_SAFE_INTEGER) {
+    for (const key of keys) {
+        const raw = normalizeInputString(process.env[key]);
+        if (!raw) {
+            continue;
+        }
+        const parsed = Number.parseInt(raw, 10);
+        if (!Number.isFinite(parsed)) {
+            continue;
+        }
+        const normalized = Math.floor(parsed);
+        if (normalized < min || normalized > max) {
+            continue;
+        }
+        return normalized;
+    }
+    return fallback;
+}
+function isPrivateIpv4(host) {
+    const segments = host.split('.');
+    if (segments.length !== 4) {
+        return false;
+    }
+    const numbers = segments.map((segment) => Number.parseInt(segment, 10));
+    if (numbers.some((value) => !Number.isFinite(value) || value < 0 || value > 255)) {
+        return false;
+    }
+    const [a, b] = numbers;
+    if (a === 10 || a === 127 || a === 0) {
+        return true;
+    }
+    if (a === 169 && b === 254) {
+        return true;
+    }
+    if (a === 192 && b === 168) {
+        return true;
+    }
+    if (a === 172 && b >= 16 && b <= 31) {
+        return true;
+    }
+    return false;
+}
+function isPrivateIpv6(host) {
+    const normalized = host.toLowerCase();
+    return normalized === '::1'
+        || normalized.startsWith('fc')
+        || normalized.startsWith('fd')
+        || normalized.startsWith('fe80:');
+}
+function validateAttachmentSourceUrl(input) {
+    let parsed;
+    try {
+        parsed = new URL(input);
+    }
+    catch {
+        throw new Error('Invalid attachment URL');
+    }
+    const protocol = parsed.protocol.toLowerCase();
+    if (protocol !== 'https:' && protocol !== 'http:') {
+        throw new Error(`Unsupported attachment URL protocol: ${protocol}`);
+    }
+    if (parsed.username || parsed.password) {
+        throw new Error('Attachment URL must not include username/password');
+    }
+    const hostname = parsed.hostname.trim().toLowerCase();
+    if (!hostname) {
+        throw new Error('Attachment URL hostname is required');
+    }
+    if (hostname === 'localhost' || hostname.endsWith('.localhost') || hostname.endsWith('.local')) {
+        throw new Error('Attachment URL localhost/local domains are not allowed');
+    }
+    const ipType = isIP(hostname);
+    if (ipType === 4 && isPrivateIpv4(hostname)) {
+        throw new Error('Attachment URL private IPv4 is not allowed');
+    }
+    if (ipType === 6 && isPrivateIpv6(hostname)) {
+        throw new Error('Attachment URL private IPv6 is not allowed');
+    }
+    return parsed;
+}
+async function readResponseBytesWithLimit(response, maxBytes) {
+    const contentLengthText = normalizeInputString(response.headers.get('content-length'));
+    if (contentLengthText) {
+        const contentLength = Number.parseInt(contentLengthText, 10);
+        if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+            throw new Error(`Attachment exceeds max size (${contentLength} > ${maxBytes})`);
+        }
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    const chunks = [];
+    let total = 0;
+    while (true) {
+        const step = await reader.read();
+        if (step.done) {
+            break;
+        }
+        const chunk = step.value;
+        total += chunk.byteLength;
+        if (total > maxBytes) {
+            try {
+                await reader.cancel('attachment_too_large');
+            }
+            catch {
+                // ignore
+            }
+            throw new Error(`Attachment exceeds max size (${total} > ${maxBytes})`);
+        }
+        chunks.push(chunk);
+    }
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        merged.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return merged;
+}
 function randomString(length) {
     const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
     const bytes = randomBytes(length);
@@ -340,11 +551,19 @@ async function loadAttachmentBytes(attachment) {
         };
     }
     if (/^https?:\/\//i.test(attachment.source)) {
-        const resp = await fetch(attachment.source);
+        const parsedUrl = validateAttachmentSourceUrl(attachment.source);
+        const timeoutMs = readPositiveIntegerEnv(['ROUTECODEX_QWENCHAT_ATTACHMENT_FETCH_TIMEOUT_MS', 'RCC_QWENCHAT_ATTACHMENT_FETCH_TIMEOUT_MS'], DEFAULT_ATTACHMENT_FETCH_TIMEOUT_MS, 1_000, 300_000);
+        const maxBytes = readPositiveIntegerEnv(['ROUTECODEX_QWENCHAT_ATTACHMENT_MAX_BYTES', 'RCC_QWENCHAT_ATTACHMENT_MAX_BYTES'], DEFAULT_ATTACHMENT_MAX_BYTES, 1024);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort('attachment_fetch_timeout'), timeoutMs);
+        if (typeof timer.unref === 'function') {
+            timer.unref();
+        }
+        const resp = await fetch(parsedUrl, { signal: controller.signal }).finally(() => clearTimeout(timer));
         if (!resp.ok) {
             throw new Error(`Failed to fetch attachment URL: HTTP ${resp.status}`);
         }
-        const bytes = new Uint8Array(await resp.arrayBuffer());
+        const bytes = await readResponseBytesWithLimit(resp, maxBytes);
         const mimeType = normalizeMimeType(attachment.mimeType || resp.headers.get('content-type'));
         return {
             bytes,
@@ -363,23 +582,45 @@ async function loadAttachmentBytes(attachment) {
         explicitType: attachment.explicitType
     };
 }
-function qwenCommonHeaders(baxiaTokens, authHeaders) {
+function qwenCommonHeaders(baxiaTokens, authHeaders, options) {
+    const forwardAuthHeaders = readBooleanEnv(['ROUTECODEX_QWENCHAT_FORWARD_AUTH_HEADERS', 'RCC_QWENCHAT_FORWARD_AUTH_HEADERS'], false);
+    const normalizedBase = normalizeInputString(options?.baseUrl) || DEFAULT_QWENCHAT_BASE_URL;
+    const base = normalizedBase.replace(/\/$/, '');
+    const referer = options?.refererMode === 'guest' ? `${base}/c/guest` : `${base}/`;
+    const accept = options?.acceptMode === 'json' ? 'application/json' : 'application/json, text/plain, */*';
     return {
-        'Accept': 'application/json, text/plain, */*',
+        'Accept': accept,
         'Content-Type': 'application/json',
         'bx-ua': baxiaTokens.bxUa,
         'bx-umidtoken': baxiaTokens.bxUmidToken,
         'bx-v': baxiaTokens.bxV,
         'source': 'web',
         'timezone': new Date().toUTCString(),
-        'Referer': `${DEFAULT_QWENCHAT_BASE_URL}/`,
+        'Referer': referer,
         'User-Agent': DEFAULT_QWENCHAT_USER_AGENT,
         'Accept-Language': DEFAULT_QWENCHAT_ACCEPT_LANGUAGE,
         'x-request-id': randomUUID(),
-        ...(authHeaders || {})
+        ...(forwardAuthHeaders ? authHeaders || {} : {})
     };
 }
 function extractQwenErrorMessage(payload) {
+    const readNestedMessage = (value) => {
+        if (typeof value === 'string') {
+            return normalizeInputString(value);
+        }
+        if (!isRecord(value)) {
+            return '';
+        }
+        const nested = [
+            normalizeInputString(value.message),
+            normalizeInputString(value.msg),
+            normalizeInputString(value.details),
+            normalizeInputString(value.template),
+            normalizeInputString(value.code),
+            isRecord(value.error) ? normalizeInputString(value.error.message) : ''
+        ].filter(Boolean);
+        return nested[0] || '';
+    };
     const readNode = (node) => {
         if (!node)
             return '';
@@ -387,7 +628,10 @@ function extractQwenErrorMessage(payload) {
             normalizeInputString(node.msg),
             normalizeInputString(node.message),
             normalizeInputString(node.error),
-            normalizeInputString(node.err_msg)
+            normalizeInputString(node.err_msg),
+            normalizeInputString(node.details),
+            normalizeInputString(node.template),
+            normalizeInputString(node.code)
         ].filter(Boolean);
         if (direct.length > 0) {
             return direct[0];
@@ -402,10 +646,17 @@ function extractQwenErrorMessage(payload) {
                 return nested[0];
             }
         }
+        if (isRecord(node.details)) {
+            const nestedDetails = readNestedMessage(node.details);
+            if (nestedDetails) {
+                return nestedDetails;
+            }
+        }
         return '';
     };
     const dataNode = isRecord(payload.data) ? payload.data : undefined;
-    return readNode(payload) || readNode(dataNode) || '';
+    const detailsNode = isRecord(dataNode?.details) ? dataNode.details : undefined;
+    return readNode(payload) || readNode(dataNode) || readNode(detailsNode) || '';
 }
 function extractQwenUploadTokenData(payload) {
     const tryReadNode = (node) => {
@@ -462,7 +713,7 @@ async function requestUploadToken(baseUrl, file, baxiaTokens, authHeaders) {
     const filetype = inferFileCategory(file.mimeType, file.explicitType);
     const resp = await fetch(joinUrl(baseUrl, '/api/v2/files/getstsToken'), {
         method: 'POST',
-        headers: qwenCommonHeaders(baxiaTokens, authHeaders),
+        headers: qwenCommonHeaders(baxiaTokens, authHeaders, { baseUrl, refererMode: 'web', acceptMode: 'default' }),
         body: JSON.stringify({
             filename: file.filename,
             filesize: file.bytes.length,
@@ -653,7 +904,7 @@ async function ensureUploadStatusForNonVideo(baseUrl, filetype, baxiaTokens, aut
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
         const resp = await fetch(joinUrl(baseUrl, '/api/v2/users/status'), {
             method: 'POST',
-            headers: qwenCommonHeaders(baxiaTokens, authHeaders),
+            headers: qwenCommonHeaders(baxiaTokens, authHeaders, { baseUrl, refererMode: 'web', acceptMode: 'default' }),
             body: JSON.stringify({
                 typarms: {
                     typarm1: 'web',
@@ -689,7 +940,7 @@ async function parseDocumentIfNeeded(baseUrl, qwenFilePayload, filetype, baxiaTo
     }
     const resp = await fetch(joinUrl(baseUrl, '/api/v2/files/parse'), {
         method: 'POST',
-        headers: qwenCommonHeaders(baxiaTokens, authHeaders),
+        headers: qwenCommonHeaders(baxiaTokens, authHeaders, { baseUrl, refererMode: 'web', acceptMode: 'default' }),
         body: JSON.stringify({ file_id: fileId })
     });
     const text = await resp.text().catch(() => '');
@@ -730,10 +981,17 @@ export async function uploadAttachments(args) {
 export function extractQwenChatPayload(request) {
     const container = isRecord(request) ? request : {};
     const payload = isRecord(container.data) ? container.data : container;
-    const model = normalizeInputString(payload.model) || 'qwen3.5-plus';
-    const messages = Array.isArray(payload.messages) ? payload.messages : [];
+    const model = normalizeInputString(payload.model) || 'qwen3.6-plus';
+    const directMessages = Array.isArray(payload.messages) ? payload.messages : [];
+    const compatPrompt = normalizeInputString(payload.prompt);
+    const messages = directMessages.length > 0
+        ? directMessages
+        : compatPrompt
+            ? [{ role: 'user', content: compatPrompt }]
+            : [];
     const streamFlag = payload.stream;
-    const stream = streamFlag === undefined ? true : streamFlag === true;
+    // Follow OpenAI semantics: stream defaults to false unless explicitly true.
+    const stream = streamFlag === true;
     const metadata = isRecord(payload.metadata)
         ? payload.metadata
         : isRecord(container.metadata)
@@ -748,12 +1006,29 @@ export function extractQwenChatPayload(request) {
     };
 }
 export function shouldUseSearchMode(payload) {
+    if (parseQwenImageGenerationOptions(payload.metadata).enabled) {
+        return false;
+    }
     if (payload.metadata?.qwenWebSearch === true || payload.metadata?.webSearch === true) {
         return true;
     }
     return false;
 }
+function shouldUseImageGenerationMode(payload) {
+    return parseQwenImageGenerationOptions(payload.metadata).enabled;
+}
 function extractChatIdFromCreatePayload(payload) {
+    const readChatIdFromText = (value) => {
+        const text = normalizeInputString(value);
+        if (!text) {
+            return '';
+        }
+        const namedMatch = text.match(/(?:chat[_-]?id|session[_-]?id|conversation[_-]?id)\s*[:=]\s*["']?([a-zA-Z0-9._:-]{8,})["']?/i);
+        if (namedMatch?.[1]) {
+            return namedMatch[1].trim();
+        }
+        return '';
+    };
     const readDirect = (node) => {
         if (!node) {
             return '';
@@ -764,27 +1039,122 @@ function extractChatIdFromCreatePayload(payload) {
             normalizeInputString(node.session_id) ||
             normalizeInputString(node.sessionId) ||
             normalizeInputString(node.conversation_id) ||
-            normalizeInputString(node.conversationId));
+            normalizeInputString(node.conversationId) ||
+            readChatIdFromText(node.details) ||
+            readChatIdFromText(node.message) ||
+            readChatIdFromText(node.msg));
     };
     const root = payload;
     const dataNode = isRecord(root.data) ? root.data : undefined;
     const resultNode = isRecord(root.result) ? root.result : undefined;
     const chatNode = isRecord(dataNode?.chat) ? dataNode.chat : undefined;
-    return readDirect(dataNode) || readDirect(chatNode) || readDirect(resultNode) || readDirect(root);
+    const dataDetailsNode = isRecord(dataNode?.details) ? dataNode.details : undefined;
+    const resultDetailsNode = isRecord(resultNode?.details) ? resultNode.details : undefined;
+    const rootDetailsNode = isRecord(root.details) ? root.details : undefined;
+    const nestedDataNode = isRecord(dataNode?.data) ? dataNode.data : undefined;
+    const nestedResultNode = isRecord(dataNode?.result) ? dataNode.result : undefined;
+    const conversationNode = isRecord(dataNode?.conversation) ? dataNode.conversation : undefined;
+    const sessionNode = isRecord(dataNode?.session) ? dataNode.session : undefined;
+    return (readDirect(dataNode) ||
+        readDirect(chatNode) ||
+        readDirect(conversationNode) ||
+        readDirect(sessionNode) ||
+        readDirect(nestedDataNode) ||
+        readDirect(nestedResultNode) ||
+        readDirect(resultNode) ||
+        readDirect(dataDetailsNode) ||
+        readDirect(resultDetailsNode) ||
+        readDirect(rootDetailsNode) ||
+        readDirect(root));
 }
 function extractCreateErrorMessage(payload) {
-    const parts = [
-        normalizeInputString(payload.msg),
-        normalizeInputString(payload.message),
-        normalizeInputString(payload.error),
-        isRecord(payload.error) ? normalizeInputString(payload.error.message) : ''
+    const reason = extractQwenErrorMessage(payload);
+    if (reason) {
+        return reason;
+    }
+    const dataNode = isRecord(payload.data) ? payload.data : undefined;
+    const detailsNode = isRecord(dataNode?.details) ? dataNode.details : undefined;
+    const detailsParts = [
+        detailsNode ? normalizeInputString(detailsNode.message) : '',
+        detailsNode ? normalizeInputString(detailsNode.msg) : '',
+        detailsNode ? normalizeInputString(detailsNode.details) : '',
+        detailsNode ? normalizeInputString(detailsNode.template) : '',
+        detailsNode ? normalizeInputString(detailsNode.code) : ''
     ].filter(Boolean);
-    return parts[0] || '';
+    return detailsParts[0] || '';
+}
+function inferCreateSessionStatusCode(payload, reason) {
+    const dataNode = isRecord(payload.data) ? payload.data : undefined;
+    const normalized = [
+        normalizeInputString(payload.code),
+        normalizeInputString(dataNode?.code),
+        reason
+    ]
+        .filter(Boolean)
+        .join(' ')
+        .toLowerCase();
+    if (normalized.includes('ratelimit') ||
+        normalized.includes('rate_limit') ||
+        normalized.includes('daily usage limit') ||
+        normalized.includes('too many request') ||
+        normalized.includes('达到今日的使用上限') ||
+        normalized.includes('请求过于频繁')) {
+        return 429;
+    }
+    if (normalized.includes('forbidden') ||
+        normalized.includes('permission denied') ||
+        normalized.includes('没有权限') ||
+        normalized.includes('无权限') ||
+        normalized.includes('permission')) {
+        return 403;
+    }
+    if (normalized.includes('unauthorized') ||
+        normalized.includes('invalid token') ||
+        normalized.includes('login') ||
+        normalized.includes('auth') ||
+        normalized.includes('未登录')) {
+        return 401;
+    }
+    return 502;
+}
+function parseQwenUpstreamBusinessErrorFromRaw(rawPayload) {
+    const trimmed = rawPayload.trim();
+    if (!trimmed || trimmed.startsWith('data:')) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!isRecord(parsed)) {
+            return null;
+        }
+        const success = parsed.success;
+        const hasErrorNode = isRecord(parsed.error);
+        const hasCode = Boolean(normalizeInputString(parsed.code));
+        // Only treat as business rejection when payload explicitly signals failure.
+        if (success !== false && !hasErrorNode && !hasCode) {
+            return null;
+        }
+        const reason = extractQwenErrorMessage(parsed) || normalizeInputString(parsed.message) || 'upstream rejected request';
+        const statusCode = inferCreateSessionStatusCode(parsed, reason);
+        const code = statusCode === 429 ? 'QWENCHAT_RATE_LIMITED' : 'QWENCHAT_COMPLETION_REJECTED';
+        return {
+            message: `QwenChat upstream rejected completion request: ${reason}`,
+            statusCode,
+            code
+        };
+    }
+    catch {
+        return null;
+    }
 }
 export async function createQwenChatSession(args) {
     const resp = await fetch(joinUrl(args.baseUrl, DEFAULT_QWENCHAT_CHAT_CREATE_ENDPOINT), {
         method: 'POST',
-        headers: qwenCommonHeaders(args.baxiaTokens, args.authHeaders),
+        headers: qwenCommonHeaders(args.baxiaTokens, args.authHeaders, {
+            baseUrl: args.baseUrl,
+            refererMode: 'guest',
+            acceptMode: 'json'
+        }),
         body: JSON.stringify({
             title: '新建对话',
             models: [args.model],
@@ -803,13 +1173,27 @@ export async function createQwenChatSession(args) {
         err.code = 'QWENCHAT_CREATE_SESSION_FAILED';
         throw err;
     }
+    const chatId = extractChatIdFromCreatePayload(parsed.data);
     const success = parsed.data.success === true;
-    const chatId = success ? extractChatIdFromCreatePayload(parsed.data) : '';
+    if (chatId) {
+        return chatId;
+    }
+    if (parsed.data.success === false) {
+        const reason = extractCreateErrorMessage(parsed.data);
+        const dataNode = isRecord(parsed.data.data) ? parsed.data.data : undefined;
+        const dataKeys = dataNode ? Object.keys(dataNode).slice(0, 8).join(',') : '';
+        const detail = [reason, dataKeys ? `keys=${dataKeys}` : ''].filter(Boolean).join(' ');
+        const suffix = detail ? ` (${detail})` : '';
+        const err = new Error(`Failed to create qwenchat session: upstream rejected request${suffix}`);
+        err.statusCode = inferCreateSessionStatusCode(parsed.data, reason);
+        err.code = 'QWENCHAT_CREATE_SESSION_REJECTED';
+        throw err;
+    }
     if (!chatId) {
         const reason = extractCreateErrorMessage(parsed.data);
         const dataNode = isRecord(parsed.data.data) ? parsed.data.data : undefined;
         const dataKeys = dataNode ? Object.keys(dataNode).slice(0, 8).join(',') : '';
-        const detail = reason || (dataKeys ? `keys=${dataKeys}` : '');
+        const detail = reason || (dataKeys ? `keys=${dataKeys}` : '') || (success ? 'success=true' : '');
         const suffix = detail ? ` (${detail})` : '';
         const err = new Error(`Failed to create qwenchat session: missing chat id${suffix}`);
         err.statusCode = 502;
@@ -819,7 +1203,7 @@ export async function createQwenChatSession(args) {
     return chatId;
 }
 export function buildQwenChatCompletionRequest(args) {
-    return {
+    const request = {
         stream: true,
         version: '2.1',
         incremental_output: true,
@@ -855,6 +1239,10 @@ export function buildQwenChatCompletionRequest(args) {
         ],
         timestamp: Date.now()
     };
+    if (args.chatType === 't2i' && args.imageSize) {
+        request.size = args.imageSize;
+    }
+    return request;
 }
 function extractReasoningContentFromDelta(delta) {
     const direct = normalizeInputString(delta.reasoning_content || delta.reasoning);
@@ -942,30 +1330,6 @@ function createOpenAiChunk(args) {
     }
     return chunk;
 }
-function looksLikeToolMarkupNoise(text) {
-    const normalized = normalizeInputString(text);
-    if (!normalized) {
-        return false;
-    }
-    return (/<\s*\/?\s*function_calls\b/i.test(normalized) ||
-        /<\s*\/?\s*tool_call\b/i.test(normalized) ||
-        /<\s*\/?\s*tool_name\b/i.test(normalized) ||
-        /<\s*\/?\s*arg_key\b/i.test(normalized) ||
-        /<\s*\/?\s*arg_value\b/i.test(normalized) ||
-        /"tool_calls"\s*:/i.test(normalized));
-}
-function sanitizeDeltaForStreamEmit(delta) {
-    const next = { ...delta };
-    const content = normalizeInputString(next.content);
-    if (content && looksLikeToolMarkupNoise(content)) {
-        delete next.content;
-    }
-    const reasoning = normalizeInputString(next.reasoning_content);
-    if (reasoning && looksLikeToolMarkupNoise(reasoning)) {
-        delete next.reasoning_content;
-    }
-    return next;
-}
 function processQwenSsePayloadLines(args) {
     for (const line of args.payload.split('\n')) {
         const trimmed = line.trimStart();
@@ -1001,8 +1365,15 @@ function processQwenSsePayloadLines(args) {
                 if (reasoning)
                     args.collect.reasoningParts.push(reasoning);
             }
+            if (args.collect && deltaNode) {
+                const phase = normalizeInputString(deltaNode.phase);
+                const rawContent = normalizeInputString(deltaNode.content);
+                if (phase === 'image_gen' && /^https?:\/\//i.test(rawContent)) {
+                    args.collect.imageUrls.push(rawContent);
+                }
+            }
             if (delta || finishReason || usage) {
-                const deltaForEmit = delta ? sanitizeDeltaForStreamEmit(delta) : {};
+                const deltaForEmit = delta ? { ...delta } : {};
                 args.onChunk(createOpenAiChunk({
                     id: args.responseId,
                     created: args.created,
@@ -1026,6 +1397,7 @@ export function createOpenAiMappedSseStream(input) {
     let buffer = '';
     const contentParts = [];
     const reasoningParts = [];
+    const imageUrls = [];
     const usageRef = {};
     let lastUpstreamFinishReason = null;
     const writeDone = () => {
@@ -1051,7 +1423,7 @@ export function createOpenAiMappedSseStream(input) {
                     lastUpstreamFinishReason = reason;
                 },
                 includeFinishReason: false,
-                collect: { contentParts, reasoningParts, usageRef },
+                collect: { contentParts, reasoningParts, imageUrls, usageRef },
                 responseId,
                 created,
                 model: input.model
@@ -1060,6 +1432,19 @@ export function createOpenAiMappedSseStream(input) {
     });
     input.upstreamStream.on('end', () => {
         if (buffer.trim()) {
+            const upstreamBusinessError = parseQwenUpstreamBusinessErrorFromRaw(buffer);
+            if (upstreamBusinessError) {
+                output.write(`data: ${JSON.stringify({
+                    error: {
+                        message: upstreamBusinessError.message,
+                        code: upstreamBusinessError.code,
+                        status: upstreamBusinessError.statusCode
+                    }
+                })}\n\n`);
+                writeDone();
+                output.end();
+                return;
+            }
             processQwenSsePayloadLines({
                 payload: buffer,
                 onChunk: (mappedChunk) => {
@@ -1072,13 +1457,17 @@ export function createOpenAiMappedSseStream(input) {
                     lastUpstreamFinishReason = reason;
                 },
                 includeFinishReason: false,
-                collect: { contentParts, reasoningParts, usageRef },
+                collect: { contentParts, reasoningParts, imageUrls, usageRef },
                 responseId,
                 created,
                 model: input.model
             });
         }
-        const harvested = applyStandardizedTextHarvestToChatPayload({
+        const dedupImageUrls = Array.from(new Set(imageUrls));
+        const aggregatedContent = dedupImageUrls.length > 0
+            ? dedupImageUrls.join('\n')
+            : contentParts.join('');
+        const harvested = applyStandardToolTextHarvestToChatPayload({
             id: responseId,
             object: 'chat.completion',
             created,
@@ -1089,7 +1478,7 @@ export function createOpenAiMappedSseStream(input) {
                     finish_reason: 'stop',
                     message: {
                         role: 'assistant',
-                        content: contentParts.join(''),
+                        content: aggregatedContent,
                         ...(reasoningParts.length ? { reasoning_content: reasoningParts.join('') } : {})
                     }
                 }
@@ -1132,6 +1521,7 @@ export function createOpenAiMappedSseStream(input) {
 export async function collectQwenSseAsOpenAiResult(args) {
     const contentParts = [];
     const reasoningParts = [];
+    const imageUrls = [];
     const usageRef = {};
     let buffer = '';
     await new Promise((resolve, reject) => {
@@ -1141,6 +1531,13 @@ export async function collectQwenSseAsOpenAiResult(args) {
         args.upstreamStream.on('end', resolve);
         args.upstreamStream.on('error', reject);
     });
+    const upstreamBusinessError = parseQwenUpstreamBusinessErrorFromRaw(buffer);
+    if (upstreamBusinessError) {
+        const err = new Error(upstreamBusinessError.message);
+        err.statusCode = upstreamBusinessError.statusCode;
+        err.code = upstreamBusinessError.code;
+        throw err;
+    }
     processQwenSsePayloadLines({
         payload: buffer,
         onChunk: () => {
@@ -1149,11 +1546,15 @@ export async function collectQwenSseAsOpenAiResult(args) {
         onDone: () => {
             // no-op in aggregate mode
         },
-        collect: { contentParts, reasoningParts, usageRef },
+        collect: { contentParts, reasoningParts, imageUrls, usageRef },
         responseId: `chatcmpl-${randomUUID()}`,
         created: Math.floor(Date.now() / 1000),
         model: args.model
     });
+    const dedupImageUrls = Array.from(new Set(imageUrls));
+    const aggregatedContent = dedupImageUrls.length > 0
+        ? dedupImageUrls.join('\n')
+        : contentParts.join('');
     const result = {
         id: `chatcmpl-${randomUUID()}`,
         object: 'chat.completion',
@@ -1164,7 +1565,7 @@ export async function collectQwenSseAsOpenAiResult(args) {
                 index: 0,
                 message: {
                     role: 'assistant',
-                    content: contentParts.join(''),
+                    content: aggregatedContent,
                     ...(reasoningParts.length ? { reasoning_content: reasoningParts.join('') } : {})
                 },
                 finish_reason: 'stop'
@@ -1174,7 +1575,22 @@ export async function collectQwenSseAsOpenAiResult(args) {
     if (usageRef.usage) {
         result.usage = usageRef.usage;
     }
-    return applyStandardizedTextHarvestToChatPayload(result);
+    const harvested = applyStandardToolTextHarvestToChatPayload(result);
+    const firstChoice = Array.isArray(harvested.choices) && harvested.choices.length > 0 && isRecord(harvested.choices[0])
+        ? harvested.choices[0]
+        : undefined;
+    const messageNode = firstChoice && isRecord(firstChoice.message) ? firstChoice.message : undefined;
+    const finishReason = normalizeInputString(firstChoice?.finish_reason) || 'stop';
+    const content = normalizeInputString(messageNode?.content);
+    const reasoning = normalizeInputString(messageNode?.reasoning_content);
+    const toolCalls = messageNode && Array.isArray(messageNode.tool_calls) ? messageNode.tool_calls : [];
+    if (finishReason === 'stop' && !content && !reasoning && toolCalls.length === 0) {
+        const err = new Error('QwenChat upstream returned an empty assistant message');
+        err.statusCode = 502;
+        err.code = 'QWENCHAT_EMPTY_ASSISTANT';
+        throw err;
+    }
+    return harvested;
 }
 export async function buildQwenChatSendPlan(input) {
     const normalizedPayload = applyStandardToolTextRequest(input.payload);
@@ -1184,7 +1600,12 @@ export async function buildQwenChatSendPlan(input) {
         err.code = 'QWENCHAT_INVALID_REQUEST';
         throw err;
     }
-    const chatType = shouldUseSearchMode(normalizedPayload) ? 'search' : 't2t';
+    const imageGenOptions = parseQwenImageGenerationOptions(normalizedPayload.metadata);
+    const chatType = shouldUseImageGenerationMode(normalizedPayload)
+        ? 't2i'
+        : shouldUseSearchMode(normalizedPayload)
+            ? 'search'
+            : 't2t';
     const chatId = await createQwenChatSession({
         baseUrl: input.baseUrl,
         model: normalizedPayload.model,
@@ -1193,6 +1614,9 @@ export async function buildQwenChatSendPlan(input) {
         authHeaders: input.authHeaders
     });
     const parsedMessages = parseIncomingMessages(normalizedPayload.messages);
+    const finalContent = chatType === 't2i' && imageGenOptions.count > 1
+        ? `${parsedMessages.content}\n\n(Generate ${imageGenOptions.count} images.)`
+        : parsedMessages.content;
     const uploaded = parsedMessages.attachments.length
         ? await uploadAttachments({
             baseUrl: input.baseUrl,
@@ -1204,14 +1628,18 @@ export async function buildQwenChatSendPlan(input) {
     const completionBody = buildQwenChatCompletionRequest({
         chatId,
         model: normalizedPayload.model,
-        content: parsedMessages.content,
+        content: finalContent,
         uploadedFiles: uploaded.files,
-        chatType
+        chatType,
+        ...(chatType === 't2i' ? { imageSize: imageGenOptions.sizeRatio } : {})
     });
     const completionHeaders = {
-        ...qwenCommonHeaders(input.baxiaTokens, input.authHeaders),
-        version: '0.2.9',
-        Referer: `${input.baseUrl.replace(/\/$/, '')}/c/guest`
+        ...qwenCommonHeaders(input.baxiaTokens, input.authHeaders, {
+            baseUrl: input.baseUrl,
+            refererMode: 'guest',
+            acceptMode: 'json'
+        }),
+        version: '0.2.9'
     };
     return {
         completionUrl: `${joinUrl(input.baseUrl, DEFAULT_QWENCHAT_COMPLETION_ENDPOINT)}?chat_id=${encodeURIComponent(chatId)}`,
@@ -1223,29 +1651,27 @@ function applyStandardToolTextRequest(payload) {
     if (!Array.isArray(payload.tools) || payload.tools.length === 0) {
         return payload;
     }
-    try {
-        const transformed = applyStandardToolTextRequestTransform({
-            model: payload.model,
-            messages: payload.messages,
-            tools: payload.tools,
-            metadata: payload.metadata
-        }, {
-            providerProtocol: 'openai-chat',
-            entryEndpoint: '/v1/chat/completions'
-        });
-        const prompt = normalizeInputString(transformed.prompt);
-        if (!prompt) {
-            return payload;
-        }
-        return {
-            ...payload,
-            messages: [{ role: 'user', content: prompt }],
-            tools: undefined
-        };
-    }
-    catch {
-        return payload;
+    const transformed = applyStandardToolTextRequestTransform({
+        model: payload.model,
+        messages: payload.messages,
+        tools: payload.tools,
+        metadata: payload.metadata
+    }, {
+        providerProtocol: 'openai-chat',
+        entryEndpoint: '/v1/chat/completions'
+    });
+    const prompt = normalizeInputString(transformed.prompt);
+    if (!prompt) {
+        const err = new Error('QwenChat tool-text transform failed: prompt is empty');
+        err.statusCode = 422;
+        err.code = 'QWENCHAT_TOOL_TEXT_TRANSFORM_FAILED';
+        throw err;
     }
+    return {
+        ...payload,
+        messages: [{ role: 'user', content: prompt }],
+        tools: undefined
+    };
 }
 export function extractForwardAuthHeaders(headers) {
     const out = {};
@@ -1269,13 +1695,4 @@ export function classifyQwenChatProviderIdentity(input) {
         value.includes('qwenchat') ||
         value === 'chat:qwenchat-web');
 }
-function applyStandardizedTextHarvestToChatPayload(payload) {
-    try {
-        const harvested = processChatResponseTools(payload);
-        return isRecord(harvested) ? harvested : payload;
-    }
-    catch {
-        return payload;
-    }
-}
 //# sourceMappingURL=qwenchat-http-provider-helpers.js.map