LogoQwen Image Edit

Solución de Problemas

Soluciones a problemas comunes y consejos de solución de problemas

Problemas de Autenticación

Error: "Clave API Inválida"

Síntomas:

  • Código de error: AUTH_INVALID
  • Mensaje: "La clave API proporcionada no es válida"

Soluciones:

  1. Verificar la clave API

    // Verificar que la clave esté correctamente configurada
console.log('Clave API:', process.env.QWEN_API_KEY?.substring(0, 10) + '...');

  2. Regenerar clave API

    • Ve a tu panel de control
    • Navega a "Configuración de API"
    • Genera una nueva clave
    • Actualiza tu configuración

  3. Verificar formato de clave

    // La clave debe tener este formato
const formatoValido = /^qwen_[a-zA-Z0-9]{32,}$/.test(apiKey);
if (!formatoValido) {
  console.error('Formato de clave API inválido');
}

Error: "Región No Soportada"

Síntomas:

  • Código de error: REGION_INVALID
  • Mensaje: "La región especificada no está disponible"

Soluciones:

// Regiones válidas
const regionesValidas = [
  'us-east-1',
  'us-west-2', 
  'eu-west-1',
  'ap-southeast-1'
];

const editor = new QwenImageEdit({
  apiKey: process.env.QWEN_API_KEY,
  region: 'us-east-1' // Usar región válida
});

Problemas de Cuota y Límites

Error: "Cuota Excedida"

Síntomas:

  • Código de error: QUOTA_EXCEEDED
  • Mensaje: "Has excedido tu límite mensual"

Soluciones:

  1. Verificar uso actual

    const uso = await editor.getUsage();
console.log('Uso actual:', uso);
console.log('Límite:', uso.limite);
console.log('Restante:', uso.limite - uso.usado);

  2. Actualizar plan

    • Ve a "Facturación" en tu panel
    • Selecciona un plan superior
    • El límite se actualizará inmediatamente

  3. Optimizar uso

    // Usar caché para evitar procesamiento duplicado
const editor = new QwenImageEdit({
  apiKey: process.env.QWEN_API_KEY,
  cache: true,
  cacheConfig: {
    ttl: 3600, // 1 hora
    maxSize: 1000
  }
});

Error: "Límite de Velocidad"

Síntomas:

  • Código de error: RATE_LIMITED
  • Mensaje: "Demasiadas solicitudes por minuto"

Soluciones:

  1. Implementar rate limiting

    import pLimit from 'p-limit';

const limit = pLimit(5); // Máximo 5 solicitudes concurrentes

const promesas = imagenes.map(imagen => 
  limit(() => editor.editText({ imagen, prompt: 'Editar' }))
);

const resultados = await Promise.all(promesas);

  2. Usar delays entre solicitudes

    async function procesarConDelay(imagenes) {
  const resultados = [];
  
  for (const imagen of imagenes) {
    const resultado = await editor.editText({ imagen, prompt: 'Editar' });
    resultados.push(resultado);
    
    // Esperar 1 segundo entre solicitudes
    await new Promise(resolve => setTimeout(resolve, 1000));
  }
  
  return resultados;
}

Problemas de Imagen

Error: "Imagen Muy Grande"

Síntomas:

  • Código de error: IMAGE_TOO_LARGE
  • Mensaje: "El archivo de imagen excede el tamaño máximo"

Soluciones:

  1. Redimensionar imagen

    // Redimensionar antes de procesar
const imagenRedimensionada = await editor.resizeImage({
  imagen: 'imagen-grande.jpg',
  dimensiones: {
    ancho: 2048,
    alto: 2048
  },
  mantenerAspecto: true
});

// Luego procesar la imagen redimensionada
const resultado = await editor.editText({
  imagen: imagenRedimensionada.imagenUrl,
  prompt: 'Editar texto'
});

  2. Comprimir imagen

    const imagenComprimida = await editor.compressImage({
  imagen: 'imagen-grande.jpg',
  calidad: 80,
  formato: 'jpeg'
});

Error: "Formato No Soportado"

Síntomas:

  • Código de error: INVALID_FORMAT
  • Mensaje: "El formato de imagen no es compatible"

Soluciones:

  1. Convertir formato

    // Formatos soportados
const formatosSoportados = ['jpg', 'jpeg', 'png', 'webp', 'bmp', 'tiff'];

// Convertir a formato soportado
const imagenConvertida = await editor.convertFormat({
  imagen: 'imagen.gif',
  formatoDestino: 'png'
});

  2. Validar formato antes de procesar

    function validarFormato(rutaImagen) {
  const extension = rutaImagen.split('.').pop()?.toLowerCase();
  const formatosValidos = ['jpg', 'jpeg', 'png', 'webp'];
  
  if (!formatosValidos.includes(extension)) {
    throw new Error(`Formato ${extension} no soportado`);
  }
}

Problemas de Red

Error: "Timeout de Conexión"

Síntomas:

  • Código de error: TIMEOUT
  • Mensaje: "La solicitud ha excedido el tiempo límite"

Soluciones:

  1. Aumentar timeout

    const editor = new QwenImageEdit({
  apiKey: process.env.QWEN_API_KEY,
  timeout: 60000, // 60 segundos
  maxRetries: 3
});

  2. Implementar reintentos con backoff

    async function editarConReintentos(opciones, maxReintentos = 3) {
  for (let intento = 1; intento <= maxReintentos; intento++) {
    try {
      return await editor.editText(opciones);
    } catch (error) {
      if (error.codigo === 'TIMEOUT' && intento < maxReintentos) {
        const delay = Math.pow(2, intento) * 1000; // Backoff exponencial
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }
      throw error;
    }
  }
}

Error: "Error de Red"

Síntomas:

  • Código de error: NETWORK_ERROR
  • Mensaje: "No se pudo conectar al servidor"

Soluciones:

  1. Verificar conectividad

    async function verificarConectividad() {
  try {
    const response = await fetch('https://api.qwen.com/health');
    if (response.ok) {
      console.log('Conectividad OK');
    } else {
      console.error('Servidor no disponible');
    }
  } catch (error) {
    console.error('Error de red:', error.message);
  }
}

  2. Configurar proxy si es necesario

    const editor = new QwenImageEdit({
  apiKey: process.env.QWEN_API_KEY,
  proxy: {
    host: 'proxy.empresa.com',
    port: 8080,
    auth: {
      username: process.env.PROXY_USER,
      password: process.env.PROXY_PASS
    }
  }
});

Problemas de Procesamiento

Error: "Procesamiento Fallido"

Síntomas:

  • Código de error: PROCESSING_FAILED
  • Mensaje: "No se pudo procesar la imagen"

Soluciones:

  1. Verificar calidad de imagen

    // Analizar imagen antes de procesar
const analisis = await editor.analyzeImage({
  imagen: 'imagen.jpg',
  detectar: ['calidad', 'objetos']
});

if (analisis.calidad.puntuacion < 0.5) {
  console.warn('Imagen de baja calidad, mejorando...');
  const imagenMejorada = await editor.enhanceImage({
    imagen: 'imagen.jpg',
    mejoras: ['nitidez', 'contraste']
  });
}

  2. Simplificar prompt

    // Prompt muy complejo
const promptComplejo = 'Cambiar el texto azul en la esquina superior derecha que dice "Hola" por "Adiós" manteniendo exactamente el mismo estilo, fuente y color pero en rojo';

// Prompt simplificado
const promptSimple = 'Cambiar "Hola" por "Adiós" en rojo';

const resultado = await editor.editText({
  imagen: 'imagen.jpg',
  prompt: promptSimple
});

Error: "Contenido No Detectado"

Síntomas:

  • Código de error: CONTENT_NOT_FOUND
  • Mensaje: "No se encontró el contenido especificado"

Soluciones:

  1. Analizar contenido primero

    // Detectar texto disponible
const analisis = await editor.analyzeImage({
  imagen: 'imagen.jpg',
  detectar: ['texto']
});

console.log('Texto detectado:', analisis.texto);

// Usar texto detectado en el prompt
if (analisis.texto.length > 0) {
  const textoOriginal = analisis.texto[0].contenido;
  const resultado = await editor.editText({
    imagen: 'imagen.jpg',
    prompt: `Cambiar "${textoOriginal}" por "Nuevo texto"`
  });
}

  2. Usar coordenadas específicas

    const resultado = await editor.editText({
  imagen: 'imagen.jpg',
  prompt: 'Agregar texto "Nuevo"',
  posicion: {
    x: 100,
    y: 50,
    alineacion: 'centro'
  }
});

Problemas de Performance

Procesamiento Lento

Síntomas:

  • Tiempos de respuesta muy altos
  • Timeouts frecuentes

Soluciones:

  1. Optimizar imágenes

    // Redimensionar para mejor performance
const imagenOptimizada = await editor.resizeImage({
  imagen: 'imagen-4k.jpg',
  dimensiones: { ancho: 1920, alto: 1080 },
  calidad: 85
});

  2. Usar procesamiento asíncrono

    // Para imágenes grandes, usar webhooks
const trabajo = await editor.editTextAsync({
  imagen: 'imagen-grande.jpg',
  prompt: 'Editar texto',
  webhook: {
    url: 'https://mi-app.com/webhook',
    eventos: ['completado', 'error']
  }
});

console.log('ID de trabajo:', trabajo.id);

  3. Implementar caché inteligente

    import crypto from 'crypto';

function generarCacheKey(opciones) {
  const hash = crypto.createHash('md5');
  hash.update(JSON.stringify(opciones));
  return hash.digest('hex');
}

const cache = new Map();

async function editarConCache(opciones) {
  const cacheKey = generarCacheKey(opciones);
  
  if (cache.has(cacheKey)) {
    console.log('Resultado desde caché');
    return cache.get(cacheKey);
  }
  
  const resultado = await editor.editText(opciones);
  cache.set(cacheKey, resultado);
  
  return resultado;
}

Problemas de Memoria

Error: "Memoria Insuficiente"

Síntomas:

  • Aplicación se bloquea
  • Errores de "out of memory"

Soluciones:

  1. Procesar en lotes

    async function procesarEnLotes(imagenes, tamañoLote = 5) {
  const resultados = [];
  
  for (let i = 0; i < imagenes.length; i += tamañoLote) {
    const lote = imagenes.slice(i, i + tamañoLote);
    
    const resultadosLote = await Promise.all(
      lote.map(imagen => editor.editText({ imagen, prompt: 'Editar' }))
    );
    
    resultados.push(...resultadosLote);
    
    // Limpiar memoria entre lotes
    if (global.gc) {
      global.gc();
    }
  }
  
  return resultados;
}

  2. Usar streams para archivos grandes

    import fs from 'fs';

async function procesarConStream(rutaImagen) {
  const stream = fs.createReadStream(rutaImagen);
  
  const resultado = await editor.editTextStream({
    imagenStream: stream,
    prompt: 'Editar texto'
  });
  
  return resultado;
}

Herramientas de Debug

Logging Detallado

const editor = new QwenImageEdit({
  apiKey: process.env.QWEN_API_KEY,
  debug: true,
  logger: {
    error: (msg, meta) => console.error('❌', msg, meta),
    warn: (msg, meta) => console.warn('⚠️', msg, meta),
    info: (msg, meta) => console.info('ℹ️', msg, meta),
    debug: (msg, meta) => console.debug('🐛', msg, meta)
  }
});

Interceptor de Solicitudes

const editor = new QwenImageEdit({
  apiKey: process.env.QWEN_API_KEY,
  interceptors: {
    request: (config) => {
      console.log('📤 Enviando:', {
        url: config.url,
        metodo: config.method,
        tamaño: config.data?.length || 0
      });
      return config;
    },
    response: (response) => {
      console.log('📥 Recibido:', {
        status: response.status,
        tamaño: response.data?.length || 0,
        tiempo: response.duration
      });
      return response;
    },
    error: (error) => {
      console.error('💥 Error:', {
        codigo: error.codigo,
        mensaje: error.mensaje,
        url: error.config?.url
      });
      throw error;
    }
  }
});

Health Check

async function verificarSalud() {
  try {
    const salud = await editor.healthCheck();
    console.log('✅ Servicio saludable:', salud);
    return true;
  } catch (error) {
    console.error('❌ Servicio no disponible:', error.message);
    return false;
  }
}

// Verificar cada 30 segundos
setInterval(verificarSalud, 30000);

Contacto de Soporte

Si los problemas persisten:

  1. Documentación: Consulta la documentación completa
  2. Ejemplos: Revisa los ejemplos de código
  3. Comunidad: Únete a nuestro Discord
  4. Soporte: Contacta a support@qwen.com

Información para Soporte

Cuando contactes soporte, incluye:

// Información del sistema
const infoSistema = {
  version: process.version,
  plataforma: process.platform,
  arquitectura: process.arch,
  qwenVersion: editor.version,
  timestamp: new Date().toISOString()
};

console.log('Información del sistema:', infoSistema);
  • Código de error específico
  • Mensaje de error completo
  • Pasos para reproducir el problema
  • Configuración utilizada (sin claves API)
  • Logs relevantes

Configuración

Guía de configuración y configuración para Qwen Image Edit

Funciones Avanzadas

Funciones avanzadas y capacidades de Qwen Image Edit