Raffle Desk API

BASE=https://api.skillsafe.ai/v1/app-api

# A guest token (no Authorization header):
curl -s -X POST "$BASE/guest" \
  -H "Content-Type: application/json" \
  -d '{"slug":"raffle-desk"}'
# {"ok":true,"data":{"token":"...","guest_id":"..."}}

# screen and announce are metered: use a personal token from /tokens.html
export SKILLSAFE_TOKEN="YOUR_TOKEN"

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

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

def api(method, path, body=None, headers=None):
    """body is a JSON string or None; returns the envelope's data."""
    h = {"Content-Type": "application/json", **(headers or {})}
    if TOKEN:
        h["Authorization"] = "Bearer " + TOKEN
    data = body.encode("utf-8") if body is not None else None
    req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
    try:
        with urllib.request.urlopen(req) as res:
            return json.load(res)["data"]
    except urllib.error.HTTPError as e:
        try:
            err = json.loads(e.read() or b"{}").get("error") or {}
        except ValueError:
            err = {}
        raise RuntimeError(f"{e.code} {err.get('code')}: {err.get('message')}") from None

if not TOKEN:  # no personal token yet: mint a guest one
    TOKEN = api("POST", "/guest", json.dumps({"slug": "raffle-desk"}))["token"]

// Node 18+. Save as raffle.mjs (top-level await).
import { readFileSync } from "node:fs";

const BASE = "https://api.skillsafe.ai/v1/app-api";
let TOKEN = ""; // paste YOUR_TOKEN from /tokens.html for metered runs

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

if (!TOKEN) {
  TOKEN = (await api("POST", "/guest", JSON.stringify({ slug: "raffle-desk" }))).token;
}

package main

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

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

var token = os.Getenv("SKILLSAFE_TOKEN")

type envelope struct {
	Data  json.RawMessage `json:"data"`
	Error *struct {
		Code    string `json:"code"`
		Message string `json:"message"`
	} `json:"error"`
}

// api sends body (a JSON string, "" for none) and returns the envelope's data.
func api(method, path, body string, hdr map[string]string) (json.RawMessage, error) {
	req, err := http.NewRequest(method, base+path, strings.NewReader(body))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")
	if token != "" {
		req.Header.Set("Authorization", "Bearer "+token)
	}
	for k, v := range hdr {
		req.Header.Set(k, v)
	}
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	raw, _ := io.ReadAll(res.Body)
	var env envelope
	json.Unmarshal(raw, &env)
	if res.StatusCode >= 300 {
		if env.Error != nil {
			return nil, fmt.Errorf("%d %s: %s", res.StatusCode, env.Error.Code, env.Error.Message)
		}
		return nil, fmt.Errorf("HTTP %d", res.StatusCode)
	}
	return env.Data, nil
}

func main() {
	if token == "" { // no personal token yet: mint a guest one
		d, err := api("POST", "/guest", `{"slug":"raffle-desk"}`, nil)
		if err != nil {
			panic(err)
		}
		var g struct {
			Token string `json:"token"`
		}
		json.Unmarshal(d, &g)
		token = g.Token
	}
	// the later steps go here
}

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.regex.Pattern;

public class Raffle {
  static final String BASE = "https://api.skillsafe.ai/v1/app-api";
  static final HttpClient HTTP = HttpClient.newHttpClient();
  static String token = System.getenv().getOrDefault("SKILLSAFE_TOKEN", "");

  // body is a JSON string or null; returns the whole envelope as text
  static String api(String method, String path, String body, String... hdr) throws Exception {
    var b = HttpRequest.newBuilder(URI.create(BASE + path))
        .header("Content-Type", "application/json")
        .method(method, body == null ? HttpRequest.BodyPublishers.noBody()
            : HttpRequest.BodyPublishers.ofString(body));
    if (!token.isEmpty()) b.header("Authorization", "Bearer " + token);
    for (int i = 0; i + 1 < hdr.length; i += 2) b.header(hdr[i], hdr[i + 1]);
    var res = HTTP.send(b.build(), HttpResponse.BodyHandlers.ofString());
    if (res.statusCode() >= 300)
      throw new RuntimeException(res.statusCode() + " " + str(res.body(), "code")
          + ": " + str(res.body(), "message"));
    return res.body();
  }

  // The JDK has no JSON parser. This reads the first "key":"string" value;
  // use Jackson or Gson in real code.
  static String str(String json, String key) {
    var m = Pattern.compile("\"" + key + "\"\\s*:\\s*\"").matcher(json);
    if (!m.find()) return null;
    var sb = new StringBuilder();
    for (int i = m.end(); i < json.length(); i++) {
      char c = json.charAt(i);
      if (c == '"') return sb.toString();
      if (c != '\\') { sb.append(c); continue; }
      char e = json.charAt(++i);
      switch (e) {
        case 'n': sb.append('\n'); break;
        case 't': sb.append('\t'); break;
        case 'r': sb.append('\r'); break;
        case 'b': sb.append('\b'); break;
        case 'f': sb.append('\f'); break;
        case 'u': sb.append((char) Integer.parseInt(json.substring(i + 1, i + 5), 16)); i += 4; break;
        default: sb.append(e);
      }
    }
    return null;
  }

  public static void main(String[] args) throws Exception {
    if (token.isEmpty()) token = str(api("POST", "/guest", "{\"slug\":\"raffle-desk\"}"), "token");
    // the later steps go here
  }
}

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

BASE = "https://api.skillsafe.ai/v1/app-api"
$token = ENV.fetch("SKILLSAFE_TOKEN", "")

# body is a JSON string or nil; returns the envelope's data
def api(method, path, body = nil, headers = {})
  uri = URI(BASE + path)
  hdr = { "Content-Type" => "application/json" }.merge(headers)
  hdr["Authorization"] = "Bearer #{$token}" unless $token.empty?
  res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
    http.send_request(method, uri.request_uri, body, hdr)
  end
  json = (JSON.parse(res.body) rescue {})
  unless res.is_a?(Net::HTTPSuccess)
    err = json["error"] || {}
    raise "#{res.code} #{err["code"]}: #{err["message"]}"
  end
  json["data"]
end

# no personal token yet: mint a guest one
$token = api("POST", "/guest", JSON.generate(slug: "raffle-desk"))["token"] if $token.empty?

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

// $body is a JSON string or null; returns the envelope's data
function api(string $method, string $path, ?string $body = null, array $headers = []): array
{
    global $token;
    $h = array_merge(["Content-Type: application/json"], $headers);
    if ($token !== "") $h[] = "Authorization: Bearer " . $token;
    $ch = curl_init(BASE . $path);
    curl_setopt_array($ch, [
        CURLOPT_CUSTOMREQUEST => $method,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => $h,
    ]);
    if ($body !== null) curl_setopt($ch, CURLOPT_POSTFIELDS, $body);
    $raw = curl_exec($ch);
    $status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
    curl_close($ch);
    $json = json_decode((string) $raw, true) ?: [];
    if ($raw === false || $status >= 300) {
        $e = $json["error"] ?? [];
        throw new RuntimeException("$status " . ($e["code"] ?? "") . ": " . ($e["message"] ?? ""));
    }
    return $json["data"];
}

// no personal token yet: mint a guest one
if ($token === "") $token = api("POST", "/guest", json_encode(["slug" => "raffle-desk"]))["token"];

// Program.cs (.NET 6+): top-level statements first, the helper class at the end.
using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

if (Api.Token == "") // no personal token yet: mint a guest one
{
    var guest = await Api.Call("POST", "/guest", "{\"slug\":\"raffle-desk\"}");
    Api.Token = guest.GetProperty("token").GetString();
}
// the later steps go here

static class Api
{
    public const string Base = "https://api.skillsafe.ai/v1/app-api";
    public static readonly HttpClient Http = new HttpClient();
    public static string Token = Environment.GetEnvironmentVariable("SKILLSAFE_TOKEN") ?? "";

    // body is a JSON string or null; returns the envelope's data
    public static async Task<JsonElement> Call(string method, string path, string body = null,
        params (string Name, string Value)[] headers)
    {
        var req = new HttpRequestMessage(new HttpMethod(method), Base + path);
        if (body != null) req.Content = new StringContent(body, Encoding.UTF8, "application/json");
        if (Token != "") req.Headers.Add("Authorization", "Bearer " + Token);
        foreach (var (name, value) in headers) req.Headers.Add(name, value);
        var res = await Http.SendAsync(req);
        var text = await res.Content.ReadAsStringAsync();
        JsonElement root = default;
        try { root = JsonDocument.Parse(text).RootElement.Clone(); } catch (JsonException) { }
        if (!res.IsSuccessStatusCode)
        {
            var err = root.ValueKind == JsonValueKind.Object && root.TryGetProperty("error", out var e)
                ? e.ToString() : text;
            throw new HttpRequestException($"{(int)res.StatusCode} {err}");
        }
        return root.GetProperty("data");
    }
}

curl -s "$BASE/me" -H "Authorization: Bearer $SKILLSAFE_TOKEN"

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

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

d, err := api("GET", "/me", "", nil)
if err != nil {
	panic(err)
}
var me struct {
	SubjectType string  `json:"subject_type"`
	Credits     float64 `json:"credits"`
}
json.Unmarshal(d, &me)
fmt.Println(me.SubjectType, me.Credits)

var me = api("GET", "/me", null);
System.out.println(str(me, "subject_type") + " " + me);

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

$me = api("GET", "/me");
echo $me["subject_type"], " ", $me["credits"] ?? "", "\n";

var me = await Api.Call("GET", "/me");
Console.WriteLine($"{me.GetProperty("subject_type")} {me.GetProperty("credits")}");

curl -s -X POST "$BASE/estimate" \
  -H "Authorization: Bearer $SKILLSAFE_TOKEN" \
  -H "Content-Type: application/json" \
  --data-binary @body.json

body = open("body.json", encoding="utf-8").read()
print(json.dumps(api("POST", "/estimate", body), indent=2))

const body = readFileSync("body.json", "utf8");
console.log(await api("POST", "/estimate", body));

body, _ := os.ReadFile("body.json")
est, err := api("POST", "/estimate", string(body), nil)
if err != nil {
	panic(err)
}
fmt.Println(string(est))

var body = Files.readString(Path.of("body.json"));
System.out.println(api("POST", "/estimate", body));

body = File.read("body.json")
puts JSON.pretty_generate(api("POST", "/estimate", body))

$body = file_get_contents("body.json");
print_r(api("POST", "/estimate", $body));

var body = File.ReadAllText("body.json");
Console.WriteLine(await Api.Call("POST", "/estimate", body));

curl -s -X POST "$BASE/run" \
  -H "Authorization: Bearer $SKILLSAFE_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: raffle-desk:announce:quorlby-2026-03-16:a1" \
  --data-binary @body.json
# {"ok":true,"data":{"job_id":"..."}}

body = open("body.json", encoding="utf-8").read()
key = "raffle-desk:announce:quorlby-2026-03-16:a1"
job_id = api("POST", "/run", body, {"Idempotency-Key": key})["job_id"]
print(job_id)

const body = readFileSync("body.json", "utf8");
const key = "raffle-desk:announce:quorlby-2026-03-16:a1";
const { job_id } = await api("POST", "/run", body, { "Idempotency-Key": key });
console.log(job_id);

body, _ := os.ReadFile("body.json")
key := "raffle-desk:announce:quorlby-2026-03-16:a1"
d, err := api("POST", "/run", string(body), map[string]string{"Idempotency-Key": key})
if err != nil {
	panic(err)
}
var run struct {
	JobID string `json:"job_id"`
}
json.Unmarshal(d, &run)
fmt.Println(run.JobID)

var body = Files.readString(Path.of("body.json"));
var run = api("POST", "/run", body,
    "Idempotency-Key", "raffle-desk:announce:quorlby-2026-03-16:a1");
System.out.println(str(run, "job_id"));

body = File.read("body.json")
key = "raffle-desk:announce:quorlby-2026-03-16:a1"
job_id = api("POST", "/run", body, { "Idempotency-Key" => key })["job_id"]
puts job_id

$body = file_get_contents("body.json");
$key = "raffle-desk:announce:quorlby-2026-03-16:a1";
$jobId = api("POST", "/run", $body, ["Idempotency-Key: $key"])["job_id"];
echo $jobId, "\n";

var body = File.ReadAllText("body.json");
var run = await Api.Call("POST", "/run", body,
    ("Idempotency-Key", "raffle-desk:announce:quorlby-2026-03-16:a1"));
Console.WriteLine(run.GetProperty("job_id").GetString());

# needs jq
JOB_ID="JOB_ID"   # from the /run response
while :; do
  JOB=$(curl -s "$BASE/jobs/$JOB_ID" -H "Authorization: Bearer $SKILLSAFE_TOKEN")
  STATUS=$(printf '%s' "$JOB" | jq -r '.data.status')
  [ "$STATUS" = succeeded ] || [ "$STATUS" = failed ] && break
  sleep 1
done
printf '%s' "$JOB" | jq '.data | {status, charged_credits, truncated, error}'

deadline = time.time() + 180
while True:
    job = api("GET", "/jobs/" + urllib.parse.quote(job_id, safe=""))
    if job["status"] in ("succeeded", "failed"):
        break
    if time.time() > deadline:
        raise TimeoutError("job timed out")
    time.sleep(1)
print(job["status"], job.get("charged_credits"), job.get("truncated"), job.get("error"))
text = (job.get("output") or {}).get("output") or ""

const start = Date.now();
let job;
for (;;) {
  job = await api("GET", "/jobs/" + encodeURIComponent(job_id));
  if (job.status === "succeeded" || job.status === "failed") break;
  if (Date.now() - start > 180000) throw new Error("job timed out");
  await new Promise((r) => setTimeout(r, 1000));
}
console.log(job.status, job.charged_credits, job.truncated, job.error);
const text = (job.output && job.output.output) || "";

// add "net/url" and "time" to the imports
jobID := "JOB_ID" // from step 4
var job struct {
	Status         string          `json:"status"`
	ChargedCredits float64         `json:"charged_credits"`
	Truncated      bool            `json:"truncated"`
	Error          json.RawMessage `json:"error"`
	Output         struct {
		Output string `json:"output"`
	} `json:"output"`
}
start := time.Now()
for {
	d, err := api("GET", "/jobs/"+url.PathEscape(jobID), "", nil)
	if err != nil {
		panic(err)
	}
	json.Unmarshal(d, &job)
	if job.Status == "succeeded" || job.Status == "failed" {
		break
	}
	if time.Since(start) > 180*time.Second {
		panic("job timed out")
	}
	time.Sleep(time.Second)
}
fmt.Println(job.Status, job.ChargedCredits, job.Truncated, string(job.Error))
text := job.Output.Output

var jobId = "JOB_ID"; // from step 4
long start = System.currentTimeMillis();
String job;
for (;;) {
  job = api("GET", "/jobs/" + URLEncoder.encode(jobId, StandardCharsets.UTF_8), null);
  var status = str(job, "status");
  if ("succeeded".equals(status) || "failed".equals(status)) break;
  if (System.currentTimeMillis() - start > 180_000) throw new RuntimeException("job timed out");
  Thread.sleep(1000);
}
System.out.println(job);
var text = str(job, "output"); // job.output.output: the reply text

job_id = "JOB_ID" # from step 4
job = nil
start = Time.now
loop do
  job = api("GET", "/jobs/#{URI.encode_www_form_component(job_id)}")
  break if %w[succeeded failed].include?(job["status"])
  raise "job timed out" if Time.now - start > 180
  sleep 1
end
puts job.values_at("status", "charged_credits", "truncated", "error").inspect
text = job.dig("output", "output").to_s

$jobId = "JOB_ID"; // from step 4
$start = time();
while (true) {
    $job = api("GET", "/jobs/" . rawurlencode($jobId));
    if (in_array($job["status"], ["succeeded", "failed"], true)) break;
    if (time() - $start > 180) throw new RuntimeException("job timed out");
    sleep(1);
}
echo $job["status"], " ", $job["charged_credits"] ?? "", "\n";
$text = $job["output"]["output"] ?? "";

var jobId = "JOB_ID"; // from step 4
var start = DateTime.UtcNow;
JsonElement job;
while (true)
{
    job = await Api.Call("GET", "/jobs/" + Uri.EscapeDataString(jobId));
    var status = job.GetProperty("status").GetString();
    if (status == "succeeded" || status == "failed") break;
    if (DateTime.UtcNow - start > TimeSpan.FromSeconds(180)) throw new TimeoutException("job timed out");
    await Task.Delay(1000);
}
Console.WriteLine(job);
var text = job.TryGetProperty("output", out var o) && o.ValueKind == JsonValueKind.Object
    ? o.GetProperty("output").GetString() : "";

curl -sN -X POST "$BASE/run-stream" \
  -H "Authorization: Bearer $SKILLSAFE_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: raffle-desk:announce:quorlby-2026-03-16:s1" \
  --data-binary @body.json
# event: NAME
# data: {...JSON...}
# (blank line between frames)

body = open("body.json", encoding="utf-8").read()
req = urllib.request.Request(BASE + "/run-stream", data=body.encode("utf-8"), method="POST",
    headers={"Content-Type": "application/json", "Authorization": "Bearer " + TOKEN,
             "Idempotency-Key": "raffle-desk:announce:quorlby-2026-03-16:s1"})
final, text = None, ""
with urllib.request.urlopen(req) as res:
    if "text/event-stream" not in res.headers.get("Content-Type", ""):
        final = json.load(res)["data"]  # plain JSON envelope (replay)
    else:
        event, data = "message", ""
        for raw in res:
            line = raw.decode("utf-8").rstrip("\r\n")
            if line.startswith("event:"):
                event = line[6:].strip()
            elif line.startswith("data:"):
                data += line[5:].strip()
            elif line == "":
                if data:
                    msg = json.loads(data)
                    if event == "delta":
                        text += msg.get("text", "")
                    elif event in ("done", "pending"):
                        final = msg
                    elif event == "error":
                        raise RuntimeError(f"{msg.get('code')}: {msg.get('message')}")
                event, data = "message", ""
text = ((final or {}).get("output") or {}).get("output") or text

const res = await fetch(BASE + "/run-stream", {
  method: "POST",
  headers: { "Content-Type": "application/json", Authorization: "Bearer " + TOKEN,
    "Idempotency-Key": "raffle-desk:announce:quorlby-2026-03-16:s1" },
  body: readFileSync("body.json", "utf8"),
});
let final = null, deltas = "";
if (!(res.headers.get("content-type") || "").includes("text/event-stream")) {
  const json = await res.json().catch(() => ({}));
  if (!res.ok) throw new Error(`${res.status} ${json.error && json.error.message}`);
  final = json.data; // plain JSON envelope (replay)
} else {
  const decoder = new TextDecoder();
  let buf = "";
  for await (const chunk of res.body) {
    buf += decoder.decode(chunk, { stream: true });
    let i;
    while ((i = buf.indexOf("\n\n")) >= 0) {
      const frame = buf.slice(0, i);
      buf = buf.slice(i + 2);
      let event = "message", data = "";
      for (const line of frame.split("\n")) {
        if (line.startsWith("event:")) event = line.slice(6).trim();
        else if (line.startsWith("data:")) data += line.slice(5).trim();
      }
      if (!data) continue;
      const msg = JSON.parse(data);
      if (event === "delta") deltas += msg.text || "";
      else if (event === "done" || event === "pending") final = msg;
      else if (event === "error") throw new Error(`${msg.code}: ${msg.message}`);
    }
  }
}
const text = (final && final.output && final.output.output) || deltas;

// add "bufio" to the imports
body, _ := os.ReadFile("body.json")
req, _ := http.NewRequest("POST", base+"/run-stream", strings.NewReader(string(body)))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Idempotency-Key", "raffle-desk:announce:quorlby-2026-03-16:s1")
res, err := http.DefaultClient.Do(req)
if err != nil {
	panic(err)
}
defer res.Body.Close()
var final json.RawMessage
text := ""
if !strings.Contains(res.Header.Get("Content-Type"), "text/event-stream") {
	var env envelope // plain JSON envelope (replay)
	json.NewDecoder(res.Body).Decode(&env)
	if res.StatusCode >= 300 {
		panic(fmt.Sprintf("HTTP %d", res.StatusCode))
	}
	final = env.Data
} else {
	sc := bufio.NewScanner(res.Body)
	sc.Buffer(make([]byte, 64*1024), 16*1024*1024)
	event, data := "message", ""
	for sc.Scan() {
		line := strings.TrimRight(sc.Text(), "\r")
		switch {
		case strings.HasPrefix(line, "event:"):
			event = strings.TrimSpace(line[6:])
		case strings.HasPrefix(line, "data:"):
			data += strings.TrimSpace(line[5:])
		case line == "":
			if data != "" {
				switch event {
				case "delta":
					var m struct {
						Text string `json:"text"`
					}
					json.Unmarshal([]byte(data), &m)
					text += m.Text
				case "done", "pending":
					final = json.RawMessage(data)
				case "error":
					panic("stream error: " + data)
				}
			}
			event, data = "message", ""
		}
	}
}
var done struct {
	Output struct {
		Output string `json:"output"`
	} `json:"output"`
}
json.Unmarshal(final, &done)
if done.Output.Output != "" {
	text = done.Output.Output
}

var req = HttpRequest.newBuilder(URI.create(BASE + "/run-stream"))
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer " + token)
    .header("Idempotency-Key", "raffle-desk:announce:quorlby-2026-03-16:s1")
    .POST(HttpRequest.BodyPublishers.ofString(Files.readString(Path.of("body.json"))))
    .build();
var res = HTTP.send(req, HttpResponse.BodyHandlers.ofLines());
var ctype = res.headers().firstValue("content-type").orElse("");
var lines = res.body().iterator();
String fin = null, event = "message", data = "";
var deltas = new StringBuilder();
if (!ctype.contains("text/event-stream")) {
  var sb = new StringBuilder(); // plain JSON envelope (replay)
  while (lines.hasNext()) sb.append(lines.next()).append('\n');
  if (res.statusCode() >= 300) throw new RuntimeException(res.statusCode() + " " + sb);
  fin = sb.toString();
} else {
  while (lines.hasNext()) {
    var line = lines.next();
    if (line.startsWith("event:")) event = line.substring(6).trim();
    else if (line.startsWith("data:")) data += line.substring(5).trim();
    else if (line.isEmpty()) {
      if (!data.isEmpty()) {
        if (event.equals("delta")) { var t = str(data, "text"); if (t != null) deltas.append(t); }
        else if (event.equals("done") || event.equals("pending")) fin = data;
        else if (event.equals("error")) throw new RuntimeException(str(data, "message"));
      }
      event = "message";
      data = "";
    }
  }
}
var out = fin == null ? null : str(fin, "output");
var text = out != null ? out : deltas.toString();

uri = URI(BASE + "/run-stream")
req = Net::HTTP::Post.new(uri, "Content-Type" => "application/json",
  "Authorization" => "Bearer #{$token}",
  "Idempotency-Key" => "raffle-desk:announce:quorlby-2026-03-16:s1")
req.body = File.read("body.json")
final, text = nil, +""
Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
  http.request(req) do |res|
    unless res["Content-Type"].to_s.include?("text/event-stream")
      final = JSON.parse(res.body)["data"] # plain JSON envelope (replay)
      next
    end
    buf, event, data = +"", "message", +""
    res.read_body do |chunk|
      buf << chunk
      while (i = buf.index("\n"))
        line = buf.slice!(0..i).chomp
        if line.start_with?("event:") then event = line[6..].strip
        elsif line.start_with?("data:") then data << line[5..].strip
        elsif line.empty?
          unless data.empty?
            msg = JSON.parse(data)
            case event
            when "delta" then text << msg["text"].to_s
            when "done", "pending" then final = msg
            when "error" then raise "#{msg["code"]}: #{msg["message"]}"
            end
          end
          event, data = "message", +""
        end
      end
    end
  end
end
text = final.dig("output", "output") if final && final.dig("output", "output")

$final = null; $error = null; $text = ""; $raw = ""; $buf = "";
$event = "message"; $data = "";
$onLine = function (string $line) use (&$event, &$data, &$final, &$error, &$text) {
    if (strncmp($line, "event:", 6) === 0) { $event = trim(substr($line, 6)); return; }
    if (strncmp($line, "data:", 5) === 0) { $data .= trim(substr($line, 5)); return; }
    if ($line !== "") return;
    $msg = $data !== "" ? json_decode($data, true) : null;
    if (is_array($msg)) {
        if ($event === "delta") $text .= $msg["text"] ?? "";
        elseif ($event === "done" || $event === "pending") $final = $msg;
        elseif ($event === "error") $error = $msg;
    }
    $event = "message"; $data = "";
};
$ch = curl_init(BASE . "/run-stream");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => file_get_contents("body.json"),
    CURLOPT_HTTPHEADER => ["Content-Type: application/json", "Authorization: Bearer $token",
        "Idempotency-Key: raffle-desk:announce:quorlby-2026-03-16:s1"],
    CURLOPT_WRITEFUNCTION => function ($ch, $chunk) use (&$buf, &$raw, $onLine) {
        $raw .= $chunk;
        $buf .= $chunk;
        while (($i = strpos($buf, "\n")) !== false) {
            $onLine(rtrim(substr($buf, 0, $i), "\r"));
            $buf = substr($buf, $i + 1);
        }
        return strlen($chunk);
    },
]);
curl_exec($ch);
$ctype = (string) curl_getinfo($ch, CURLINFO_CONTENT_TYPE);
curl_close($ch);
if (strpos($ctype, "text/event-stream") === false) {
    $final = json_decode($raw, true)["data"] ?? null; // plain JSON envelope (replay)
}
if ($error) throw new RuntimeException(($error["code"] ?? "") . ": " . ($error["message"] ?? ""));
$text = $final["output"]["output"] ?? $text;

var req = new HttpRequestMessage(HttpMethod.Post, Api.Base + "/run-stream")
{
    Content = new StringContent(File.ReadAllText("body.json"), Encoding.UTF8, "application/json")
};
req.Headers.Add("Authorization", "Bearer " + Api.Token);
req.Headers.Add("Idempotency-Key", "raffle-desk:announce:quorlby-2026-03-16:s1");
using var res = await Api.Http.SendAsync(req, HttpCompletionOption.ResponseHeadersRead);
JsonElement? done = null;
var deltas = new StringBuilder();
if (res.Content.Headers.ContentType?.MediaType != "text/event-stream")
{
    var env = JsonDocument.Parse(await res.Content.ReadAsStringAsync()).RootElement;
    if (!res.IsSuccessStatusCode) throw new HttpRequestException(env.ToString());
    done = env.GetProperty("data"); // plain JSON envelope (replay)
}
else
{
    using var reader = new StreamReader(await res.Content.ReadAsStreamAsync());
    string evt = "message", data = "", line;
    while ((line = await reader.ReadLineAsync()) != null)
    {
        if (line.StartsWith("event:")) evt = line[6..].Trim();
        else if (line.StartsWith("data:")) data += line[5..].Trim();
        else if (line.Length == 0)
        {
            if (data.Length > 0)
            {
                var msg = JsonDocument.Parse(data).RootElement;
                if (evt == "delta" && msg.TryGetProperty("text", out var t)) deltas.Append(t.GetString());
                else if (evt == "done" || evt == "pending") done = msg;
                else if (evt == "error") throw new Exception(msg.GetProperty("message").GetString());
            }
            evt = "message"; data = "";
        }
    }
}
var text = done is JsonElement d && d.TryGetProperty("output", out var o)
    && o.ValueKind == JsonValueKind.Object ? o.GetProperty("output").GetString() : deltas.ToString();

# needs jq; job.json is the GET /jobs/{id} response from step 4
jq -r '.data.output.output' job.json \
  | sed -e '1s/^```[A-Za-z]*//' -e '$s/```$//' \
  | jq '{task, headline}'
# jq fails if prose surrounds the object; the other tabs cut from the first { to the last }

import re

def parse_reply(text):
    t = re.sub(r"^```[a-z]*\s*", "", text.strip(), flags=re.I)
    t = re.sub(r"```\s*$", "", t)
    a, b = t.find("{"), t.rfind("}")
    if a == -1:
        raise ValueError("no JSON object in the reply")
    return json.loads(t[a:] if b == -1 else t[a:b + 1])

reply = parse_reply(text)
print(reply.get("task"), reply.get("headline"))

function parseReply(text) {
  const t = String(text || "").trim().replace(/^```[a-z]*\s*/i, "").replace(/```\s*$/, "");
  const a = t.indexOf("{"), b = t.lastIndexOf("}");
  if (a === -1) throw new Error("no JSON object in the reply");
  return JSON.parse(t.slice(a, b === -1 ? t.length : b + 1));
}

const reply = parseReply(text);
console.log(reply.task, reply.headline);

// add "regexp" to the imports
t := strings.TrimSpace(text)
t = regexp.MustCompile("(?i)^```[a-z]*\\s*").ReplaceAllString(t, "")
t = regexp.MustCompile("```\\s*$").ReplaceAllString(t, "")
a, b := strings.Index(t, "{"), strings.LastIndex(t, "}")
if a == -1 {
	panic("no JSON object in the reply")
}
if b < a {
	b = len(t) - 1
}
var reply map[string]any
if err := json.Unmarshal([]byte(t[a:b+1]), &reply); err != nil {
	panic(err)
}
fmt.Println(reply["task"], reply["headline"])

var t = text.strip().replaceFirst("(?i)^```[a-z]*\\s*", "").replaceFirst("```\\s*$", "");
int a = t.indexOf('{'), b = t.lastIndexOf('}');
if (a == -1) throw new RuntimeException("no JSON object in the reply");
var replyJson = t.substring(a, b == -1 ? t.length() : b + 1);
// hand replyJson to Jackson or Gson; str() is enough for the flat string fields
System.out.println(str(replyJson, "task") + ": " + str(replyJson, "headline"));

def parse_reply(text)
  t = text.to_s.strip.sub(/\A```[a-z]*\s*/i, "").sub(/```\s*\z/, "")
  a, b = t.index("{"), t.rindex("}")
  raise "no JSON object in the reply" if a.nil?
  JSON.parse(t[a..(b || -1)])
end

reply = parse_reply(text)
puts "#{reply["task"]}: #{reply["headline"]}"

function parse_reply(string $text): array
{
    $t = preg_replace('/^```[a-z]*\s*/i', "", trim($text));
    $t = preg_replace('/```\s*$/', "", $t);
    $a = strpos($t, "{");
    $b = strrpos($t, "}");
    if ($a === false) throw new RuntimeException("no JSON object in the reply");
    $len = ($b === false ? strlen($t) : $b + 1) - $a;
    return json_decode(substr($t, $a, $len), true, 512, JSON_THROW_ON_ERROR);
}

$reply = parse_reply($text);
echo $reply["task"], ": ", $reply["headline"] ?? "", "\n";

// add: using System.Text.RegularExpressions;
var s = Regex.Replace(text.Trim(), "^```[a-z]*\\s*", "", RegexOptions.IgnoreCase);
s = Regex.Replace(s, "```\\s*$", "");
int a = s.IndexOf('{'), b = s.LastIndexOf('}');
if (a == -1) throw new Exception("no JSON object in the reply");
var reply = JsonDocument.Parse(s.Substring(a, (b == -1 ? s.Length : b + 1) - a)).RootElement;
Console.WriteLine($"{reply.GetProperty("task")}: {reply.GetProperty("headline")}");