{
  "error": {
    "code": "invalid_api_key",
    "message": "The API key provided is invalid or has been revoked.",
    "type": "authentication_error",
    "param": null,
    "doc_url": "https://developer.kallglot.com/errors#invalid_api_key"
  }
}

try {
  const response = await fetch('https://api.kallglot.com/v1/sessions', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer sk_live_xxx',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      mode: 'bidirectional_translation',
      source_language: 'de',
      target_language: 'en'
    })
  });

  if (!response.ok) {
    const errorBody = await response.json();
    throw {
      type: errorBody.error.type,
      param: errorBody.error.param,
      message: errorBody.error.message,
      headers: Object.fromEntries(response.headers.entries())
    };
  }
} catch (error) {
  if (error.type === 'authentication_error') {
    // Handle auth errors
    console.error('Check your API key');
  } else if (error.type === 'validation_error') {
    // Handle validation errors
    console.error(`Invalid parameter: ${error.param}`);
  } else if (error.type === 'rate_limit_error') {
    // Handle rate limiting
    const retryAfter = error.headers['retry-after'];
    await sleep(retryAfter * 1000);
    // Retry the request
  } else {
    // Handle other errors
    console.error(`Error: ${error.message}`);
  }
}

import requests
import time

try:
    response = requests.post(
        'https://api.kallglot.com/v1/sessions',
        headers={
            'Authorization': 'Bearer sk_live_xxx',
            'Content-Type': 'application/json'
        },
        json={
            'mode': 'bidirectional_translation',
            'source_language': 'de',
            'target_language': 'en'
        }
    )
    response.raise_for_status()
except requests.HTTPError as e:
    if e.response.status_code == 429:
        retry_after = int(e.response.headers.get('Retry-After', 1))
        time.sleep(retry_after)
    else:
        error = e.response.json().get('error', {})
        print(f"Error: {error.get('code')} - {error.get('message')}")

async function withRetry(fn, maxRetries = 3) {
  let lastError;

  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      lastError = error;

      if (!isRetryable(error)) {
        throw error;
      }

      const delay = Math.pow(2, i) * 1000;  // 1s, 2s, 4s
      await sleep(delay);
    }
  }

  throw lastError;
}

function isRetryable(error) {
  return error.type === 'server_error' ||
         error.type === 'rate_limit_error' ||
         error.code === 'provider_timeout';
}

ws.on('close', (code, reason) => {
  switch (code) {
    case 1000:
      console.log('Connection closed normally');
      break;
    case 4000:
      console.log('Session ended');
      break;
    case 4001:
      console.log('Token expired - reconnect with new token');
      break;
    case 4002:
      console.log('Rate limited - slow down');
      break;
    default:
      console.log(`Closed: ${code} - ${reason}`);
  }
});