# Enviar tarea de generación de imágenes
curl -X POST https://api.evolink.ai/v1/images/generations \\
  -H "Authorization: Bearer YOUR_API_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "gpt-4o-image",
    "prompt": "A cute cat running on the grass at sunset with warm lighting"
  }'

{
  "created": 1757156493,
  "id": "task-unified-1757156493-imcg5zqt",
  "model": "gpt-4o-image",
  "object": "image.generation.task",
  "progress": 0,
  "status": "pending",
  "task_info": {
    "can_cancel": true,
    "estimated_time": 100
  },
  "type": "image",
  "usage": {
    "billing_rule": "per_call",
    "credits_reserved": 252,
    "estimated_cost": 0.252,
    "user_group": "default"
  }
}

# Usar el ID de tarea devuelto para consultar el estado
curl https://api.evolink.ai/v1/tasks/task-unified-1757156493-imcg5zqt \\
  -H "Authorization: Bearer YOUR_API_KEY"

{
  "created": 1757156493,
  "id": "task-unified-1757156493-imcg5zqt",
  "model": "gpt-4o-image",
  "object": "image.generation.task",
  "progress": 100,
  "results": [
    "https://tempfile.aiquickdraw.com/s/generated_image_url.png"
  ],
  "status": "completed",
  "task_info": {
    "can_cancel": false
  },
  "type": "image"
}

import requests
import time

# Generación de video con Veo3-Fast
def generate_video():
    # Enviar tarea de generación de video
    response = requests.post(
        "https://api.evolink.ai/v1/videos/generations",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={
            "model": "veo3-fast",
            "prompt": "A cat chasing butterflies in the garden, slow motion",
            "aspect_ratio": "16:9"
        }
    )

    task = response.json()
    task_id = task['id']

    print(f"Video task created: {task_id}")
    print(f"Estimated completion time: {task['task_info']['estimated_time']} seconds")
    print(f"Estimated cost: ${task['usage']['estimated_cost']}")

    return task_id

# Monitorear progreso de la tarea
def monitor_task(task_id):
    while True:
        response = requests.get(
            f"https://api.evolink.ai/v1/tasks/{task_id}",
            headers={"Authorization": "Bearer YOUR_API_KEY"}
        )

        task = response.json()
        status = task['status']
        progress = task['progress']

        print(f"Status: {status}, Progress: {progress}%")

        if status == "completed":
            return task['results'][0]  # URL del video en el array de resultados
        elif status == "failed":
            raise Exception(f"Task failed: {task.get('error')}")

        time.sleep(10)  # Consultar cada 10 segundos

# Ejemplo de uso
task_id = generate_video()
video_url = monitor_task(task_id)
print(f"Video generation completed: {video_url}")

import openai
import requests

class EvoLinkClient:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.evolink.ai"
        self.headers = {"Authorization": f"Bearer {api_key}"}

    def create_image(self, model, prompt, **kwargs):
        """Crear tarea de generación de imágenes"""
        response = requests.post(
            f"{self.base_url}/v1/images/generations",
            headers=self.headers,
            json={"model": model, "prompt": prompt, **kwargs}
        )
        return response.json()

    def create_video(self, model, prompt, **kwargs):
        """Crear tarea de generación de video"""
        response = requests.post(
            f"{self.base_url}/v1/videos/generations",
            headers=self.headers,
            json={"model": model, "prompt": prompt, **kwargs}
        )
        return response.json()

    def get_task(self, task_id):
        """Obtener estado de la tarea"""
        response = requests.get(
            f"{self.base_url}/v1/tasks/{task_id}",
            headers=self.headers
        )
        return response.json()

    def wait_for_completion(self, task_id, timeout=300):
        """Esperar a que se complete la tarea"""
        import time
        start_time = time.time()

        while time.time() - start_time < timeout:
            task = self.get_task(task_id)

            if task['status'] == 'completed':
                return task
            elif task['status'] == 'failed':
                raise Exception(f"Task failed: {task.get('error')}")

            time.sleep(5)

        raise TimeoutError("Task execution timeout")

# Ejemplo de uso
client = EvoLinkClient("YOUR_API_KEY")

# Generar imagen
task = client.create_image(
    model="gpt-4o-image",
    prompt="A modern intelligent office building"
)

result = client.wait_for_completion(task['id'])
print(f"Image URL: {result['results'][0]}")

class EvoLinkClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = 'https://api.evolink.ai';
  }

  async createImage(model, prompt, options = {}) {
    const response = await fetch(`${this.baseURL}/v1/images/generations`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ model, prompt, ...options })
    });

    return response.json();
  }

  async getTask(taskId) {
    const response = await fetch(`${this.baseURL}/v1/tasks/${taskId}`, {
      headers: { 'Authorization': `Bearer ${this.apiKey}` }
    });

    return response.json();
  }

  async waitForCompletion(taskId, timeout = 300000) {
    const startTime = Date.now();

    while (Date.now() - startTime < timeout) {
      const task = await this.getTask(taskId);

      if (task.status === 'completed') {
        return task;
      } else if (task.status === 'failed') {
        throw new Error(`Task failed: ${task.error}`);
      }

      await new Promise(resolve => setTimeout(resolve, 5000));
    }

    throw new Error('Task execution timeout');
  }
}

// Ejemplo de uso
async function generateImage() {
  const client = new EvoLinkClient('YOUR_API_KEY');

  try {
    // Crear tarea
    const task = await client.createImage(
      'doubao-seedream-4.0',
      'An abstract art painting with rich colors'
    );

    console.log('Task created:', task.id);

    // Esperar a que se complete
    const result = await client.waitForCompletion(task.id);
    console.log('Image generation completed:', result.results[0]);

  } catch (error) {
    console.error('Generation failed:', error.message);
  }
}

generateImage();

import requests
from typing import Optional
import time

class EvoLinkError(Exception):
    """Clase base de excepciones de la API de EvoLink"""
    pass

class RateLimitError(EvoLinkError):
    """Excepción de límite de velocidad"""
    pass

class QuotaExhaustedError(EvoLinkError):
    """Excepción de cuota agotada"""
    pass

def handle_api_call(func, *args, **kwargs):
    """Manejo unificado de errores en llamadas API"""
    max_retries = 3
    retry_delay = 1

    for attempt in range(max_retries):
        try:
            response = func(*args, **kwargs)

            if response.status_code == 200:
                return response.json()
            elif response.status_code == 429:
                # Límite de velocidad, esperar y reintentar
                wait_time = int(response.headers.get('Retry-After', retry_delay))
                print(f"Rate limit hit, waiting {wait_time} seconds before retry...")
                time.sleep(wait_time)
                retry_delay *= 2
                continue
            elif response.status_code == 402:
                raise QuotaExhaustedError("Saldo insuficiente en la cuenta, por favor recarga")
            else:
                error_data = response.json()
                raise EvoLinkError(f"API call failed: {error_data.get('error', {}).get('message')}")

        except requests.exceptions.RequestException as e:
            if attempt == max_retries - 1:
                raise EvoLinkError(f"Network request failed: {str(e)}")
            time.sleep(retry_delay)
            retry_delay *= 2

    raise EvoLinkError("Se alcanzó el número máximo de reintentos")

# Ejemplo de uso
try:
    result = handle_api_call(
        requests.post,
        "https://api.evolink.ai/v1/images/generations",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={"model": "gpt-4o-image", "prompt": "Test image"}
    )
    print("Task created successfully:", result['id'])
except QuotaExhaustedError:
    print("Por favor recarga en la consola: https://evolink.ai/dashboard/billing")
except EvoLinkError as e:
    print(f"API call exception: {e}")

import logging
from datetime import datetime

class EvoLinkMonitor:
    def __init__(self):
        # Configurar registro
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('evolink_api.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)

    def log_task_creation(self, task_id, model, cost):
        """Registrar creación de tarea"""
        self.logger.info(f"Task created | ID:{task_id} | Model:{model} | Cost:${cost}")

    def log_task_completion(self, task_id, duration, status):
        """Registrar finalización de tarea"""
        self.logger.info(f"Task completed | ID:{task_id} | Duration:{duration}s | Status:{status}")

    def log_error(self, error, context=""):
        """Registrar errores"""
        self.logger.error(f"API error | {context} | {str(error)}")

# Ejemplo de uso
monitor = EvoLinkMonitor()

# Usar en llamadas API
start_time = time.time()
try:
    task = client.create_image("gpt-4o-image", "Test prompt")
    monitor.log_task_creation(
        task['id'],
        task['model'],
        task['usage']['estimated_cost']
    )

    result = client.wait_for_completion(task['id'])
    duration = time.time() - start_time
    monitor.log_task_completion(task['id'], int(duration), "completed")

except Exception as e:
    monitor.log_error(e, f"Task ID: {task.get('id', 'unknown')}")