Turn documents into structured JSON

import base64, json, os, time, urllib.request

API, TOKEN = os.environ["GOBARE_API"], os.environ["GOBARE_TOKEN"]
PATH = "invoice-8842.pdf"                     # your file, on your disk

def call(method, path, body=None):
    req = urllib.request.Request(
        API + path,
        data=json.dumps(body).encode() if body is not None else None,
        headers={"Authorization": "Bearer " + TOKEN, "content-type": "application/json"},
        method=method,
    )
    return json.load(urllib.request.urlopen(req))

# 1. Create a session with the file already inside it. The bytes are base64;
#    `path` is relative to /workspace.
session = call("POST", "/v1/sessions", {
    "agent": {
        "model": "MiniMax-M3",
        "instructions": "Extract invoice fields exactly as written. "
                        "Never infer a missing value — use null.",
        "text": {"format": {"type": "json_schema", "schema": {
            "type": "object",
            "properties": {
                "invoice_number": {"type": "string"},
                "total":          {"type": "number"},
                "currency":       {"type": "string"},
                "issued_on":      {"type": ["string", "null"]},
            },
            "required": ["invoice_number", "total", "currency"],
            "additionalProperties": False,
        }}},
    },
    "environment": {"files": [{
        "type": "inline",
        "path": "invoices/" + os.path.basename(PATH),
        "data": base64.b64encode(open(PATH, "rb").read()).decode(),
    }]},
    "metadata": {"source": os.path.basename(PATH)},
    "input": f"Extract the fields from invoices/{os.path.basename(PATH)} and "
             f"write them to /workspace/outputs/result.json.",
})
sid = session["id"]
print("session", sid)

# 2. Wait for the artifacts, not for the turn. See "Why two waits" below.
while True:
    turns = call("GET", f"/v1/sessions/{sid}/turns?limit=1")["data"]
    if turns and turns[0]["artifacts"] in ("ready", "partial", "failed"):
        break
    time.sleep(5)

# 3. Collect and validate. The schema above is a request, not a guarantee —
#    this step is where your guarantee comes from.
for art in call("GET", f"/v1/sessions/{sid}/artifacts")["data"]:
    raw = urllib.request.urlopen(urllib.request.Request(
        f"{API}/v1/sessions/{sid}/artifacts/{art['id']}/content",
        headers={"Authorization": "Bearer " + TOKEN})).read()
    row = json.loads(raw)
    assert isinstance(row["total"], (int, float)), f"total is not a number: {row['total']!r}"
    print(json.dumps(row, indent=2))

import { readFile } from "node:fs/promises";
import { basename } from "node:path";

const { GOBARE_API: API, GOBARE_TOKEN: TOKEN } = process.env as Record<string, string>;
const PATH = "invoice-8842.pdf";              // your file, on your disk

async function call(method: string, path: string, body?: unknown) {
  const response = await fetch(API + path, {
    method,
    headers: { Authorization: `Bearer ${TOKEN}`, "content-type": "application/json" },
    body: body === undefined ? undefined : JSON.stringify(body),
  });
  if (!response.ok) throw new Error(`${method} ${path} → ${response.status} ${await response.text()}`);
  return response.json();
}

// 1. Create a session with the file already inside it. The bytes are base64;
//    `path` is relative to /workspace.
const session = await call("POST", "/v1/sessions", {
  agent: {
    model: "MiniMax-M3",
    instructions: "Extract invoice fields exactly as written. Never infer a missing value — use null.",
    text: { format: { type: "json_schema", schema: {
      type: "object",
      properties: {
        invoice_number: { type: "string" },
        total:          { type: "number" },
        currency:       { type: "string" },
        issued_on:      { type: ["string", "null"] },
      },
      required: ["invoice_number", "total", "currency"],
      additionalProperties: false,
    } } },
  },
  environment: { files: [{
    type: "inline",
    path: `invoices/${basename(PATH)}`,
    data: (await readFile(PATH)).toString("base64"),
  }] },
  metadata: { source: basename(PATH) },
  input: `Extract the fields from invoices/${basename(PATH)} and write them to /workspace/outputs/result.json.`,
});
console.log("session", session.id);

// 2. Wait for the artifacts, not for the turn. See "Why two waits" below.
for (;;) {
  const { data: turns } = await call("GET", `/v1/sessions/${session.id}/turns?limit=1`);
  if (turns[0] && ["ready", "partial", "failed"].includes(turns[0].artifacts)) break;
  await new Promise((resolve) => setTimeout(resolve, 5000));
}

// 3. Collect and validate. The schema above is a request, not a guarantee —
//    this step is where your guarantee comes from.
const { data: artifacts } = await call("GET", `/v1/sessions/${session.id}/artifacts`);
for (const artifact of artifacts) {
  const bytes = await fetch(`${API}/v1/sessions/${session.id}/artifacts/${artifact.id}/content`, {
    headers: { Authorization: `Bearer ${TOKEN}` },
  });
  const row = await bytes.json();
  if (typeof row.total !== "number") throw new Error(`total is not a number: ${JSON.stringify(row.total)}`);
  console.log(JSON.stringify(row, null, 2));
}