Rate limits & retries

import os
import random
import time
 
import requests
 
API_URL = "https://app.syntic.ai/v1/chat/completions"
HEADERS = {"Authorization": f"Bearer {os.environ['SYNTIC_API_KEY']}"}
 
BASE_DELAY = 0.5   # seconds
MAX_DELAY = 30.0   # seconds
MAX_ATTEMPTS = 5
 
 
class ApiError(Exception):
    def __init__(self, status, body, request_id):
        super().__init__(f"{status} {body.get('error')} (request {request_id})")
        self.status, self.body, self.request_id = status, body, request_id
 
 
def should_retry(status, body):
    if status == 429 or status >= 500:
        return True
    return status == 503 and (body.get("error") or {}).get("code") == "usage_check_unavailable"
 
 
def wait_time(attempt, retry_after):
    # Retry-After wins whenever the server sent one.
    if retry_after and retry_after.strip().isdigit():
        return int(retry_after) + random.uniform(0, 1)
    return random.uniform(0, min(MAX_DELAY, BASE_DELAY * 2 ** attempt))
 
 
def chat(messages, model="Amara S1.2", max_tokens=1024):
    payload = {"model": model, "messages": messages, "stream": False, "max_tokens": max_tokens}
 
    for attempt in range(MAX_ATTEMPTS):
        last = attempt == MAX_ATTEMPTS - 1
        try:
            res = requests.post(API_URL, headers=HEADERS, json=payload, timeout=120)
        except (requests.ConnectionError, requests.Timeout):
            if last:
                raise
            time.sleep(wait_time(attempt, None))
            continue
 
        if res.ok:
            return res.json()
 
        try:
            body = res.json()
        except ValueError:
            body = {}
        if not isinstance(body, dict):
            body = {}
 
        if last or not should_retry(res.status_code, body):
            raise ApiError(res.status_code, body, res.headers.get("x-syntic-request-id"))
 
        time.sleep(wait_time(attempt, res.headers.get("Retry-After")))
 
 
if __name__ == "__main__":
    reply = chat([{"role": "user", "content": "Name three uses for a paperclip."}])
    print(reply["choices"][0]["message"]["content"])

const API_URL = 'https://app.syntic.ai/v1/chat/completions'
const BASE_DELAY_MS = 500
const MAX_DELAY_MS = 30_000
const MAX_ATTEMPTS = 5
 
type Message = { role: 'system' | 'user' | 'assistant'; content: string }
type ErrorBody = { error?: { type?: string; code?: string; message?: string; [key: string]: unknown } }
 
export class ApiError extends Error {
  constructor(public status: number, public body: ErrorBody, public requestId: string | null) {
    super(`${status} ${body.error?.code ?? 'error'} (request ${requestId})`)
  }
}
 
const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
 
function shouldRetry(status: number, body: ErrorBody): boolean {
  if (status === 429 || status >= 500) return true
  return status === 503 && body.error?.code === 'usage_check_unavailable'
}
 
function waitMs(attempt: number, retryAfter: string | null): number {
  // Retry-After wins whenever the server sent one.
  const serverWait = Number(retryAfter)
  if (retryAfter !== null && retryAfter.trim() !== '' && Number.isFinite(serverWait) && serverWait >= 0) {
    return serverWait * 1000 + Math.random() * 1000
  }
  return Math.random() * Math.min(MAX_DELAY_MS, BASE_DELAY_MS * 2 ** attempt)
}
 
export async function chat(messages: Message[], model = 'Amara S1.2', maxTokens = 1024) {
  const payload = JSON.stringify({ model, messages, stream: false, max_tokens: maxTokens })
 
  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
    const last = attempt === MAX_ATTEMPTS - 1
    let res: Response
    try {
      res = await fetch(API_URL, {
        method: 'POST',
        headers: {
          Authorization: `Bearer ${process.env.SYNTIC_API_KEY}`,
          'Content-Type': 'application/json',
        },
        body: payload,
        signal: AbortSignal.timeout(120_000),
      })
    } catch (networkError) {
      if (last) throw networkError
      await sleep(waitMs(attempt, null))
      continue
    }
 
    if (res.ok) return res.json()
 
    const body: ErrorBody = await res.json().catch(() => ({}))
    if (last || !shouldRetry(res.status, body)) {
      throw new ApiError(res.status, body, res.headers.get('x-syntic-request-id'))
    }
    await sleep(waitMs(attempt, res.headers.get('retry-after')))
  }
  throw new Error('unreachable')
}
 
const reply = await chat([{ role: 'user', content: 'Name three uses for a paperclip.' }])
console.log(reply.choices[0].message.content)