Drive Battle Simulator from your own code

# Paste your token from /tokens.html and export it once.
export BS_TOKEN="YOUR_TOKEN"
BASE="https://api.skillsafe.ai/v1/app-api"

# bs METHOD PATH [JSON-BODY] [EXTRA-HEADER]
bs() {
  curl -sS -X "$1" "$BASE$2" \
    -H "Authorization: Bearer $BS_TOKEN" \
    -H "Content-Type: application/json" \
    ${4:+-H "$4"} \
    ${3:+-d "$3"}
}

# Envelope unwrap. Everything useful is under .data; a failure is
# {"error":{"code":"...","message":"..."}} and can arrive with a 200-shaped
# body, so read the code rather than trusting the status alone.
unwrap() {
  python3 -c 'import sys,json; e=json.load(sys.stdin); sys.exit("API "+e["error"]["code"]+": "+e["error"]["message"]) if e.get("error") else print(json.dumps(e["data"], indent=2))'
}

import json, requests

TOKEN = "YOUR_TOKEN"                          # from /tokens.html
BASE  = "https://api.skillsafe.ai/v1/app-api"
H = {"Authorization": f"Bearer {TOKEN}",
     "Content-Type": "application/json"}


class ApiError(RuntimeError):
    def __init__(self, code, message):
        super().__init__(f"{code}: {message}")
        self.code = code


def call(method, path, body=None, extra=None, timeout=120):
    r = requests.request(method, f"{BASE}{path}",
                         headers=dict(H, **(extra or {})),
                         json=body, timeout=timeout)
    env = r.json()
    if "error" in env:
        raise ApiError(env["error"]["code"], env["error"]["message"])
    return env["data"]

const TOKEN = "YOUR_TOKEN";                       // from /tokens.html
const BASE  = "https://api.skillsafe.ai/v1/app-api";
const H = { Authorization: `Bearer ${TOKEN}`,
  "Content-Type": "application/json" };

async function call(method, path, body, extra) {
  const res = await fetch(`${BASE}${path}`, {
    method,
    headers: { ...H, ...(extra || {}) },
    body: body === undefined ? undefined : JSON.stringify(body)
  });
  const env = await res.json();
  if (env.error) {
    const err = new Error(`${env.error.code}: ${env.error.message}`);
    err.code = env.error.code;
    throw err;
  }
  return env.data;
}

package main

import (
  "bytes"
  "encoding/json"
  "errors"
  "io"
  "net/http"
  "os"
)

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

// The token comes from /tokens.html. Read it from the environment rather
// than pasting it into source: os.Getenv("SKILLSAFE_TOKEN").
func call(method, path string, body []byte, extra map[string]string) (json.RawMessage, error) {
  var rdr io.Reader
  if body != nil {
    rdr = bytes.NewReader(body)
  }
  req, _ := http.NewRequest(method, base+path, rdr)
  req.Header.Set("Authorization", "Bearer "+os.Getenv("SKILLSAFE_TOKEN"))
  req.Header.Set("Content-Type", "application/json")
  for k, v := range extra {
    req.Header.Set(k, v)
  }
  res, err := http.DefaultClient.Do(req)
  if err != nil {
    return nil, 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"`
  }
  if err := json.NewDecoder(res.Body).Decode(&env); err != nil {
    return nil, err
  }
  if env.Error != nil {
    return nil, errors.New(env.Error.Code + ": " + env.Error.Message)
  }
  return env.Data, nil
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

static final String BASE  = "https://api.skillsafe.ai/v1/app-api";
static final String TOKEN = "YOUR_TOKEN";              // from /tokens.html
static final HttpClient HTTP = HttpClient.newHttpClient();

// Returns the raw envelope. Unwrap `data` with whichever JSON library you
// already use, and read `error.code` before trusting a 200.
static String call(String method, String path, String body,
                   String headerName, String headerValue) throws Exception {
  var pub = (body == null)
      ? HttpRequest.BodyPublishers.noBody()
      : HttpRequest.BodyPublishers.ofString(body);
  var b = HttpRequest.newBuilder()
      .uri(URI.create(BASE + path))
      .header("Authorization", "Bearer " + TOKEN)
      .header("Content-Type", "application/json")
      .method(method, pub);
  if (headerName != null) b = b.header(headerName, headerValue);
  return HTTP.send(b.build(), HttpResponse.BodyHandlers.ofString()).body();
}

require "net/http"
require "json"

TOKEN = "YOUR_TOKEN"                          # from /tokens.html
BASE  = "https://api.skillsafe.ai/v1/app-api"

class ApiError < StandardError; end

def call(method, path, body = nil, extra = {})
  uri   = URI("#{BASE}#{path}")
  klass = method == "GET" ? Net::HTTP::Get : Net::HTTP::Post
  req   = klass.new(uri)
  req["Authorization"] = "Bearer #{TOKEN}"
  req["Content-Type"]  = "application/json"
  extra.each { |k, v| req[k] = v }
  req.body = JSON.generate(body) if body

  res = Net::HTTP.start(uri.host, uri.port, use_ssl: true, read_timeout: 300) { |h| h.request(req) }
  env = JSON.parse(res.body)
  raise ApiError, "#{env["error"]["code"]}: #{env["error"]["message"]}" if env["error"]
  env["data"]
end

<?php
$token = "YOUR_TOKEN";                          // from /tokens.html
$base  = "https://api.skillsafe.ai/v1/app-api";

function bs_call($method, $path, $body = null, $extra = []) {
  global $token, $base;
  $ch = curl_init("$base$path");
  curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST  => $method,
    CURLOPT_HTTPHEADER     => array_merge([
      "Authorization: Bearer $token",
      "Content-Type: application/json",
    ], $extra),
  ]);
  if ($body !== null) {
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($body));
  }
  $env = json_decode(curl_exec($ch), true);
  if (isset($env["error"])) {
    throw new RuntimeException($env["error"]["code"] . ": " . $env["error"]["message"]);
  }
  return $env["data"];
}

using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

var token   = "YOUR_TOKEN";                        // from /tokens.html
var baseUrl = "https://api.skillsafe.ai/v1/app-api";

using var http = new HttpClient { Timeout = TimeSpan.FromMinutes(5) };
http.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", token);

async Task<JsonElement> Call(HttpMethod method, string path, string? body = null,
                             string? headerName = null, string? headerValue = null) {
    var msg = new HttpRequestMessage(method, baseUrl + path);
    if (body != null) msg.Content = new StringContent(body, Encoding.UTF8, "application/json");
    if (headerName != null) msg.Headers.Add(headerName, headerValue);

    var res  = await http.SendAsync(msg);
    var root = JsonDocument.Parse(await res.Content.ReadAsStringAsync()).RootElement;
    if (root.TryGetProperty("error", out var err))
        throw new Exception(err.GetProperty("code").GetString() + ": " +
                            err.GetProperty("message").GetString());
    return root.GetProperty("data");
}

curl -sS -X POST "https://api.skillsafe.ai/v1/app-api/guest" \
  -H "Content-Type: application/json" \
  -d '{"slug":"battle-simulator"}'

# {"data":{"token":"...","guest_id":"..."}}
# Then: export BS_TOKEN="the token you just got"

g = requests.post(f"{BASE}/guest",
                  headers={"Content-Type": "application/json"},
                  json={"slug": "battle-simulator"}, timeout=30).json()["data"]

TOKEN = g["token"]
H["Authorization"] = f"Bearer {TOKEN}"
print("guest", g["guest_id"])

const g = (await (await fetch(`${BASE}/guest`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ slug: "battle-simulator" })
})).json()).data;

H.Authorization = `Bearer ${g.token}`;
console.log("guest", g.guest_id);

// No Authorization header on this one.
body := []byte(`{"slug":"battle-simulator"}`)
req, _ := http.NewRequest("POST", base+"/guest", bytes.NewReader(body))
req.Header.Set("Content-Type", "application/json")

res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()

var env struct {
  Data struct {
    Token   string `json:"token"`
    GuestID string `json:"guest_id"`
  } `json:"data"`
}
json.NewDecoder(res.Body).Decode(&env)
os.Setenv("SKILLSAFE_TOKEN", env.Data.Token)

var req = HttpRequest.newBuilder()
    .uri(URI.create(BASE + "/guest"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString("{\"slug\":\"battle-simulator\"}"))
    .build();

// {"data":{"token":"...","guest_id":"..."}} — pull data.token out and use it
// as TOKEN above. No Authorization header is sent on this request.
System.out.println(HTTP.send(req, HttpResponse.BodyHandlers.ofString()).body());

uri = URI("#{BASE}/guest")
req = Net::HTTP::Post.new(uri)
req["Content-Type"] = "application/json"
req.body = JSON.generate({ slug: "battle-simulator" })

res   = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
guest = JSON.parse(res.body)["data"]
puts guest["guest_id"]
# Use guest["token"] as TOKEN above.

<?php
$ch = curl_init("$base/guest");
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_POST           => true,
  CURLOPT_POSTFIELDS     => json_encode(["slug" => "battle-simulator"]),
  CURLOPT_HTTPHEADER     => ["Content-Type: application/json"],
]);
$guest = json_decode(curl_exec($ch), true)["data"];

$token = $guest["token"];   // reuse as the bearer token above
echo $guest["guest_id"];

using var plain = new HttpClient();   // deliberately unauthenticated
var res = await plain.PostAsync("https://api.skillsafe.ai/v1/app-api/guest",
    new StringContent("{\"slug\":\"battle-simulator\"}", Encoding.UTF8, "application/json"));

var guest = JsonDocument.Parse(await res.Content.ReadAsStringAsync())
    .RootElement.GetProperty("data");

token = guest.GetProperty("token").GetString()!;
Console.WriteLine(guest.GetProperty("guest_id").GetString());

bs GET /me | unwrap

# {"subject_type":"user","subject_id":"...","credits":1840}
# subject_type is "user" when signed in, and something else for a guest.

me = call("GET", "/me")

signed_in = me["subject_type"] == "user"
print(me["subject_type"], me["credits"], "signed in" if signed_in else "guest")

const me = await call("GET", "/me");

const signedIn = me.subject_type === "user";
console.log(me.subject_type, me.credits, signedIn ? "signed in" : "guest");

raw, err := call("GET", "/me", nil, nil)
if err != nil {
  panic(err)
}

var me struct {
  SubjectType string  `json:"subject_type"`
  SubjectID   string  `json:"subject_id"`
  Credits     float64 `json:"credits"`
}
json.Unmarshal(raw, &me)
fmt.Println(me.SubjectType, me.Credits, me.SubjectType == "user")

var body = call("GET", "/me", null, null, null);

// {"data":{"subject_type":"user","subject_id":"...","credits":1840}}
// Only those three fields exist; the signed-in test is subject_type "user".
System.out.println(body);

me = call("GET", "/me")

signed_in = me["subject_type"] == "user"
puts [me["subject_type"], me["credits"], signed_in ? "signed in" : "guest"].join(" ")

<?php
$me = bs_call("GET", "/me");

$signedIn = $me["subject_type"] === "user";
echo $me["subject_type"], " ", $me["credits"], " ", $signedIn ? "signed in" : "guest", "\n";

var me = await Call(HttpMethod.Get, "/me");

var subjectType = me.GetProperty("subject_type").GetString();
var credits     = me.GetProperty("credits").GetDouble();
Console.WriteLine($"{subjectType} {credits} {(subjectType == "user" ? "signed in" : "guest")}");

# Put the worked "adjudicate" body from above in input.json, then check its
# shape locally, because the endpoint will not check it for you.
python3 - input.json <<'PY'
import json, sys
d = json.load(open(sys.argv[1]))
assert isinstance(d, dict), "the body must be an object, not a wrapper or a list"
assert "input" not in d, "do not wrap the body in {\"input\": ...}"
assert d.get("shape") in ("adjudicate", "rematch", "challenge"), "bad shape"
assert isinstance(d.get("sides"), list) and len(d["sides"]) == 2, "sides must be exactly two"
PY

bs POST /estimate "$(cat input.json)" | unwrap
# {"hold_credits":...,"min_credits":...,"model":"gpt-5.6-terra","model_alias":"gpt-terra"}

SHAPES = ("adjudicate", "rematch", "challenge")


def must_be_valid(inp):
    """The endpoint validates nothing, so this is the only gate there is."""
    if not isinstance(inp, dict):
        raise TypeError(f"input must be a plain object, got {type(inp).__name__}")
    if "input" in inp:
        raise ValueError("do not wrap the body in {'input': ...}")
    if inp.get("shape") not in SHAPES:
        raise ValueError(f"shape must be one of {SHAPES}")
    if not isinstance(inp.get("sides"), list) or len(inp["sides"]) != 2:
        raise ValueError("sides must be exactly two fact blocks")
    if inp["shape"] in ("rematch", "challenge") and not inp.get("prior"):
        raise ValueError(f"{inp['shape']} requires prior")
    if inp["shape"] == "challenge" and not (inp.get("challenge_text") or "").strip():
        raise ValueError("challenge requires challenge_text")
    return inp


payload = json.load(open("input.json"))          # the worked body from above
est = call("POST", "/estimate", must_be_valid(payload))
print(est["hold_credits"], est["min_credits"], est["model"], est["model_alias"])

const SHAPES = ["adjudicate", "rematch", "challenge"];

// The endpoint validates nothing, so this is the only gate there is.
function mustBeValid(input) {
  if (!input || typeof input !== "object" || Array.isArray(input)) {
    throw new TypeError("input must be a plain object");
  }
  if ("input" in input) throw new Error("do not wrap the body in { input: ... }");
  if (!SHAPES.includes(input.shape)) throw new Error("shape must be one of " + SHAPES);
  if (!Array.isArray(input.sides) || input.sides.length !== 2) {
    throw new Error("sides must be exactly two fact blocks");
  }
  if (input.shape !== "adjudicate" && !input.prior) throw new Error(input.shape + " requires prior");
  if (input.shape === "challenge" && !(input.challenge_text || "").trim()) {
    throw new Error("challenge requires challenge_text");
  }
  return input;
}

const est = await call("POST", "/estimate", mustBeValid(payload));
console.log(est.hold_credits, est.min_credits, est.model_alias);

// payload is the worked "adjudicate" body, marshalled from your own struct
// or read from disk. Validate it here: /estimate will not.
var check map[string]any
if err := json.Unmarshal(payload, &check); err != nil {
  panic("body must be a JSON object")
}
if _, wrapped := check["input"]; wrapped {
  panic(`do not wrap the body in {"input": ...}`)
}
if sides, ok := check["sides"].([]any); !ok || len(sides) != 2 {
  panic("sides must be exactly two fact blocks")
}

raw, err := call("POST", "/estimate", payload, nil)
if err != nil {
  panic(err)
}

var est struct {
  HoldCredits float64 `json:"hold_credits"`
  MinCredits  float64 `json:"min_credits"`
  ModelAlias  string  `json:"model_alias"`
}
json.Unmarshal(raw, &est)
fmt.Println(est.HoldCredits, est.MinCredits, est.ModelAlias)

// payload is the worked "adjudicate" body as a JSON string. Validate its
// shape with your JSON library before spending: /estimate will not.
if (payload.trim().charAt(0) != '{' || payload.contains("\"input\":")) {
  throw new IllegalArgumentException("body must be the input object itself, unwrapped");
}

var body = call("POST", "/estimate", payload, null, null);

// {"data":{"hold_credits":...,"min_credits":...,"model":"gpt-5.6-terra",
//          "model_alias":"gpt-terra"}}
// hold_credits is a reservation against the full output cap, not the price.
System.out.println(body);

SHAPES = %w[adjudicate rematch challenge].freeze

# The endpoint validates nothing, so this is the only gate there is.
def must_be_valid(input)
  raise ArgumentError, "input must be a Hash" unless input.is_a?(Hash)
  raise ArgumentError, "do not wrap the body in {input: ...}" if input.key?("input")
  raise ArgumentError, "bad shape" unless SHAPES.include?(input["shape"])
  raise ArgumentError, "sides must be exactly two" unless input["sides"].is_a?(Array) && input["sides"].size == 2
  raise ArgumentError, "#{input["shape"]} requires prior" if input["shape"] != "adjudicate" && !input["prior"]
  input
end

payload = JSON.parse(File.read("input.json"))
est = call("POST", "/estimate", must_be_valid(payload))
puts [est["hold_credits"], est["min_credits"], est["model_alias"]].join(" ")

<?php
// The endpoint validates nothing, so this is the only gate there is.
function must_be_valid(array $input): array {
  if (array_is_list($input))       throw new InvalidArgumentException("body must be an object");
  if (isset($input["input"]))      throw new InvalidArgumentException("do not wrap the body");
  if (!in_array($input["shape"] ?? "", ["adjudicate", "rematch", "challenge"], true)) {
    throw new InvalidArgumentException("bad shape");
  }
  if (count($input["sides"] ?? []) !== 2) throw new InvalidArgumentException("sides must be two");
  return $input;
}

$payload = json_decode(file_get_contents("input.json"), true);
$est = bs_call("POST", "/estimate", must_be_valid($payload));
echo $est["hold_credits"], " ", $est["min_credits"], " ", $est["model_alias"], "\n";

// payload is the worked "adjudicate" body as a JSON string.
// Validate it here: /estimate will not.
var probe = JsonDocument.Parse(payload).RootElement;
if (probe.ValueKind != JsonValueKind.Object)          throw new ArgumentException("body must be an object");
if (probe.TryGetProperty("input", out _))             throw new ArgumentException("do not wrap the body");
if (probe.GetProperty("sides").GetArrayLength() != 2) throw new ArgumentException("sides must be two");

var est = await Call(HttpMethod.Post, "/estimate", payload);
Console.WriteLine($"{est.GetProperty("hold_credits")} " +
                  $"{est.GetProperty("min_credits")} " +
                  $"{est.GetProperty("model_alias").GetString()}");

# Submit. The body IS the input object - there is no {"input": ...} wrapper
# and there is no X-App-Slug header.
KEY="battle-simulator:adjudicate:8f3ka2-1x:a1"
JOB=$(bs POST /run "$(cat input.json)" "Idempotency-Key: $KEY" \
  | python3 -c 'import sys,json; print(json.load(sys.stdin)["data"]["job_id"])')

# Poll until terminal. Two seconds; do not tight-loop.
while true; do
  S=$(bs GET "/jobs/$JOB")
  echo "$S" | grep -q '"status":"succeeded"' && break
  echo "$S" | grep -q '"status":"failed"' && { echo "$S"; exit 1; }
  sleep 2
done

# The verdict is a JSON string at .data.output.output - parse it again.
echo "$S" | python3 -c 'import sys,json; print(json.load(sys.stdin)["data"]["output"]["output"])'

import time

key = "battle-simulator:adjudicate:8f3ka2-1x:a1"
job = call("POST", "/run", must_be_valid(payload), {"Idempotency-Key": key})

while job["status"] in ("queued", "running"):
    time.sleep(2)
    job = call("GET", f"/jobs/{job['job_id']}")

if job["status"] == "failed":
    raise RuntimeError(job.get("error") or "the run did not complete")

verdict = json.loads(job["output"]["output"])      # a JSON string, parsed again
print(verdict["verdict"]["favoured"], verdict["verdict"]["margin"])
print(verdict["decisive_factor"]["claim"])
print(verdict["strongest_counter"]["how_close"])

const key = "battle-simulator:adjudicate:8f3ka2-1x:a1";
let job = await call("POST", "/run", mustBeValid(payload), { "Idempotency-Key": key });

while (job.status === "queued" || job.status === "running") {
  await new Promise(r => setTimeout(r, 2000));
  job = await call("GET", `/jobs/${job.job_id}`);
}
if (job.status === "failed") throw new Error(job.error || "the run did not complete");

const verdict = JSON.parse(job.output.output);     // a JSON string, parsed again
console.log(verdict.verdict.favoured, verdict.verdict.margin);
console.log(verdict.strongest_counter.how_close);

key := map[string]string{"Idempotency-Key": "battle-simulator:adjudicate:8f3ka2-1x:a1"}
raw, err := call("POST", "/run", payload, key)
if err != nil {
  panic(err)
}

var job struct {
  JobID  string `json:"job_id"`
  Status string `json:"status"`
  Output struct {
    Output string `json:"output"`
  } `json:"output"`
}
json.Unmarshal(raw, &job)

for job.Status == "queued" || job.Status == "running" {
  time.Sleep(2 * time.Second)
  raw, err = call("GET", "/jobs/"+job.JobID, nil, nil)
  if err != nil {
    panic(err)
  }
  json.Unmarshal(raw, &job)
}

// job.Output.Output is a JSON string holding the verdict; unmarshal it again.
var verdict map[string]any
json.Unmarshal([]byte(job.Output.Output), &verdict)

var key = "battle-simulator:adjudicate:8f3ka2-1x:a1";
var submitted = call("POST", "/run", payload, "Idempotency-Key", key);

// Pull data.job_id out of `submitted`, then poll "/jobs/" + jobId every two
// seconds until data.status is "succeeded" or "failed".
String jobBody;
do {
  Thread.sleep(2000);
  jobBody = call("GET", "/jobs/" + jobId, null, null, null);
} while (jobBody.contains("\"status\":\"queued\"")
      || jobBody.contains("\"status\":\"running\""));

// The verdict is the JSON *string* at data.output.output - parse it again.
System.out.println(jobBody);

key = "battle-simulator:adjudicate:8f3ka2-1x:a1"
job = call("POST", "/run", must_be_valid(payload), { "Idempotency-Key" => key })

while %w[queued running].include?(job["status"])
  sleep 2
  job = call("GET", "/jobs/#{job["job_id"]}")
end
raise "the run did not complete" if job["status"] == "failed"

verdict = JSON.parse(job["output"]["output"])   # a JSON string, parsed again
puts verdict["verdict"]["favoured"], verdict["verdict"]["margin"]
puts verdict["strongest_counter"]["how_close"]

<?php
$key = "battle-simulator:adjudicate:8f3ka2-1x:a1";
$job = bs_call("POST", "/run", must_be_valid($payload), ["Idempotency-Key: $key"]);

while (in_array($job["status"], ["queued", "running"], true)) {
  sleep(2);
  $job = bs_call("GET", "/jobs/" . rawurlencode($job["job_id"]));
}
if ($job["status"] === "failed") {
  throw new RuntimeException("the run did not complete");
}

$verdict = json_decode($job["output"]["output"], true);   // parsed again
echo $verdict["verdict"]["favoured"], " ", $verdict["verdict"]["margin"], "\n";
echo $verdict["strongest_counter"]["how_close"], "\n";

var key = "battle-simulator:adjudicate:8f3ka2-1x:a1";
var job = await Call(HttpMethod.Post, "/run", payload, "Idempotency-Key", key);

var jobId  = job.GetProperty("job_id").GetString();
var status = job.GetProperty("status").GetString();
while (status is "queued" or "running") {
    await Task.Delay(2000);
    job    = await Call(HttpMethod.Get, $"/jobs/{jobId}");
    status = job.GetProperty("status").GetString();
}
if (status == "failed") throw new Exception("the run did not complete");

// A JSON string holding the verdict - parse it again.
var verdict = JsonDocument.Parse(
    job.GetProperty("output").GetProperty("output").GetString()!).RootElement;
Console.WriteLine(verdict.GetProperty("verdict").GetProperty("margin").GetString());

curl -N -X POST "https://api.skillsafe.ai/v1/app-api/run-stream" \
  -H "Authorization: Bearer $BS_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: battle-simulator:adjudicate:8f3ka2-1x:a1" \
  -d @input.json

# Frames arrive as `event: NAME` + `data: JSON`, separated by a blank line.
# Concatenate the .text of every `delta`; the `done` frame carries
# charged_credits and output.output.

out, done = "", None
headers = dict(H, **{"Idempotency-Key": "battle-simulator:adjudicate:8f3ka2-1x:a1"})

with requests.post(f"{BASE}/run-stream", headers=headers,
                   json=must_be_valid(payload), stream=True, timeout=600) as r:
    event = "message"
    for line in r.iter_lines(decode_unicode=True):
        if line is None or line == "":
            event = "message"
            continue
        if line.startswith("event:"):
            event = line[6:].strip()
        elif line.startswith("data:"):
            evt = json.loads(line[5:].strip())
            if event == "delta":
                out += evt.get("text", "")
            elif event in ("done", "pending"):
                done = evt
            elif event == "error":
                raise ApiError(evt.get("code", "INTERNAL"), evt.get("message", ""))

print(done["charged_credits"])
verdict = json.loads(out)

const res = await fetch(`${BASE}/run-stream`, {
  method: "POST",
  headers: { ...H, "Idempotency-Key": "battle-simulator:adjudicate:8f3ka2-1x:a1" },
  body: JSON.stringify(mustBeValid(payload))
});

// An idempotent replay answers with plain JSON instead of a stream.
if (!(res.headers.get("content-type") || "").includes("text/event-stream")) {
  const env = await res.json();
  return JSON.parse(env.data.output.output);
}

const reader = res.body.getReader();
const dec = new TextDecoder();
let buf = "", out = "", done = null;
for (;;) {
  const chunk = await reader.read();
  if (chunk.done) break;
  buf += dec.decode(chunk.value, { stream: true });
  let i;
  while ((i = buf.indexOf("\n\n")) >= 0) {
    const frame = buf.slice(0, i);
    buf = buf.slice(i + 2);
    let name = "message", data = "";
    for (const l of frame.split("\n")) {
      if (l.startsWith("event:")) name = l.slice(6).trim();
      else if (l.startsWith("data:")) data += l.slice(5).trim();
    }
    if (!data) continue;
    const evt = JSON.parse(data);
    if (name === "delta") out += evt.text || "";
    else if (name === "done" || name === "pending") done = evt;
    else if (name === "error") throw new Error(`${evt.code}: ${evt.message}`);
  }
}
console.log(done.charged_credits);
const verdict = JSON.parse(out);

req, _ := http.NewRequest("POST", base+"/run-stream", bytes.NewReader(payload))
req.Header.Set("Authorization", "Bearer "+os.Getenv("SKILLSAFE_TOKEN"))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Idempotency-Key", "battle-simulator:adjudicate:8f3ka2-1x:a1")

res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()

var out strings.Builder
name := "message"
sc := bufio.NewScanner(res.Body)
sc.Buffer(make([]byte, 0, 64*1024), 8*1024*1024)
for sc.Scan() {
  line := sc.Text()
  switch {
  case line == "":
    name = "message"
  case strings.HasPrefix(line, "event:"):
    name = strings.TrimSpace(line[6:])
  case strings.HasPrefix(line, "data:") && name == "delta":
    var evt struct {
      Text string `json:"text"`
    }
    json.Unmarshal([]byte(strings.TrimSpace(line[5:])), &evt)
    out.WriteString(evt.Text)
  }
}

var verdict map[string]any
json.Unmarshal([]byte(out.String()), &verdict)

var req = HttpRequest.newBuilder()
    .uri(URI.create(BASE + "/run-stream"))
    .header("Authorization", "Bearer " + TOKEN)
    .header("Content-Type", "application/json")
    .header("Idempotency-Key", "battle-simulator:adjudicate:8f3ka2-1x:a1")
    .POST(HttpRequest.BodyPublishers.ofString(payload))
    .build();

var out  = new StringBuilder();
var name = new String[]{ "message" };
HTTP.send(req, HttpResponse.BodyHandlers.ofLines()).body().forEach(line -> {
  if (line.isEmpty()) { name[0] = "message"; }
  else if (line.startsWith("event:")) { name[0] = line.substring(6).trim(); }
  else if (line.startsWith("data:") && name[0].equals("delta")) {
    // Parse the frame with your JSON library and append its `text`.
    out.append(textOf(line.substring(5).trim()));
  }
});

uri = URI("#{BASE}/run-stream")
req = Net::HTTP::Post.new(uri)
req["Authorization"]   = "Bearer #{TOKEN}"
req["Content-Type"]    = "application/json"
req["Idempotency-Key"] = "battle-simulator:adjudicate:8f3ka2-1x:a1"
req.body = JSON.generate(must_be_valid(payload))

out  = +""
name = "message"
Net::HTTP.start(uri.host, uri.port, use_ssl: true, read_timeout: 600) do |http|
  http.request(req) do |res|
    res.read_body do |chunk|
      chunk.each_line do |line|
        line = line.chomp
        if line.empty?                    then name = "message"
        elsif line.start_with?("event:")  then name = line[6..].strip
        elsif line.start_with?("data:")
          evt = JSON.parse(line[5..].strip)
          out << evt["text"].to_s if name == "delta"
        end
      end
    end
  end
end

verdict = JSON.parse(out)

<?php
$out  = "";
$name = "message";

$ch = curl_init("$base/run-stream");
curl_setopt_array($ch, [
  CURLOPT_POST       => true,
  CURLOPT_POSTFIELDS => json_encode(must_be_valid($payload)),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer $token",
    "Content-Type: application/json",
    "Idempotency-Key: battle-simulator:adjudicate:8f3ka2-1x:a1",
  ],
  CURLOPT_WRITEFUNCTION => function ($ch, $chunk) use (&$out, &$name) {
    foreach (explode("\n", $chunk) as $line) {
      $line = rtrim($line, "\r");
      if ($line === "") {
        $name = "message";
      } elseif (str_starts_with($line, "event:")) {
        $name = trim(substr($line, 6));
      } elseif (str_starts_with($line, "data:") && $name === "delta") {
        $evt  = json_decode(trim(substr($line, 5)), true);
        $out .= $evt["text"] ?? "";
      }
    }
    return strlen($chunk);
  },
]);
curl_exec($ch);

$verdict = json_decode($out, true);

var msg = new HttpRequestMessage(HttpMethod.Post, $"{baseUrl}/run-stream") {
    Content = new StringContent(payload, Encoding.UTF8, "application/json")
};
msg.Headers.Add("Idempotency-Key", "battle-simulator:adjudicate:8f3ka2-1x:a1");

var res = await http.SendAsync(msg, HttpCompletionOption.ResponseHeadersRead);
using var sr = new StreamReader(await res.Content.ReadAsStreamAsync());

var sb   = new StringBuilder();
var name = "message";
while (await sr.ReadLineAsync() is string line) {
    if (line.Length == 0)              { name = "message"; }
    else if (line.StartsWith("event:")) { name = line[6..].Trim(); }
    else if (line.StartsWith("data:") && name == "delta") {
        var evt = JsonDocument.Parse(line[5..].Trim()).RootElement;
        if (evt.TryGetProperty("text", out var t)) sb.Append(t.GetString());
    }
}

var verdict = JsonDocument.Parse(sb.ToString()).RootElement;

REQUIRED='title matchup conditions_read evidence_basis sides decisive_factor
strongest_counter likely_course verdict flips not_measured unknowns'

bs GET "/jobs/$JOB" \
  | python3 -c 'import sys,json; print(json.load(sys.stdin)["data"]["output"]["output"])' \
  | sed -e 's/^```json//' -e 's/^```//' -e 's/```$//' \
  | python3 -c "
import sys, json
v = json.loads(sys.stdin.read())
missing = [k for k in '''$REQUIRED'''.split() if k not in v]
print('missing:', missing or 'none')
print(v['verdict']['favoured'], v['verdict']['margin'])
"

import re

REQUIRED = ("title", "matchup", "conditions_read", "evidence_basis", "sides",
            "decisive_factor", "strongest_counter", "likely_course", "verdict",
            "flips", "not_measured", "unknowns")


def first_object(s):
    """The first {...} in the reply, fence and preamble discarded."""
    t = re.sub(r"^```(?:json)?\s*", "", s.strip())
    t = re.sub(r"```\s*$", "", t).strip()
    start = t.find("{")
    if start < 0:
        raise ValueError("no JSON object in the reply")
    depth, in_str, esc = 0, False, False
    for i in range(start, len(t)):
        c = t[i]
        if esc:            esc = False; continue
        if c == "\\":      esc = True;  continue
        if c == '"':       in_str = not in_str; continue
        if in_str:         continue
        if c == "{":       depth += 1
        elif c == "}":
            depth -= 1
            if depth == 0:
                return t[start:i + 1], True
    return t[start:], False          # truncated: repair before parsing


def parse_verdict(raw):
    text, complete = first_object(raw)
    v = json.loads(text)             # if not complete, repair first
    missing = [k for k in REQUIRED if k not in v]
    if missing:
        raise ValueError("reply is missing " + ", ".join(missing))
    if v["evidence_basis"] not in ("documented", "mixed", "qualitative"):
        raise ValueError("bad evidence_basis")
    if v["verdict"]["margin"] not in ("decisive", "clear", "narrow", "coin-flip"):
        raise ValueError("bad margin")
    if len(v["sides"]) != 2 or [s["side"] for s in v["sides"]] != ["A", "B"]:
        raise ValueError("sides must be A then B")

    # Calibration: a counter that nearly lands forbids a decisive verdict.
    if v["strongest_counter"]["how_close"] in ("decisive", "substantial"):
        if v["decisive_factor"]["confidence"] == "high" or v["verdict"]["margin"] == "decisive":
            raise ValueError("reply concedes a strong counter and still claims certainty")
    return v

const REQUIRED = ["title", "matchup", "conditions_read", "evidence_basis", "sides",
  "decisive_factor", "strongest_counter", "likely_course", "verdict",
  "flips", "not_measured", "unknowns"];

function firstObject(s) {
  let t = String(s || "").trim()
    .replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/, "").trim();
  const start = t.indexOf("{");
  if (start === -1) throw new Error("no JSON object in the reply");
  let depth = 0, inStr = false, esc = false;
  for (let i = start; i < t.length; i++) {
    const c = t[i];
    if (esc) { esc = false; continue; }
    if (c === "\\") { esc = true; continue; }
    if (c === '"') { inStr = !inStr; continue; }
    if (inStr) continue;
    if (c === "{") depth++;
    else if (c === "}" && --depth === 0) return { text: t.slice(start, i + 1), complete: true };
  }
  return { text: t.slice(start), complete: false };   // truncated: repair first
}

function parseVerdict(raw) {
  const { text } = firstObject(raw);
  const v = JSON.parse(text);
  const missing = REQUIRED.filter(k => !(k in v));
  if (missing.length) throw new Error("reply is missing " + missing.join(", "));
  if (!["documented", "mixed", "qualitative"].includes(v.evidence_basis)) {
    throw new Error("bad evidence_basis");
  }
  if (v.sides.length !== 2 || v.sides[0].side !== "A" || v.sides[1].side !== "B") {
    throw new Error("sides must be A then B");
  }
  return v;
}

var required = []string{"title", "matchup", "conditions_read", "evidence_basis",
  "sides", "decisive_factor", "strongest_counter", "likely_course", "verdict",
  "flips", "not_measured", "unknowns"}

// firstObject returns the first {...} in the reply, with any code fence and
// preamble discarded. complete is false when the stream was cut mid-object.
func firstObject(s string) (text string, complete bool) {
  t := strings.TrimSpace(s)
  t = strings.TrimPrefix(strings.TrimPrefix(t, "```json"), "```")
  t = strings.TrimSuffix(strings.TrimSpace(t), "```")
  start := strings.Index(t, "{")
  if start < 0 {
    return "", false
  }
  depth, inStr, esc := 0, false, false
  for i := start; i < len(t); i++ {
    c := t[i]
    switch {
    case esc:
      esc = false
    case c == '\\':
      esc = true
    case c == '"':
      inStr = !inStr
    case inStr:
    case c == '{':
      depth++
    case c == '}':
      depth--
      if depth == 0 {
        return t[start : i+1], true
      }
    }
  }
  return t[start:], false
}

text, _ := firstObject(job.Output.Output)
var v map[string]any
json.Unmarshal([]byte(text), &v)
for _, k := range required {
  if _, ok := v[k]; !ok {
    panic("reply is missing " + k)
  }
}

static final String[] REQUIRED = {
  "title", "matchup", "conditions_read", "evidence_basis", "sides",
  "decisive_factor", "strongest_counter", "likely_course", "verdict",
  "flips", "not_measured", "unknowns"
};

// The first {...} in the reply, fence and preamble discarded. Returns the
// fragment as-is when the stream was cut, so the caller can repair it.
static String firstObject(String s) {
  var t = s.strip().replaceFirst("^```(?:json)?\\s*", "").replaceFirst("```\\s*$", "").strip();
  int start = t.indexOf('{');
  if (start < 0) throw new IllegalStateException("no JSON object in the reply");
  int depth = 0; boolean inStr = false, esc = false;
  for (int i = start; i < t.length(); i++) {
    char c = t.charAt(i);
    if (esc)            { esc = false; continue; }
    if (c == '\\')      { esc = true;  continue; }
    if (c == '"')       { inStr = !inStr; continue; }
    if (inStr)          continue;
    if (c == '{')       depth++;
    else if (c == '}' && --depth == 0) return t.substring(start, i + 1);
  }
  return t.substring(start);
}

// Parse firstObject(...) with your JSON library, then assert every key in
// REQUIRED is present before rendering anything.

REQUIRED = %w[title matchup conditions_read evidence_basis sides
              decisive_factor strongest_counter likely_course verdict
              flips not_measured unknowns].freeze

def first_object(s)
  t = s.to_s.strip.sub(/\A```(?:json)?\s*/i, "").sub(/```\s*\z/, "").strip
  start = t.index("{")
  raise "no JSON object in the reply" unless start

  depth = 0; in_str = false; esc = false
  (start...t.length).each do |i|
    c = t[i]
    if esc        then esc = false
    elsif c == "\\" then esc = true
    elsif c == '"'  then in_str = !in_str
    elsif in_str    then next
    elsif c == "{"  then depth += 1
    elsif c == "}"
      depth -= 1
      return [t[start..i], true] if depth.zero?
    end
  end
  [t[start..], false]   # truncated: repair before parsing
end

text, = first_object(job["output"]["output"])
v = JSON.parse(text)
missing = REQUIRED.reject { |k| v.key?(k) }
raise "reply is missing #{missing.join(", ")}" unless missing.empty?

<?php
const REQUIRED = ["title", "matchup", "conditions_read", "evidence_basis", "sides",
  "decisive_factor", "strongest_counter", "likely_course", "verdict",
  "flips", "not_measured", "unknowns"];

function first_object(string $s): array {
  $t = preg_replace('/^```(?:json)?\s*/i', "", trim($s));
  $t = trim(preg_replace('/```\s*$/', "", $t));
  $start = strpos($t, "{");
  if ($start === false) throw new RuntimeException("no JSON object in the reply");

  $depth = 0; $inStr = false; $esc = false;
  for ($i = $start; $i < strlen($t); $i++) {
    $c = $t[$i];
    if ($esc)            { $esc = false; continue; }
    if ($c === "\\")     { $esc = true;  continue; }
    if ($c === '"')      { $inStr = !$inStr; continue; }
    if ($inStr)          continue;
    if ($c === "{")      $depth++;
    elseif ($c === "}" && --$depth === 0) return [substr($t, $start, $i - $start + 1), true];
  }
  return [substr($t, $start), false];   // truncated: repair before parsing
}

[$text, ] = first_object($job["output"]["output"]);
$v = json_decode($text, true);
$missing = array_values(array_filter(REQUIRED, fn($k) => !array_key_exists($k, $v)));
if ($missing) throw new RuntimeException("reply is missing " . implode(", ", $missing));

static readonly string[] Required = {
    "title", "matchup", "conditions_read", "evidence_basis", "sides",
    "decisive_factor", "strongest_counter", "likely_course", "verdict",
    "flips", "not_measured", "unknowns"
};

// The first {...} in the reply, fence and preamble discarded. complete is
// false when the stream was cut mid-object, so the caller can repair it.
static (string Text, bool Complete) FirstObject(string s) {
    var t = s.Trim();
    if (t.StartsWith("```json")) t = t[7..];
    else if (t.StartsWith("```")) t = t[3..];
    if (t.EndsWith("```")) t = t[..^3];
    t = t.Trim();

    var start = t.IndexOf('{');
    if (start < 0) throw new InvalidOperationException("no JSON object in the reply");

    int depth = 0; bool inStr = false, esc = false;
    for (var i = start; i < t.Length; i++) {
        var c = t[i];
        if (esc)       { esc = false; continue; }
        if (c == '\\') { esc = true;  continue; }
        if (c == '"')  { inStr = !inStr; continue; }
        if (inStr)     continue;
        if (c == '{')  depth++;
        else if (c == '}' && --depth == 0) return (t[start..(i + 1)], true);
    }
    return (t[start..], false);
}

var (text, _) = FirstObject(jobOutput);
var v = JsonDocument.Parse(text).RootElement;
foreach (var k in Required)
    if (!v.TryGetProperty(k, out _))
        throw new Exception($"reply is missing {k}");