Drive Dating Profile Review from your own code

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

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

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

import json, requests

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


class ApiError(RuntimeError):
    """The four fields the error envelope carries. `details` is where an
    invalid_input says which field it disliked."""

    def __init__(self, err):
        super().__init__(f"{err.get('code')}: {err.get('message')}")
        self.code    = err.get("code")
        self.status  = err.get("status")
        self.details = err.get("details")


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

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

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

package main

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

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

// The token comes from /tokens.html. Read it from the environment rather than
// pasting it into source: os.Getenv("SKILLSAFE_TOKEN").
func call(method, path string, body []byte, extra map[string]string) (json.RawMessage, error) {
  var rdr io.Reader
  if body != nil {
    rdr = bytes.NewReader(body)
  }
  req, _ := http.NewRequest(method, base+path, rdr)
  req.Header.Set("Authorization", "Bearer "+os.Getenv("SKILLSAFE_TOKEN"))
  req.Header.Set("Content-Type", "application/json")
  for k, v := range extra {
    req.Header.Set(k, v)
  }
  res, err := http.DefaultClient.Do(req)
  if err != nil {
    return nil, err
  }
  defer res.Body.Close()

  var env struct {
    Data  json.RawMessage `json:"data"`
    Error *struct {
      Code    string          `json:"code"`
      Message string          `json:"message"`
      Status  int             `json:"status"`
      Details json.RawMessage `json:"details"`
    } `json:"error"`
  }
  if err := json.NewDecoder(res.Body).Decode(&env); err != nil {
    return nil, err
  }
  if env.Error != nil {
    return nil, errors.New(env.Error.Code + ": " + env.Error.Message)
  }
  return env.Data, nil
}

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

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

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

require "net/http"
require "json"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

dd GET /me | unwrap

# {"subject_type":"user","subject_id":"...","credits":1840}
# subject_type is "user" when signed in, and something else for a guest.
# Those three keys are the whole object - there is nothing else to read.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Put the two worked bodies from above in profile.json and opener.json, then
# check each locally, because the endpoint will not check it for you.
check() {
  python3 - "$1" <<'PY'
import json, sys
d = json.load(open(sys.argv[1]))
assert isinstance(d, dict), "the body must be the input object, not a wrapper or a list"
assert "input" not in d, "do not wrap the body in {\"input\": ...}"
assert d.get("task") in ("profile", "opener"), "task is required and picks the lane"
assert d.get("tone") in ("plain", "warm", "dry", "playful"), "bad tone"
if d["task"] == "profile":
    assert d.get("profile") or d.get("about_me"), "the profile lane needs profile or about_me"
else:
    assert (d.get("their_profile") or "").strip(), "the opener lane needs their_profile"
    assert int(d.get("count") or 0) > 0, "the opener lane needs a count"
PY
}

for f in profile.json opener.json; do
  check "$f" || exit 1
  echo "== $f"
  dd POST /estimate "$(cat "$f")" | unwrap
done

# {"hold_credits":...,"min_credits":...,"model":"gpt-5.6-terra",
#  "model_alias":"gpt-terra","markup_bps":1000}

TASKS = ("profile", "opener")
TONES = ("plain", "warm", "dry", "playful")


def must_be_valid(inp):
    """The lane router is the `task` field. /estimate checks none of this."""
    if not isinstance(inp, dict):
        raise TypeError(f"input must be a plain object, got {type(inp).__name__}")
    if "input" in inp:
        raise ValueError("do not wrap the body in {'input': ...}")
    if inp.get("task") not in TASKS:
        raise ValueError(f"task is required and must be one of {TASKS}")
    if inp.get("tone") not in TONES:
        raise ValueError(f"tone must be one of {TONES}")
    if not isinstance(inp.get("scan"), dict):
        raise ValueError("scan is required on both lanes")
    if inp["task"] == "profile":
        if not (inp.get("profile") or inp.get("about_me")):
            raise ValueError("the profile lane needs profile or about_me")
    else:
        if not (inp.get("their_profile") or "").strip():
            raise ValueError("the opener lane needs their_profile")
        if int(inp.get("count") or 0) < 1:
            raise ValueError("the opener lane needs a count of at least 1")
    return inp


# profile_body and opener_body are the two worked bodies above.
for body in (profile_body, opener_body):
    est = call("POST", "/estimate", must_be_valid(body))
    print(body["task"], "hold", est["hold_credits"], "min", est["min_credits"],
          est["model"], est["model_alias"], "markup_bps", est["markup_bps"])

const TASKS = ["profile", "opener"];
const TONES = ["plain", "warm", "dry", "playful"];

// The lane router is the `task` field. /estimate checks none of this.
function mustBeValid(input) {
  if (!input || typeof input !== "object" || Array.isArray(input)) {
    throw new TypeError("input must be a plain object");
  }
  if ("input" in input) throw new Error("do not wrap the body in { input: ... }");
  if (!TASKS.includes(input.task)) throw new Error("task is required: " + TASKS);
  if (!TONES.includes(input.tone)) throw new Error("tone must be one of " + TONES);
  if (!input.scan || typeof input.scan !== "object") throw new Error("scan is required");
  if (input.task === "profile") {
    if (!input.profile && !input.about_me) {
      throw new Error("the profile lane needs profile or about_me");
    }
  } else {
    if (!(input.their_profile || "").trim()) throw new Error("the opener lane needs their_profile");
    if (!(input.count >= 1)) throw new Error("the opener lane needs a count of at least 1");
  }
  return input;
}

for (const body of [profileBody, openerBody]) {
  const est = await call("POST", "/estimate", mustBeValid(body));
  console.log(body.task, est.hold_credits, est.min_credits, est.model_alias, est.markup_bps);
}

// profileBody and openerBody are the two worked bodies, marshalled from your
// own structs or read from disk. Validate here: /estimate will not.
func mustBeValid(payload []byte) []byte {
  var d map[string]any
  if err := json.Unmarshal(payload, &d); err != nil {
    panic("body must be a JSON object")
  }
  if _, wrapped := d["input"]; wrapped {
    panic(`do not wrap the body in {"input": ...}`)
  }
  task, _ := d["task"].(string)
  if task != "profile" && task != "opener" {
    panic("task is required and must be profile or opener")
  }
  if task == "profile" {
    if d["profile"] == "" && d["about_me"] == "" {
      panic("the profile lane needs profile or about_me")
    }
  } else if s, _ := d["their_profile"].(string); strings.TrimSpace(s) == "" {
    panic("the opener lane needs their_profile")
  }
  return payload
}

for _, payload := range [][]byte{profileBody, openerBody} {
  raw, err := call("POST", "/estimate", mustBeValid(payload), nil)
  if err != nil {
    panic(err)
  }
  var est struct {
    HoldCredits float64 `json:"hold_credits"`
    MinCredits  float64 `json:"min_credits"`
    Model       string  `json:"model"`
    ModelAlias  string  `json:"model_alias"`
    MarkupBps   int     `json:"markup_bps"`
  }
  json.Unmarshal(raw, &est)
  fmt.Println(est.HoldCredits, est.MinCredits, est.Model, est.ModelAlias, est.MarkupBps)
}

// profileBody and openerBody are the two worked bodies as JSON strings.
// Validate them with your JSON library before spending: /estimate will not.
static String mustBeValid(String payload) {
  var t = payload.trim();
  if (t.charAt(0) != '{' || t.contains("\"input\":")) {
    throw new IllegalArgumentException("body must be the input object itself, unwrapped");
  }
  if (!t.contains("\"task\":\"profile\"") && !t.contains("\"task\":\"opener\"")) {
    throw new IllegalArgumentException("task is required and picks the lane");
  }
  return payload;
}

for (var payload : new String[]{ profileBody, openerBody }) {
  var body = call("POST", "/estimate", mustBeValid(payload), null, null);
  // {"data":{"hold_credits":...,"min_credits":...,"model":"gpt-5.6-terra",
  //          "model_alias":"gpt-terra","markup_bps":1000}}
  // hold_credits is a reservation against the output cap, not the price, and
  // the two lanes do not hold the same amount.
  System.out.println(body);
}

TASKS = %w[profile opener].freeze
TONES = %w[plain warm dry playful].freeze

# The lane router is the `task` field. /estimate checks none of this.
def must_be_valid(input)
  raise ArgumentError, "input must be a Hash" unless input.is_a?(Hash)
  raise ArgumentError, "do not wrap the body in {input: ...}" if input.key?("input")
  raise ArgumentError, "task is required" unless TASKS.include?(input["task"])
  raise ArgumentError, "bad tone" unless TONES.include?(input["tone"])
  raise ArgumentError, "scan is required" unless input["scan"].is_a?(Hash)
  if input["task"] == "profile"
    raise ArgumentError, "needs profile or about_me" if input["profile"].to_s.empty? &&
                                                        input["about_me"].to_s.empty?
  else
    raise ArgumentError, "needs their_profile" if input["their_profile"].to_s.strip.empty?
    raise ArgumentError, "needs a count" if input["count"].to_i < 1
  end
  input
end

[profile_body, opener_body].each do |body|
  est = call("POST", "/estimate", must_be_valid(body))
  puts [body["task"], est["hold_credits"], est["min_credits"],
        est["model"], est["model_alias"], est["markup_bps"]].join(" ")
end

<?php
// The lane router is the `task` field. /estimate checks none of this.
function must_be_valid(array $input): array {
  if (array_is_list($input))  throw new InvalidArgumentException("body must be an object");
  if (isset($input["input"])) throw new InvalidArgumentException("do not wrap the body");
  if (!in_array($input["task"] ?? "", ["profile", "opener"], true)) {
    throw new InvalidArgumentException("task is required and picks the lane");
  }
  if (!in_array($input["tone"] ?? "", ["plain", "warm", "dry", "playful"], true)) {
    throw new InvalidArgumentException("bad tone");
  }
  if ($input["task"] === "profile") {
    if (($input["profile"] ?? "") === "" && ($input["about_me"] ?? "") === "") {
      throw new InvalidArgumentException("the profile lane needs profile or about_me");
    }
  } else {
    if (trim($input["their_profile"] ?? "") === "") {
      throw new InvalidArgumentException("the opener lane needs their_profile");
    }
    if ((int)($input["count"] ?? 0) < 1) throw new InvalidArgumentException("needs a count");
  }
  return $input;
}

foreach ([$profileBody, $openerBody] as $body) {
  $est = dd_call("POST", "/estimate", must_be_valid($body));
  echo $body["task"], " ", $est["hold_credits"], " ", $est["min_credits"], " ",
       $est["model"], " ", $est["model_alias"], " ", $est["markup_bps"], "\n";
}

// profileBody and openerBody are the two worked bodies as JSON strings.
// Validate here: /estimate will not.
string MustBeValid(string payload) {
    var probe = JsonDocument.Parse(payload).RootElement;
    if (probe.ValueKind != JsonValueKind.Object)  throw new ArgumentException("body must be an object");
    if (probe.TryGetProperty("input", out _))     throw new ArgumentException("do not wrap the body");
    var task = probe.GetProperty("task").GetString();
    if (task is not ("profile" or "opener"))      throw new ArgumentException("task picks the lane");
    if (task == "profile") {
        var hasProfile  = probe.TryGetProperty("profile", out var p)  && p.GetString()?.Length > 0;
        var hasAboutMe  = probe.TryGetProperty("about_me", out var a) && a.GetString()?.Length > 0;
        if (!hasProfile && !hasAboutMe) throw new ArgumentException("needs profile or about_me");
    } else if (string.IsNullOrWhiteSpace(probe.GetProperty("their_profile").GetString())) {
        throw new ArgumentException("the opener lane needs their_profile");
    }
    return payload;
}

foreach (var payload in new[] { profileBody, openerBody }) {
    var est = await Call(HttpMethod.Post, "/estimate", MustBeValid(payload));
    Console.WriteLine($"{est.GetProperty("hold_credits")} {est.GetProperty("min_credits")} " +
                      $"{est.GetProperty("model").GetString()} " +
                      $"{est.GetProperty("model_alias").GetString()} " +
                      $"{est.GetProperty("markup_bps")}");
}

# Submit. The body IS the input object - there is no {"input": ...} wrapper
# and there is no X-App-Slug header. The lane goes in the key.
TASK=$(python3 -c 'import sys,json; print(json.load(open("profile.json"))["task"])')
KEY="dating-profile-review:$TASK:7b41ce9d:a1"

JOB=$(dd POST /run "$(cat profile.json)" "Idempotency-Key: $KEY" \
  | python3 -c 'import sys,json; print(json.load(sys.stdin)["data"]["job_id"])')

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

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

import time

payload = must_be_valid(profile_body)              # or opener_body
key = f"dating-profile-review:{payload['task']}:7b41ce9d:a1" # the lane is in the key
job = call("POST", "/run", payload, {"Idempotency-Key": key})

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

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

reply = json.loads(job["output"]["output"])        # a JSON string, parsed again
print(reply["lane"], reply["route_to_help"])
print(reply["reads_as"])

const payload = mustBeValid(profileBody);            // or openerBody
const key = `dating-profile-review:${payload.task}:7b41ce9d:a1`;  // the lane is in the key
let job = await call("POST", "/run", payload, { "Idempotency-Key": key });

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

const reply = JSON.parse(job.output.output);        // a JSON string, parsed again
console.log(reply.lane, reply.route_to_help);
console.log(reply.reads_as);

// The lane belongs in the key: the same text can legitimately run in both.
key := map[string]string{"Idempotency-Key": "dating-profile-review:profile:7b41ce9d:a1"}
raw, err := call("POST", "/run", mustBeValid(profileBody), key)
if err != nil {
  panic(err)
}

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

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

// job.Output.Output is a JSON string holding the reply; unmarshal it again.
var reply map[string]any
json.Unmarshal([]byte(job.Output.Output), &reply)
fmt.Println(reply["lane"], reply["route_to_help"])

// The lane belongs in the key: the same text can legitimately run in both.
var key = "dating-profile-review:profile:7b41ce9d:a1";
var submitted = call("POST", "/run", mustBeValid(profileBody), "Idempotency-Key", key);

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

// The reply is the JSON *string* at data.output.output - parse it again, then
// read route_to_help before anything else.
System.out.println(jobBody);

payload = must_be_valid(profile_body)              # or opener_body
key = "dating-profile-review:#{payload["task"]}:7b41ce9d:a1" # the lane is in the key
job = call("POST", "/run", payload, { "Idempotency-Key" => key })

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

reply = JSON.parse(job["output"]["output"])        # a JSON string, parsed again
puts reply["lane"], reply["route_to_help"]
puts reply["reads_as"]

<?php
$payload = must_be_valid($profileBody);            // or $openerBody
$key = "dating-profile-review:{$payload["task"]}:7b41ce9d:a1";   // the lane is in the key
$job = dd_call("POST", "/run", $payload, ["Idempotency-Key: $key"]);

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

$reply = json_decode($job["output"]["output"], true);   // parsed again
echo $reply["lane"], " ", var_export($reply["route_to_help"], true), "\n";
echo $reply["reads_as"], "\n";

// The lane belongs in the key: the same text can legitimately run in both.
var key = "dating-profile-review:profile:7b41ce9d:a1";
var job = await Call(HttpMethod.Post, "/run", MustBeValid(profileBody),
                     "Idempotency-Key", key);

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

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

curl -N -X POST "https://api.skillsafe.ai/v1/app-api/run-stream" \
  -H "Authorization: Bearer $DD_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: dating-profile-review:opener:7b41ce9d:a1" \
  -d @opener.json

# Frames arrive as `event: NAME` + `data: JSON`, separated by a blank line.
# Concatenate the .text of every `delta`; the `done` frame carries
# charged_credits and output.output. -N is required: without it curl buffers
# and you get the whole stream at the end, which defeats the point.

out, done = "", None
headers = dict(H, **{"Idempotency-Key": "dating-profile-review:opener:7b41ce9d:a1"})

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

print("charged", done.get("charged_credits"))
reply = json.loads(out)
print(reply["lane"], reply["route_to_help"])

const res = await fetch(`${BASE}/run-stream`, {
  method: "POST",
  headers: { ...H, "Idempotency-Key": "dating-profile-review:opener:7b41ce9d:a1" },
  body: JSON.stringify(mustBeValid(openerBody))
});

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

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

req, _ := http.NewRequest("POST", base+"/run-stream",
  bytes.NewReader(mustBeValid(openerBody)))
req.Header.Set("Authorization", "Bearer "+os.Getenv("SKILLSAFE_TOKEN"))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Idempotency-Key", "dating-profile-review:opener:7b41ce9d:a1")

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

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

var reply map[string]any
json.Unmarshal([]byte(out.String()), &reply)
fmt.Println(reply["lane"], reply["route_to_help"])

var req = HttpRequest.newBuilder()
    .uri(URI.create(BASE + "/run-stream"))
    .header("Authorization", "Bearer " + TOKEN)
    .header("Content-Type", "application/json")
    .header("Idempotency-Key", "dating-profile-review:opener:7b41ce9d:a1")
    .POST(HttpRequest.BodyPublishers.ofString(mustBeValid(openerBody)))
    .build();

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

// out now holds the reply object as a string; parse it and read
// route_to_help before lines or openers.
System.out.println(out);

uri = URI("#{BASE}/run-stream")
req = Net::HTTP::Post.new(uri)
req["Authorization"]   = "Bearer #{TOKEN}"
req["Content-Type"]    = "application/json"
req["Idempotency-Key"] = "dating-profile-review:opener:7b41ce9d:a1"
req.body = JSON.generate(must_be_valid(opener_body))

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

reply = JSON.parse(out)
puts reply["lane"], reply["route_to_help"]

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

$ch = curl_init("$base/run-stream");
curl_setopt_array($ch, [
  CURLOPT_POST       => true,
  CURLOPT_POSTFIELDS => json_encode(must_be_valid($openerBody)),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer $token",
    "Content-Type: application/json",
    "Idempotency-Key: dating-profile-review:opener:7b41ce9d:a1",
  ],
  CURLOPT_WRITEFUNCTION => function ($ch, $chunk) use (&$out, &$name) {
    foreach (explode("\n", $chunk) as $line) {
      $line = rtrim($line, "\r");
      if ($line === "") {
        $name = "message";              // a blank line ends the frame
      } elseif (str_starts_with($line, "event:")) {
        $name = trim(substr($line, 6));
      } elseif (str_starts_with($line, "data:") && $name === "delta") {
        $evt  = json_decode(trim(substr($line, 5)), true);
        $out .= $evt["text"] ?? "";
      }
    }
    return strlen($chunk);
  },
]);
curl_exec($ch);

$reply = json_decode($out, true);
echo $reply["lane"], "\n";

var msg = new HttpRequestMessage(HttpMethod.Post, $"{baseUrl}/run-stream") {
    Content = new StringContent(MustBeValid(openerBody), Encoding.UTF8, "application/json")
};
msg.Headers.Add("Idempotency-Key", "dating-profile-review:opener:7b41ce9d:a1");

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

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

var reply = JsonDocument.Parse(sb.ToString()).RootElement;
Console.WriteLine(reply.GetProperty("lane").GetString());

# $S is the terminal job body from step 5, and profile.json is what you sent.
echo "$S" | python3 - profile.json <<'PY'
import json, sys, re
job  = json.load(sys.stdin)
sent = json.load(open(sys.argv[1]))
text = re.sub(r"^\s*```(?:json)?|```\s*$", "", job["data"]["output"]["output"]).strip()
r    = json.loads(text[text.index("{"):text.rindex("}") + 1])

if r.get("route_to_help"):
    print("refused:", r["route"], "-", r["reason"])
    sys.exit(0)

if r["lane"] == "profile":
    src = sent.get("profile") or sent.get("about_me") or ""
    for ln in r["lines"]:
        mark = "ok " if ln["quote"] in src else "UNVERIFIED "
        print(mark + ln["verdict"] + ": " + ln["quote"])
    print("\n" + r["rewrite"])
else:
    src = sent["their_profile"]
    for o in r["openers"]:
        mark = "ok " if o["hook"] in src else "UNVERIFIED "
        print(mark + o["frame"] + ": " + o["text"])
PY

import re

FENCE = re.compile(r"^\s*```(?:json)?|```\s*$")


def first_object(text):
    """One bare object is the contract. Survive a fence or a preamble anyway."""
    t = FENCE.sub("", text).strip()
    start = t.find("{")
    if start < 0:
        raise ValueError("no JSON object in the reply")
    depth, in_str, esc = 0, False, False
    for i in range(start, len(t)):
        c = t[i]
        if esc:
            esc = False
        elif c == "\\":
            esc = True
        elif c == '"':
            in_str = not in_str
        elif not in_str:
            if c == "{":
                depth += 1
            elif c == "}":
                depth -= 1
                if depth == 0:
                    return json.loads(t[start:i + 1])
    raise ValueError("the object was truncated")


r = first_object(job["output"]["output"])

if r["route_to_help"]:
    # A refusal is a successful, charged run. Show it; do not retry it.
    print(r["route"], r["reason"], r.get("instead"))
elif r["lane"] == "profile":
    src = payload.get("profile") or payload.get("about_me") or ""
    for ln in r["lines"] + r["cut"]:
        if ln["quote"] not in src:
            print("UNVERIFIED quote:", ln["quote"])
    print(r["reads_as"], r["gap"], sep="\n")
    print(r["rewrite"])
    print("carried through:", ", ".join(r["facts_used"]))
else:
    src = payload["their_profile"]
    for o in r["openers"]:
        if o["hook"] not in src:
            print("UNVERIFIED hook:", o["hook"])
        print(f"[{o['frame']}] {o['text']}")
        if o["risk"]:
            print("   risk:", o["risk"])

function firstObject(text) {
  // One bare object is the contract. Survive a fence or a preamble anyway.
  const t = text.replace(/^\s*```(?:json)?/, "").replace(/```\s*$/, "").trim();
  const start = t.indexOf("{");
  if (start < 0) throw new Error("no JSON object in the reply");
  let depth = 0, inStr = false, esc = false;
  for (let i = start; i < t.length; i++) {
    const c = t[i];
    if (esc) { esc = false; continue; }
    if (c === "\\") { esc = true; continue; }
    if (c === '"') { inStr = !inStr; continue; }
    if (inStr) continue;
    if (c === "{") depth++;
    else if (c === "}" && --depth === 0) return JSON.parse(t.slice(start, i + 1));
  }
  throw new Error("the object was truncated");
}

const r = firstObject(job.output.output);

if (r.route_to_help) {
  // A refusal is a successful, charged run. Show it; do not retry it.
  console.log(r.route, r.reason, r.instead);
} else if (r.lane === "profile") {
  const src = payload.profile || payload.about_me || "";
  for (const ln of [...r.lines, ...r.cut]) {
    if (!src.includes(ln.quote)) console.warn("UNVERIFIED quote:", ln.quote);
  }
  console.log(r.reads_as, r.gap, r.rewrite);
  console.log("carried through:", r.facts_used.join(", "));
} else {
  const src = payload.their_profile;
  for (const o of r.openers) {
    if (!src.includes(o.hook)) console.warn("UNVERIFIED hook:", o.hook);
    console.log(`[${o.frame}] ${o.text}`, o.risk ? `(risk: ${o.risk})` : "");
  }
}

// One bare object is the contract. Survive a fence or a preamble anyway.
func firstObject(text string) (string, bool) {
  t := strings.TrimSpace(text)
  t = strings.TrimPrefix(strings.TrimPrefix(t, "```json"), "```")
  t = strings.TrimSuffix(strings.TrimSpace(t), "```")
  start := strings.Index(t, "{")
  if start < 0 {
    return "", false
  }
  depth, inStr, esc := 0, false, false
  for i := start; i < len(t); i++ {
    c := t[i]
    switch {
    case esc:
      esc = false
    case c == '\\':
      esc = true
    case c == '"':
      inStr = !inStr
    case inStr:
    case c == '{':
      depth++
    case c == '}':
      depth--
      if depth == 0 {
        return t[start : i+1], true
      }
    }
  }
  return t[start:], false
}

text, complete := firstObject(job.Output.Output)
if !complete {
  fmt.Println("warning: the object was truncated; repair rather than discard")
}

var r struct {
  Lane        string `json:"lane"`
  RouteToHelp bool   `json:"route_to_help"`
  Route       string `json:"route"`
  Reason      string `json:"reason"`
  Lines       []struct {
    Quote   string `json:"quote"`
    Verdict string `json:"verdict"`
  } `json:"lines"`
  Openers []struct {
    Text  string `json:"text"`
    Hook  string `json:"hook"`
    Frame string `json:"frame"`
  } `json:"openers"`
}
json.Unmarshal([]byte(text), &r)

switch {
case r.RouteToHelp:
  fmt.Println("refused:", r.Route, r.Reason)
case r.Lane == "profile":
  for _, ln := range r.Lines {
    if !strings.Contains(sentProfile, ln.Quote) {
      fmt.Println("UNVERIFIED quote:", ln.Quote)
    }
  }
default:
  for _, o := range r.Openers {
    if !strings.Contains(sentTheirProfile, o.Hook) {
      fmt.Println("UNVERIFIED hook:", o.Hook)
    }
    fmt.Printf("[%s] %s\n", o.Frame, o.Text)
  }
}

// One bare object is the contract. Survive a fence or a preamble anyway.
static String firstObject(String text) {
  var t = text.strip().replaceFirst("^```(?:json)?", "").replaceFirst("```$", "").strip();
  int start = t.indexOf('{');
  if (start < 0) throw new IllegalStateException("no JSON object in the reply");
  int depth = 0;
  boolean inStr = false, esc = false;
  for (int i = start; i < t.length(); i++) {
    char c = t.charAt(i);
    if (esc)            { esc = false; continue; }
    if (c == '\\')      { esc = true;  continue; }
    if (c == '"')       { inStr = !inStr; continue; }
    if (inStr)          continue;
    if (c == '{')       depth++;
    else if (c == '}' && --depth == 0) return t.substring(start, i + 1);
  }
  throw new IllegalStateException("the object was truncated");
}

var reply = parse(firstObject(jobOutput));   // your JSON library

if (reply.getBoolean("route_to_help")) {
  // A refusal is a successful, charged run. Show it; do not retry it.
  System.out.println(reply.getString("route") + ": " + reply.getString("reason"));
} else if ("profile".equals(reply.getString("lane"))) {
  for (var line : reply.getArray("lines")) {
    var quote = line.getString("quote");
    if (!sentProfile.contains(quote)) System.out.println("UNVERIFIED quote: " + quote);
  }
  System.out.println(reply.getString("rewrite"));
} else {
  for (var o : reply.getArray("openers")) {
    var hook = o.getString("hook");
    if (!sentTheirProfile.contains(hook)) System.out.println("UNVERIFIED hook: " + hook);
    System.out.println("[" + o.getString("frame") + "] " + o.getString("text"));
  }
}

# One bare object is the contract. Survive a fence or a preamble anyway.
def first_object(text)
  t = text.strip.sub(/\A```(?:json)?/, "").sub(/```\z/, "").strip
  start = t.index("{") or raise "no JSON object in the reply"
  depth = 0
  in_str = false
  esc = false
  (start...t.length).each do |i|
    c = t[i]
    if esc         then esc = false
    elsif c == "\\" then esc = true
    elsif c == '"'  then in_str = !in_str
    elsif in_str    then next
    elsif c == "{"  then depth += 1
    elsif c == "}"
      depth -= 1
      return JSON.parse(t[start..i]) if depth.zero?
    end
  end
  raise "the object was truncated"
end

r = first_object(job["output"]["output"])

if r["route_to_help"]
  # A refusal is a successful, charged run. Show it; do not retry it.
  puts "#{r["route"]}: #{r["reason"]}"
elsif r["lane"] == "profile"
  src = payload["profile"].to_s.empty? ? payload["about_me"].to_s : payload["profile"]
  (r["lines"] + r["cut"]).each do |ln|
    puts "UNVERIFIED quote: #{ln["quote"]}" unless src.include?(ln["quote"])
  end
  puts r["rewrite"]
  puts "carried through: #{r["facts_used"].join(", ")}"
else
  src = payload["their_profile"]
  r["openers"].each do |o|
    puts "UNVERIFIED hook: #{o["hook"]}" unless src.include?(o["hook"])
    puts "[#{o["frame"]}] #{o["text"]}"
    puts "   risk: #{o["risk"]}" if o["risk"]
  end
end

<?php
// One bare object is the contract. Survive a fence or a preamble anyway.
function first_object(string $text): array {
  $t = trim(preg_replace('/^```(?:json)?|```$/', "", trim($text)));
  $start = strpos($t, "{");
  if ($start === false) throw new RuntimeException("no JSON object in the reply");
  $depth = 0; $inStr = false; $esc = false;
  for ($i = $start; $i < strlen($t); $i++) {
    $c = $t[$i];
    if ($esc)            { $esc = false; continue; }
    if ($c === "\\")     { $esc = true;  continue; }
    if ($c === '"')      { $inStr = !$inStr; continue; }
    if ($inStr)          continue;
    if ($c === "{")      $depth++;
    elseif ($c === "}" && --$depth === 0) {
      return json_decode(substr($t, $start, $i - $start + 1), true);
    }
  }
  throw new RuntimeException("the object was truncated");
}

$r = first_object($job["output"]["output"]);

if ($r["route_to_help"]) {
  // A refusal is a successful, charged run. Show it; do not retry it.
  echo $r["route"], ": ", $r["reason"], "\n";
} elseif ($r["lane"] === "profile") {
  $src = $payload["profile"] !== "" ? $payload["profile"] : $payload["about_me"];
  foreach (array_merge($r["lines"], $r["cut"]) as $ln) {
    if (!str_contains($src, $ln["quote"])) echo "UNVERIFIED quote: ", $ln["quote"], "\n";
  }
  echo $r["rewrite"], "\n";
} else {
  foreach ($r["openers"] as $o) {
    if (!str_contains($payload["their_profile"], $o["hook"])) {
      echo "UNVERIFIED hook: ", $o["hook"], "\n";
    }
    echo "[", $o["frame"], "] ", $o["text"], "\n";
  }
}

// One bare object is the contract. Survive a fence or a preamble anyway.
static (string, bool) FirstObject(string text) {
    var t = text.Trim();
    if (t.StartsWith("```json")) t = t[7..];
    else if (t.StartsWith("```")) t = t[3..];
    if (t.EndsWith("```")) t = t[..^3];
    t = t.Trim();

    var start = t.IndexOf('{');
    if (start < 0) throw new Exception("no JSON object in the reply");
    int depth = 0; bool inStr = false, esc = false;
    for (var i = start; i < t.Length; i++) {
        var c = t[i];
        if (esc)       { esc = false; continue; }
        if (c == '\\') { esc = true;  continue; }
        if (c == '"')  { inStr = !inStr; continue; }
        if (inStr)     continue;
        if (c == '{')  depth++;
        else if (c == '}' && --depth == 0) return (t[start..(i + 1)], true);
    }
    return (t[start..], false);
}

var (text, _) = FirstObject(jobOutput);
var r = JsonDocument.Parse(text).RootElement;

if (r.GetProperty("route_to_help").GetBoolean()) {
    // A refusal is a successful, charged run. Show it; do not retry it.
    Console.WriteLine($"{r.GetProperty("route").GetString()}: {r.GetProperty("reason").GetString()}");
} else if (r.GetProperty("lane").GetString() == "profile") {
    foreach (var ln in r.GetProperty("lines").EnumerateArray()) {
        var quote = ln.GetProperty("quote").GetString()!;
        if (!sentProfile.Contains(quote)) Console.WriteLine($"UNVERIFIED quote: {quote}");
    }
    Console.WriteLine(r.GetProperty("rewrite").GetString());
} else {
    foreach (var o in r.GetProperty("openers").EnumerateArray()) {
        var hook = o.GetProperty("hook").GetString()!;
        if (!sentTheirProfile.Contains(hook)) Console.WriteLine($"UNVERIFIED hook: {hook}");
        Console.WriteLine($"[{o.GetProperty("frame").GetString()}] {o.GetProperty("text").GetString()}");
    }
}