Errors

curl -s https://api.console.larsa.larsima.com/v1/chat/completions \
  -H "Authorization: Bearer $LARSA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "not-a-model", "messages": []}' \
  | jq -r '.error.message // .detail'

import os
import requests

resp = requests.post(
    "https://api.console.larsa.larsima.com/v1/chat/completions",
    headers={"Authorization": f"Bearer {os.environ['LARSA_API_KEY']}"},
    json={"model": "larsa-general", "messages": [{"role": "user", "content": "hi"}]},
)
if not resp.ok:
    body = resp.json()
    message = (body.get("error") or {}).get("message") or body.get("detail")
    raise RuntimeError(f"{resp.status_code}: {message}")

const res = await fetch("https://api.console.larsa.larsima.com/v1/chat/completions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.LARSA_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ model: "larsa-general",
                        messages: [{ role: "user", content: "hi" }] }),
});
if (!res.ok) {
  const body = await res.json();
  throw new Error(`${res.status}: ${body.error?.message ?? body.detail}`);
}

interface ErrorEnvelope {
  error?: { message: string; type: string; param: string | null; code: string };
  detail?: string;
}

const res = await fetch("https://api.console.larsa.larsima.com/v1/chat/completions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.LARSA_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ model: "larsa-general",
                        messages: [{ role: "user", content: "hi" }] }),
});
if (!res.ok) {
  const body = (await res.json()) as ErrorEnvelope;
  throw new Error(`${res.status}: ${body.error?.message ?? body.detail}`);
}

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"strings"
)

type errorEnvelope struct {
	Error  *struct{ Message string `json:"message"` } `json:"error"`
	Detail string                                     `json:"detail"`
}

func readError(resp *http.Response) error {
	var e errorEnvelope
	json.NewDecoder(resp.Body).Decode(&e)
	msg := e.Detail
	if e.Error != nil {
		msg = e.Error.Message
	}
	return fmt.Errorf("%d: %s", resp.StatusCode, strings.TrimSpace(msg))
}

async fn check(resp: reqwest::Response) -> Result<reqwest::Response, String> {
    if resp.status().is_success() {
        return Ok(resp);
    }
    let status = resp.status();
    let body: serde_json::Value = resp.json().await.unwrap_or_default();
    let message = body["error"]["message"].as_str()
        .or_else(|| body["detail"].as_str())
        .unwrap_or("unknown error");
    Err(format!("{}: {}", status, message))
}

import java.net.http.HttpResponse;
import com.fasterxml.jackson.databind.*;

static void checkForError(HttpResponse<String> resp) throws Exception {
    if (resp.statusCode() < 400) return;
    JsonNode body = new ObjectMapper().readTree(resp.body());
    JsonNode error = body.path("error").path("message");
    String message = error.isMissingNode() ? body.path("detail").asText()
                                            : error.asText();
    throw new RuntimeException(resp.statusCode() + ": " + message);
}

using System.Text.Json;

async Task EnsureOkAsync(HttpResponseMessage resp) {
    if (resp.IsSuccessStatusCode) return;
    var body = JsonDocument.Parse(await resp.Content.ReadAsStringAsync()).RootElement;
    var message = body.TryGetProperty("error", out var err)
        ? err.GetProperty("message").GetString()
        : body.GetProperty("detail").GetString();
    throw new Exception($"{(int)resp.StatusCode}: {message}");
}

<?php
function ensureOk(int $status, string $rawBody): void {
    if ($status < 400) return;
    $body = json_decode($rawBody, true);
    $message = $body["error"]["message"] ?? $body["detail"] ?? "unknown error";
    throw new RuntimeException("{$status}: {$message}");
}

require "json"

def ensure_ok!(response)
  return if response.code.to_i < 400
  body = JSON.parse(response.body)
  message = body.dig("error", "message") || body["detail"] || "unknown error"
  raise "#{response.code}: #{message}"
end