Upload a lab report

1. Client uploads file via multipart  →  200 { ok, upload_id, storage_key, terra_status, note }
2. File lands in R2 immediately.
3. Terra OCR runs in background (~30s).
4. Webhook `lab_report` arrives.
5. Backend writes biomarkers; the upload's terra_status advances.
6. Biomarkers surface in the next amy.data.sync() payload.

curl -X POST "$AMY_BASE_URL/v1/labs/upload" \
  -H "Authorization: Bearer $AMY_API_KEY" \
  -F "[email protected];type=application/pdf"

{
  "ok": true,
  "upload_id": "lab_01HX2K3M4N5P6Q7R8S9T0V1W2X",
  "storage_key": "labs/user_…/lab_01HX2K3M4N5P6Q7R8S9T0V1W2X.pdf",
  "terra_status": "submitted",
  "note": "Parsing runs asynchronously; biomarkers appear in your next data sync."
}

import { Amy } from "@amy/sdk";
import { readFile } from "node:fs/promises";

const amy = new Amy({
  apiKey: process.env.AMY_API_KEY!,
  baseUrl: process.env.AMY_BASE_URL!,
});

const bytes = await readFile("./panel.pdf");
const blob = new Blob([bytes], { type: "application/pdf" });

const lab = await amy.labs.upload({
  file: blob,
  filename: "panel.pdf",
});

console.log(lab.upload_id, lab.terra_status); // lab_01HX…  submitted

<input type="file" id="lab" accept="application/pdf,image/*" />

import { Amy } from "@amy/sdk";

const amy = new Amy({ apiKey, baseUrl });

document.getElementById("lab")!.addEventListener("change", async (e) => {
  const file = (e.target as HTMLInputElement).files?.[0];
  if (!file) return;

  if (file.size > 10 * 1024 * 1024) {
    alert("File too large. Max 10 MB.");
    return;
  }

  const lab = await amy.labs.upload({ file });
  pollUntilParsed(lab.upload_id);
});

const fd = new FormData();
fd.append("file", file);

const res = await fetch(`${baseUrl}/v1/labs/upload`, {
  method: "POST",
  headers: { Authorization: `Bearer ${apiKey}` }, // do NOT set Content-Type — let fetch set the boundary
  body: fd,
});
const lab = await res.json(); // { ok, upload_id, storage_key, terra_status, note }

import * as DocumentPicker from "expo-document-picker";
import { Amy } from "@amy/sdk";

const amy = new Amy({ apiKey, baseUrl });

async function pickAndUpload() {
  const result = await DocumentPicker.getDocumentAsync({
    type: ["application/pdf", "image/jpeg", "image/png"],
    copyToCacheDirectory: true,
  });

  if (result.canceled) return;

  // SDK accepts the picker asset directly — it knows how to read uri/name/mimeType.
  const lab = await amy.labs.upload({ file: result.assets[0] });
  pollUntilParsed(lab.upload_id);
}

const fd = new FormData();
fd.append("file", {
  uri: result.assets[0].uri,
  name: result.assets[0].name,
  type: result.assets[0].mimeType,
} as any);

await fetch(`${baseUrl}/v1/labs/upload`, {
  method: "POST",
  headers: { Authorization: `Bearer ${apiKey}` },
  body: fd,
});

UPLOAD_ID="lab_01HX…"
while true; do
  RES=$(curl -s -H "Authorization: Bearer $AMY_API_KEY" \
    "$AMY_BASE_URL/v1/labs")
  STATUS=$(echo "$RES" | jq -r --arg id "$UPLOAD_ID" \
    '.uploads[] | select(.id == $id) | .terra_status')
  echo "terra_status: $STATUS"
  [ "$STATUS" = "parsed" ] && break
  case "$STATUS" in failed*) echo "parse failed"; break;; esac
  sleep 3
done

# Biomarkers land in the data-sync payload, not the labs list.
curl -s -H "Authorization: Bearer $AMY_API_KEY" \
  "$AMY_BASE_URL/v1/data/sync" | jq .biomarkers

// `amy.labs.retrieve(id)` is Planned — until it ships, poll the list
// endpoint and find the row by id. (Or call /v1/labs/:id directly when
// it lands; the SDK will add the helper.)
async function pollUntilParsed(amy: Amy, id: string, timeoutMs = 120_000) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const { uploads } = await amy.labs.list();
    const lab = uploads.find((l) => l.id === id);
    if (lab?.terra_status === "parsed") {
      // Biomarkers arrive via `amy.data.sync()` — pull the latest delta.
      const delta = await amy.data.sync();
      return { lab, biomarkers: delta.biomarkers };
    }
    if (lab?.terra_status?.startsWith("failed")) {
      throw new Error(`lab parse failed: ${lab.terra_status}`);
    }
    await new Promise((r) => setTimeout(r, 3_000));
  }
  throw new Error(`lab ${id} still processing after ${timeoutMs}ms`);
}

{
  "biomarkers": [
    {
      "name": "ldl_cholesterol",
      "value": 124,
      "unit": "mg/dL",
      "reference_range": "<100",
      "out_of_range": true
    },
    {
      "name": "hba1c",
      "value": 5.4,
      "unit": "%",
      "reference_range": "4.0-5.6",
      "out_of_range": false
    }
  ]
}

const { biomarkers } = await amy.data.sync();
const concerning = biomarkers.filter((b) => b.out_of_range);
for (const b of concerning) {
  console.log(`⚠ ${b.name}: ${b.value} ${b.unit} (ref: ${b.reference_range})`);
}

// one entry from GET /v1/labs → uploads[]
{
  "id": "lab_01HX…",
  "terra_status": "failed_ocr",
  "uploaded_at": "2026-05-25T10:00:00Z"
}

const lab = await pollUntilParsed(amy, id).catch((err) => {
  showError(`Lab parse failed: ${err.message}`);
  showRetryButton();
  return null;
});

if (file.size > 10 * 1024 * 1024) {
  alert(`File is ${(file.size / 1024 / 1024).toFixed(1)} MB. Max is 10 MB.`);
  return;
}