TypeScript

# From the repo root
git clone https://github.com/yatendra2001/amy_health_assistant.git
cd amy_health_assistant
bun install

# Scaffold your new client under apps/ (example: an Expo app)
bun create expo@latest apps/mobile --template default

# Add to apps/mobile/package.json:
#   "dependencies": {
#     "@amy/sdk":       "workspace:*",
#     "@amy/contracts": "workspace:*",
#     "zod":            "^3"
#   }
# Add "apps/*" to the root package.json `workspaces` array.

bun install

import { Amy } from "@amy/sdk";
import { useAuth } from "@clerk/expo"; // web: "@clerk/react"

const { getToken } = useAuth();

const amy = new Amy({
  apiKeyProvider: () => getToken(),
  baseUrl: "https://amy.heyamy.xyz",
});

const amy = new Amy({
  apiKey: process.env.AMY_API_KEY!, // 30-day Amy JWT from `amy whoami --print-key`
  baseUrl: process.env.AMY_BASE_URL ?? "https://amy.heyamy.xyz",
});

// Rotate later (e.g. after a Clerk refresh in long-running processes):
amy.setApiKey(newToken);

new Amy({
  apiKey,                  // or apiKeyProvider — exactly one
  baseUrl,                 // default: https://amy.heyamy.xyz
  timeout: 60_000,         // ms per non-stream request
  maxRetries: 2,           // 429 / 5xx / network failures, exp. backoff
  fetch: globalThis.fetch, // override (Workers, Undici, polyfilled fetch)
  headers: { "x-myapp": "v1" },
  userAgent: "myapp/1.0",
});

const me = await amy.me.get();
// → { user_id, email, connections: TerraConnection[], env }

const { data } = await amy.sources.list();
// → [{ id: "src_…", provider: "whoop", connected_at, last_sync_at, status }]

const { widget_url } = await amy.sources.terra.connect({
  provider: "WHOOP",                            // optional, defaults to "WHOOP"
  redirect_url: "https://your-app/callback",    // optional
});
// Open widget_url in a browser; Terra runs the OAuth dance and
// emits webhooks back to the Worker.

await amy.sources.disconnect("src_…");          // 204, no return

// Upload a PDF, PNG, or JPEG (≤10MB).
const r = await amy.labs.upload({ file: blobOrFile, filename: "panel.pdf" });
// → { ok, upload_id, storage_key, terra_status, note }

const { uploads } = await amy.labs.list();
// → [{ id, uploaded_at, terra_status, parsed_at }]

// Delta sync — pass the previous response's `now` as the next `since`
// for a clean incremental loop.
const a = await amy.data.sync();
const b = await amy.data.sync({ since: a.now });
// → { user_id, since, now, daily_summary, activities,
//     sleep_sessions, biomarkers, counts }

const turn = await amy.turns.create({
  messages: [{ role: "user", content: "How's my recovery this week?" }],
});
// → { id: "turn_…", status: "queued", created_at, stream_url }

// Poll for the final result.
const t = await amy.turns.retrieve(turn.id);
if (t.status === "completed") console.log(t.result?.answer);

// Or list, with cursor pagination.
const page = await amy.turns.list({ limit: 20, status: "completed" });
// → { data: TurnSummary[], next_cursor, has_more }

for await (const ev of amy.turns.stream(turn.id)) {
  if (ev.type === "phase") {
    // Real-time progress: "Data Science Agent | executing python (17 lines)"
    console.log(`${ev.data.agent} → ${ev.data.phase}`);
  }
  if (ev.type === "synthesis_delta") {
    // Token-level streaming of the final answer text.
    process.stdout.write(ev.data.text);
  }
  if (ev.type === "turn.completed") {
    console.log("\n→", ev.data.result.answer);
  }
}

for await (const ev of amy.turns.stream(turn.id, { lastEventId: 42 })) {
  // server replays events with id > 42 (1-hour buffer after completion)
}

const ac = new AbortController();
setTimeout(() => ac.abort(), 10_000);
for await (const ev of amy.turns.stream(turn.id, { signal: ac.signal })) {
  // throws AmyApiError({ code: "aborted" }) when ac.abort() fires
}

const { url, headers } = amy.turns.eventSourceInit(turn.id);
// → { url: "https://amy.heyamy.xyz/v1/turns/.../events",
//     headers: { Authorization: "Bearer ...", Accept: "text/event-stream" } }

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

try {
  await amy.turns.retrieve("turn_does_not_exist");
} catch (e) {
  if (e instanceof AmyApiError) {
    e.code         // "turn_not_found" | "invalid_token" | ... | "network_error" | "timeout"
    e.status       // 404 (or 0 for transport failures)
    e.message      // human-readable
    e.requestId    // "req_…" — paste into a bug report
    e.docsUrl      // "https://docs.heyamy.xyz/docs/concepts/errors#turn_not_found"
    e.details      // server-supplied structured detail, if any
    e.isRetryable()// true for 429 / 5xx / network / timeout
  }
}

const turn = await amy.turns.create(
  { messages: [...] },
  { idempotencyKey: "user-action-abc-123" },
);

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

for await (const ev of amy.turns.stream(turn.id)) { /* … */ }

const res = await DocumentPicker.getDocumentAsync({ type: "application/pdf" });
const file = await fetch(res.assets[0].uri).then((r) => r.blob());
await amy.labs.upload({ file, filename: res.assets[0].name });