Clients and SDKs

# types only, no runtime dependency
npx openapi-typescript https://docs.get-exo.com/spec/exo-v1.json \
  -o src/exo.d.ts

# pydantic models from the schemas
datamodel-codegen \
  --url https://docs.get-exo.com/spec/exo-v1.json \
  --input-file-type openapi \
  --output exo_models.py

# full client via openapi-generator
openapi-generator-cli generate \
  -i https://docs.get-exo.com/spec/exo-v1.json \
  -g <language> \
  -o ./exo-client

import httpx


class ExoError(RuntimeError):
    def __init__(self, problem: dict) -> None:
        self.code = problem.get("code", "unknown")
        self.request_id = problem.get("requestId", "")
        super().__init__(f"{self.code}: {problem.get('detail', '')} [{self.request_id}]")


class Exo:
    def __init__(self, api_key: str, subject: str | None = None) -> None:
        headers = {"X-Exo-API-Key": api_key}
        if subject:
            headers["X-Exo-Subject"] = subject
        self._client = httpx.Client(
            base_url="https://api.get-exo.com", headers=headers, timeout=30.0
        )

    def call(self, method: str, path: str, **kwargs):
        response = self._client.request(method, path, **kwargs)
        if response.is_error:
            raise ExoError(response.json())
        return response.json() if response.content else None

    def retrieve(self, query: str, top_k: int = 8):
        return self.call("POST", "/v1/retrieve", json={"query": query, "topK": top_k})

export class ExoError extends Error {
  constructor(readonly problem: Record<string, unknown>) {
    super(`${problem.code}: ${problem.detail} [${problem.requestId}]`);
  }
}

export class Exo {
  constructor(
    private readonly apiKey: string,
    private readonly subject?: string,
  ) {}

  async call(method: string, path: string, body?: unknown) {
    const headers: Record<string, string> = { "X-Exo-API-Key": this.apiKey };
    if (this.subject) headers["X-Exo-Subject"] = this.subject;
    if (body) headers["Content-Type"] = "application/json";

    const response = await fetch(`https://api.get-exo.com${path}`, {
      method,
      headers,
      body: body ? JSON.stringify(body) : undefined,
    });
    if (!response.ok) throw new ExoError(await response.json());
    return response.status === 204 ? null : response.json();
  }

  retrieve(query: string, topK = 8) {
    return this.call("POST", "/v1/retrieve", { query, topK });
  }
}

# the same thing, as a shell function
exo() {
  local method="$1" path="$2" body="${3:-}"
  curl -sS -X "$method" "https://api.get-exo.com${path}" \
    -H "X-Exo-API-Key: $EXO_KEY" \
    ${body:+-H "Content-Type: application/json" -d "$body"}
}

exo POST /v1/retrieve '{"query": "Where did we land on pricing?", "topK": 8}'