Errors

import os, random, time
import httpx

BASE = "https://api.smry.ai"
KEY = os.environ["SMRY_API_KEY"]

# Codes that are retryable even though they arrive with a 4xx status.
RETRYABLE_4XX = {"commit_in_progress", "asset_upload_busy"}
# Codes that never succeed on retry, whatever the status says.
TERMINAL = {
    "PAYWALL_ERROR",
    "UNSUPPORTED_PUBLISHER",
    "VALIDATION_ERROR",
    "ARTICLE_CONTENT_UNAVAILABLE",
    "storage_quota_exceeded",
    "malware_detected",
}


class SmryError(Exception):
    def __init__(self, status: int, body: dict):
        self.status = status
        self.code = body.get("code", "unknown")
        self.body = body
        super().__init__(f"{self.code} ({status}): {body.get('error', '')}")


def call(client: httpx.Client, method: str, path: str, json=None, attempts=3):
    for attempt in range(attempts):
        response = client.request(
            method,
            BASE + path,
            json=json,
            headers={"Authorization": f"Bearer {KEY}"},
        )
        if response.is_success:
            return response.json()

        body = response.json()
        code = body.get("code", "unknown")
        last = attempt == attempts - 1

        if code in TERMINAL or last:
            raise SmryError(response.status_code, body)

        # Explicit server guidance wins over any status heuristic.
        retryable = body.get("retryable")
        if retryable is False:
            raise SmryError(response.status_code, body)
        if retryable is not True:
            retryable = response.status_code >= 500 or (
                response.status_code == 429 or code in RETRYABLE_4XX
            )
        if not retryable:
            raise SmryError(response.status_code, body)

        # 429 tells you exactly how long. Everything else gets backoff + jitter.
        wait = body.get("retryAfter") or response.headers.get("retry-after")
        delay = float(wait) if wait else (2**attempt) + random.random()
        time.sleep(delay)

    raise AssertionError("unreachable")


with httpx.Client(timeout=60) as client:
    article = call(
        client,
        "POST",
        "/v1/articles/search",
        {"url": "https://example.com/post", "query": "funding round"},
    )
    print(article["matchedBlocks"], "matching blocks")

const BASE = "https://api.smry.ai";
const KEY = process.env.SMRY_API_KEY!;

/** Retryable even though they arrive with a 4xx status. */
const RETRYABLE_4XX = new Set(["commit_in_progress", "asset_upload_busy"]);
/** Never succeed on retry, whatever the status says. */
const TERMINAL = new Set([
  "PAYWALL_ERROR",
  "UNSUPPORTED_PUBLISHER",
  "VALIDATION_ERROR",
  "ARTICLE_CONTENT_UNAVAILABLE",
  "storage_quota_exceeded",
  "malware_detected",
]);

export interface SmryErrorBody {
  error: string;
  code: string;
  field?: string;
  hint?: string;
  retryable?: boolean;
  retryAfter?: number;
}

export class SmryError extends Error {
  constructor(
    readonly status: number,
    readonly body: SmryErrorBody,
  ) {
    super(`${body.code} (${status}): ${body.error}`);
  }
}

const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));

export async function call<T>(
  method: string,
  path: string,
  body?: unknown,
  attempts = 3,
): Promise<T> {
  for (let attempt = 0; attempt < attempts; attempt++) {
    const response = await fetch(BASE + path, {
      method,
      headers: {
        Authorization: `Bearer ${KEY}`,
        ...(body ? { "Content-Type": "application/json" } : {}),
      },
      body: body ? JSON.stringify(body) : undefined,
    });
    if (response.ok) return (await response.json()) as T;

    const failure = (await response.json()) as SmryErrorBody;
    const last = attempt === attempts - 1;
    if (TERMINAL.has(failure.code) || last) {
      throw new SmryError(response.status, failure);
    }

    // Explicit server guidance wins over any status heuristic.
    const retryable =
      failure.retryable ??
      (response.status >= 500 ||
        response.status === 429 ||
        RETRYABLE_4XX.has(failure.code));
    if (!retryable) throw new SmryError(response.status, failure);

    // 429 tells you exactly how long. Everything else gets backoff + jitter.
    const header = response.headers.get("retry-after");
    const seconds = failure.retryAfter ?? (header ? Number(header) : null);
    const delay = seconds
      ? seconds * 1000
      : 2 ** attempt * 1000 + Math.random() * 1000;
    await sleep(delay);
  }
  throw new Error("unreachable");
}

const search = await call<{ matchedBlocks: number }>(
  "POST",
  "/v1/articles/search",
  { url: "https://example.com/post", query: "funding round" },
);
console.log(search.matchedBlocks, "matching blocks");

# Read the code, not the message. jq makes the branch explicit.
curl -sS -X POST "https://api.smry.ai/v1/articles/read" \
  -H "Authorization: Bearer $SMRY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/post", "maxTokens": 2000}' \
  | jq 'if .code then {code, retryable, retryAfter, field} else {tokensReturned, nextCursor} end'