export API="https://api.skillsafe.ai/v1/app-api"
export SKILLSAFE_TOKEN="YOUR_TOKEN"   # from /tokens.html, or the POST /guest below

# every authenticated call looks like:
#   curl -s "$API/..." -H "Authorization: Bearer $SKILLSAFE_TOKEN" \
#        -H "Content-Type: application/json" [-d '{json}']
# jq pulls fields out of the {"ok":true,"data":...} envelope

# a headless guest token (browse + estimate only on this app):
curl -s -X POST "$API/guest" \
  -H "Content-Type: application/json" \
  -d '{"slug":"chat-with-all"}' | jq -r '.data.token'

import os, requests

API = "https://api.skillsafe.ai/v1/app-api"
TOKEN = os.environ.get("SKILLSAFE_TOKEN", "YOUR_TOKEN")

def api(method, path, body=None, **headers):
    res = requests.request(
        method, API + path, json=body,
        headers={"Authorization": f"Bearer {TOKEN}", **headers})
    payload = res.json()
    if not res.ok:
        err = payload.get("error", {})
        raise RuntimeError(f"{err.get('code', res.status_code)}: {err.get('message', res.reason)}")
    return payload["data"]

# a headless guest token (browse + estimate only on this app):
guest = requests.post(API + "/guest", json={"slug": "chat-with-all"}).json()["data"]
print(guest["token"], guest["guest_id"], guest["expires_at"])

// Node 18+ (built-in fetch)
const API = "https://api.skillsafe.ai/v1/app-api";
const TOKEN = "YOUR_TOKEN"; // paste from /tokens.html - never commit it

async function api(method, path, body, extraHeaders = {}) {
  const res = await fetch(API + path, {
    method,
    headers: {
      Authorization: `Bearer ${TOKEN}`,
      "Content-Type": "application/json",
      ...extraHeaders,
    },
    body: body === undefined ? undefined : JSON.stringify(body),
  });
  const json = await res.json();
  if (!res.ok) {
    const e = new Error(json.error?.message ?? res.statusText);
    e.code = json.error?.code;
    e.status = res.status;
    throw e;
  }
  return json.data;
}

// a headless guest token (browse + estimate only on this app):
const guestRes = await fetch(API + "/guest", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ slug: "chat-with-all" }),
});
const { token, guest_id, expires_at } = (await guestRes.json()).data;

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

const API = "https://api.skillsafe.ai/v1/app-api"

var token = os.Getenv("SKILLSAFE_TOKEN")

func call(method, path string, body, out any, headers map[string]string) error {
	var buf bytes.Buffer
	if body != nil {
		json.NewEncoder(&buf).Encode(body)
	}
	req, _ := http.NewRequest(method, API+path, &buf)
	if token != "" {
		req.Header.Set("Authorization", "Bearer "+token)
	}
	req.Header.Set("Content-Type", "application/json")
	for k, v := range headers {
		req.Header.Set(k, v)
	}
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()
	var env struct {
		Data  json.RawMessage `json:"data"`
		Error *struct {
			Code    string `json:"code"`
			Message string `json:"message"`
		} `json:"error"`
	}
	json.NewDecoder(res.Body).Decode(&env)
	if res.StatusCode >= 400 {
		return fmt.Errorf("%s: %s", env.Error.Code, env.Error.Message)
	}
	if out == nil {
		return nil
	}
	return json.Unmarshal(env.Data, out)
}

// a headless guest token (browse + estimate only on this app):
func guest() (string, error) {
	var g struct {
		Token     string `json:"token"`
		GuestID   string `json:"guest_id"`
		ExpiresAt string `json:"expires_at"`
	}
	err := call("POST", "/guest", map[string]string{"slug": "chat-with-all"}, &g, nil)
	return g.Token, err
}

// Java 17+, no dependencies. Pair it with your JSON library (Jackson, Gson...)
// to read fields out of the returned envelope.
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.Map;

public class ChatWithAll {
    static final String API = "https://api.skillsafe.ai/v1/app-api";
    static final String TOKEN = System.getenv("SKILLSAFE_TOKEN");
    static final HttpClient HTTP = HttpClient.newHttpClient();

    static String api(String method, String path, String jsonBody, Map<String, String> headers)
            throws Exception {
        var b = HttpRequest.newBuilder(URI.create(API + path))
            .header("Content-Type", "application/json")
            .method(method, jsonBody == null
                ? HttpRequest.BodyPublishers.noBody()
                : HttpRequest.BodyPublishers.ofString(jsonBody));
        if (TOKEN != null) b = b.header("Authorization", "Bearer " + TOKEN);
        if (headers != null) for (var e : headers.entrySet()) b = b.header(e.getKey(), e.getValue());
        var res = HTTP.send(b.build(), HttpResponse.BodyHandlers.ofString());
        if (res.statusCode() >= 400) throw new RuntimeException(res.body());
        return res.body(); // envelope: {"ok":true,"data":...}
    }

    // a headless guest token (browse + estimate only on this app):
    static String guestEnvelope() throws Exception {
        return api("POST", "/guest", "{\"slug\":\"chat-with-all\"}", null);
        // token is at data.token, plus data.guest_id and data.expires_at
    }
}

require "net/http"
require "json"

API = "https://api.skillsafe.ai/v1/app-api"
TOKEN = ENV.fetch("SKILLSAFE_TOKEN", "YOUR_TOKEN")

def api(method, path, body = nil, headers = {})
  uri = URI(API + path)
  req = Net::HTTP.const_get(method.capitalize).new(uri)
  req["Authorization"] = "Bearer #{TOKEN}"
  req["Content-Type"] = "application/json"
  headers.each { |k, v| req[k] = v }
  req.body = body.to_json if body
  res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
  payload = JSON.parse(res.body)
  unless res.is_a?(Net::HTTPSuccess)
    raise "#{payload.dig('error', 'code')}: #{payload.dig('error', 'message')}"
  end
  payload["data"]
end

# a headless guest token (browse + estimate only on this app):
guest = api("POST", "/guest", { slug: "chat-with-all" })
puts guest["token"], guest["guest_id"], guest["expires_at"]

<?php
const API = "https://api.skillsafe.ai/v1/app-api";
$TOKEN = getenv("SKILLSAFE_TOKEN") ?: "YOUR_TOKEN";

function api(string $method, string $path, ?array $body = null, array $headers = []): mixed {
    global $TOKEN;
    $hdr = array_merge([
        "Authorization: Bearer $TOKEN",
        "Content-Type: application/json",
    ], $headers);
    $ch = curl_init(API . $path);
    curl_setopt_array($ch, [
        CURLOPT_CUSTOMREQUEST  => $method,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER     => $hdr,
        CURLOPT_POSTFIELDS     => $body === null ? null : json_encode($body),
    ]);
    $payload = json_decode(curl_exec($ch), true);
    $status  = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
    curl_close($ch);
    if ($status >= 400) {
        throw new Exception(($payload["error"]["code"] ?? "http_$status") . ": "
            . ($payload["error"]["message"] ?? "request failed"));
    }
    return $payload["data"];
}

// a headless guest token (browse + estimate only on this app):
$guest = api("POST", "/guest", ["slug" => "chat-with-all"]);
echo $guest["token"], " ", $guest["guest_id"], " ", $guest["expires_at"], "\n";

// .NET 8+
using System.Net.Http.Json;
using System.Text.Json;

static class ChatWithAll
{
    const string Api = "https://api.skillsafe.ai/v1/app-api";
    static readonly HttpClient Http = new();

    static ChatWithAll() =>
        Http.DefaultRequestHeaders.Authorization =
            new("Bearer", Environment.GetEnvironmentVariable("SKILLSAFE_TOKEN"));

    public static async Task<JsonElement> ApiAsync(
        HttpMethod method, string path, object? body = null,
        (string Name, string Value)[]? headers = null)
    {
        var req = new HttpRequestMessage(method, Api + path);
        if (body != null) req.Content = JsonContent.Create(body);
        if (headers != null)
            foreach (var h in headers) req.Headers.Add(h.Name, h.Value);
        var res = await Http.SendAsync(req);
        var json = await res.Content.ReadFromJsonAsync<JsonElement>();
        if (!res.IsSuccessStatusCode)
        {
            var err = json.GetProperty("error");
            throw new Exception($"{err.GetProperty("code")}: {err.GetProperty("message")}");
        }
        return json.GetProperty("data");
    }
}

// a headless guest token (browse + estimate only on this app):
var guest = await ChatWithAll.ApiAsync(HttpMethod.Post, "/guest",
    new { slug = "chat-with-all" });
Console.WriteLine(guest.GetProperty("token").GetString());

curl -s "$API/me" -H "Authorization: Bearer $SKILLSAFE_TOKEN" | jq '.data'

me = api("GET", "/me")
print(me["subject_type"], me["subject_id"], me["credits"])

const me = await api("GET", "/me");
console.log(me.subject_type, me.subject_id, me.credits);

var me struct {
	SubjectType string `json:"subject_type"`
	SubjectID   string `json:"subject_id"`
	Credits     int64  `json:"credits"`
}
err := call("GET", "/me", nil, &me, nil)

String envelope = api("GET", "/me", null, null);
// data.subject_type, data.subject_id, data.credits

me = api("GET", "/me")
puts "#{me["subject_type"]} #{me["subject_id"]}: #{me["credits"]} credits"

$me = api("GET", "/me");
echo "{$me['subject_type']}: {$me['credits']} credits\n";

var me = await ChatWithAll.ApiAsync(HttpMethod.Get, "/me");
Console.WriteLine($"{me.GetProperty("subject_type")}: {me.GetProperty("credits")} credits");

# public - no Authorization header, and NOT under /v1/app-api
curl -s "https://api.skillsafe.ai/v1/models" \
  | jq '.data.models[] | select(.available) | {id, provider, out: .rates.billed_usd_per_mtok.out}'

# the alias map
curl -s "https://api.skillsafe.ai/v1/models" | jq '.data.aliases'

import requests

# public - no Authorization header, and NOT under /v1/app-api
cat = requests.get("https://api.skillsafe.ai/v1/models").json()["data"]
usable = [m for m in cat["models"] if m["available"]]
for m in usable:
    print(m["id"], m["provider"], m["rates"]["billed_usd_per_mtok"]["out"])

for m in cat["models"]:
    if not m["available"]:
        print("skip", m["id"], "-", m["unavailable_reason"])

print("aliases:", cat["aliases"])
print("default:", cat["default_model"])

// public - no Authorization header, and NOT under /v1/app-api
const cat = (await (await fetch("https://api.skillsafe.ai/v1/models")).json()).data;
const usable = cat.models.filter((m) => m.available);
for (const m of usable) {
  console.log(m.id, m.provider, m.rates.billed_usd_per_mtok.out);
}
// never hardcode ids - anthropic/* is available:false on this deployment
const pick = usable.find((m) => m.id === "gpt-5.6-terra") ?? usable[0];

type Model struct {
	ID                string `json:"id"`
	Label             string `json:"label"`
	Provider          string `json:"provider"`
	Available         bool   `json:"available"`
	UnavailableReason string `json:"unavailable_reason"`
	Rates             struct {
		BilledUSDPerMTok struct {
			In  float64 `json:"in"`
			Out float64 `json:"out"`
		} `json:"billed_usd_per_mtok"`
	} `json:"rates"`
	Caps struct {
		MaxInputTokens  int `json:"max_input_tokens"`
		MaxOutputTokens int `json:"max_output_tokens"`
		WallClockMs     int `json:"wall_clock_ms"`
	} `json:"caps"`
}

// public - no Authorization header, and NOT under /v1/app-api
res, _ := http.Get("https://api.skillsafe.ai/v1/models")
defer res.Body.Close()
var env struct {
	Data struct {
		DefaultModel string            `json:"default_model"`
		Models       []Model           `json:"models"`
		Aliases      map[string]string `json:"aliases"`
	} `json:"data"`
}
json.NewDecoder(res.Body).Decode(&env)
for _, m := range env.Data.Models {
	if m.Available {
		fmt.Println(m.ID, m.Provider, m.Rates.BilledUSDPerMTok.Out)
	}
}

// public - no Authorization header, and NOT under /v1/app-api
var req = HttpRequest.newBuilder(URI.create("https://api.skillsafe.ai/v1/models")).build();
var res = HttpClient.newHttpClient().send(req, HttpResponse.BodyHandlers.ofString());
String envelope = res.body();
// data.models[] -> id, label, provider, available, unavailable_reason,
//                  rates.billed_usd_per_mtok.{in,out},
//                  caps.{max_input_tokens,max_output_tokens,wall_clock_ms}
// data.aliases  -> {"gpt-terra":"gpt-5.6-terra", ...}
// Filter on `available` before offering a model in your UI.

require "net/http"
require "json"

# public - no Authorization header, and NOT under /v1/app-api
cat = JSON.parse(Net::HTTP.get(URI("https://api.skillsafe.ai/v1/models")))["data"]
cat["models"].select { |m| m["available"] }.each do |m|
  puts "#{m["id"]} #{m["provider"]} #{m.dig("rates", "billed_usd_per_mtok", "out")}"
end
puts cat["aliases"]["gpt-terra"] # => "gpt-5.6-terra"

<?php
// public - no Authorization header, and NOT under /v1/app-api
$cat = json_decode(file_get_contents("https://api.skillsafe.ai/v1/models"), true)["data"];
foreach ($cat["models"] as $m) {
    if (!$m["available"]) { continue; }
    echo $m["id"], " ", $m["provider"], " ",
         $m["rates"]["billed_usd_per_mtok"]["out"], "\n";
}
echo $cat["aliases"]["gpt-terra"], "\n"; // gpt-5.6-terra

// public - no Authorization header, and NOT under /v1/app-api
using var plain = new HttpClient();
var cat = (await plain.GetFromJsonAsync<JsonElement>("https://api.skillsafe.ai/v1/models"))
    .GetProperty("data");
foreach (var m in cat.GetProperty("models").EnumerateArray())
{
    if (!m.GetProperty("available").GetBoolean()) continue;
    Console.WriteLine($"{m.GetProperty("id")} {m.GetProperty("provider")}");
}
var terra = cat.GetProperty("aliases").GetProperty("gpt-terra").GetString();

curl -s -X POST "$API/estimate" \
  -H "Authorization: Bearer $SKILLSAFE_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"content":"Explain CRDTs in two paragraphs.","$model":"gpt-5.6-terra"}' \
  | jq '.data'
# => {"hold_credits":1367,"min_credits":58,"model":"gpt-5.6-terra",
#     "model_alias":null,"markup_bps":0,"sponsor_enabled":false,"byok":false}

# the body IS the input object - no {"input": ...} wrapper
est = api("POST", "/estimate", {
    "content": "Explain CRDTs in two paragraphs.",
    "$model": "gpt-5.6-terra",
})
print(est["hold_credits"], est["min_credits"], est["model"], est["markup_bps"])
# 1367 58 gpt-5.6-terra 0

me = api("GET", "/me")
if me["credits"] < est["hold_credits"]:
    print("not enough credits to place the hold - the turn would 402")

// the body IS the input object - no { input: ... } wrapper
const est = await api("POST", "/estimate", {
  content: "Explain CRDTs in two paragraphs.",
  $model: "gpt-5.6-terra",
});
console.log(est.hold_credits, est.min_credits, est.model, est.markup_bps);
// 1367 58 gpt-5.6-terra 0

// price the whole lineup at once, like the app's meter does
const lineup = ["@cf/google/gemma-4-26b-a4b-it", "gpt-5.6-terra", "gpt-5.6-sol"];
const quotes = await Promise.all(lineup.map((m) =>
  api("POST", "/estimate", { content: "Explain CRDTs in two paragraphs.", $model: m })));
console.log(quotes.reduce((sum, q) => sum + q.hold_credits, 0)); // total hold

// the body IS the input object - no {"input": ...} wrapper
var est struct {
	HoldCredits int64   `json:"hold_credits"`
	MinCredits  int64   `json:"min_credits"`
	Model       string  `json:"model"`
	ModelAlias  *string `json:"model_alias"`
	MarkupBps   int     `json:"markup_bps"`
}
err := call("POST", "/estimate", map[string]any{
	"content": "Explain CRDTs in two paragraphs.",
	"$model":  "gpt-5.6-terra",
}, &est, nil)
fmt.Println(est.HoldCredits, est.MinCredits, est.Model) // 1367 58 gpt-5.6-terra

// the body IS the input object - no {"input": ...} wrapper
String envelope = api("POST", "/estimate", """
    {"content":"Explain CRDTs in two paragraphs.","$model":"gpt-5.6-terra"}""", null);
// data.hold_credits = 1367, data.min_credits = 58,
// data.model = "gpt-5.6-terra", data.model_alias = null, data.markup_bps = 0

# the body IS the input object - no {"input" => ...} wrapper
est = api("POST", "/estimate", {
  "content" => "Explain CRDTs in two paragraphs.",
  "$model" => "gpt-5.6-terra",
})
puts "hold #{est["hold_credits"]} / min #{est["min_credits"]} on #{est["model"]}"
# hold 1367 / min 58 on gpt-5.6-terra

<?php
// the body IS the input object - no ["input" => ...] wrapper
$est = api("POST", "/estimate", [
    "content" => "Explain CRDTs in two paragraphs.",
    "\$model" => "gpt-5.6-terra",
]);
printf("hold %d / min %d on %s (markup %d bps)\n",
    $est["hold_credits"], $est["min_credits"], $est["model"], $est["markup_bps"]);
// hold 1367 / min 58 on gpt-5.6-terra (markup 0 bps)

// the body IS the input object - no { input = ... } wrapper.
// "$model" is not a legal C# identifier, so build the body as a dictionary.
var est = await ChatWithAll.ApiAsync(HttpMethod.Post, "/estimate",
    new Dictionary<string, object> {
        ["content"] = "Explain CRDTs in two paragraphs.",
        ["$model"] = "gpt-5.6-terra",
    });
Console.WriteLine($"hold {est.GetProperty("hold_credits")} / min {est.GetProperty("min_credits")}");
// hold 1367 / min 58

SESSION=$(curl -s -X POST "$API/sessions" \
  -H "Authorization: Bearer $SKILLSAFE_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"title":"CRDT comparison"}' | jq -r '.data.session.session_id')
echo "$SESSION"

session = api("POST", "/sessions", {"title": "CRDT comparison"})["session"]
sid = session["session_id"]

const { session } = await api("POST", "/sessions", { title: "CRDT comparison" });
const sid = session.session_id;

var created struct {
	Session struct {
		SessionID string `json:"session_id"`
		Title     string `json:"title"`
	} `json:"session"`
}
err := call("POST", "/sessions", map[string]string{"title": "CRDT comparison"}, &created, nil)
sid := created.Session.SessionID

String envelope = api("POST", "/sessions", """
    {"title":"CRDT comparison"}""", null);
// the id is at data.session.session_id

session = api("POST", "/sessions", { title: "CRDT comparison" })["session"]
sid = session["session_id"]

<?php
$session = api("POST", "/sessions", ["title" => "CRDT comparison"])["session"];
$sid = $session["session_id"];

var created = await ChatWithAll.ApiAsync(HttpMethod.Post, "/sessions",
    new { title = "CRDT comparison" });
var sid = created.GetProperty("session").GetProperty("session_id").GetString();

curl -s "$API/sessions" -H "Authorization: Bearer $SKILLSAFE_TOKEN" | jq '.data.sessions'
curl -s "$API/sessions/$SESSION" -H "Authorization: Bearer $SKILLSAFE_TOKEN" | jq '.data'
curl -s -X DELETE "$API/sessions/$SESSION" -H "Authorization: Bearer $SKILLSAFE_TOKEN" | jq '.ok'

sessions = api("GET", "/sessions")["sessions"]
detail   = api("GET", f"/sessions/{sid}")
api("DELETE", f"/sessions/{sid}")

const { sessions } = await api("GET", "/sessions");
const detail = await api("GET", `/sessions/${encodeURIComponent(sid)}`);
await api("DELETE", `/sessions/${encodeURIComponent(sid)}`);

var list struct {
	Sessions []struct {
		SessionID string `json:"session_id"`
		Title     string `json:"title"`
	} `json:"sessions"`
}
call("GET", "/sessions", nil, &list, nil)
call("GET", "/sessions/"+url.PathEscape(sid), nil, nil, nil)
call("DELETE", "/sessions/"+url.PathEscape(sid), nil, nil, nil)

String list   = api("GET", "/sessions", null, null);          // data.sessions[]
String detail = api("GET", "/sessions/" + sid, null, null);
api("DELETE", "/sessions/" + sid, null, null);

sessions = api("GET", "/sessions")["sessions"]
detail   = api("GET", "/sessions/#{sid}")
api("DELETE", "/sessions/#{sid}")

<?php
$sessions = api("GET", "/sessions")["sessions"];
$detail   = api("GET", "/sessions/" . rawurlencode($sid));
api("DELETE", "/sessions/" . rawurlencode($sid));

var list = await ChatWithAll.ApiAsync(HttpMethod.Get, "/sessions");
foreach (var s in list.GetProperty("sessions").EnumerateArray())
    Console.WriteLine(s.GetProperty("session_id"));
await ChatWithAll.ApiAsync(HttpMethod.Get, $"/sessions/{Uri.EscapeDataString(sid!)}");
await ChatWithAll.ApiAsync(HttpMethod.Delete, $"/sessions/{Uri.EscapeDataString(sid!)}");

# submit (no "stream" -> job + poll), with an idempotency key
KEY=$(printf '%s|%s|%s' "$SESSION" "Explain CRDTs in two paragraphs." 1 | shasum -a 256 | cut -c1-32)

JOB=$(curl -s -X POST "$API/sessions/$SESSION/messages" \
  -H "Authorization: Bearer $SKILLSAFE_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $KEY" \
  -d '{"content":"Explain CRDTs in two paragraphs.","$model":"gpt-5.6-terra"}' \
  | jq -r '.data.job_id')

# poll until terminal
while :; do
  J=$(curl -s "$API/jobs/$JOB" -H "Authorization: Bearer $SKILLSAFE_TOKEN" | jq '.data')
  S=$(echo "$J" | jq -r '.status')
  [ "$S" = "succeeded" ] || [ "$S" = "failed" ] && break
  sleep 1
done
echo "$J" | jq -r '.output.output'
echo "$J" | jq '{charged_credits, truncated}'

import hashlib, time

def turn_key(session_id, content, attempt=1):
    raw = f"{session_id}|{content}|{attempt}".encode()
    return hashlib.sha256(raw).hexdigest()[:32]

content = "Explain CRDTs in two paragraphs."
sub = api("POST", f"/sessions/{sid}/messages",
          {"content": content, "$model": "gpt-5.6-terra"},
          **{"Idempotency-Key": turn_key(sid, content)})

job = api("GET", f"/jobs/{sub['job_id']}")
while job["status"] not in ("succeeded", "failed"):
    time.sleep(1)
    job = api("GET", f"/jobs/{sub['job_id']}")

if job["status"] == "succeeded":
    print(job["output"]["output"])
    print("charged", job["charged_credits"], "credits")
    if job.get("truncated"):
        print("cut short by your balance - top up to continue")
else:
    print("failed:", job["error"])

import { createHash } from "node:crypto";

const turnKey = (sessionId, content, attempt = 1) =>
  createHash("sha256").update(`${sessionId}|${content}|${attempt}`).digest("hex").slice(0, 32);

const content = "Explain CRDTs in two paragraphs.";
const sub = await api("POST", `/sessions/${encodeURIComponent(sid)}/messages`,
  { content, $model: "gpt-5.6-terra" },
  { "Idempotency-Key": turnKey(sid, content) });

let job = await api("GET", `/jobs/${encodeURIComponent(sub.job_id)}`);
while (job.status !== "succeeded" && job.status !== "failed") {
  await new Promise((r) => setTimeout(r, 1000));
  job = await api("GET", `/jobs/${encodeURIComponent(sub.job_id)}`);
}
if (job.status === "succeeded") {
  console.log(job.output.output);
  console.log("charged", job.charged_credits, "credits");
  if (job.truncated) console.log("cut short by your balance - top up to continue");
} else {
  console.error("failed:", job.error);
}

func turnKey(sessionID, content string, attempt int) string {
	sum := sha256.Sum256([]byte(fmt.Sprintf("%s|%s|%d", sessionID, content, attempt)))
	return hex.EncodeToString(sum[:])[:32]
}

content := "Explain CRDTs in two paragraphs."
var sub struct {
	JobID     string `json:"job_id"`
	SessionID string `json:"session_id"`
}
err := call("POST", "/sessions/"+url.PathEscape(sid)+"/messages", map[string]any{
	"content": content,
	"$model":  "gpt-5.6-terra",
}, &sub, map[string]string{"Idempotency-Key": turnKey(sid, content, 1)})

var job struct {
	Status         string `json:"status"`
	ChargedCredits int64  `json:"charged_credits"`
	Truncated      bool   `json:"truncated"`
	Output         struct {
		Output string `json:"output"`
	} `json:"output"`
}
for {
	if err := call("GET", "/jobs/"+url.PathEscape(sub.JobID), nil, &job, nil); err != nil {
		break
	}
	if job.Status == "succeeded" || job.Status == "failed" {
		break
	}
	time.Sleep(time.Second)
}
fmt.Println(job.Output.Output, job.ChargedCredits, job.Truncated)

static String turnKey(String sessionId, String content, int attempt) throws Exception {
    var md = java.security.MessageDigest.getInstance("SHA-256");
    var d = md.digest((sessionId + "|" + content + "|" + attempt).getBytes("UTF-8"));
    var sb = new StringBuilder();
    for (byte b : d) sb.append(String.format("%02x", b));
    return sb.substring(0, 32);
}

String content = "Explain CRDTs in two paragraphs.";
String sub = api("POST", "/sessions/" + sid + "/messages",
    "{\"content\":\"" + content + "\",\"$model\":\"gpt-5.6-terra\"}",
    Map.of("Idempotency-Key", turnKey(sid, content, 1)));
// data.job_id -> poll GET /jobs/{job_id} once a second until
// data.status is "succeeded" or "failed"; then read
// data.output.output, data.charged_credits, data.truncated

require "digest"

def turn_key(session_id, content, attempt = 1)
  Digest::SHA256.hexdigest("#{session_id}|#{content}|#{attempt}")[0, 32]
end

content = "Explain CRDTs in two paragraphs."
sub = api("POST", "/sessions/#{sid}/messages",
          { "content" => content, "$model" => "gpt-5.6-terra" },
          { "Idempotency-Key" => turn_key(sid, content) })

job = api("GET", "/jobs/#{sub["job_id"]}")
until %w[succeeded failed].include?(job["status"])
  sleep 1
  job = api("GET", "/jobs/#{sub["job_id"]}")
end
puts job.dig("output", "output")
puts "charged #{job["charged_credits"]} credits (truncated: #{job["truncated"]})"

<?php
function turn_key(string $sessionId, string $content, int $attempt = 1): string {
    return substr(hash("sha256", "$sessionId|$content|$attempt"), 0, 32);
}

$content = "Explain CRDTs in two paragraphs.";
$sub = api("POST", "/sessions/" . rawurlencode($sid) . "/messages",
    ["content" => $content, "\$model" => "gpt-5.6-terra"],
    ["Idempotency-Key: " . turn_key($sid, $content)]);

do {
    sleep(1);
    $job = api("GET", "/jobs/" . rawurlencode($sub["job_id"]));
} while (!in_array($job["status"], ["succeeded", "failed"], true));

echo $job["output"]["output"], "\n";
printf("charged %d credits%s\n", $job["charged_credits"],
    !empty($job["truncated"]) ? " (cut short by your balance)" : "");

using System.Security.Cryptography;
using System.Text;

static string TurnKey(string sessionId, string content, int attempt = 1)
{
    var bytes = SHA256.HashData(Encoding.UTF8.GetBytes($"{sessionId}|{content}|{attempt}"));
    return Convert.ToHexString(bytes)[..32].ToLowerInvariant();
}

var content = "Explain CRDTs in two paragraphs.";
var sub = await ChatWithAll.ApiAsync(HttpMethod.Post,
    $"/sessions/{Uri.EscapeDataString(sid!)}/messages",
    new Dictionary<string, object> { ["content"] = content, ["$model"] = "gpt-5.6-terra" },
    new[] { ("Idempotency-Key", TurnKey(sid!, content)) });

var jobId = sub.GetProperty("job_id").GetString();
JsonElement job;
string status;
do
{
    await Task.Delay(1000);
    job = await ChatWithAll.ApiAsync(HttpMethod.Get, $"/jobs/{Uri.EscapeDataString(jobId!)}");
    status = job.GetProperty("status").GetString()!;
} while (status != "succeeded" && status != "failed");

Console.WriteLine(job.GetProperty("output").GetProperty("output").GetString());
Console.WriteLine($"charged {job.GetProperty("charged_credits")} credits");

curl -N -s -X POST "$API/sessions/$SESSION/messages" \
  -H "Authorization: Bearer $SKILLSAFE_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $KEY" \
  -d '{"content":"Explain CRDTs in two paragraphs.","$model":"gpt-5.6-terra","stream":true}'

# -N disables curl's buffering so frames arrive as they are produced:
#   event: job    / data: {"job_id":"...","session_id":"..."}
#   event: delta  / data: {"text":"..."}
#   event: done   / data: {"job_id":"...","status":"succeeded","charged_credits":91,
#                          "output":{"output":"..."},"truncated":false}

import json, requests

def stream_turn(sid, content, model, key):
    res = requests.post(
        f"{API}/sessions/{sid}/messages",
        json={"content": content, "$model": model, "stream": True},
        headers={"Authorization": f"Bearer {TOKEN}",
                 "Idempotency-Key": key},
        stream=True)
    if "text/event-stream" not in res.headers.get("content-type", ""):
        return res.json()["data"]          # replay or early rejection: plain JSON

    result, failure, frame = None, None, []
    for line in res.iter_lines(decode_unicode=True):
        if line:
            frame.append(line)
            continue
        event, data_str = "message", ""
        for ln in frame:
            if ln.startswith("event:"):
                event = ln[6:].strip()
            elif ln.startswith("data:"):
                data_str += ln[5:].strip()
        frame = []
        if not data_str:
            continue
        try:
            data = json.loads(data_str)
        except ValueError:
            continue
        if event == "delta":
            print(data.get("text", ""), end="", flush=True)
        elif event == "job":
            pass                            # hold placed, model running
        elif event in ("done", "pending"):
            result = data
        elif event == "error":
            failure = data
    if failure:
        raise RuntimeError(f"{failure.get('code')}: {failure.get('message', 'job failed')}")
    return result

done = stream_turn(sid, "Explain CRDTs in two paragraphs.", "gpt-5.6-terra", key)
print("\ncharged", done["charged_credits"], "truncated", done["truncated"])

// This is what sdk.js does internally (_readSse), unrolled.
async function streamTurn(sid, content, model, key, onDelta) {
  const res = await fetch(`${API}/sessions/${encodeURIComponent(sid)}/messages`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${TOKEN}`,
      "Content-Type": "application/json",
      "Idempotency-Key": key,
    },
    body: JSON.stringify({ content, $model: model, stream: true }),
  });
  const ctype = res.headers.get("content-type") || "";
  if (ctype.indexOf("text/event-stream") === -1) {
    const json = await res.json();
    if (!res.ok) throw new Error(json.error?.message);
    return json.data;                        // replay or early rejection
  }

  const reader = res.body.getReader();
  const decoder = new TextDecoder();
  let buffer = "", result = null, failure = null;
  for (;;) {
    const chunk = await reader.read();
    if (chunk.done) break;
    buffer += decoder.decode(chunk.value, { stream: true });
    let idx;
    while ((idx = buffer.indexOf("\n\n")) >= 0) {
      const raw = buffer.slice(0, idx);
      buffer = buffer.slice(idx + 2);
      let event = "message", dataStr = "";
      for (const line of raw.split("\n")) {
        if (line.startsWith("event:")) event = line.slice(6).trim();
        else if (line.startsWith("data:")) dataStr += line.slice(5).trim();
      }
      if (!dataStr) continue;
      let data;
      try { data = JSON.parse(dataStr); } catch { continue; }
      if (event === "delta") onDelta(data.text || "");
      else if (event === "done" || event === "pending") result = data;
      else if (event === "error") failure = data;
    }
  }
  if (failure) throw Object.assign(new Error(failure.message || "job failed"),
                                   { code: failure.code, job_id: failure.job_id });
  return result; // { job_id, status, charged_credits, output, truncated }
}

func streamTurn(sid, content, model, key string, onDelta func(string)) (map[string]any, error) {
	body, _ := json.Marshal(map[string]any{
		"content": content, "$model": model, "stream": true,
	})
	req, _ := http.NewRequest("POST",
		API+"/sessions/"+url.PathEscape(sid)+"/messages", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+token)
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Idempotency-Key", key)
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	if !strings.Contains(res.Header.Get("Content-Type"), "text/event-stream") {
		var env struct{ Data map[string]any `json:"data"` }
		json.NewDecoder(res.Body).Decode(&env)
		return env.Data, nil // replay or early rejection
	}

	var result, failure map[string]any
	sc := bufio.NewScanner(res.Body)
	sc.Buffer(make([]byte, 1<<20), 1<<20)
	event, dataStr := "message", ""
	flush := func() {
		defer func() { event, dataStr = "message", "" }()
		if dataStr == "" {
			return
		}
		var data map[string]any
		if json.Unmarshal([]byte(dataStr), &data) != nil {
			return
		}
		switch event {
		case "delta":
			s, _ := data["text"].(string)
			onDelta(s)
		case "done", "pending":
			result = data
		case "error":
			failure = data
		}
	}
	for sc.Scan() {
		line := sc.Text()
		switch {
		case line == "":
			flush()
		case strings.HasPrefix(line, "event:"):
			event = strings.TrimSpace(line[6:])
		case strings.HasPrefix(line, "data:"):
			dataStr += strings.TrimSpace(line[5:])
		}
	}
	flush()
	if failure != nil {
		return nil, fmt.Errorf("%v: %v", failure["code"], failure["message"])
	}
	return result, nil // job_id, status, charged_credits, output, truncated
}

// Java 17+: stream the body line by line and reassemble SSE frames.
var body = "{\"content\":\"" + content + "\",\"$model\":\"gpt-5.6-terra\",\"stream\":true}";
var req = HttpRequest.newBuilder(URI.create(API + "/sessions/" + sid + "/messages"))
    .header("Authorization", "Bearer " + TOKEN)
    .header("Content-Type", "application/json")
    .header("Idempotency-Key", turnKey(sid, content, 1))
    .POST(HttpRequest.BodyPublishers.ofString(body))
    .build();
var res = HTTP.send(req, HttpResponse.BodyHandlers.ofLines());

if (!res.headers().firstValue("content-type").orElse("").contains("text/event-stream")) {
    // replay or early rejection: an ordinary {"ok":..,"data":..} envelope
}

var event = new StringBuilder("message");
var data = new StringBuilder();
res.body().forEach(line -> {
    if (line.isEmpty()) {
        // frame end: parse `data` as JSON and dispatch on `event`
        //   "delta"           -> append data.text
        //   "job"             -> hold placed, model running
        //   "done" | "pending"-> terminal result: job_id, status,
        //                        charged_credits, output.output, truncated
        //   "error"           -> data.message / data.code / data.job_id
        event.setLength(0); event.append("message");
        data.setLength(0);
    } else if (line.startsWith("event:")) {
        event.setLength(0); event.append(line.substring(6).trim());
    } else if (line.startsWith("data:")) {
        data.append(line.substring(5).trim());
    }
});

require "net/http"
require "json"

def stream_turn(sid, content, model, key)
  uri = URI("#{API}/sessions/#{sid}/messages")
  req = Net::HTTP::Post.new(uri)
  req["Authorization"] = "Bearer #{TOKEN}"
  req["Content-Type"] = "application/json"
  req["Idempotency-Key"] = key
  req.body = { "content" => content, "$model" => model, "stream" => true }.to_json

  result = nil
  failure = nil
  Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
    http.request(req) do |res|
      unless res["content-type"].to_s.include?("text/event-stream")
        return JSON.parse(res.body)["data"] # replay or early rejection
      end
      buffer = ""
      res.read_body do |chunk|
        buffer += chunk
        while (idx = buffer.index("\n\n"))
          frame = buffer.slice!(0, idx + 2)
          event = "message"
          data_str = +""
          frame.split("\n").each do |line|
            if line.start_with?("event:") then event = line[6..].strip
            elsif line.start_with?("data:") then data_str << line[5..].strip
            end
          end
          next if data_str.empty?
          data = (JSON.parse(data_str) rescue next)
          case event
          when "delta"          then print data["text"].to_s
          when "job"            then nil # hold placed, model running
          when "done", "pending" then result = data
          when "error"          then failure = data
          end
        end
      end
    end
  end
  raise "#{failure["code"]}: #{failure["message"] || "job failed"}" if failure
  result
end

<?php
function stream_turn(string $sid, string $content, string $model, string $key): ?array {
    global $TOKEN;
    $result = null;
    $failure = null;
    $buffer = "";

    $ch = curl_init(API . "/sessions/" . rawurlencode($sid) . "/messages");
    curl_setopt_array($ch, [
        CURLOPT_POST       => true,
        CURLOPT_HTTPHEADER => [
            "Authorization: Bearer $TOKEN",
            "Content-Type: application/json",
            "Idempotency-Key: $key",
        ],
        CURLOPT_POSTFIELDS => json_encode([
            "content" => $content, "\$model" => $model, "stream" => true,
        ]),
        CURLOPT_WRITEFUNCTION => function ($ch, $chunk) use (&$buffer, &$result, &$failure) {
            $buffer .= $chunk;
            while (($idx = strpos($buffer, "\n\n")) !== false) {
                $frame  = substr($buffer, 0, $idx);
                $buffer = substr($buffer, $idx + 2);
                $event = "message";
                $dataStr = "";
                foreach (explode("\n", $frame) as $line) {
                    if (str_starts_with($line, "event:")) {
                        $event = trim(substr($line, 6));
                    } elseif (str_starts_with($line, "data:")) {
                        $dataStr .= trim(substr($line, 5));
                    }
                }
                if ($dataStr === "") { continue; }
                $data = json_decode($dataStr, true);
                if ($data === null) { continue; }
                if ($event === "delta") { echo $data["text"] ?? ""; }
                elseif ($event === "done" || $event === "pending") { $result = $data; }
                elseif ($event === "error") { $failure = $data; }
            }
            return strlen($chunk);
        },
    ]);
    curl_exec($ch);
    curl_close($ch);
    if ($failure) {
        throw new Exception(($failure["code"] ?? "error") . ": "
            . ($failure["message"] ?? "job failed"));
    }
    return $result; // job_id, status, charged_credits, output, truncated
}

// .NET 8+
static async Task<JsonElement?> StreamTurnAsync(
    HttpClient http, string sid, string content, string model, string key, Action<string> onDelta)
{
    var req = new HttpRequestMessage(HttpMethod.Post,
        $"https://api.skillsafe.ai/v1/app-api/sessions/{Uri.EscapeDataString(sid)}/messages")
    {
        Content = JsonContent.Create(new Dictionary<string, object> {
            ["content"] = content, ["$model"] = model, ["stream"] = true,
        }),
    };
    req.Headers.Add("Idempotency-Key", key);

    var res = await http.SendAsync(req, HttpCompletionOption.ResponseHeadersRead);
    if (res.Content.Headers.ContentType?.MediaType != "text/event-stream")
    {
        var plain = await res.Content.ReadFromJsonAsync<JsonElement>();
        return plain.GetProperty("data");   // replay or early rejection
    }

    using var reader = new StreamReader(await res.Content.ReadAsStreamAsync());
    JsonElement? result = null, failure = null;
    string evt = "message", dataStr = "";
    while (await reader.ReadLineAsync() is { } line)
    {
        if (line.Length == 0)
        {
            if (dataStr.Length > 0)
            {
                try
                {
                    var data = JsonDocument.Parse(dataStr).RootElement.Clone();
                    if (evt == "delta")
                        onDelta(data.TryGetProperty("text", out var t) ? t.GetString() ?? "" : "");
                    else if (evt is "done" or "pending") result = data;
                    else if (evt == "error") failure = data;
                }
                catch (JsonException) { /* skip unparseable frame */ }
            }
            evt = "message"; dataStr = "";
        }
        else if (line.StartsWith("event:")) evt = line[6..].Trim();
        else if (line.StartsWith("data:")) dataStr += line[5..].Trim();
    }
    if (failure is { } f)
        throw new Exception(f.GetProperty("message").GetString() ?? "job failed");
    return result; // job_id, status, charged_credits, output, truncated
}

# write the comparison history
curl -s -X PUT "$API/data/history" \
  -H "Authorization: Bearer $SKILLSAFE_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"value":[{"id":"cmp_x","ts":"2026-08-07T00:00:00Z","prompt":"Explain CRDTs in two paragraphs.","lanes":[{"model":"gpt-5.6-terra","label":"GPT-5.6 Terra","status":"succeeded","text":"...","chars":3,"elapsed_ms":4200,"charged_credits":190,"truncated":false,"error":null}]}]}'

# read it back (404 simply means "nothing stored yet")
curl -s "$API/data/history" -H "Authorization: Bearer $SKILLSAFE_TOKEN" | jq '.data.value'

# list keys, then drop one
curl -s "$API/data" -H "Authorization: Bearer $SKILLSAFE_TOKEN" | jq '.data.keys'
curl -s -X DELETE "$API/data/history" -H "Authorization: Bearer $SKILLSAFE_TOKEN" | jq '.ok'

lane = {"model": "gpt-5.6-terra", "label": "GPT-5.6 Terra", "status": "succeeded",
        "text": "...", "chars": 3, "elapsed_ms": 4200,
        "charged_credits": 190, "truncated": False, "error": None}
history = [{"id": "cmp_x", "ts": "2026-08-07T00:00:00Z",
            "prompt": "Explain CRDTs in two paragraphs.", "lanes": [lane]}]
api("PUT", "/data/history", {"value": history})

try:
    history = api("GET", "/data/history")["value"]
except RuntimeError:
    history = []          # a missing key is a 404 - that just means "empty"

keys = api("GET", "/data")["keys"]
api("DELETE", "/data/history")

const lane = { model: "gpt-5.6-terra", label: "GPT-5.6 Terra", status: "succeeded",
               text: "...", chars: 3, elapsed_ms: 4200,
               charged_credits: 190, truncated: false, error: null };
const history = [{ id: "cmp_x", ts: "2026-08-07T00:00:00Z",
                   prompt: "Explain CRDTs in two paragraphs.", lanes: [lane] }];
await api("PUT", "/data/history", { value: history });

// a missing key is 404 - that just means "empty"
const stored = await api("GET", "/data/history")
  .then((d) => d.value)
  .catch((e) => (e.status === 404 ? [] : Promise.reject(e)));

const { keys } = await api("GET", "/data");
await api("DELETE", "/data/history");

type Lane struct {
	Model          string  `json:"model"`
	Label          string  `json:"label"`
	Status         string  `json:"status"`
	Text           string  `json:"text"`
	Chars          int     `json:"chars"`
	ElapsedMs      int     `json:"elapsed_ms"`
	ChargedCredits *int    `json:"charged_credits"` // nil = never settled
	Truncated      bool    `json:"truncated"`
	Error          *string `json:"error"`
}
type Entry struct {
	ID     string `json:"id"`
	Ts     string `json:"ts"`
	Prompt string `json:"prompt"`
	Lanes  []Lane `json:"lanes"`
}

cost := 190
history := []Entry{{ID: "cmp_x", Ts: "2026-08-07T00:00:00Z",
	Prompt: "Explain CRDTs in two paragraphs.",
	Lanes:  []Lane{{Model: "gpt-5.6-terra", Label: "GPT-5.6 Terra", Status: "succeeded",
		Text: "...", Chars: 3, ElapsedMs: 4200, ChargedCredits: &cost}}}}
call("PUT", "/data/history", map[string]any{"value": history}, nil, nil)

var got struct {
	Value []Entry `json:"value"`
}
// a missing key returns 404 - treat that as an empty history
_ = call("GET", "/data/history", nil, &got, nil)

var keys struct {
	Keys []string `json:"keys"`
}
call("GET", "/data", nil, &keys, nil)
call("DELETE", "/data/history", nil, nil, nil)

api("PUT", "/data/history", """
    {"value":[{"id":"cmp_x","ts":"2026-08-07T00:00:00Z","prompt":"Explain CRDTs in two paragraphs.","lanes":[{"model":"gpt-5.6-terra","label":"GPT-5.6 Terra","status":"succeeded","text":"...","chars":3,"elapsed_ms":4200,"charged_credits":190,"truncated":false,"error":null}]}]}""", null);

String stored = api("GET", "/data/history", null, null); // data.value; 404 = never written
String keys   = api("GET", "/data", null, null);         // data.keys[]
api("DELETE", "/data/history", null, null);

lane = { "model" => "gpt-5.6-terra", "label" => "GPT-5.6 Terra", "status" => "succeeded",
         "text" => "...", "chars" => 3, "elapsed_ms" => 4200,
         "charged_credits" => 190, "truncated" => false, "error" => nil }
history = [{ "id" => "cmp_x", "ts" => "2026-08-07T00:00:00Z",
             "prompt" => "Explain CRDTs in two paragraphs.", "lanes" => [lane] }]
api("PUT", "/data/history", { "value" => history })

stored = begin
  api("GET", "/data/history")["value"]
rescue RuntimeError
  [] # a missing key is a 404 - that just means "empty"
end

keys = api("GET", "/data")["keys"]
api("DELETE", "/data/history")

<?php
$lane = ["model" => "gpt-5.6-terra", "label" => "GPT-5.6 Terra", "status" => "succeeded",
         "text" => "...", "chars" => 3, "elapsed_ms" => 4200,
         "charged_credits" => 190, "truncated" => false, "error" => null];
$history = [["id" => "cmp_x", "ts" => "2026-08-07T00:00:00Z",
             "prompt" => "Explain CRDTs in two paragraphs.", "lanes" => [$lane]]];
api("PUT", "/data/history", ["value" => $history]);

try {
    $stored = api("GET", "/data/history")["value"];
} catch (Exception $e) {
    $stored = []; // a missing key is a 404 - that just means "empty"
}

$keys = api("GET", "/data")["keys"];
api("DELETE", "/data/history");

var lane = new {
    model = "gpt-5.6-terra", label = "GPT-5.6 Terra", status = "succeeded",
    text = "...", chars = 3, elapsed_ms = 4200,
    charged_credits = (int?)190, truncated = false, error = (string?)null,
};
var history = new[] {
    new { id = "cmp_x", ts = "2026-08-07T00:00:00Z",
          prompt = "Explain CRDTs in two paragraphs.", lanes = new[] { lane } },
};
await ChatWithAll.ApiAsync(HttpMethod.Put, "/data/history", new { value = history });

JsonElement? stored = null;
try { stored = (await ChatWithAll.ApiAsync(HttpMethod.Get, "/data/history")).GetProperty("value"); }
catch (Exception) { /* 404: nothing stored yet */ }

var keys = await ChatWithAll.ApiAsync(HttpMethod.Get, "/data");
await ChatWithAll.ApiAsync(HttpMethod.Delete, "/data/history");