Drive TRIPOD Desk from your own code

# Every call is the same three things: the base URL, your bearer token, and a
# JSON body. Keep the token in a shell variable.
BASE="https://api.skillsafe.ai/v1/app-api"
TOKEN="$SKILLSAFE_TOKEN"   # from https://tripod-desk.skillsafe.ai/tokens.html

call() {                   # call <path> [json-body]
  if [ -n "$2" ]; then
    curl -sS -X POST "$BASE/$1" \
      -H "Authorization: Bearer $TOKEN" \
      -H "Content-Type: application/json" \
      -d "$2"
  else
    curl -sS "$BASE/$1" -H "Authorization: Bearer $TOKEN"
  fi
}

# Unwrap the envelope: print data, or exit non-zero with the API error code.
data() {
  python3 -c '
import sys, json
env = json.load(sys.stdin)
if not env.get("ok"):
    err = env.get("error") or {}
    raise SystemExit("%s: %s" % (err.get("code"), err.get("message")))
json.dump(env["data"], sys.stdout)
'
}

call me | data
# {"subject_type": "user", "subject_id": "usr_...", "credits": 51234}
#
# No X-App-Slug header. The slug was only ever needed by POST /guest.

import json, os, urllib.error, urllib.request

BASE = "https://api.skillsafe.ai/v1/app-api"
TOKEN = os.environ.get("SKILLSAFE_TOKEN", "YOUR_TOKEN")  # from /tokens.html


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


def call(path, body=None, headers=None):
    """Returns the unwrapped `data`, or raises ApiError with the API error code.

    Two headers only: Content-Type and Authorization. There is no X-App-Slug -
    the token is already bound to tripod-desk.
    """
    payload = json.dumps(body).encode() if body is not None else None
    req = urllib.request.Request(
        f"{BASE}/{path}", data=payload, method="POST" if body is not None else "GET")
    req.add_header("Authorization", f"Bearer {TOKEN}")
    if payload is not None:
        req.add_header("Content-Type", "application/json")
    for k, v in (headers or {}).items():
        req.add_header(k, v)
    try:
        with urllib.request.urlopen(req) as res:
            env = json.load(res)
    except urllib.error.HTTPError as exc:          # 4xx and 5xx carry the envelope too
        env = json.loads(exc.read() or b"{}")
    if not env.get("ok"):
        err = env.get("error") or {}
        raise ApiError(err.get("code", "INTERNAL"), err.get("message", "no message"),
                       err.get("details"))
    return env["data"]


print(call("me"))
# {'subject_type': 'user', 'subject_id': 'usr_...', 'credits': 51234}

// Node 18+ or any browser. Paste a token from
// https://tripod-desk.skillsafe.ai/tokens.html, or mint a guest one in step 1.
const BASE = "https://api.skillsafe.ai/v1/app-api";
const TOKEN = "YOUR_TOKEN";

class ApiError extends Error {
  constructor(code, message, details) {
    super(`${code}: ${message}`);
    this.code = code;
    this.details = details ?? {};
  }
}

// call("me") -> GET; call("estimate", input) -> POST with the input object as
// the whole body. Extra headers are for Idempotency-Key on a run.
async function call(path, body, extraHeaders = {}) {
  const res = await fetch(`${BASE}/${path}`, {
    method: body === undefined ? "GET" : "POST",
    headers: {
      Authorization: `Bearer ${TOKEN}`,
      ...(body === undefined ? {} : { "Content-Type": "application/json" }),
      ...extraHeaders,
    },
    body: body === undefined ? undefined : JSON.stringify(body),
  });
  const env = await res.json();
  if (!env.ok) throw new ApiError(env.error.code, env.error.message, env.error.details);
  return env.data;
}

console.log(await call("me"));
// { subject_type: 'user', subject_id: 'usr_...', credits: 51234 }
// Two headers, and no X-App-Slug: the token already carries the app.

package main

// Imports used across every Go sample on this page:
// bytes, crypto/sha256, encoding/json, fmt, io, net/http, os, strings, time

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

// From https://tripod-desk.skillsafe.ai/tokens.html, or minted in step 1.
var token = func() string {
	if t := os.Getenv("SKILLSAFE_TOKEN"); t != "" {
		return t
	}
	return "YOUR_TOKEN"
}()

type apiError struct {
	Code    string          `json:"code"`
	Message string          `json:"message"`
	Details json.RawMessage `json:"details"`
}

func (e *apiError) Error() string { return e.Code + ": " + e.Message }

type envelope struct {
	OK    bool            `json:"ok"`
	Data  json.RawMessage `json:"data"`
	Error *apiError       `json:"error"`
}

// call returns the raw `data` for the caller to unmarshal into its own struct.
// Two headers only - there is no X-App-Slug in this API.
func call(path string, body any, extra map[string]string) (json.RawMessage, error) {
	method := http.MethodGet
	var reader io.Reader
	if body != nil {
		method = http.MethodPost
		raw, err := json.Marshal(body)
		if err != nil {
			return nil, err
		}
		reader = bytes.NewReader(raw)
	}
	req, err := http.NewRequest(method, base+"/"+path, reader)
	if err != nil {
		return nil, err
	}
	req.Header.Set("Authorization", "Bearer "+token)
	if body != nil {
		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 envelope
	if err := json.NewDecoder(res.Body).Decode(&env); err != nil {
		return nil, err
	}
	if !env.OK {
		if env.Error != nil {
			return nil, env.Error
		}
		return nil, fmt.Errorf("INTERNAL: no error body on HTTP %d", res.StatusCode)
	}
	return env.Data, nil
}

// java.net.http, single file. Imports: java.net.URI, java.net.http.*,
// java.security.MessageDigest, java.util.Map.
public final class TripodDesk {
    static final String BASE = "https://api.skillsafe.ai/v1/app-api";

    // From https://tripod-desk.skillsafe.ai/tokens.html, or minted in step 1.
    static String token = System.getenv("SKILLSAFE_TOKEN") == null
        ? "YOUR_TOKEN" : System.getenv("SKILLSAFE_TOKEN");

    static final HttpClient HTTP = HttpClient.newHttpClient();

    static class ApiError extends RuntimeException {
        final String code;
        ApiError(String code, String message) { super(code + ": " + message); this.code = code; }
    }

    /** GET when body is null, POST otherwise. Returns the raw response text.
     *  Two headers: Content-Type and Authorization. There is no X-App-Slug. */
    static String call(String path, String jsonBody, Map<String, String> extra) throws Exception {
        var b = HttpRequest.newBuilder(URI.create(BASE + "/" + path))
            .header("Authorization", "Bearer " + token);
        if (jsonBody == null) {
            b = b.GET();
        } else {
            b = b.header("Content-Type", "application/json")
                 .POST(HttpRequest.BodyPublishers.ofString(jsonBody));
        }
        for (var e : extra.entrySet()) b = b.header(e.getKey(), e.getValue());

        HttpResponse<String> res = HTTP.send(b.build(), HttpResponse.BodyHandlers.ofString());
        String text = res.body();
        // These samples keep the envelope as text and use a real JSON library in
        // production (Jackson, Gson). The only thing to get right is the check:
        // an envelope with "ok":false carries error.code and never data.
        if (text.contains("\"ok\":false")) throw new ApiError("API_ERROR", text);
        return text;
    }
}

require "json"
require "net/http"
require "uri"

BASE = "https://api.skillsafe.ai/v1/app-api"
# From https://tripod-desk.skillsafe.ai/tokens.html, or minted in step 1.
TOKEN = ENV.fetch("SKILLSAFE_TOKEN", "YOUR_TOKEN")

class ApiError < StandardError
  attr_reader :code, :details
  def initialize(code, message, details = {})
    super("#{code}: #{message}")
    @code = code
    @details = details
  end
end

# call("me") -> GET; call("estimate", input) -> POST with the input object as
# the whole body. No X-App-Slug: the token already carries the app.
def call(path, body = nil, extra = {})
  uri = URI("#{BASE}/#{path}")
  req = body.nil? ? Net::HTTP::Get.new(uri) : Net::HTTP::Post.new(uri)
  req["Authorization"] = "Bearer #{TOKEN}"
  unless body.nil?
    req["Content-Type"] = "application/json"
    req.body = JSON.generate(body)
  end
  extra.each { |k, v| req[k] = v }

  res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
  env = JSON.parse(res.body)
  unless env["ok"]
    err = env["error"] || {}
    raise ApiError.new(err["code"], err["message"], err["details"] || {})
  end
  env["data"]
end

p call("me")
# {"subject_type"=>"user", "subject_id"=>"usr_...", "credits"=>51234}

<?php
const BASE = "https://api.skillsafe.ai/v1/app-api";
// From https://tripod-desk.skillsafe.ai/tokens.html, or minted in step 1.
define("TOKEN", getenv("SKILLSAFE_TOKEN") ?: "YOUR_TOKEN");

class ApiError extends RuntimeException {
    public string $code;
    public array $details;
    public function __construct(string $code, string $message, array $details = []) {
        parent::__construct("$code: $message");
        $this->code = $code;
        $this->details = $details;
    }
}

// call("me") is a GET; call("estimate", $input) POSTs $input as the whole body.
// Two headers only - there is no X-App-Slug in this API.
function call(string $path, ?array $body = null, array $extra = []): array {
    $headers = ["Authorization: Bearer " . TOKEN];
    if ($body !== null) $headers[] = "Content-Type: application/json";
    foreach ($extra as $k => $v) $headers[] = "$k: $v";

    $ch = curl_init(BASE . "/" . $path);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    if ($body !== null) {
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($body));
    }
    $raw = curl_exec($ch);
    curl_close($ch);

    $env = json_decode($raw, true) ?: [];
    if (empty($env["ok"])) {
        $err = $env["error"] ?? [];
        throw new ApiError($err["code"] ?? "INTERNAL", $err["message"] ?? "no message",
                           $err["details"] ?? []);
    }
    return $env["data"];
}

print_r(call("me"));
// Array ( [subject_type] => user [subject_id] => usr_... [credits] => 51234 )

// .NET 8. Usings: System.Net.Http.Json, System.Security.Cryptography,
// System.Text, System.Text.Json.
static class TripodDesk
{
    const string Base = "https://api.skillsafe.ai/v1/app-api";

    // From https://tripod-desk.skillsafe.ai/tokens.html, or minted in step 1.
    public static string Token =
        Environment.GetEnvironmentVariable("SKILLSAFE_TOKEN") ?? "YOUR_TOKEN";

    static readonly HttpClient Http = new();

    public class ApiError : Exception
    {
        public string Code { get; }
        public ApiError(string code, string message) : base($"{code}: {message}") => Code = code;
    }

    /// GET when body is null, POST otherwise. Returns the unwrapped `data`.
    /// Two headers: Content-Type and Authorization. There is no X-App-Slug.
    public static async Task<JsonElement> Call(string path, object? body = null,
                                              Dictionary<string, string>? extra = null)
    {
        var req = new HttpRequestMessage(body is null ? HttpMethod.Get : HttpMethod.Post,
                                        $"{Base}/{path}");
        req.Headers.Add("Authorization", $"Bearer {Token}");
        if (body is not null)
            req.Content = new StringContent(JsonSerializer.Serialize(body),
                                            Encoding.UTF8, "application/json");
        foreach (var kv in extra ?? new()) req.Headers.Add(kv.Key, kv.Value);

        var res = await Http.SendAsync(req);
        var env = await res.Content.ReadFromJsonAsync<JsonElement>();
        if (!env.GetProperty("ok").GetBoolean())
        {
            var err = env.GetProperty("error");
            throw new ApiError(err.GetProperty("code").GetString() ?? "INTERNAL",
                               err.GetProperty("message").GetString() ?? "no message");
        }
        return env.GetProperty("data");
    }
}

var me = await TripodDesk.Call("me");
Console.WriteLine(me.GetProperty("credits").GetInt32());

# The token page is the shortest path for a person. It shows the token this
# browser holds and hands you a ready-made shell export:
#
#   https://tripod-desk.skillsafe.ai/tokens.html
#   export SKILLSAFE_TOKEN="..."
#
# To mint a guest token from the command line instead. The slug goes in the BODY;
# there is no X-App-Slug header anywhere in this API.
curl -sS -i -X POST "https://api.skillsafe.ai/v1/app-api/guest" \
  -H "Content-Type: application/json" \
  -d '{"slug":"tripod-desk"}'

# HTTP/1.1 201 Created
# {"ok":true,"data":{"token":"sk_guest_...","guest_id":"gst_...",
#                    "expires_at":"2026-08-27T09:14:02Z"}}

TOKEN=$(curl -sS -X POST "https://api.skillsafe.ai/v1/app-api/guest" \
  -H "Content-Type: application/json" \
  -d '{"slug":"tripod-desk"}' \
  | python3 -c 'import sys,json;print(json.load(sys.stdin)["data"]["token"])')

# A guest token covers /me and /estimate. A metered review needs a personal
# token from signing in on the token page.

# Open https://tripod-desk.skillsafe.ai/tokens.html and press "Copy token", or
# mint a guest token here. The slug goes in the BODY of /guest and nowhere else.
import json, urllib.request

GUEST_BODY = json.dumps({"slug": "tripod-desk"}).encode()

req = urllib.request.Request(
    "https://api.skillsafe.ai/v1/app-api/guest", data=GUEST_BODY, method="POST")
req.add_header("Content-Type", "application/json")
with urllib.request.urlopen(req) as res:
    status = res.status                    # 201
    guest = json.load(res)["data"]

TOKEN = guest["token"]
print(status, guest["guest_id"], "expires", guest["expires_at"])

# Keep guest_id: it is what lets a later sign-in migrate this wallet. Keep
# expires_at too - a long-lived worker re-mints instead of caching forever.
# A guest token can call /me and /estimate; a metered review cannot.

// Open https://tripod-desk.skillsafe.ai/tokens.html and press "Copy token", or
// mint a guest token here. The slug goes in the BODY of /guest and nowhere else.
const res = await fetch("https://api.skillsafe.ai/v1/app-api/guest", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ slug: "tripod-desk" }),
});
console.log(res.status); // 201

const guest = (await res.json()).data;
const guestToken = guest.token;
console.log(guest.guest_id, "expires", guest.expires_at);

// Keep guest_id - a later sign-in migrates the guest wallet with it. A guest
// token can call /me and /estimate but not a metered run.

// Open https://tripod-desk.skillsafe.ai/tokens.html and press "Copy token", or
// mint a guest token here. The slug goes in the BODY of /guest and nowhere else.
guestBody := []byte(`{"slug":"tripod-desk"}`)

guestReq, _ := http.NewRequest(http.MethodPost,
	"https://api.skillsafe.ai/v1/app-api/guest", bytes.NewReader(guestBody))
guestReq.Header.Set("Content-Type", "application/json")

guestRes, err := http.DefaultClient.Do(guestReq)
if err != nil {
	panic(err)
}
defer guestRes.Body.Close()
fmt.Println(guestRes.StatusCode) // 201

var guest struct {
	Data struct {
		Token     string `json:"token"`
		GuestID   string `json:"guest_id"`
		ExpiresAt string `json:"expires_at"`
	} `json:"data"`
}
_ = json.NewDecoder(guestRes.Body).Decode(&guest)
token = guest.Data.Token // the package-level token the helper reads
fmt.Println(guest.Data.GuestID, "expires", guest.Data.ExpiresAt)
// A guest token covers /me and /estimate; a metered review needs a personal one.

// Open https://tripod-desk.skillsafe.ai/tokens.html and press "Copy token", or
// mint a guest token here. The slug goes in the BODY of /guest and nowhere else.
var guestReq = HttpRequest.newBuilder(URI.create("https://api.skillsafe.ai/v1/app-api/guest"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString("{\"slug\":\"tripod-desk\"}"))
    .build();

HttpResponse<String> guest = TripodDesk.HTTP.send(guestReq,
    HttpResponse.BodyHandlers.ofString());
System.out.println(guest.statusCode()); // 201
System.out.println(guest.body());
// {"ok":true,"data":{"token":"sk_guest_...","guest_id":"gst_...",
//                    "expires_at":"2026-08-27T09:14:02Z"}}
//
// Keep guest_id (a later sign-in migrates the wallet with it) and expires_at
// (re-mint rather than cache forever). A guest token cannot start a metered run.

# Open https://tripod-desk.skillsafe.ai/tokens.html and press "Copy token", or
# mint a guest token here. The slug goes in the BODY of /guest and nowhere else.
require "json"
require "net/http"
require "uri"

uri = URI("https://api.skillsafe.ai/v1/app-api/guest")
req = Net::HTTP::Post.new(uri)
req["Content-Type"] = "application/json"
req.body = JSON.generate({ "slug" => "tripod-desk" })
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }

puts res.code # "201"
guest = JSON.parse(res.body)["data"]
guest_token = guest["token"]
puts "#{guest['guest_id']} expires #{guest['expires_at']}"
# A guest token covers /me and /estimate; a metered review needs a personal one.

<?php
// Open https://tripod-desk.skillsafe.ai/tokens.html and press "Copy token", or
// mint a guest token here. The slug goes in the BODY of /guest and nowhere else.
$ch = curl_init("https://api.skillsafe.ai/v1/app-api/guest");
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["slug" => "tripod-desk"]));
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$guest = json_decode(curl_exec($ch), true)["data"];
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE); // 201
curl_close($ch);

echo $status, " ", $guest["guest_id"], " expires ", $guest["expires_at"], PHP_EOL;
$guestToken = $guest["token"];
// A guest token covers /me and /estimate; a metered review needs a personal one.

// Open https://tripod-desk.skillsafe.ai/tokens.html and press "Copy token", or
// mint a guest token here. The slug goes in the BODY of /guest and nowhere else.
using var http = new HttpClient();
var guestReq = new HttpRequestMessage(HttpMethod.Post,
    "https://api.skillsafe.ai/v1/app-api/guest")
{
    Content = new StringContent("{\"slug\":\"tripod-desk\"}",
        Encoding.UTF8, "application/json"),
};

var guestRes = await http.SendAsync(guestReq);
Console.WriteLine((int)guestRes.StatusCode); // 201

var guest = (await guestRes.Content.ReadFromJsonAsync<JsonElement>()).GetProperty("data");
TripodDesk.Token = guest.GetProperty("token").GetString()!;
Console.WriteLine($"{guest.GetProperty("guest_id").GetString()} expires " +
                  $"{guest.GetProperty("expires_at").GetString()}");
// A guest token covers /me and /estimate; a metered review needs a personal one.

call me
# {"ok":true,"data":{"subject_type":"user","subject_id":"usr_...","credits":51234}}

# Branch on subject_type. There is no is_guest field to test, and no user_id -
# the id is subject_id for both kinds of subject.
call me | python3 -c '
import sys, json
me = json.load(sys.stdin)["data"]
kind = me["subject_type"]                       # "guest" or "user"
print(kind, me["subject_id"], me["credits"], "credits")
if kind == "guest":
    print("guest token: /me and /estimate only, no metered run")
'

me = call("me")

# Exactly three fields: subject_type, subject_id, credits.
kind = me["subject_type"]          # "guest" or "user"
print(kind, me["subject_id"], me["credits"], "credits")

# Branch on subject_type. There is no is_guest flag - a truthiness test on one
# is False for everybody, which reads as "signed in" for a guest token.
if kind == "guest":
    print("guest token: /me and /estimate only; a review needs a personal token")

# me.get("user_id") is always None. The identifier is subject_id.

const me = await call("me");

// Exactly three fields: subject_type, subject_id, credits.
console.log(me.subject_type, me.subject_id, me.credits);

// Branch on subject_type. me.is_guest is undefined, so `if (me.is_guest)` is
// false for a guest too - which is exactly backwards.
if (me.subject_type === "guest") {
  console.log("guest token: /me and /estimate only; a review needs a personal token");
}

// me.user_id is undefined. The identifier is subject_id for both kinds.

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

// Exactly three fields. No UserID, no IsGuest - adding them to this struct just
// gives you a zero value that looks like an answer.
var me struct {
	SubjectType string `json:"subject_type"` // "guest" or "user"
	SubjectID   string `json:"subject_id"`
	Credits     int    `json:"credits"`
}
_ = json.Unmarshal(raw, &me)
fmt.Println(me.SubjectType, me.SubjectID, me.Credits)

if me.SubjectType == "guest" {
	fmt.Println("guest token: /me and /estimate only; a review needs a personal token")
}

String meJson = TripodDesk.call("me", null, Map.of());
System.out.println(meJson);
// {"ok":true,"data":{"subject_type":"user","subject_id":"usr_...","credits":51234}}
//
// Three fields, and only three: subject_type ("guest" or "user"), subject_id and
// credits. There is no user_id and no is_guest, so branch on subject_type:
//
//   boolean guest = "guest".equals(subjectType);
//
// A guest token can call /me and /estimate. A metered review needs a personal
// token from https://tripod-desk.skillsafe.ai/tokens.html.
System.out.println(meJson.contains("\"subject_type\":\"guest\"")
    ? "guest token: no metered run"
    : "personal token: metered runs allowed");

me = call("me")

# Exactly three fields: subject_type, subject_id, credits.
puts "#{me['subject_type']} #{me['subject_id']} #{me['credits']} credits"

# Branch on subject_type. me["is_guest"] is nil for everybody, and me["user_id"]
# does not exist - the identifier is subject_id.
if me["subject_type"] == "guest"
  puts "guest token: /me and /estimate only; a review needs a personal token"
end

<?php
$me = call("me");

// Exactly three fields: subject_type, subject_id, credits.
echo $me["subject_type"], " ", $me["subject_id"], " ", $me["credits"], PHP_EOL;

// Branch on subject_type. $me["is_guest"] is not set, so an isset() test is
// false for a guest as well, and there is no user_id at all.
if ($me["subject_type"] === "guest") {
    echo "guest token: /me and /estimate only; a review needs a personal token", PHP_EOL;
}

var me = await TripodDesk.Call("me");

// Exactly three fields: subject_type, subject_id, credits.
var kind = me.GetProperty("subject_type").GetString(); // "guest" or "user"
Console.WriteLine($"{kind} {me.GetProperty("subject_id").GetString()} " +
                  $"{me.GetProperty("credits").GetInt32()}");

// Branch on subject_type. TryGetProperty("is_guest", ...) is always false, and
// there is no user_id - subject_id is the identifier for both kinds.
if (kind == "guest")
    Console.WriteLine("guest token: /me and /estimate only; a review needs a personal token");

# The report and the metrics table as shell variables, so the JSON stays readable.
REPORT=$(cat <<'EOF'
Model: ICU-DETERIORATE v2 (gradient-boosted trees)
Care setting: two tertiary ICUs, 2019-2023
Data source: retrospective EHR extract
Index time: first 6 hours after ICU admission
Prediction horizon: 24 hours
Primary outcome: in-hospital mortality or unplanned transfer to a higher level of care
Outcome ascertainment: discharge coding, adjudicated by two intensivists
Sample size: 18412
Events: 1104
Candidate predictors: 214
Predictor selection: SHAP-ranked, top 40 retained
Split strategy: random 70/30 split
External validation: none
Discrimination: AUC 0.91 (95% CI 0.90-0.92)
Calibration: not assessed
Threshold: 0.15
Attribution method: TreeSHAP with a 100-row background set
EOF
)

METRICS=$(printf '%s\n%s\n%s\n' \
  "split	n	events	prevalence	auc	auc_lo	auc_hi	brier	cal_slope	cal_intercept	sens	spec	ppv	npv	threshold" \
  "development	12888	773	0.060	0.94	0.93	0.95	0.041	1.00	0.00	0.88	0.87	0.31	0.99	0.15" \
  "internal	5524	331	0.060	0.91	0.90	0.92	0.048	0.71	0.35	0.86	0.84	0.26	0.99	0.15")

# Build the body with python3 so the newlines and tabs are escaped correctly.
# THE BODY IS THE INPUT OBJECT ITSELF - there is no "input" key.
INPUT=$(REPORT="$REPORT" METRICS="$METRICS" python3 -c '
import json, os
print(json.dumps({
    "task": "validate",
    "report": os.environ["REPORT"],
    "metrics": os.environ["METRICS"],
    "stage": "internal",
    "audience": "journal",
    "context": "Reviewer 2 asked only for a calibration plot. Submission deadline in three weeks.",
    "prescan_facts": {
        "flags": [
            {"uid": "F1", "id": "TD-LEAK-TESTSET", "severity": "blocking", "area": "leakage",
             "label": "Predictor selection ran before the split",
             "detail": "214 candidates were SHAP-ranked and the top 40 kept, with no statement that the ranking was computed inside the training fold.",
             "line": 11, "evidence": "Predictor selection: SHAP-ranked, top 40 retained"},
            {"uid": "F2", "id": "TD-NO-CALIBRATION", "severity": "high", "area": "calibration",
             "label": "Calibration is stated as not assessed",
             "detail": "No calibration slope, intercept or O:E appears in the text.",
             "line": 15, "evidence": "Calibration: not assessed"},
            {"uid": "F3", "id": "TD-EPV", "severity": "high", "area": "predictors",
             "label": "5.2 events per candidate predictor",
             "detail": "1104 events over 214 candidates.",
             "line": 10, "evidence": "Candidate predictors: 214"},
            {"uid": "F4", "id": "TD-SINGLE-SPLIT", "severity": "medium", "area": "validation",
             "label": "A single random split is the whole validation",
             "detail": "One 70/30 draw gives one estimate with no variance around it.",
             "line": 12, "evidence": "Split strategy: random 70/30 split"}
        ],
        "free_read_verdict": "not_supported",
        "numbers": {"n": 18412, "events": 1104, "predictors": 214, "epv": 5.16,
                    "prevalence": 0.06, "prevalence_source": "derived from events / sample size"},
        "evidence": {"discrimination": "reported", "calibration": "declared_absent",
                     "classification": "reported", "utility": "absent"},
        "checklist_summary": {"total": 47, "reported": 24, "partial": 0, "not_reported": 23,
                              "outstanding": [{"no": 12, "item": "Calibration: method and results",
                                               "status": "not_reported"}]},
        "unassessable": [{"item": "Whether the 100-row background set is representative",
                          "why": "the report does not say how it was drawn"}]
    }
}))')

call estimate "$INPUT" | data
# {"model": "gpt-5.6-terra", "model_alias": "gpt-terra", "markup_bps": 1000,
#  "hold_credits": 2960, "min_credits": 340, "sponsor_enabled": false}
#
# estimate is FREE - no job, no charge - but it IS authenticated, so it comes
# after step 1. Assert the alias, then compare min_credits against /me.
call estimate "$INPUT" | python3 -c '
import sys, json
est = json.load(sys.stdin)["data"]
assert est["model_alias"] == "gpt-terra", est["model_alias"]
print("hold", est["hold_credits"], "min", est["min_credits"],
      "sponsored", est["sponsor_enabled"])
'

REPORT = "\n".join([
    "Model: ICU-DETERIORATE v2 (gradient-boosted trees)",
    "Care setting: two tertiary ICUs, 2019-2023",
    "Data source: retrospective EHR extract",
    "Index time: first 6 hours after ICU admission",
    "Prediction horizon: 24 hours",
    "Primary outcome: in-hospital mortality or unplanned transfer to a higher level of care",
    "Outcome ascertainment: discharge coding, adjudicated by two intensivists",
    "Sample size: 18412",
    "Events: 1104",
    "Candidate predictors: 214",
    "Predictor selection: SHAP-ranked, top 40 retained",
    "Split strategy: random 70/30 split",
    "External validation: none",
    "Discrimination: AUC 0.91 (95% CI 0.90-0.92)",
    "Calibration: not assessed",
    "Threshold: 0.15",
    "Attribution method: TreeSHAP with a 100-row background set",
])

# Tab-separated; CSV, semicolons and markdown pipe tables parse too.
METRICS = (
    "split\tn\tevents\tprevalence\tauc\tauc_lo\tauc_hi\tbrier\t"
    "cal_slope\tcal_intercept\tsens\tspec\tppv\tnpv\tthreshold\n"
    "development\t12888\t773\t0.060\t0.94\t0.93\t0.95\t0.041\t"
    "1.00\t0.00\t0.88\t0.87\t0.31\t0.99\t0.15\n"
    "internal\t5524\t331\t0.060\t0.91\t0.90\t0.92\t0.048\t"
    "0.71\t0.35\t0.86\t0.84\t0.26\t0.99\t0.15\n"
)

PRESCAN = {
    "flags": [
        {"uid": "F1", "id": "TD-LEAK-TESTSET", "severity": "blocking", "area": "leakage",
         "label": "Predictor selection ran before the split",
         "detail": "214 candidates were SHAP-ranked and the top 40 kept, with no statement "
                   "that the ranking was computed inside the training fold.",
         "line": 11, "evidence": "Predictor selection: SHAP-ranked, top 40 retained"},
        {"uid": "F2", "id": "TD-NO-CALIBRATION", "severity": "high", "area": "calibration",
         "label": "Calibration is stated as not assessed",
         "detail": "No calibration slope, intercept or O:E appears in the text.",
         "line": 15, "evidence": "Calibration: not assessed"},
        {"uid": "F3", "id": "TD-EPV", "severity": "high", "area": "predictors",
         "label": "5.2 events per candidate predictor",
         "detail": "1104 events over 214 candidates.",
         "line": 10, "evidence": "Candidate predictors: 214"},
        {"uid": "F4", "id": "TD-SINGLE-SPLIT", "severity": "medium", "area": "validation",
         "label": "A single random split is the whole validation",
         "detail": "One 70/30 draw gives one estimate with no variance around it.",
         "line": 12, "evidence": "Split strategy: random 70/30 split"},
    ],
    "free_read_verdict": "not_supported",
    "numbers": {"n": 18412, "events": 1104, "predictors": 214, "epv": 5.16,
                "prevalence": 0.06,
                "prevalence_source": "derived from events / sample size"},
    "evidence": {"discrimination": "reported", "calibration": "declared_absent",
                 "classification": "reported", "utility": "absent"},
    "checklist_summary": {"total": 47, "reported": 24, "partial": 0, "not_reported": 23,
                          "outstanding": [{"no": 12,
                                           "item": "Calibration: method and results",
                                           "status": "not_reported"}]},
    "unassessable": [{"item": "Whether the 100-row background set is representative",
                      "why": "the report does not say how it was drawn"}],
}

INPUT = {
    "task": "validate",
    "report": REPORT,
    "metrics": METRICS,
    "stage": "internal",
    "audience": "journal",
    "context": "Reviewer 2 asked only for a calibration plot. "
               "Submission deadline in three weeks.",
    "prescan_facts": PRESCAN,
}

# This is the whole body. It is NOT {"input": INPUT} - that shape returns 200 and
# the model never sees a field of it.
est = call("estimate", INPUT)
assert est["model_alias"] == "gpt-terra", est["model_alias"]
print(est["model"], est["model_alias"], est["markup_bps"])
print("hold", est["hold_credits"], "min", est["min_credits"],
      "sponsored", est["sponsor_enabled"])

me = call("me")
if not est["sponsor_enabled"] and me["credits"] < est["min_credits"]:
    raise SystemExit(f"balance {me['credits']} is below min_credits {est['min_credits']}")

const REPORT = [
  "Model: ICU-DETERIORATE v2 (gradient-boosted trees)",
  "Care setting: two tertiary ICUs, 2019-2023",
  "Data source: retrospective EHR extract",
  "Index time: first 6 hours after ICU admission",
  "Prediction horizon: 24 hours",
  "Primary outcome: in-hospital mortality or unplanned transfer to a higher level of care",
  "Outcome ascertainment: discharge coding, adjudicated by two intensivists",
  "Sample size: 18412",
  "Events: 1104",
  "Candidate predictors: 214",
  "Predictor selection: SHAP-ranked, top 40 retained",
  "Split strategy: random 70/30 split",
  "External validation: none",
  "Discrimination: AUC 0.91 (95% CI 0.90-0.92)",
  "Calibration: not assessed",
  "Threshold: 0.15",
  "Attribution method: TreeSHAP with a 100-row background set",
].join("\n");

// Tab-separated; CSV, semicolons and markdown pipe tables parse too.
const METRICS =
  "split\tn\tevents\tprevalence\tauc\tauc_lo\tauc_hi\tbrier\t" +
  "cal_slope\tcal_intercept\tsens\tspec\tppv\tnpv\tthreshold\n" +
  "development\t12888\t773\t0.060\t0.94\t0.93\t0.95\t0.041\t1.00\t0.00\t0.88\t0.87\t0.31\t0.99\t0.15\n" +
  "internal\t5524\t331\t0.060\t0.91\t0.90\t0.92\t0.048\t0.71\t0.35\t0.86\t0.84\t0.26\t0.99\t0.15\n";

const PRESCAN = {
  flags: [
    { uid: "F1", id: "TD-LEAK-TESTSET", severity: "blocking", area: "leakage",
      label: "Predictor selection ran before the split",
      detail: "214 candidates were SHAP-ranked and the top 40 kept, with no statement that the ranking was computed inside the training fold.",
      line: 11, evidence: "Predictor selection: SHAP-ranked, top 40 retained" },
    { uid: "F2", id: "TD-NO-CALIBRATION", severity: "high", area: "calibration",
      label: "Calibration is stated as not assessed",
      detail: "No calibration slope, intercept or O:E appears in the text.",
      line: 15, evidence: "Calibration: not assessed" },
    { uid: "F3", id: "TD-EPV", severity: "high", area: "predictors",
      label: "5.2 events per candidate predictor",
      detail: "1104 events over 214 candidates.",
      line: 10, evidence: "Candidate predictors: 214" },
    { uid: "F4", id: "TD-SINGLE-SPLIT", severity: "medium", area: "validation",
      label: "A single random split is the whole validation",
      detail: "One 70/30 draw gives one estimate with no variance around it.",
      line: 12, evidence: "Split strategy: random 70/30 split" },
  ],
  free_read_verdict: "not_supported",
  numbers: { n: 18412, events: 1104, predictors: 214, epv: 5.16, prevalence: 0.06,
             prevalence_source: "derived from events / sample size" },
  evidence: { discrimination: "reported", calibration: "declared_absent",
              classification: "reported", utility: "absent" },
  checklist_summary: { total: 47, reported: 24, partial: 0, not_reported: 23,
                       outstanding: [{ no: 12, item: "Calibration: method and results",
                                       status: "not_reported" }] },
  unassessable: [{ item: "Whether the 100-row background set is representative",
                   why: "the report does not say how it was drawn" }],
};

const INPUT = {
  task: "validate",
  report: REPORT,
  metrics: METRICS,
  stage: "internal",
  audience: "journal",
  context: "Reviewer 2 asked only for a calibration plot. Submission deadline in three weeks.",
  prescan_facts: PRESCAN,
};

// This is the whole body - not { input: INPUT }, which returns 200 while the
// model sees nothing.
const est = await call("estimate", INPUT);
if (est.model_alias !== "gpt-terra") throw new Error(`unexpected model ${est.model_alias}`);
console.log(est.model, est.markup_bps, "hold", est.hold_credits, "min", est.min_credits);

const me = await call("me");
if (!est.sponsor_enabled && me.credits < est.min_credits) {
  throw new Error(`balance ${me.credits} is below min_credits ${est.min_credits}`);
}

report := strings.Join([]string{
	"Model: ICU-DETERIORATE v2 (gradient-boosted trees)",
	"Care setting: two tertiary ICUs, 2019-2023",
	"Data source: retrospective EHR extract",
	"Index time: first 6 hours after ICU admission",
	"Prediction horizon: 24 hours",
	"Primary outcome: in-hospital mortality or unplanned transfer to a higher level of care",
	"Sample size: 18412",
	"Events: 1104",
	"Candidate predictors: 214",
	"Predictor selection: SHAP-ranked, top 40 retained",
	"Split strategy: random 70/30 split",
	"External validation: none",
	"Discrimination: AUC 0.91 (95% CI 0.90-0.92)",
	"Calibration: not assessed",
	"Threshold: 0.15",
	"Attribution method: TreeSHAP with a 100-row background set",
}, "\n")

metrics := "split\tn\tevents\tprevalence\tauc\tauc_lo\tauc_hi\tbrier\t" +
	"cal_slope\tcal_intercept\tsens\tspec\tppv\tnpv\tthreshold\n" +
	"development\t12888\t773\t0.060\t0.94\t0.93\t0.95\t0.041\t1.00\t0.00\t0.88\t0.87\t0.31\t0.99\t0.15\n" +
	"internal\t5524\t331\t0.060\t0.91\t0.90\t0.92\t0.048\t0.71\t0.35\t0.86\t0.84\t0.26\t0.99\t0.15\n"

input := map[string]any{
	"task":     "validate",
	"report":   report,
	"metrics":  metrics,
	"stage":    "internal",
	"audience": "journal",
	"context":  "Reviewer 2 asked only for a calibration plot. Deadline in three weeks.",
	"prescan_facts": map[string]any{
		"flags": []any{
			map[string]any{
				"uid": "F1", "id": "TD-LEAK-TESTSET", "severity": "blocking",
				"area": "leakage", "label": "Predictor selection ran before the split",
				"detail":   "The top 40 of 214 candidates were kept by a ranking computed on all records.",
				"line":     11,
				"evidence": "Predictor selection: SHAP-ranked, top 40 retained",
			},
			map[string]any{
				"uid": "F2", "id": "TD-NO-CALIBRATION", "severity": "high",
				"area": "calibration", "label": "Calibration is stated as not assessed",
				"detail": "No slope, intercept or O:E appears in the text.", "line": 15,
				"evidence": "Calibration: not assessed",
			},
		},
		"free_read_verdict": "not_supported",
		"numbers": map[string]any{
			"n": 18412, "events": 1104, "predictors": 214, "epv": 5.16, "prevalence": 0.06,
		},
		"evidence": map[string]any{
			"discrimination": "reported", "calibration": "declared_absent",
			"classification": "reported", "utility": "absent",
		},
	},
}

// The body is `input` itself, not map[string]any{"input": input}.
raw, err := call("estimate", input, nil)
if err != nil {
	panic(err)
}
var est struct {
	Model          string `json:"model"`
	ModelAlias     string `json:"model_alias"`
	MarkupBps      int    `json:"markup_bps"`
	HoldCredits    int    `json:"hold_credits"`
	MinCredits     int    `json:"min_credits"`
	SponsorEnabled bool   `json:"sponsor_enabled"`
}
_ = json.Unmarshal(raw, &est)
if est.ModelAlias != "gpt-terra" {
	panic("unexpected model alias " + est.ModelAlias)
}
fmt.Println(est.Model, est.HoldCredits, est.MinCredits, est.SponsorEnabled)
// Free: no job is created and nothing is charged. The hold is a reservation.

// The input object, built as JSON text. In production use Jackson or Gson and
// build a Map; the shape is what matters, and the shape is FLAT.
String report = String.join("\\n",
    "Model: ICU-DETERIORATE v2 (gradient-boosted trees)",
    "Index time: first 6 hours after ICU admission",
    "Prediction horizon: 24 hours",
    "Primary outcome: in-hospital mortality or unplanned transfer",
    "Sample size: 18412",
    "Events: 1104",
    "Candidate predictors: 214",
    "Predictor selection: SHAP-ranked, top 40 retained",
    "Split strategy: random 70/30 split",
    "External validation: none",
    "Discrimination: AUC 0.91 (95% CI 0.90-0.92)",
    "Calibration: not assessed",
    "Threshold: 0.15");

String metrics = String.join("\\n",
    "split\\tn\\tevents\\tauc\\tcal_slope\\tcal_intercept\\tthreshold",
    "development\\t12888\\t773\\t0.94\\t1.00\\t0.00\\t0.15",
    "internal\\t5524\\t331\\t0.91\\t0.71\\t0.35\\t0.15");

// Note the absence of any wrapper key: task, report, metrics, stage, audience,
// context and prescan_facts are all TOP-LEVEL.
String input = """
    {"task":"validate",
     "report":"%s",
     "metrics":"%s",
     "stage":"internal",
     "audience":"journal",
     "context":"Reviewer 2 asked only for a calibration plot.",
     "prescan_facts":{"flags":[
        {"uid":"F1","id":"TD-LEAK-TESTSET","severity":"blocking","area":"leakage",
         "label":"Predictor selection ran before the split",
         "detail":"The top 40 of 214 candidates were kept by a ranking computed on all records.",
         "line":11,"evidence":"Predictor selection: SHAP-ranked, top 40 retained"},
        {"uid":"F2","id":"TD-NO-CALIBRATION","severity":"high","area":"calibration",
         "label":"Calibration is stated as not assessed",
         "detail":"No slope, intercept or O:E appears in the text.",
         "line":15,"evidence":"Calibration: not assessed"}],
       "free_read_verdict":"not_supported",
       "numbers":{"n":18412,"events":1104,"predictors":214,"epv":5.16}}}
    """.formatted(report, metrics);

String est = TripodDesk.call("estimate", input, Map.of());
System.out.println(est);
// {"ok":true,"data":{"model":"gpt-5.6-terra","model_alias":"gpt-terra",
//   "markup_bps":1000,"hold_credits":2960,"min_credits":340,"sponsor_enabled":false}}

if (!est.contains("\"model_alias\":\"gpt-terra\""))
    throw new IllegalStateException("not this app's model: " + est);
// estimate is free and creates no job - but it is authenticated, so step 1 first.

REPORT = [
  "Model: ICU-DETERIORATE v2 (gradient-boosted trees)",
  "Care setting: two tertiary ICUs, 2019-2023",
  "Index time: first 6 hours after ICU admission",
  "Prediction horizon: 24 hours",
  "Primary outcome: in-hospital mortality or unplanned transfer to a higher level of care",
  "Sample size: 18412",
  "Events: 1104",
  "Candidate predictors: 214",
  "Predictor selection: SHAP-ranked, top 40 retained",
  "Split strategy: random 70/30 split",
  "External validation: none",
  "Discrimination: AUC 0.91 (95% CI 0.90-0.92)",
  "Calibration: not assessed",
  "Threshold: 0.15",
  "Attribution method: TreeSHAP with a 100-row background set"
].join("\n")

METRICS = [
  %w[split n events prevalence auc auc_lo auc_hi brier cal_slope cal_intercept
     sens spec ppv npv threshold].join("\t"),
  %w[development 12888 773 0.060 0.94 0.93 0.95 0.041 1.00 0.00 0.88 0.87 0.31 0.99 0.15].join("\t"),
  %w[internal 5524 331 0.060 0.91 0.90 0.92 0.048 0.71 0.35 0.86 0.84 0.26 0.99 0.15].join("\t")
].join("\n") + "\n"

INPUT = {
  "task" => "validate",
  "report" => REPORT,
  "metrics" => METRICS,
  "stage" => "internal",
  "audience" => "journal",
  "context" => "Reviewer 2 asked only for a calibration plot. Deadline in three weeks.",
  "prescan_facts" => {
    "flags" => [
      { "uid" => "F1", "id" => "TD-LEAK-TESTSET", "severity" => "blocking",
        "area" => "leakage", "label" => "Predictor selection ran before the split",
        "detail" => "The top 40 of 214 candidates were kept by a ranking computed on all records.",
        "line" => 11, "evidence" => "Predictor selection: SHAP-ranked, top 40 retained" },
      { "uid" => "F2", "id" => "TD-NO-CALIBRATION", "severity" => "high",
        "area" => "calibration", "label" => "Calibration is stated as not assessed",
        "detail" => "No slope, intercept or O:E appears in the text.",
        "line" => 15, "evidence" => "Calibration: not assessed" }
    ],
    "free_read_verdict" => "not_supported",
    "numbers" => { "n" => 18412, "events" => 1104, "predictors" => 214, "epv" => 5.16 },
    "evidence" => { "discrimination" => "reported", "calibration" => "declared_absent",
                    "classification" => "reported", "utility" => "absent" }
  }
}

# The whole body, flat. Not {"input" => INPUT}.
est = call("estimate", INPUT)
raise "unexpected model #{est['model_alias']}" unless est["model_alias"] == "gpt-terra"
puts "#{est['model']} hold #{est['hold_credits']} min #{est['min_credits']}"

me = call("me")
if !est["sponsor_enabled"] && me["credits"] < est["min_credits"]
  abort "balance #{me['credits']} is below min_credits #{est['min_credits']}"
end

<?php
$report = implode("\n", [
    "Model: ICU-DETERIORATE v2 (gradient-boosted trees)",
    "Care setting: two tertiary ICUs, 2019-2023",
    "Index time: first 6 hours after ICU admission",
    "Prediction horizon: 24 hours",
    "Primary outcome: in-hospital mortality or unplanned transfer to a higher level of care",
    "Sample size: 18412",
    "Events: 1104",
    "Candidate predictors: 214",
    "Predictor selection: SHAP-ranked, top 40 retained",
    "Split strategy: random 70/30 split",
    "External validation: none",
    "Discrimination: AUC 0.91 (95% CI 0.90-0.92)",
    "Calibration: not assessed",
    "Threshold: 0.15",
    "Attribution method: TreeSHAP with a 100-row background set",
]);

$metrics = implode("\n", [
    "split\tn\tevents\tprevalence\tauc\tauc_lo\tauc_hi\tbrier\tcal_slope\tcal_intercept\tsens\tspec\tppv\tnpv\tthreshold",
    "development\t12888\t773\t0.060\t0.94\t0.93\t0.95\t0.041\t1.00\t0.00\t0.88\t0.87\t0.31\t0.99\t0.15",
    "internal\t5524\t331\t0.060\t0.91\t0.90\t0.92\t0.048\t0.71\t0.35\t0.86\t0.84\t0.26\t0.99\t0.15",
]) . "\n";

// Flat. Every key here is top-level; there is no "input" wrapper.
$INPUT = [
    "task" => "validate",
    "report" => $report,
    "metrics" => $metrics,
    "stage" => "internal",
    "audience" => "journal",
    "context" => "Reviewer 2 asked only for a calibration plot. Deadline in three weeks.",
    "prescan_facts" => [
        "flags" => [
            ["uid" => "F1", "id" => "TD-LEAK-TESTSET", "severity" => "blocking",
             "area" => "leakage", "label" => "Predictor selection ran before the split",
             "detail" => "The top 40 of 214 candidates were kept by a ranking computed on all records.",
             "line" => 11, "evidence" => "Predictor selection: SHAP-ranked, top 40 retained"],
            ["uid" => "F2", "id" => "TD-NO-CALIBRATION", "severity" => "high",
             "area" => "calibration", "label" => "Calibration is stated as not assessed",
             "detail" => "No slope, intercept or O:E appears in the text.",
             "line" => 15, "evidence" => "Calibration: not assessed"],
        ],
        "free_read_verdict" => "not_supported",
        "numbers" => ["n" => 18412, "events" => 1104, "predictors" => 214, "epv" => 5.16],
        "evidence" => ["discrimination" => "reported", "calibration" => "declared_absent",
                       "classification" => "reported", "utility" => "absent"],
    ],
];

$est = call("estimate", $INPUT);
if ($est["model_alias"] !== "gpt-terra") {
    throw new RuntimeException("unexpected model " . $est["model_alias"]);
}
echo $est["model"], " hold ", $est["hold_credits"], " min ", $est["min_credits"], PHP_EOL;

$me = call("me");
if (!$est["sponsor_enabled"] && $me["credits"] < $est["min_credits"]) {
    throw new RuntimeException("balance below min_credits");
}

var report = string.Join("\n", new[] {
    "Model: ICU-DETERIORATE v2 (gradient-boosted trees)",
    "Care setting: two tertiary ICUs, 2019-2023",
    "Index time: first 6 hours after ICU admission",
    "Prediction horizon: 24 hours",
    "Primary outcome: in-hospital mortality or unplanned transfer to a higher level of care",
    "Sample size: 18412",
    "Events: 1104",
    "Candidate predictors: 214",
    "Predictor selection: SHAP-ranked, top 40 retained",
    "Split strategy: random 70/30 split",
    "External validation: none",
    "Discrimination: AUC 0.91 (95% CI 0.90-0.92)",
    "Calibration: not assessed",
    "Threshold: 0.15",
    "Attribution method: TreeSHAP with a 100-row background set",
});

var metrics = string.Join("\n", new[] {
    "split\tn\tevents\tprevalence\tauc\tauc_lo\tauc_hi\tbrier\tcal_slope\tcal_intercept\tsens\tspec\tppv\tnpv\tthreshold",
    "development\t12888\t773\t0.060\t0.94\t0.93\t0.95\t0.041\t1.00\t0.00\t0.88\t0.87\t0.31\t0.99\t0.15",
    "internal\t5524\t331\t0.060\t0.91\t0.90\t0.92\t0.048\t0.71\t0.35\t0.86\t0.84\t0.26\t0.99\t0.15",
}) + "\n";

// Anonymous object, serialised flat. No "input" wrapper anywhere.
var input = new
{
    task = "validate",
    report,
    metrics,
    stage = "internal",
    audience = "journal",
    context = "Reviewer 2 asked only for a calibration plot. Deadline in three weeks.",
    prescan_facts = new
    {
        flags = new object[]
        {
            new { uid = "F1", id = "TD-LEAK-TESTSET", severity = "blocking", area = "leakage",
                  label = "Predictor selection ran before the split",
                  detail = "The top 40 of 214 candidates were kept by a ranking computed on all records.",
                  line = 11, evidence = "Predictor selection: SHAP-ranked, top 40 retained" },
            new { uid = "F2", id = "TD-NO-CALIBRATION", severity = "high", area = "calibration",
                  label = "Calibration is stated as not assessed",
                  detail = "No slope, intercept or O:E appears in the text.",
                  line = 15, evidence = "Calibration: not assessed" },
        },
        free_read_verdict = "not_supported",
        numbers = new { n = 18412, events = 1104, predictors = 214, epv = 5.16 },
        evidence = new { discrimination = "reported", calibration = "declared_absent",
                         classification = "reported", utility = "absent" },
    },
};

var est = await TripodDesk.Call("estimate", input);
var alias = est.GetProperty("model_alias").GetString();
if (alias != "gpt-terra") throw new Exception($"unexpected model {alias}");
Console.WriteLine($"{est.GetProperty("model").GetString()} " +
                  $"hold {est.GetProperty("hold_credits").GetInt32()} " +
                  $"min {est.GetProperty("min_credits").GetInt32()}");

# Always send an Idempotency-Key derived from the input, with the lane in it.
# A retried request with the same key returns the SAME job instead of billing twice.
KEY="tripod-desk:$(printf '%s' "$INPUT" | shasum -a 256 | cut -c1-16):validate:a1"

JOB=$(curl -sS -X POST "$BASE/run" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $KEY" \
  -d "$INPUT" | python3 -c 'import sys,json;print(json.load(sys.stdin)["data"]["job_id"])')

# Poll until the job reaches a terminal status.
while :; do
  OUT=$(call "jobs/$JOB")
  STATUS=$(printf '%s' "$OUT" | python3 -c 'import sys,json;print(json.load(sys.stdin)["data"]["status"])')
  [ "$STATUS" = "succeeded" ] && break
  [ "$STATUS" = "failed" ] && echo "$OUT" && exit 1
  sleep 2
done

# The terminal job looks like this:
# {"ok":true,"data":{"job_id":"job_...","status":"succeeded",
#   "output":{"output":"{\"lane\":\"validate\",\"verdict\":\"not_supported\", ...}"},
#   "charged_credits":734,"truncated":false}}

# The review is a JSON string inside the envelope, so unwrap it twice, then check
# the invariants before you believe a word of it.
printf '%s' "$OUT" | python3 -c '
import sys, json
job = json.load(sys.stdin)["data"]
rep = json.loads(job["output"]["output"])

assert rep["lane"] == "validate", "wrong lane: %s - did the body get wrapped?" % rep["lane"]
assert not job.get("truncated"), "truncated: this is a prefix, not a review"

sent = {"F1", "F2", "F3", "F4"}
back = [c["flag_uid"] for c in rep["reconciliation"]]
assert sorted(back) == sorted(sent), "reconciliation mismatch: %s" % back

worst = min((["blocking","high","medium","low","info"].index(f["severity"])
             for f in rep["findings"]), default=4)
expect = ["not_supported","revise","ready_with_notes","ready_with_notes","ready"][worst]
assert rep["verdict"] == expect, "verdict %s against worst finding" % rep["verdict"]

print(rep["lane"], rep["verdict"], "-", rep["headline"])
for f in rep["findings"]:
    print("  %-8s %-14s %s" % (f["severity"], f["area"], f["title"]))
print("charged", job.get("charged_credits"))
'

import hashlib, time

SEV = ["blocking", "high", "medium", "low", "info"]
VERDICT_FOR = ["not_supported", "revise", "ready_with_notes", "ready_with_notes", "ready"]

LANE_KEYS = {
    "cohort":   {"data_source_review", "index_definition", "outcome_definition",
                 "leakage_review", "sample_size", "must_fix"},
    "validate": {"design_review", "metric_review", "calibration", "discrimination",
                 "utility", "sample_size_for_validation", "must_fix"},
    "attrib":   {"method_review", "claim_review", "stability", "subgroup_attribution",
                 "safe_wording", "must_fix"},
    "report":   {"checklist", "abstract_draft", "limitations", "intended_use_statement",
                 "open_items", "must_fix"},
}


def run_and_wait(body, attempt=1, interval=2.0, timeout=420.0):
    """POST /run with an idempotency key, then poll jobs/{job_id} to a terminal state."""
    payload = json.dumps(body, sort_keys=True).encode()
    digest = hashlib.sha256(payload).hexdigest()[:16]
    # The lane is part of the body, so it belongs in the key.
    key = f"tripod-desk:{digest}:{body.get('task', 'validate')}:a{attempt}"

    # body, not {"input": body}.
    started = call("run", body, {"Idempotency-Key": key})
    job_id = started["job_id"]

    deadline = time.monotonic() + timeout
    while True:
        job = call(f"jobs/{job_id}")
        if job["status"] in ("succeeded", "failed"):
            return job
        if time.monotonic() > deadline:
            raise TimeoutError(f"job {job_id} still {job['status']}")
        time.sleep(interval)


def check(report, job, task, sent_uids):
    """The six assertions from the verification list, in order of what they catch."""
    if report["lane"] != task:
        raise ValueError(f"lane {report['lane']} != task {task}: was the body wrapped?")
    if job.get("truncated"):
        raise ValueError("truncated: retry with a retry_note, do not repair")

    back = [c["flag_uid"] for c in report["reconciliation"]]
    if sorted(back) != sorted(sent_uids):
        raise ValueError(f"reconciliation {back} != flags sent {sorted(sent_uids)}")
    if len(back) != len(set(back)):
        raise ValueError("a uid was reconciled twice")

    worst = min((SEV.index(f["severity"]) for f in report["findings"]), default=4)
    if report["verdict"] != VERDICT_FOR[worst]:
        raise ValueError(f"verdict {report['verdict']} contradicts worst finding {SEV[worst]}")

    extra = set(report["body"]) - LANE_KEYS[report["lane"]]
    if extra:
        raise ValueError(f"body carries keys from another lane: {sorted(extra)}")

    must_fix = report["body"].get("must_fix") or []
    if (report["verdict"] == "not_supported") != bool(must_fix):
        raise ValueError("must_fix and not_supported must agree")
    return report


job = run_and_wait(INPUT, attempt=1)
if job["status"] == "failed":
    raise RuntimeError(job.get("error"))

raw = job["output"]["output"]
report = json.loads(raw[raw.index("{"):raw.rindex("}") + 1])
check(report, job, INPUT["task"], [f["uid"] for f in PRESCAN["flags"]])

print(report["lane"], report["verdict"], "-", report["headline"])
for f in report["findings"]:
    print(f"  {f['severity']:8} {f['area']:14} {f['title']}")
for c in report["reconciliation"]:
    print(f"  {c['flag_uid']:4} {c['status']:15} {c['note'][:70]}")
print("charged", job.get("charged_credits"), "truncated", job.get("truncated"))

import { createHash } from "node:crypto";

const SEV = ["blocking", "high", "medium", "low", "info"];
const VERDICT_FOR = ["not_supported", "revise", "ready_with_notes", "ready_with_notes", "ready"];
const LANE_KEYS = {
  cohort: ["data_source_review", "index_definition", "outcome_definition",
           "leakage_review", "sample_size", "must_fix"],
  validate: ["design_review", "metric_review", "calibration", "discrimination",
             "utility", "sample_size_for_validation", "must_fix"],
  attrib: ["method_review", "claim_review", "stability", "subgroup_attribution",
           "safe_wording", "must_fix"],
  report: ["checklist", "abstract_draft", "limitations", "intended_use_statement",
           "open_items", "must_fix"],
};

async function runAndWait(body, attempt = 1, intervalMs = 2000) {
  const digest = createHash("sha256").update(JSON.stringify(body)).digest("hex").slice(0, 16);
  // The lane is part of the body, so it belongs in the key.
  const key = `tripod-desk:${digest}:${body.task ?? "validate"}:a${attempt}`;

  // body, not { input: body }.
  const started = await call("run", body, { "Idempotency-Key": key });

  let job = started;
  while (job.status !== "succeeded" && job.status !== "failed") {
    await new Promise((r) => setTimeout(r, intervalMs));
    job = await call(`jobs/${started.job_id}`);
  }
  return job;
}

function check(report, job, task, sentUids) {
  if (report.lane !== task)
    throw new Error(`lane ${report.lane} != task ${task}: was the body wrapped?`);
  if (job.truncated) throw new Error("truncated: retry with a retry_note, do not repair");

  const back = report.reconciliation.map((c) => c.flag_uid).sort();
  const sent = [...sentUids].sort();
  if (back.join() !== sent.join())
    throw new Error(`reconciliation ${back} != flags sent ${sent}`);

  const worst = report.findings.length
    ? Math.min(...report.findings.map((f) => SEV.indexOf(f.severity)))
    : 4;
  if (report.verdict !== VERDICT_FOR[worst])
    throw new Error(`verdict ${report.verdict} contradicts worst finding ${SEV[worst]}`);

  const allowed = LANE_KEYS[report.lane];
  const extra = Object.keys(report.body).filter((k) => !allowed.includes(k));
  if (extra.length) throw new Error(`body carries other lanes' keys: ${extra}`);

  const mustFix = report.body.must_fix ?? [];
  if ((report.verdict === "not_supported") !== mustFix.length > 0)
    throw new Error("must_fix and not_supported must agree");
  return report;
}

const job = await runAndWait(INPUT, 1);
if (job.status === "failed") throw new Error(JSON.stringify(job.error));

const raw = job.output.output;
const report = JSON.parse(raw.slice(raw.indexOf("{"), raw.lastIndexOf("}") + 1));
check(report, job, INPUT.task, PRESCAN.flags.map((f) => f.uid));

console.log(report.lane, report.verdict, "-", report.headline);
for (const f of report.findings) console.log(" ", f.severity, f.area, f.title);
console.log("charged", job.charged_credits, "truncated", job.truncated);

// Always send an Idempotency-Key derived from the input, with the lane in it.
body, _ := json.Marshal(input)
sum := sha256.Sum256(body)
key := fmt.Sprintf("tripod-desk:%x:%s:a1", sum[:8], input["task"])

// call() adds the two standard headers; the extra map adds the third.
raw, err := call("run", input, map[string]string{"Idempotency-Key": key})
if err != nil {
	panic(err)
}
var started struct {
	JobID string `json:"job_id"`
}
_ = json.Unmarshal(raw, &started)

type jobState struct {
	Status string `json:"status"`
	Output struct {
		Output string `json:"output"`
	} `json:"output"`
	ChargedCredits int  `json:"charged_credits"`
	Truncated      bool `json:"truncated"`
}

var job jobState
for {
	raw, err := call("jobs/"+started.JobID, nil, nil)
	if err != nil {
		panic(err)
	}
	_ = json.Unmarshal(raw, &job)
	if job.Status == "succeeded" || job.Status == "failed" {
		break
	}
	time.Sleep(2 * time.Second)
}
if job.Status == "failed" {
	panic("run failed")
}
if job.Truncated {
	panic("truncated: this is a prefix, not a review")
}

// Take everything from the first { to the last }, then parse.
text := job.Output.Output
text = text[strings.Index(text, "{") : strings.LastIndex(text, "}")+1]

var report struct {
	Lane     string `json:"lane"`
	Verdict  string `json:"verdict"`
	Headline string `json:"headline"`
	Findings []struct {
		Severity string `json:"severity"`
		Area     string `json:"area"`
		Title    string `json:"title"`
	} `json:"findings"`
	Reconciliation []struct {
		FlagUID string `json:"flag_uid"`
		Status  string `json:"status"`
	} `json:"reconciliation"`
}
if err := json.Unmarshal([]byte(text), &report); err != nil {
	panic(err)
}
// The assertion that catches a wrapped body: the lane you asked for came back.
if report.Lane != input["task"] {
	panic("lane " + report.Lane + " is not the task that was sent")
}
if len(report.Reconciliation) != 2 { // one entry per uid sent, exactly
	panic(fmt.Sprintf("reconciliation has %d entries for 2 flags", len(report.Reconciliation)))
}
fmt.Println(report.Verdict, "-", report.Headline, "charged", job.ChargedCredits)

// The key: a content hash, the lane, and an attempt counter. Same key on a retry
// returns the same job; a changed body needs a bumped attempt.
var sha = MessageDigest.getInstance("SHA-256").digest(input.getBytes("UTF-8"));
var hex = new StringBuilder();
for (int i = 0; i < 8; i++) hex.append(String.format("%02x", sha[i]));
String key = "tripod-desk:" + hex + ":validate:a1";

// input is the flat object from step 3 - no wrapper key.
String startedJson = TripodDesk.call("run", input, Map.of("Idempotency-Key", key));
String jobId = startedJson.split("\"job_id\":\"")[1].split("\"")[0];

String jobJson;
while (true) {
    jobJson = TripodDesk.call("jobs/" + jobId, null, Map.of());
    if (jobJson.contains("\"status\":\"succeeded\"")
        || jobJson.contains("\"status\":\"failed\"")) break;
    Thread.sleep(2000);
}
if (jobJson.contains("\"status\":\"failed\"")) throw new IllegalStateException(jobJson);
if (jobJson.contains("\"truncated\":true"))
    throw new IllegalStateException("truncated: a prefix, not a review");

// data.output.output is a JSON *string*, so it arrives escaped inside the
// envelope. With a real JSON library: env.get("data").get("output").get("output")
// then parse that text. The invariants worth asserting on the parsed object:
//
//   report.lane      equals the task you sent   (a mismatch means a wrapped body)
//   reconciliation   one entry per uid you sent, exactly once each
//   verdict          not_supported iff a blocking finding exists
//   body's keys      all belong to report.lane
//
System.out.println(jobJson.contains("\"verdict\":\"not_supported\"")
    ? "not supported - see body.must_fix"
    : "check the verdict against the findings");

require "digest"

digest = Digest::SHA256.hexdigest(JSON.generate(INPUT))[0, 16]
key = "tripod-desk:#{digest}:#{INPUT['task']}:a1"

# INPUT itself is the body. Not {"input" => INPUT}.
started = call("run", INPUT, { "Idempotency-Key" => key })

job = nil
loop do
  job = call("jobs/#{started['job_id']}")
  break if %w[succeeded failed].include?(job["status"])
  sleep 2
end
abort "run failed: #{job['error']}" if job["status"] == "failed"
abort "truncated: a prefix, not a review" if job["truncated"]

raw = job["output"]["output"]
report = JSON.parse(raw[raw.index("{")..raw.rindex("}")])

# The four assertions worth having in every client.
abort "lane #{report['lane']} != #{INPUT['task']}" unless report["lane"] == INPUT["task"]
sent = INPUT["prescan_facts"]["flags"].map { |f| f["uid"] }.sort
back = report["reconciliation"].map { |c| c["flag_uid"] }.sort
abort "reconciliation #{back} != #{sent}" unless back == sent

sev = %w[blocking high medium low info]
worst = report["findings"].map { |f| sev.index(f["severity"]) }.min || 4
expect = %w[not_supported revise ready_with_notes ready_with_notes ready][worst]
abort "verdict #{report['verdict']} contradicts #{sev[worst]}" unless report["verdict"] == expect

puts "#{report['verdict']} - #{report['headline']}"
report["findings"].each { |f| puts "  #{f['severity']}\t#{f['area']}\t#{f['title']}" }
puts "charged #{job['charged_credits']}"

<?php
$digest = substr(hash("sha256", json_encode($INPUT)), 0, 16);
$key = "tripod-desk:$digest:{$INPUT['task']}:a1";

// $INPUT is the body. There is no "input" wrapper.
$started = call("run", $INPUT, ["Idempotency-Key" => $key]);

do {
    sleep(2);
    $job = call("jobs/" . $started["job_id"]);
} while (!in_array($job["status"], ["succeeded", "failed"], true));

if ($job["status"] === "failed") throw new RuntimeException(json_encode($job));
if (!empty($job["truncated"])) throw new RuntimeException("truncated: a prefix, not a review");

$raw = $job["output"]["output"];
$report = json_decode(substr($raw, strpos($raw, "{"),
                             strrpos($raw, "}") - strpos($raw, "{") + 1), true);

// Lane first: a mismatch is the only symptom a wrapped body has.
if ($report["lane"] !== $INPUT["task"]) {
    throw new RuntimeException("lane {$report['lane']} != {$INPUT['task']}");
}
$sent = array_map(fn($f) => $f["uid"], $INPUT["prescan_facts"]["flags"]);
$back = array_map(fn($c) => $c["flag_uid"], $report["reconciliation"]);
sort($sent); sort($back);
if ($sent !== $back) throw new RuntimeException("reconciliation mismatch");

$sev = ["blocking", "high", "medium", "low", "info"];
$worst = 4;
foreach ($report["findings"] as $f) $worst = min($worst, array_search($f["severity"], $sev, true));
$expect = ["not_supported", "revise", "ready_with_notes", "ready_with_notes", "ready"][$worst];
if ($report["verdict"] !== $expect) throw new RuntimeException("verdict contradicts findings");

echo $report["verdict"], " - ", $report["headline"], PHP_EOL;
echo "charged ", $job["charged_credits"], PHP_EOL;

var payload = JsonSerializer.Serialize(input);
var digest = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(payload)))
                    .ToLowerInvariant()[..16];
var key = $"tripod-desk:{digest}:validate:a1";

// input itself is the body - no wrapper key.
var started = await TripodDesk.Call("run", input,
    new Dictionary<string, string> { ["Idempotency-Key"] = key });
var jobId = started.GetProperty("job_id").GetString();

JsonElement job;
while (true)
{
    job = await TripodDesk.Call($"jobs/{jobId}");
    var status = job.GetProperty("status").GetString();
    if (status is "succeeded" or "failed") break;
    await Task.Delay(2000);
}
if (job.GetProperty("status").GetString() == "failed") throw new Exception(job.ToString());
if (job.TryGetProperty("truncated", out var tr) && tr.GetBoolean())
    throw new Exception("truncated: a prefix, not a review");

var raw = job.GetProperty("output").GetProperty("output").GetString()!;
raw = raw[raw.IndexOf('{')..(raw.LastIndexOf('}') + 1)];
var report = JsonDocument.Parse(raw).RootElement;

// Lane first: it is the only symptom a wrapped body has.
var lane = report.GetProperty("lane").GetString();
if (lane != "validate") throw new Exception($"lane {lane} is not the task that was sent");

var back = report.GetProperty("reconciliation").EnumerateArray()
                 .Select(c => c.GetProperty("flag_uid").GetString()).OrderBy(s => s).ToList();
var sent = new[] { "F1", "F2" }.OrderBy(s => s).ToList();   // the uids actually sent
if (!back.SequenceEqual(sent)) throw new Exception("reconciliation mismatch");

var sev = new[] { "blocking", "high", "medium", "low", "info" };
var worst = report.GetProperty("findings").EnumerateArray()
                  .Select(f => Array.IndexOf(sev, f.GetProperty("severity").GetString()))
                  .DefaultIfEmpty(4).Min();
var expect = new[] { "not_supported", "revise", "ready_with_notes", "ready_with_notes", "ready" }[worst];
if (report.GetProperty("verdict").GetString() != expect)
    throw new Exception("verdict contradicts its own findings");

Console.WriteLine($"{report.GetProperty("verdict").GetString()} - " +
                  $"{report.GetProperty("headline").GetString()}");

# Server-sent events. Each `delta` carries a chunk of the review JSON; the final
# `done` event carries the status, charged_credits and the truncated flag.
curl -N -X POST "$BASE/run-stream" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $KEY" \
  -H "Accept: text/event-stream" \
  -d "$INPUT"

# event: job    {"job_id":"job_..."}
# event: delta  {"text":"{\"lane\":\"validate\",\"title\":\"ICU-DETERIORATE v2"}
# event: delta  {"text":"\",\"verdict\":\"not_supported\","}
# event: done   {"status":"succeeded","charged_credits":734,"truncated":false}
#
# An idempotent replay answers with plain JSON instead of a stream, so a robust
# client checks the content type first.

# Server-sent events: the review arrives in chunks, so a UI can show progress.
req = urllib.request.Request(
    f"{BASE}/run-stream", data=json.dumps(INPUT).encode(), method="POST")
req.add_header("Authorization", f"Bearer {TOKEN}")
req.add_header("Content-Type", "application/json")
req.add_header("Idempotency-Key", key)
req.add_header("Accept", "text/event-stream")

raw = ""
done = {}
event = None
stage = "reading the report"
with urllib.request.urlopen(req) as stream:
    if "text/event-stream" not in stream.headers.get("Content-Type", ""):
        # An idempotent replay answers with plain JSON, not a stream.
        done = json.load(stream)["data"]
        raw = done.get("output", {}).get("output", "")
    else:
        for line in stream:
            line = line.decode().rstrip("\n")
            if line.startswith("event: "):
                event = line[7:]
            elif line.startswith("data: ") and event == "delta":
                raw += json.loads(line[6:]).get("text", "")
                # The arrival of a key name is the progress signal the web app uses.
                if '"summary"' in raw:
                    stage = "writing the summary"
                elif '"body"' in raw:
                    stage = "building the lane document"
                elif '"reconciliation"' in raw:
                    stage = "reconciling the prescan flags"
                elif '"findings"' in raw:
                    stage = "naming the findings"
            elif line.startswith("data: ") and event == "done":
                done = json.loads(line[6:])
            elif line.startswith("data: ") and event == "error":
                raise RuntimeError(line[6:])

report = json.loads(raw[raw.index("{"):raw.rindex("}") + 1])
print(stage, report["verdict"], len(report["findings"]), "findings",
      done.get("charged_credits"), "truncated", done.get("truncated"))

// Server-sent events: the review arrives in chunks, so a UI can show progress.
const res = await fetch(`${BASE}/run-stream`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${TOKEN}`,
    "Content-Type": "application/json",
    "Idempotency-Key": key,
    Accept: "text/event-stream",
  },
  body: JSON.stringify(INPUT),
});

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

const reader = res.body.getReader();
const decoder = new TextDecoder();
let buffer = "";
let raw = "";
let done = {};
let stage = "reading the report";

while (true) {
  const chunk = await reader.read();
  if (chunk.done) break;
  buffer += decoder.decode(chunk.value, { stream: true });
  // Events are separated by a blank line, not by a single newline.
  let idx;
  while ((idx = buffer.indexOf("\n\n")) >= 0) {
    const frame = buffer.slice(0, idx);
    buffer = buffer.slice(idx + 2);

    const event = (frame.match(/^event: (.*)$/m) || [])[1];
    const dataLine = (frame.match(/^data: (.*)$/m) || [])[1];
    if (!event || !dataLine) continue;

    if (event === "delta") {
      raw += (JSON.parse(dataLine).text ?? "");
      if (raw.includes('"summary"')) stage = "writing the summary";
      else if (raw.includes('"body"')) stage = "building the lane document";
      else if (raw.includes('"reconciliation"')) stage = "reconciling the prescan flags";
      else if (raw.includes('"findings"')) stage = "naming the findings";
    } else if (event === "done") {
      done = JSON.parse(dataLine);
    } else if (event === "error") {
      throw new Error(dataLine);
    }
  }
}

const report = JSON.parse(raw.slice(raw.indexOf("{"), raw.lastIndexOf("}") + 1));
console.log(stage, report.verdict, report.findings.length, "findings",
            done.charged_credits, "truncated", done.truncated);

// Server-sent events over the same body and the same Idempotency-Key.
raw, _ := json.Marshal(input)
req, _ := http.NewRequest(http.MethodPost, base+"/run-stream", bytes.NewReader(raw))
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Idempotency-Key", key)
req.Header.Set("Accept", "text/event-stream")

res, err := http.DefaultClient.Do(req)
if err != nil {
	panic(err)
}
defer res.Body.Close()

// An idempotent replay answers with plain JSON, not a stream.
if !strings.Contains(res.Header.Get("Content-Type"), "text/event-stream") {
	body, _ := io.ReadAll(res.Body)
	fmt.Println("replay:", string(body))
	return
}

var text strings.Builder
var event string
stage := "reading the report"
buf := make([]byte, 4096)
var pending strings.Builder
for {
	n, err := res.Body.Read(buf)
	if n > 0 {
		pending.WriteString(string(buf[:n]))
		lines := strings.Split(pending.String(), "\n")
		pending.Reset()
		pending.WriteString(lines[len(lines)-1]) // keep the partial line
		for _, line := range lines[:len(lines)-1] {
			switch {
			case strings.HasPrefix(line, "event: "):
				event = strings.TrimPrefix(line, "event: ")
			case strings.HasPrefix(line, "data: ") && event == "delta":
				var d struct{ Text string `json:"text"` }
				_ = json.Unmarshal([]byte(strings.TrimPrefix(line, "data: ")), &d)
				text.WriteString(d.Text)
				if strings.Contains(text.String(), `"summary"`) {
					stage = "writing the summary"
				} else if strings.Contains(text.String(), `"body"`) {
					stage = "building the lane document"
				}
			case strings.HasPrefix(line, "data: ") && event == "done":
				fmt.Println(stage, strings.TrimPrefix(line, "data: "))
			case strings.HasPrefix(line, "data: ") && event == "error":
				panic(strings.TrimPrefix(line, "data: "))
			}
		}
	}
	if err != nil {
		break
	}
}
out := text.String()
fmt.Println(out[strings.Index(out, "{") : strings.LastIndex(out, "}")+1])

// Streaming with java.net.http: read the body as a line stream.
var streamReq = HttpRequest.newBuilder(URI.create(TripodDesk.BASE + "/run-stream"))
    .header("Authorization", "Bearer " + TripodDesk.token)
    .header("Content-Type", "application/json")
    .header("Idempotency-Key", key)
    .header("Accept", "text/event-stream")
    .POST(HttpRequest.BodyPublishers.ofString(input))
    .build();

var stream = TripodDesk.HTTP.send(streamReq, HttpResponse.BodyHandlers.ofLines());

// An idempotent replay answers with plain JSON instead of a stream.
boolean isStream = stream.headers().firstValue("content-type")
    .orElse("").contains("text/event-stream");

var text = new StringBuilder();
var event = new String[] { "" };
var stage = new String[] { "reading the report" };
stream.body().forEach(line -> {
    if (line.startsWith("event: ")) {
        event[0] = line.substring(7);
    } else if (line.startsWith("data: ")) {
        String data = line.substring(6);
        switch (event[0]) {
            case "delta" -> {
                // data is {"text":"..."} - parse with a real JSON library.
                text.append(data);
                if (text.indexOf("\"summary\"") >= 0) stage[0] = "writing the summary";
                else if (text.indexOf("\"body\"") >= 0) stage[0] = "building the lane document";
            }
            case "done" -> System.out.println(stage[0] + " " + data);
            case "error" -> throw new IllegalStateException(data);
            default -> { }
        }
    }
});
System.out.println(isStream ? "streamed" : "replayed as plain JSON");

require "net/http"

uri = URI("#{BASE}/run-stream")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{TOKEN}"
req["Content-Type"] = "application/json"
req["Idempotency-Key"] = key
req["Accept"] = "text/event-stream"
req.body = JSON.generate(INPUT)

text = +""
event = nil
stage = "reading the report"

Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(req) do |res|
    # An idempotent replay answers with plain JSON, not a stream.
    unless res["content-type"].to_s.include?("text/event-stream")
      puts "replay: #{res.body}"
      next
    end
    buffer = +""
    res.read_body do |chunk|
      buffer << chunk
      while (i = buffer.index("\n"))
        line = buffer.slice!(0..i).chomp
        if line.start_with?("event: ")
          event = line[7..]
        elsif line.start_with?("data: ")
          data = line[6..]
          case event
          when "delta"
            text << (JSON.parse(data)["text"] || "")
            stage = "writing the summary" if text.include?('"summary"')
          when "done"  then puts "#{stage} #{data}"
          when "error" then raise data
          end
        end
      end
    end
  end
end

report = JSON.parse(text[text.index("{")..text.rindex("}")])
puts "#{report['verdict']} - #{report['headline']}"

<?php
// Streaming with curl's write callback. Events are separated by a blank line.
$text = "";
$event = "";
$stage = "reading the report";
$buffer = "";

$ch = curl_init(BASE . "/run-stream");
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($INPUT));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . TOKEN,
    "Content-Type: application/json",
    "Idempotency-Key: $key",
    "Accept: text/event-stream",
]);
curl_setopt($ch, CURLOPT_WRITEFUNCTION,
    function ($ch, $chunk) use (&$text, &$event, &$stage, &$buffer) {
        $buffer .= $chunk;
        while (($i = strpos($buffer, "\n")) !== false) {
            $line = rtrim(substr($buffer, 0, $i));
            $buffer = substr($buffer, $i + 1);
            if (str_starts_with($line, "event: ")) {
                $event = substr($line, 7);
            } elseif (str_starts_with($line, "data: ")) {
                $data = substr($line, 6);
                if ($event === "delta") {
                    $text .= json_decode($data, true)["text"] ?? "";
                    if (str_contains($text, '"summary"')) $stage = "writing the summary";
                } elseif ($event === "done") {
                    echo $stage, " ", $data, PHP_EOL;
                } elseif ($event === "error") {
                    throw new RuntimeException($data);
                }
            }
        }
        return strlen($chunk);
    });
curl_exec($ch);
curl_close($ch);

$report = json_decode(substr($text, strpos($text, "{"),
                             strrpos($text, "}") - strpos($text, "{") + 1), true);
echo $report["verdict"], " - ", $report["headline"], PHP_EOL;

var streamReq = new HttpRequestMessage(HttpMethod.Post,
    "https://api.skillsafe.ai/v1/app-api/run-stream")
{
    Content = new StringContent(JsonSerializer.Serialize(input),
        Encoding.UTF8, "application/json"),
};
streamReq.Headers.Add("Authorization", $"Bearer {TripodDesk.Token}");
streamReq.Headers.Add("Idempotency-Key", key);
streamReq.Headers.Add("Accept", "text/event-stream");

using var http2 = new HttpClient();
var res2 = await http2.SendAsync(streamReq, HttpCompletionOption.ResponseHeadersRead);

// An idempotent replay answers with plain JSON instead of a stream.
var isStream = res2.Content.Headers.ContentType?.MediaType == "text/event-stream";

using var reader = new StreamReader(await res2.Content.ReadAsStreamAsync());
var text = new StringBuilder();
var evt = "";
var stage = "reading the report";

while (!reader.EndOfStream)
{
    var line = await reader.ReadLineAsync();
    if (line is null) break;
    if (line.StartsWith("event: ")) { evt = line[7..]; continue; }
    if (!line.StartsWith("data: ")) continue;

    var data = line[6..];
    if (evt == "delta")
    {
        text.Append(JsonDocument.Parse(data).RootElement
                                .GetProperty("text").GetString());
        if (text.ToString().Contains("\"summary\"")) stage = "writing the summary";
    }
    else if (evt == "done") Console.WriteLine($"{stage} {data}");
    else if (evt == "error") throw new Exception(data);
}

var all = text.ToString();
var report2 = JsonDocument.Parse(all[all.IndexOf('{')..(all.LastIndexOf('}') + 1)]).RootElement;
Console.WriteLine($"{(isStream ? "streamed" : "replayed")} " +
                  $"{report2.GetProperty("verdict").GetString()}");

# One report, four lanes, in pipeline order. $REPORT and $METRICS are from step 3.
for LANE in cohort validate attrib report; do
  BODY=$(LANE="$LANE" REPORT="$REPORT" METRICS="$METRICS" python3 -c '
import json, os
print(json.dumps({
    "task": os.environ["LANE"],
    "report": os.environ["REPORT"],
    "metrics": os.environ["METRICS"],
    "stage": "internal",
    "audience": "journal",
    "context": "Reviewer 2 asked only for a calibration plot.",
}))')

  # A separate key per lane: the lane is part of the body.
  K="tripod-desk:$(printf '%s' "$BODY" | shasum -a 256 | cut -c1-16):$LANE:a1"
  JOB=$(curl -sS -X POST "$BASE/run" \
    -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
    -H "Idempotency-Key: $K" -d "$BODY" \
    | python3 -c 'import sys,json;print(json.load(sys.stdin)["data"]["job_id"])')

  while :; do
    OUT=$(call "jobs/$JOB")
    S=$(printf '%s' "$OUT" | python3 -c 'import sys,json;print(json.load(sys.stdin)["data"]["status"])')
    case "$S" in succeeded|failed) break;; esac
    sleep 2
  done

  printf '%s' "$OUT" | python3 -c '
import sys, json
job = json.load(sys.stdin)["data"]
rep = json.loads(job["output"]["output"])
print("%-9s %-16s %s" % (rep["lane"], rep["verdict"], rep["headline"][:70]))
'
done

# One report, four lanes, in pipeline order: each one can invalidate the next, so
# stop at the first blocking verdict rather than paying for all four.
LANES = ["cohort", "validate", "attrib", "report"]
BASE_INPUT = {k: v for k, v in INPUT.items() if k != "task"}

reviews = {}
for lane in LANES:
    body = dict(BASE_INPUT, task=lane)

    est = call("estimate", body)                 # free; price each lane separately
    print(f"{lane:9} hold {est['hold_credits']:6} min {est['min_credits']}")

    job = run_and_wait(body, attempt=1)          # its own key, because task differs
    raw = job["output"]["output"]
    rep = json.loads(raw[raw.index("{"):raw.rindex("}") + 1])
    check(rep, job, lane, [f["uid"] for f in PRESCAN["flags"]])
    reviews[lane] = rep

    print(f"{rep['lane']:9} {rep['verdict']:16} {rep['headline'][:70]}")
    if rep["verdict"] == "not_supported" and lane == "cohort":
        # A cohort that is not well posed makes every later number unreadable.
        print("stopping: fix the cohort before paying for the other three lanes")
        break

# The same fact must arrive at the same severity in every lane it appears in.
for lane, rep in reviews.items():
    worst = min((f["severity"] for f in rep["findings"]),
                key=lambda s: SEV.index(s), default="info")
    print(lane, "worst severity", worst, "must_fix", len(rep["body"].get("must_fix", [])))

// One report, four lanes, in pipeline order. Each lane is its own metered run.
const LANES = ["cohort", "validate", "attrib", "report"];
const { task: _drop, ...BASE_INPUT } = INPUT;

const reviews = {};
for (const lane of LANES) {
  const body = { ...BASE_INPUT, task: lane };

  const est = await call("estimate", body); // free; price each lane separately
  console.log(lane, "hold", est.hold_credits, "min", est.min_credits);

  const job = await runAndWait(body, 1); // its own key, because task differs
  const raw = job.output.output;
  const rep = JSON.parse(raw.slice(raw.indexOf("{"), raw.lastIndexOf("}") + 1));
  check(rep, job, lane, PRESCAN.flags.map((f) => f.uid));
  reviews[lane] = rep;

  console.log(rep.lane, rep.verdict, "-", rep.headline);
  if (lane === "cohort" && rep.verdict === "not_supported") {
    console.log("stopping: fix the cohort before paying for the other three lanes");
    break;
  }
}

// body keys differ per lane; everything outside body has the same shape.
for (const [lane, rep] of Object.entries(reviews)) {
  console.log(lane, Object.keys(rep.body).join(", "));
}

// One report, four lanes, in pipeline order. Only "task" changes.
for _, lane := range []string{"cohort", "validate", "attrib", "report"} {
	body := make(map[string]any, len(input))
	for k, v := range input {
		body[k] = v
	}
	body["task"] = lane

	// Price it first - free, and the four lanes are not priced alike.
	if raw, err := call("estimate", body, nil); err == nil {
		var est struct {
			HoldCredits int `json:"hold_credits"`
			MinCredits  int `json:"min_credits"`
		}
		_ = json.Unmarshal(raw, &est)
		fmt.Printf("%-9s hold %d min %d\n", lane, est.HoldCredits, est.MinCredits)
	}

	// A separate key per lane: the lane is part of the body.
	payload, _ := json.Marshal(body)
	sum := sha256.Sum256(payload)
	laneKey := fmt.Sprintf("tripod-desk:%x:%s:a1", sum[:8], lane)

	raw, err := call("run", body, map[string]string{"Idempotency-Key": laneKey})
	if err != nil {
		panic(err)
	}
	var started struct {
		JobID string `json:"job_id"`
	}
	_ = json.Unmarshal(raw, &started)
	fmt.Println(lane, "started as", started.JobID)
	// ...then poll jobs/{id} exactly as in step 4, and assert report.lane == lane.
}

// One report, four lanes, in pipeline order. Only the task value changes, so the
// body is one template with one substitution.
String template = input.replace("\"task\":\"validate\"", "\"task\":\"%s\"");

for (String lane : new String[] { "cohort", "validate", "attrib", "report" }) {
    String body = template.formatted(lane);

    // Free, and worth doing per lane: "report" is much wordier than "cohort".
    String est = TripodDesk.call("estimate", body, Map.of());
    System.out.println(lane + " " + est);

    // A separate key per lane - the lane is part of the body.
    var sha2 = MessageDigest.getInstance("SHA-256").digest(body.getBytes("UTF-8"));
    var hex2 = new StringBuilder();
    for (int i = 0; i < 8; i++) hex2.append(String.format("%02x", sha2[i]));
    String laneKey = "tripod-desk:" + hex2 + ":" + lane + ":a1";

    String started = TripodDesk.call("run", body, Map.of("Idempotency-Key", laneKey));
    System.out.println(lane + " started: " + started);
    // ...then poll jobs/{job_id} as in step 4, and assert that the parsed
    // report's "lane" equals this lane before reading its "body".
}

# One report, four lanes, in pipeline order. Only "task" changes.
%w[cohort validate attrib report].each do |lane|
  body = INPUT.merge("task" => lane)

  est = call("estimate", body)   # free, and the lanes are not priced alike
  puts format("%-9s hold %s min %s", lane, est["hold_credits"], est["min_credits"])

  # A separate key per lane: the lane is part of the body.
  d = Digest::SHA256.hexdigest(JSON.generate(body))[0, 16]
  started = call("run", body, { "Idempotency-Key" => "tripod-desk:#{d}:#{lane}:a1" })

  job = nil
  loop do
    job = call("jobs/#{started['job_id']}")
    break if %w[succeeded failed].include?(job["status"])
    sleep 2
  end
  next warn("#{lane} failed") if job["status"] == "failed"

  raw = job["output"]["output"]
  rep = JSON.parse(raw[raw.index("{")..raw.rindex("}")])
  raise "lane #{rep['lane']} != #{lane}" unless rep["lane"] == lane
  puts format("%-9s %-16s %s", rep["lane"], rep["verdict"], rep["headline"][0, 70])

  break if lane == "cohort" && rep["verdict"] == "not_supported"
end

<?php
// One report, four lanes, in pipeline order. Only "task" changes.
foreach (["cohort", "validate", "attrib", "report"] as $lane) {
    $body = array_merge($INPUT, ["task" => $lane]);

    $est = call("estimate", $body);   // free, and priced per lane
    printf("%-9s hold %d min %d\n", $lane, $est["hold_credits"], $est["min_credits"]);

    // A separate key per lane: the lane is part of the body.
    $d = substr(hash("sha256", json_encode($body)), 0, 16);
    $started = call("run", $body, ["Idempotency-Key" => "tripod-desk:$d:$lane:a1"]);

    do {
        sleep(2);
        $job = call("jobs/" . $started["job_id"]);
    } while (!in_array($job["status"], ["succeeded", "failed"], true));
    if ($job["status"] === "failed") { fwrite(STDERR, "$lane failed\n"); continue; }

    $raw = $job["output"]["output"];
    $rep = json_decode(substr($raw, strpos($raw, "{"),
                              strrpos($raw, "}") - strpos($raw, "{") + 1), true);
    if ($rep["lane"] !== $lane) throw new RuntimeException("lane mismatch");
    printf("%-9s %-16s %s\n", $rep["lane"], $rep["verdict"],
           substr($rep["headline"], 0, 70));

    if ($lane === "cohort" && $rep["verdict"] === "not_supported") break;
}

// One report, four lanes, in pipeline order. Only the task value changes.
foreach (var lane in new[] { "cohort", "validate", "attrib", "report" })
{
    var body = new
    {
        task = lane,
        report,
        metrics,
        stage = "internal",
        audience = "journal",
        context = "Reviewer 2 asked only for a calibration plot.",
    };

    var e = await TripodDesk.Call("estimate", body);   // free, priced per lane
    Console.WriteLine($"{lane,-9} hold {e.GetProperty("hold_credits").GetInt32()}");

    // A separate key per lane: the lane is part of the body.
    var d = Convert.ToHexString(SHA256.HashData(
        Encoding.UTF8.GetBytes(JsonSerializer.Serialize(body)))).ToLowerInvariant()[..16];
    var started2 = await TripodDesk.Call("run", body,
        new Dictionary<string, string> { ["Idempotency-Key"] = $"tripod-desk:{d}:{lane}:a1" });

    Console.WriteLine($"{lane} started as {started2.GetProperty("job_id").GetString()}");
    // ...then poll jobs/{id} as in step 4, and assert report.lane == lane before
    // reading report.body, whose keys differ per lane.
}