hazo_llm_api 1.0.4 → 1.0.5

package/dist/lib/providers/qwen/qwen_client.js

@@ -0,0 +1,1002 @@
+/**
+ * Qwen API Client Module
+ *
+ * Handles communication with Alibaba Cloud DashScope Qwen API.
+ * Uses OpenAI-compatible chat completions endpoint.
+ */
+// =============================================================================
+// Qwen API Client
+// =============================================================================
+/**
+ * Call the Qwen API with messages and optional image data
+ * @param api_url - The Qwen API endpoint URL
+ * @param api_key - The API key for authentication
+ * @param model - The model name to use
+ * @param messages - Array of messages (system + user)
+ * @param logger - Logger instance
+ * @param generation_config - Optional generation configuration parameters
+ * @returns LLM response with generated text or error
+ */
+export async function call_qwen_api(api_url, api_key, model, messages, logger, generation_config) {
+    const file_name = 'qwen_client.ts';
+    try {
+        // Build the request body
+        const request_body = {
+            model,
+            messages,
+        };
+        // Add generation config parameters if provided
+        if (generation_config) {
+            if (generation_config.temperature !== undefined) {
+                request_body.temperature = generation_config.temperature;
+            }
+            if (generation_config.max_tokens !== undefined) {
+                request_body.max_tokens = generation_config.max_tokens;
+            }
+            if (generation_config.top_p !== undefined) {
+                request_body.top_p = generation_config.top_p;
+            }
+            if (generation_config.top_k !== undefined) {
+                request_body.top_k = generation_config.top_k;
+            }
+            if (generation_config.n !== undefined) {
+                request_body.n = generation_config.n;
+            }
+            if (generation_config.stop !== undefined && generation_config.stop.length > 0) {
+                request_body.stop = generation_config.stop;
+            }
+            if (generation_config.presence_penalty !== undefined) {
+                request_body.presence_penalty = generation_config.presence_penalty;
+            }
+            if (generation_config.frequency_penalty !== undefined) {
+                request_body.frequency_penalty = generation_config.frequency_penalty;
+            }
+        }
+        // Log the API call
+        logger.debug('Calling Qwen API', {
+            file: file_name,
+            line: 125,
+            data: {
+                api_url,
+                model,
+                message_count: messages.length,
+                has_generation_config: !!generation_config,
+                generation_config: generation_config || 'none (using defaults)',
+            },
+        });
+        // Make the API request
+        const response = await fetch(api_url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${api_key}`,
+            },
+            body: JSON.stringify(request_body),
+        });
+        // Parse the response
+        const response_data = await response.json();
+        // Check for errors
+        if (!response.ok || response_data.error) {
+            const error_message = response_data.error?.message || `HTTP ${response.status}`;
+            logger.error('Qwen API returned error', {
+                file: file_name,
+                line: 152,
+                data: {
+                    status: response.status,
+                    error: response_data.error,
+                    request_model: model,
+                },
+            });
+            return {
+                success: false,
+                error: error_message,
+                raw_response: response_data,
+            };
+        }
+        // Extract the generated text from response
+        const generated_text = extract_text_from_response(response_data, logger);
+        if (generated_text) {
+            return {
+                success: true,
+                text: generated_text,
+                raw_response: response_data,
+            };
+        }
+        else {
+            logger.warn('No text content in Qwen response', {
+                file: file_name,
+                line: 177,
+                data: { raw_response: response_data },
+            });
+            return {
+                success: false,
+                error: 'No text content in response',
+                raw_response: response_data,
+            };
+        }
+    }
+    catch (error) {
+        const error_message = error instanceof Error ? error.message : String(error);
+        logger.error('Failed to call Qwen API', {
+            file: file_name,
+            line: 188,
+            data: { error: error_message, model },
+        });
+        return {
+            success: false,
+            error: error_message,
+        };
+    }
+}
+// =============================================================================
+// Response Parsing Functions
+// =============================================================================
+/**
+ * Extract text content from Qwen API response
+ * @param response - The Qwen API response
+ * @param logger - Logger instance
+ * @returns The generated text or null if not found
+ */
+function extract_text_from_response(response, logger) {
+    const file_name = 'qwen_client.ts';
+    if (!response.choices || response.choices.length === 0) {
+        logger.debug('No choices in Qwen response', {
+            file: file_name,
+            line: 210,
+        });
+        return null;
+    }
+    const first_choice = response.choices[0];
+    if (!first_choice.message || !first_choice.message.content) {
+        logger.debug('No message content in first choice', {
+            file: file_name,
+            line: 218,
+        });
+        return null;
+    }
+    return first_choice.message.content;
+}
+/**
+ * Get the default Qwen API URL
+ * @returns The default DashScope API URL
+ */
+export function get_qwen_api_url() {
+    return 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions';
+}
+/**
+ * Get the DashScope image generation API URL
+ * @param model - The model name (e.g., qwen-image-plus)
+ * @returns The DashScope image generation API URL
+ */
+export function get_qwen_image_api_url(model) {
+    // DashScope image generation endpoint format
+    // Try the standard text-to-image endpoint first
+    return 'https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/text2image/image-synthesis';
+}
+/**
+ * Get the DashScope image editing API URL
+ * @param model - The model name (e.g., qwen-image-edit)
+ * @returns The DashScope image editing API URL
+ */
+export function get_qwen_image_edit_api_url(model) {
+    // DashScope image editing uses MultiModalConversation API
+    // Uses the same chat completions endpoint as other multimodal operations
+    return 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions';
+}
+/**
+ * Build Qwen messages array from prompt and optional images
+ * @param prompt - The text prompt
+ * @param system_instruction - Optional system instruction
+ * @param b64_data - Optional array of base64 encoded images
+ * @returns Array of Qwen messages
+ */
+export function build_qwen_messages(prompt, system_instruction, b64_data) {
+    const messages = [];
+    // Add system message if provided
+    if (system_instruction) {
+        messages.push({
+            role: 'system',
+            content: system_instruction,
+        });
+    }
+    // Build user message content
+    if (b64_data && b64_data.length > 0) {
+        // Multi-modal message with images
+        const content = [];
+        // Add images first
+        for (const img of b64_data) {
+            content.push({
+                type: 'image_url',
+                image_url: {
+                    url: `data:${img.mime_type};base64,${img.data}`,
+                },
+            });
+        }
+        // Add text prompt
+        content.push({
+            type: 'text',
+            text: prompt,
+        });
+        messages.push({
+            role: 'user',
+            content,
+        });
+    }
+    else {
+        // Text-only message
+        messages.push({
+            role: 'user',
+            content: prompt,
+        });
+    }
+    return messages;
+}
+/**
+ * Call the DashScope image generation API
+ * @param api_url - The DashScope image generation API endpoint URL
+ * @param api_key - The API key for authentication
+ * @param model - The model name to use (e.g., qwen-image-plus)
+ * @param prompt - The text prompt for image generation
+ * @param logger - Logger instance
+ * @param generation_config - Optional generation configuration parameters
+ * @returns LLM response with generated image or error
+ */
+export async function call_qwen_image_api(api_url, api_key, model, prompt, logger, generation_config) {
+    const file_name = 'qwen_client.ts';
+    try {
+        // Build the request body for image generation
+        // DashScope image generation API format
+        // Allowed sizes: 1664*928, 1472*1140, 1328*1328, 1140*1472, 928*1664
+        const request_body = {
+            model,
+            input: {
+                prompt,
+            },
+            parameters: {
+                // Use square format as default (1328*1328)
+                size: '1328*1328',
+            },
+        };
+        // Add generation config parameters if provided
+        // Note: DashScope image generation may support different parameters
+        // For now, we'll use basic parameters
+        if (generation_config) {
+            const params = {};
+            if (generation_config.n !== undefined) {
+                params.n = generation_config.n;
+            }
+            // Add other parameters as needed for image generation
+            if (Object.keys(params).length > 0) {
+                request_body.parameters = params;
+            }
+        }
+        // Log the API call
+        logger.debug('Calling DashScope image generation API', {
+            file: file_name,
+            line: 380,
+            data: {
+                api_url,
+                model,
+                prompt_length: prompt.length,
+                has_generation_config: !!generation_config,
+            },
+        });
+        // Make the API request
+        // DashScope image generation requires async mode
+        const response = await fetch(api_url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${api_key}`,
+                'X-DashScope-Async': 'enable', // Enable async mode
+            },
+            body: JSON.stringify(request_body),
+        });
+        let parsed_response;
+        const response_text = await response.text();
+        try {
+            parsed_response = JSON.parse(response_text);
+            // Log the initial response to see what we get
+            logger.debug('DashScope image generation initial response', {
+                file: file_name,
+                line: 450,
+                data: {
+                    status: response.status,
+                    response_preview: response_text.substring(0, 1000),
+                },
+            });
+        }
+        catch {
+            // If not JSON, use the text as error message
+            parsed_response = { error: { message: response_text } };
+        }
+        // Check for errors
+        if (!response.ok || parsed_response.error || parsed_response.code) {
+            const error_message = parsed_response.error?.message ||
+                parsed_response.message ||
+                `HTTP ${response.status}: ${response_text.substring(0, 500)}`;
+            logger.error('DashScope image generation API returned error', {
+                file: file_name,
+                line: 420,
+                data: {
+                    status: response.status,
+                    status_text: response.statusText,
+                    error: parsed_response.error,
+                    code: parsed_response.code,
+                    message: parsed_response.message,
+                    request_model: model,
+                    request_body: JSON.stringify(request_body),
+                    full_response: response_text.substring(0, 1000), // Limit to first 1000 chars
+                },
+            });
+            return {
+                success: false,
+                error: error_message,
+                raw_response: parsed_response,
+            };
+        }
+        // Handle async task - if task_id is returned, we need to poll for results
+        const task_id = parsed_response.output?.task_id || parsed_response.task_id;
+        if (task_id && !parsed_response.output?.results) {
+            // Async mode - poll for results
+            logger.info('DashScope returned async task_id, polling for results', {
+                file: file_name,
+                line: 440,
+                data: { task_id },
+            });
+            // Poll the task status endpoint
+            // DashScope uses: /api/v1/tasks/{task_id}
+            const status_url = `https://dashscope-intl.aliyuncs.com/api/v1/tasks/${task_id}`;
+            let attempts = 0;
+            const max_attempts = 60; // Poll for up to 60 seconds (image generation can take time)
+            while (attempts < max_attempts) {
+                await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2 seconds between polls
+                const status_response = await fetch(status_url, {
+                    headers: {
+                        'Authorization': `Bearer ${api_key}`,
+                    },
+                });
+                if (!status_response.ok) {
+                    const error_text = await status_response.text();
+                    logger.warn('Task status check failed', {
+                        file: file_name,
+                        line: 510,
+                        data: { status: status_response.status, error: error_text },
+                    });
+                    attempts++;
+                    continue;
+                }
+                const status_data_raw = await status_response.json();
+                const status_data = status_data_raw;
+                // Check task status FIRST - if it's "FAILED" or "CANCELED", return error immediately
+                const task_status = status_data_raw.output?.task_status ||
+                    status_data_raw.task_status ||
+                    status_data_raw.status;
+                // Log the status response for debugging (less frequently to reduce log noise)
+                if (attempts % 5 === 0 || task_status === 'FAILED' || task_status === 'SUCCEEDED') {
+                    logger.debug('Polling task status response', {
+                        file: file_name,
+                        line: 530,
+                        data: {
+                            task_id,
+                            attempt: attempts + 1,
+                            max_attempts,
+                            response_status: status_response.status,
+                            task_status,
+                            response_data: JSON.stringify(status_data_raw).substring(0, 500), // First 500 chars
+                        },
+                    });
+                }
+                // Check for FAILED or CANCELED status immediately
+                if (task_status === 'FAILED' || task_status === 'CANCELED') {
+                    // Extract error message from output if available
+                    const output = status_data_raw.output;
+                    const error_msg = output?.message ||
+                        status_data.error?.message ||
+                        status_data.message ||
+                        `Task ${task_status.toLowerCase()}`;
+                    logger.error('Image generation task failed', {
+                        file: file_name,
+                        line: 545,
+                        data: { task_id, task_status, error_code: output?.code, error_message: error_msg },
+                    });
+                    return {
+                        success: false,
+                        error: error_msg,
+                        raw_response: status_data,
+                    };
+                }
+                // Check if task is complete and has results
+                // DashScope may return results in different structures
+                if (status_data.output?.results && status_data.output.results.length > 0) {
+                    // Results are ready
+                    parsed_response.output = status_data.output;
+                    break;
+                }
+                // Also check for direct results in response (some API versions)
+                if (status_data_raw.results &&
+                    Array.isArray(status_data_raw.results) &&
+                    status_data_raw.results.length > 0) {
+                    parsed_response.output = {
+                        results: status_data_raw.results,
+                    };
+                    break;
+                }
+                // If task is SUCCEEDED but no results yet, continue polling
+                if (task_status === 'SUCCEEDED') {
+                    // Results should be available, but if not, continue polling
+                    attempts++;
+                    continue;
+                }
+                // Check for task failure in error fields
+                if (status_data.error || status_data.code) {
+                    const error_msg = status_data.error?.message || status_data.message || 'Task failed';
+                    return {
+                        success: false,
+                        error: error_msg,
+                        raw_response: status_data,
+                    };
+                }
+                // If task is still PENDING or RUNNING, continue polling
+                if (task_status === 'PENDING' || task_status === 'RUNNING' || !task_status) {
+                    attempts++;
+                    continue;
+                }
+                // Default: continue polling
+                attempts++;
+            }
+            if (attempts >= max_attempts) {
+                return {
+                    success: false,
+                    error: 'Image generation timed out - task did not complete in time',
+                    raw_response: parsed_response,
+                };
+            }
+        }
+        // Extract image URL from response
+        const results = parsed_response.output?.results;
+        if (results && results.length > 0 && results[0].url) {
+            // Fetch the image from the URL and convert to base64
+            const image_url = results[0].url;
+            const image_response = await fetch(image_url);
+            if (!image_response.ok) {
+                return {
+                    success: false,
+                    error: `Failed to fetch generated image: HTTP ${image_response.status}`,
+                };
+            }
+            const image_array_buffer = await image_response.arrayBuffer();
+            // Convert ArrayBuffer to base64 in chunks to avoid stack overflow
+            const uint8_array = new Uint8Array(image_array_buffer);
+            const chunk_size = 8192; // Process in 8KB chunks
+            let binary_string = '';
+            for (let i = 0; i < uint8_array.length; i += chunk_size) {
+                const chunk = uint8_array.slice(i, i + chunk_size);
+                binary_string += String.fromCharCode(...chunk);
+            }
+            const image_base64 = btoa(binary_string);
+            // Get content type from response headers
+            const content_type = image_response.headers.get('content-type') || 'image/png';
+            return {
+                success: true,
+                image_b64: image_base64,
+                image_mime_type: content_type,
+                raw_response: parsed_response,
+            };
+        }
+        logger.warn('No image URL in DashScope response', {
+            file: file_name,
+            line: 470,
+            data: { raw_response: parsed_response },
+        });
+        return {
+            success: false,
+            error: 'No image URL in response',
+            raw_response: parsed_response,
+        };
+    }
+    catch (error) {
+        const error_message = error instanceof Error ? error.message : String(error);
+        logger.error('Failed to call DashScope image generation API', {
+            file: file_name,
+            line: 480,
+            data: { error: error_message, model },
+        });
+        return {
+            success: false,
+            error: error_message,
+        };
+    }
+}
+/**
+ * Call the DashScope image editing API
+ * @param api_url - The DashScope image editing API endpoint URL
+ * @param api_key - The API key for authentication
+ * @param model - The model name to use (e.g., qwen-image-edit)
+ * @param prompt - The text prompt describing the transformation
+ * @param input_images - Array of base64 encoded input images with mime types (1-3 images supported)
+ * @param logger - Logger instance
+ * @param generation_config - Optional generation configuration parameters
+ * @returns LLM response with edited image or error
+ */
+export async function call_qwen_image_edit_api(api_url, api_key, model, prompt, input_images, logger, generation_config) {
+    const file_name = 'qwen_client.ts';
+    try {
+        // Check if this is the multimodal generation endpoint (different format)
+        const is_multimodal_endpoint = api_url.includes('/multimodal-generation/');
+        let request_body;
+        if (is_multimodal_endpoint) {
+            // Multimodal generation endpoint uses input format with images array
+            // Support multiple images (1-3 images as per API requirements)
+            const content = [];
+            // Add all images first
+            for (const img of input_images) {
+                content.push({
+                    image: `data:${img.mime_type};base64,${img.data}`,
+                });
+            }
+            // Add text prompt after images
+            content.push({
+                text: prompt,
+            });
+            request_body = {
+                model,
+                input: {
+                    messages: [
+                        {
+                            role: 'user',
+                            content,
+                        },
+                    ],
+                },
+                parameters: {
+                    result_format: 'message',
+                },
+            };
+        }
+        else {
+            // Chat completions endpoint uses messages format
+            // Support multiple images
+            const messages = build_qwen_messages(prompt, undefined, input_images);
+            request_body = {
+                model,
+                messages,
+                result_format: 'message', // Required for multimodal responses with images
+                stream: false, // Disable streaming for image editing
+            };
+        }
+        // Add generation config parameters if provided
+        if (generation_config) {
+            if (is_multimodal_endpoint) {
+                // For multimodal endpoint, add to parameters object
+                const params = request_body.parameters;
+                if (generation_config.temperature !== undefined) {
+                    params.temperature = generation_config.temperature;
+                }
+                if (generation_config.max_tokens !== undefined) {
+                    params.max_tokens = generation_config.max_tokens;
+                }
+                if (generation_config.top_p !== undefined) {
+                    params.top_p = generation_config.top_p;
+                }
+                if (generation_config.top_k !== undefined) {
+                    params.top_k = generation_config.top_k;
+                }
+            }
+            else {
+                // For chat completions endpoint, add to root
+                if (generation_config.temperature !== undefined) {
+                    request_body.temperature = generation_config.temperature;
+                }
+                if (generation_config.max_tokens !== undefined) {
+                    request_body.max_tokens = generation_config.max_tokens;
+                }
+                if (generation_config.top_p !== undefined) {
+                    request_body.top_p = generation_config.top_p;
+                }
+                if (generation_config.top_k !== undefined) {
+                    request_body.top_k = generation_config.top_k;
+                }
+                if (generation_config.n !== undefined) {
+                    request_body.n = generation_config.n;
+                }
+                if (generation_config.stop !== undefined && generation_config.stop.length > 0) {
+                    request_body.stop = generation_config.stop;
+                }
+                if (generation_config.presence_penalty !== undefined) {
+                    request_body.presence_penalty = generation_config.presence_penalty;
+                }
+                if (generation_config.frequency_penalty !== undefined) {
+                    request_body.frequency_penalty = generation_config.frequency_penalty;
+                }
+            }
+        }
+        // Log the API call
+        logger.debug('Calling DashScope image editing API', {
+            file: file_name,
+            line: 730,
+            data: {
+                api_url,
+                model,
+                prompt_length: prompt.length,
+                image_count: input_images.length,
+                image_mime_types: input_images.map(img => img.mime_type),
+                has_generation_config: !!generation_config,
+            },
+        });
+        // Make the API request
+        // DashScope image editing uses chat completions endpoint
+        const response = await fetch(api_url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${api_key}`,
+            },
+            body: JSON.stringify(request_body),
+        });
+        // Parse the response - handle both chat completions and multimodal generation formats
+        const raw_response = await response.json();
+        // Log the initial response
+        logger.debug('DashScope image editing initial response', {
+            file: file_name,
+            line: 854,
+            data: {
+                status: response.status,
+                response_preview: JSON.stringify(raw_response).substring(0, 1000),
+            },
+        });
+        // Check for errors (handle both response formats)
+        // For multimodal endpoint, successful responses have 'output' field, errors have 'error' or 'code' field
+        if (!response.ok) {
+            // HTTP error status
+            const error_data = raw_response.error;
+            const error_message = error_data?.message ||
+                raw_response?.message ||
+                `HTTP ${response.status}`;
+            logger.error('DashScope image editing API returned HTTP error', {
+                file: file_name,
+                line: 870,
+                data: {
+                    status: response.status,
+                    error: error_data,
+                    request_model: model,
+                },
+            });
+            return {
+                success: false,
+                error: error_message,
+                raw_response: raw_response,
+            };
+        }
+        // Check for API-level errors in response body
+        // Only check for actual error fields, not the entire response object
+        const error_field = raw_response.error;
+        const error_code = raw_response.code;
+        const has_error = error_field !== undefined || (error_code !== undefined && error_code !== '200' && error_code !== 'Success');
+        if (has_error) {
+            const error_message = error_field?.message ||
+                raw_response?.message ||
+                `API returned error code: ${error_code}`;
+            logger.error('DashScope image editing API returned error', {
+                file: file_name,
+                line: 895,
+                data: {
+                    status: response.status,
+                    error: error_field || { code: error_code, message: raw_response?.message },
+                    request_model: model,
+                },
+            });
+            return {
+                success: false,
+                error: error_message,
+                raw_response: raw_response,
+            };
+        }
+        // Handle multimodal generation endpoint response format (wraps in output object)
+        let response_data;
+        let raw_response_data = raw_response;
+        if (is_multimodal_endpoint && raw_response.output) {
+            // Multimodal generation endpoint wraps response in output object
+            const multimodal_response = raw_response;
+            response_data = multimodal_response.output;
+            raw_response_data = multimodal_response; // Keep full response for logging
+        }
+        else {
+            // Chat completions format (direct response)
+            response_data = raw_response;
+        }
+        // Extract image from response
+        // For image editing, the response content may contain image URLs or base64 data
+        if (!response_data.choices || response_data.choices.length === 0) {
+            logger.warn('No choices in DashScope image editing response', {
+                file: file_name,
+                line: 843,
+                data: {
+                    raw_response: response_data,
+                    response_keys: Object.keys(response_data || {}),
+                    full_response: JSON.stringify(response_data, null, 2).substring(0, 2000),
+                },
+            });
+            return {
+                success: false,
+                error: 'No content in response - API returned no choices. Check logs for full response details.',
+                raw_response: response_data,
+            };
+        }
+        const first_choice = response_data.choices[0];
+        const content = first_choice.message?.content;
+        if (!content) {
+            logger.warn('No content in first choice', {
+                file: file_name,
+                line: 920,
+                data: {
+                    raw_response: response_data,
+                    first_choice: first_choice,
+                    message: first_choice.message,
+                    full_response: JSON.stringify(response_data, null, 2).substring(0, 2000),
+                },
+            });
+            return {
+                success: false,
+                error: 'No content in response - message has no content. Check logs for full response details.',
+                raw_response: response_data,
+            };
+        }
+        // Handle multimodal generation endpoint format - content is array with {image: "url"} objects
+        if (Array.isArray(content)) {
+            const content_array = content;
+            for (const item of content_array) {
+                // Check for multimodal format: {image: "url"} (multimodal generation endpoint)
+                if (item.image && typeof item.image === 'string') {
+                    const image_url = item.image;
+                    try {
+                        const image_response = await fetch(image_url);
+                        if (!image_response.ok) {
+                            return {
+                                success: false,
+                                error: `Failed to fetch edited image: HTTP ${image_response.status}`,
+                            };
+                        }
+                        const image_array_buffer = await image_response.arrayBuffer();
+                        const uint8_array = new Uint8Array(image_array_buffer);
+                        const chunk_size = 8192;
+                        let binary_string = '';
+                        for (let i = 0; i < uint8_array.length; i += chunk_size) {
+                            const chunk = uint8_array.slice(i, i + chunk_size);
+                            binary_string += String.fromCharCode(...chunk);
+                        }
+                        const image_base64 = btoa(binary_string);
+                        const content_type = image_response.headers.get('content-type') || 'image/png';
+                        return {
+                            success: true,
+                            image_b64: image_base64,
+                            image_mime_type: content_type,
+                            raw_response: response_data,
+                        };
+                    }
+                    catch (fetch_error) {
+                        logger.error('Failed to fetch image from URL', {
+                            file: file_name,
+                            line: 960,
+                            data: { error: fetch_error instanceof Error ? fetch_error.message : String(fetch_error), url: image_url },
+                        });
+                        return {
+                            success: false,
+                            error: 'Failed to fetch image from URL in response',
+                            raw_response: response_data,
+                        };
+                    }
+                }
+                // Check for chat completions format: {image_url: {url: "..."}}
+                if (item.image_url?.url) {
+                    const image_url = item.image_url.url;
+                    // Handle data URLs
+                    if (image_url.startsWith('data:')) {
+                        const base64_match = image_url.match(/data:image\/([^;]+);base64,([A-Za-z0-9+/=]+)/);
+                        if (base64_match) {
+                            const mime_type = `image/${base64_match[1]}`;
+                            const base64_data = base64_match[2];
+                            return {
+                                success: true,
+                                image_b64: base64_data,
+                                image_mime_type: mime_type,
+                                raw_response: response_data,
+                            };
+                        }
+                    }
+                    else {
+                        // Fetch from URL
+                        try {
+                            const image_response = await fetch(image_url);
+                            if (!image_response.ok) {
+                                return {
+                                    success: false,
+                                    error: `Failed to fetch edited image: HTTP ${image_response.status}`,
+                                };
+                            }
+                            const image_array_buffer = await image_response.arrayBuffer();
+                            const uint8_array = new Uint8Array(image_array_buffer);
+                            const chunk_size = 8192;
+                            let binary_string = '';
+                            for (let i = 0; i < uint8_array.length; i += chunk_size) {
+                                const chunk = uint8_array.slice(i, i + chunk_size);
+                                binary_string += String.fromCharCode(...chunk);
+                            }
+                            const image_base64 = btoa(binary_string);
+                            const content_type = image_response.headers.get('content-type') || 'image/png';
+                            return {
+                                success: true,
+                                image_b64: image_base64,
+                                image_mime_type: content_type,
+                                raw_response: response_data,
+                            };
+                        }
+                        catch (fetch_error) {
+                            logger.error('Failed to fetch image from URL', {
+                                file: file_name,
+                                line: 1000,
+                                data: { error: fetch_error instanceof Error ? fetch_error.message : String(fetch_error), url: image_url },
+                            });
+                            return {
+                                success: false,
+                                error: 'Failed to fetch image from URL in response',
+                                raw_response: response_data,
+                            };
+                        }
+                    }
+                }
+            }
+        }
+        // Check if content is a string (might contain image URL or base64)
+        if (typeof content === 'string') {
+            // Try to extract image URL or base64 from content
+            // Image URLs typically start with http:// or https://
+            const url_match = content.match(/https?:\/\/[^\s]+/);
+            if (url_match) {
+                const image_url = url_match[0];
+                try {
+                    const image_response = await fetch(image_url);
+                    if (!image_response.ok) {
+                        return {
+                            success: false,
+                            error: `Failed to fetch edited image: HTTP ${image_response.status}`,
+                        };
+                    }
+                    const image_array_buffer = await image_response.arrayBuffer();
+                    const uint8_array = new Uint8Array(image_array_buffer);
+                    const chunk_size = 8192;
+                    let binary_string = '';
+                    for (let i = 0; i < uint8_array.length; i += chunk_size) {
+                        const chunk = uint8_array.slice(i, i + chunk_size);
+                        binary_string += String.fromCharCode(...chunk);
+                    }
+                    const image_base64 = btoa(binary_string);
+                    const content_type = image_response.headers.get('content-type') || 'image/png';
+                    return {
+                        success: true,
+                        image_b64: image_base64,
+                        image_mime_type: content_type,
+                        raw_response: response_data,
+                    };
+                }
+                catch (fetch_error) {
+                    logger.error('Failed to fetch image from URL', {
+                        file: file_name,
+                        line: 890,
+                        data: { error: fetch_error instanceof Error ? fetch_error.message : String(fetch_error), url: image_url },
+                    });
+                    return {
+                        success: false,
+                        error: 'Failed to fetch image from URL in response',
+                        raw_response: response_data,
+                    };
+                }
+            }
+            // Check if content contains base64 image data
+            const base64_match = content.match(/data:image\/([^;]+);base64,([A-Za-z0-9+/=]+)/);
+            if (base64_match) {
+                const mime_type = `image/${base64_match[1]}`;
+                const base64_data = base64_match[2];
+                return {
+                    success: true,
+                    image_b64: base64_data,
+                    image_mime_type: mime_type,
+                    raw_response: response_data,
+                };
+            }
+            // If no image found, return text response
+            return {
+                success: true,
+                text: content,
+                raw_response: response_data,
+            };
+        }
+        // If content is an array (multimodal), look for image_url
+        if (Array.isArray(content)) {
+            const content_array = content;
+            for (const item of content_array) {
+                if (item.type === 'image_url' && item.image_url?.url) {
+                    const image_url = item.image_url.url;
+                    // Handle data URLs
+                    if (image_url.startsWith('data:')) {
+                        const base64_match = image_url.match(/data:image\/([^;]+);base64,([A-Za-z0-9+/=]+)/);
+                        if (base64_match) {
+                            const mime_type = `image/${base64_match[1]}`;
+                            const base64_data = base64_match[2];
+                            return {
+                                success: true,
+                                image_b64: base64_data,
+                                image_mime_type: mime_type,
+                                raw_response: response_data,
+                            };
+                        }
+                    }
+                    else {
+                        // Fetch from URL
+                        try {
+                            const image_response = await fetch(image_url);
+                            if (!image_response.ok) {
+                                return {
+                                    success: false,
+                                    error: `Failed to fetch edited image: HTTP ${image_response.status}`,
+                                };
+                            }
+                            const image_array_buffer = await image_response.arrayBuffer();
+                            const uint8_array = new Uint8Array(image_array_buffer);
+                            const chunk_size = 8192;
+                            let binary_string = '';
+                            for (let i = 0; i < uint8_array.length; i += chunk_size) {
+                                const chunk = uint8_array.slice(i, i + chunk_size);
+                                binary_string += String.fromCharCode(...chunk);
+                            }
+                            const image_base64 = btoa(binary_string);
+                            const content_type = image_response.headers.get('content-type') || 'image/png';
+                            return {
+                                success: true,
+                                image_b64: image_base64,
+                                image_mime_type: content_type,
+                                raw_response: response_data,
+                            };
+                        }
+                        catch (fetch_error) {
+                            logger.error('Failed to fetch image from URL', {
+                                file: file_name,
+                                line: 950,
+                                data: { error: fetch_error instanceof Error ? fetch_error.message : String(fetch_error), url: image_url },
+                            });
+                            return {
+                                success: false,
+                                error: 'Failed to fetch image from URL in response',
+                                raw_response: response_data,
+                            };
+                        }
+                    }
+                }
+            }
+        }
+        // If we get here, no image was found
+        logger.warn('No image found in DashScope image editing response', {
+            file: file_name,
+            line: 960,
+            data: { raw_response: response_data },
+        });
+        return {
+            success: false,
+            error: 'No image found in response',
+            raw_response: response_data,
+        };
+    }
+    catch (error) {
+        const error_message = error instanceof Error ? error.message : String(error);
+        logger.error('Failed to call DashScope image editing API', {
+            file: file_name,
+            line: 970,
+            data: { error: error_message, model },
+        });
+        return {
+            success: false,
+            error: error_message,
+        };
+    }
+}
+//# sourceMappingURL=qwen_client.js.map