Handling insufficient credits

# Send a run and branch on the status.
status=$(curl -sS -o /tmp/run.json -w '%{http_code}' https://api.opentype.dev/v1/runs \
  -H "Authorization: Bearer $OPENTYPE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: ticket-4822-triage" \
  -d '{
    "kind": "decision",
    "state": {"ticket": "I was charged twice this month and nobody answers my emails."},
    "questions": {"urgent": {"type": "noul", "instructions": "reply within the hour?"}},
    "max_output_tokens": 16
  }')

if [ "$status" = "402" ]; then
  jq -r '.error.request_id' /tmp/run.json
  # Check what is available before retrying with the same Idempotency-Key.
  curl -sS https://api.opentype.dev/v1/billing \
    -H "Authorization: Bearer $OPENTYPE_API_KEY" | jq '{balance_micros, auto_recharge, has_payment_method}'
fi

const API = "https://api.opentype.dev";
const KEY = process.env.OPENTYPE_API_KEY!;
const RUN_HOLD_MICROS = 5_000;

class OutOfCredit extends Error {
  constructor(public requestId: string) {
    super(`OpenType credit exhausted (request ${requestId})`);
  }
}

async function sendRun(idempotencyKey: string, body: unknown) {
  const res = await fetch(`${API}/v1/runs`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${KEY}`,
      "Content-Type": "application/json",
      "Idempotency-Key": idempotencyKey,
    },
    body: JSON.stringify(body),
  });
  if (res.status === 402) {
    const { error } = await res.json();
    throw new OutOfCredit(error.request_id);
  }
  if (!res.ok) throw new Error(`run failed: ${res.status}`);
  return res.json();
}

async function waitForCredit(concurrency: number, pollMs = 30_000) {
  const needed = RUN_HOLD_MICROS * concurrency;
  for (;;) {
    const res = await fetch(`${API}/v1/billing`, { headers: { Authorization: `Bearer ${KEY}` } });
    if (res.ok) {
      const billing = await res.json();
      if (billing.balance_micros >= needed) return;
    }
    await new Promise((r) => setTimeout(r, pollMs));
  }
}

// One worker loop. `queue` holds jobs with a stable business id.
async function drain(queue: { id: string; body: unknown }[], alert: (msg: string) => Promise<void>) {
  let alerted = false;
  while (queue.length > 0) {
    const job = queue[0];
    try {
      await sendRun(`triage-${job.id}`, job.body); // same key on every attempt
      queue.shift();
      alerted = false;
    } catch (err) {
      if (!(err instanceof OutOfCredit)) throw err;
      if (!alerted) {
        await alert(`OpenType credit is exhausted; runs are paused. request_id=${err.requestId}`);
        alerted = true;
      }
      await waitForCredit(1); // then retry the same job with the same key
    }
  }
}

import os
import time
import requests

API = "https://api.opentype.dev"
HEADERS = {"Authorization": f"Bearer {os.environ['OPENTYPE_API_KEY']}"}
RUN_HOLD_MICROS = 5_000


class OutOfCredit(Exception):
    def __init__(self, request_id):
        super().__init__(f"OpenType credit exhausted (request {request_id})")
        self.request_id = request_id


def send_run(idempotency_key, body):
    res = requests.post(
        f"{API}/v1/runs",
        headers={**HEADERS, "Idempotency-Key": idempotency_key},
        json=body,
        timeout=160,
    )
    if res.status_code == 402:
        raise OutOfCredit(res.json()["error"]["request_id"])
    res.raise_for_status()
    return res.json()


def wait_for_credit(concurrency=1, poll_s=30):
    needed = RUN_HOLD_MICROS * concurrency
    while True:
        res = requests.get(f"{API}/v1/billing", headers=HEADERS, timeout=30)
        if res.ok and res.json()["balance_micros"] >= needed:
            return
        time.sleep(poll_s)


def drain(queue, alert):
    """queue: list of dicts with a stable 'id' and a run 'body'."""
    alerted = False
    while queue:
        job = queue[0]
        try:
            send_run(f"triage-{job['id']}", job["body"])  # same key on every attempt
            queue.pop(0)
            alerted = False
        except OutOfCredit as err:
            if not alerted:
                alert(f"OpenType credit is exhausted; runs are paused. request_id={err.request_id}")
                alerted = True
            wait_for_credit(1)  # then retry the same job with the same key