MEMORYSHAPESEVERYTHING.

const baseUrl = process.env.ANTIDOTE_URL ?? "http://localhost:3000";
const apiKey = process.env.ANTIDOTE_API_KEY;

async function antidote<T>(path: string, body: unknown): Promise<T> {
  const response = await fetch(`${baseUrl}${path}`, {
    method: "POST",
    headers: {
      "content-type": "application/json",
      ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}),
    },
    body: JSON.stringify(body),
  });

  if (!response.ok) {
    throw new Error(`ANTIDOTE request failed: ${response.status}`);
  }

  return response.json() as Promise<T>;
}

const ingested = await antidote<{
  memories: Array<{ id: string }>;
}>("/api/ingest", {
  sourceUri: "urn:agent:policy:payments-v3",
  content: "Payments above $10,000 need two approvers.",
  actor: "policy-sync",
  idempotencyKey: "payments-policy-v3",
});

const recalled = await antidote<{
  results: Array<{ memory: { id: string }; eventId: string }>;
}>("/api/retrieve", {
  agentId: "finance-agent-07",
  query: "What approval is required for a $24,000 payment?",
  k: 5,
  context: { runId: "run-2026-08-12-001" },
});

const memoryIds = recalled.results.map((result) => result.memory.id);
if (memoryIds.length === 0) throw new Error("No trusted memory returned");

const decision = await antidote<{ id: string }>("/api/decisions", {
  agentId: "finance-agent-07",
  memoryIds,
  summary: "Request a second approver before payment",
  idempotencyKey: "decision-payment-24000-v1",
});

const action = await antidote<{ id: string; status: string }>(
  `/api/decisions/${decision.id}/actions`,
  {
    actionType: "approval.requested",
    payload: { amount: 24000, currency: "USD" },
    summary: "Second approval requested",
    externalRef: "approval-queue/REQ-184",
    idempotencyKey: "action-payment-24000-v1",
  },
);

console.log({ ingested: ingested.memories.length, decision, action });