Fork an agent with its data

import { createNeonClient } from "@neon/sdk";

const neon = createNeonClient({
  apiKey: process.env.NEON_API_KEY,
  orgId: process.env.NEON_ORG_ID, // needed with a personal key; an organization key implies it
  throwOnError: true,
});

// Creates the project, waits for its compute, and returns a pooled connection string.
const { project, connectionString } = await neon.projects.createAndConnect({ name: "inventory agent" });
const main = await neon.branches.getDefault({ projectId: project.id });

const agent = await (await fetch("https://api.agent37.com/v1/instances", {
  method: "POST",
  headers: { Authorization: `Bearer ${process.env.AGENT37_API_KEY}`, "Content-Type": "application/json" },
  body: JSON.stringify({
    template: "agent37-hermes",
    name: "inventory agent",
    budget: { credit_micros: 1000000 },
    env: { DATABASE_URL: connectionString },
    metadata: { role: "agent", neon_project_id: project.id, neon_branch_id: main.id },
  }),
})).json();

const A37 = "https://api.agent37.com/v1";
const a37Headers = { Authorization: `Bearer ${process.env.AGENT37_API_KEY}`, "Content-Type": "application/json" };

const [branch, fork] = await Promise.all([
  // A copy-on-write copy of the data, with its own read-write compute. createAndConnect
  // waits until the compute is ready and returns its pooled connection string.
  neon.branches.createAndConnect({ projectId: project.id, parentId: main.id, name: "attempt-1" }),
  // A copy of the disk: same image and files, its own id, URLs, budget, and meter.
  fetch(`${A37}/instances/${agent.id}/fork`, {
    method: "POST",
    headers: a37Headers,
    body: JSON.stringify({
      name: "inventory agent · attempt 1",
      metadata: { role: "attempt", parent: agent.id, neon_project_id: project.id },
      // Sleep at disk-only rates after an hour with no traffic on the fork's URLs,
      // so a round you walk away from stops billing compute.
      auto_sleep: true,
      idle_timeout_seconds: 3600,
    }),
  }).then((res) => res.json()),
]);

// The branch keeps the agent's role passwords, so its connection string would also
// log in to the agent's own database. Give the branch a password of its own.
const roleName = new URL(branch.connectionString).username;
await neon.postgres.roles.resetPassword(
  { projectId: project.id, branchId: branch.branch.id, roleName },
  { waitForReadiness: true }
);
const branchUri = await neon.postgres.connectionString({ projectId: project.id, branchId: branch.branch.id, pooled: true });

await fetch(`${A37}/instances/${fork.id}`, {
  method: "PATCH",
  headers: a37Headers,
  body: JSON.stringify({
    env: { DATABASE_URL: branchUri },
    metadata: { ...fork.metadata, neon_branch_id: branch.branch.id },
  }),
});
await fetch(`${A37}/instances/${fork.id}/restart`, { method: "POST", headers: a37Headers });

// A fork has its own budget and meter: grant headroom for the attempt.
await fetch(`${A37}/instances/${fork.id}/budget/top-up`, {
  method: "POST",
  headers: a37Headers,
  body: JSON.stringify({ amount_micros: 1000000, idempotency_key: `${fork.id}-attempt` }),
});

const controller = new AbortController();
const res = await fetch(`https://${fork.id}.agent37.app/v1/responses`, {
  method: "POST",
  headers: { "X-Agent37-Key": process.env.AGENT37_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({ input: task, stream: true }),
  signal: controller.signal,
});
let buffer = "";
for await (const chunk of res.body) {
  buffer += new TextDecoder().decode(chunk);
  const created = buffer.match(/event: response\.created\ndata: (.+)\n/);
  if (created) {
    sessionId = JSON.parse(created[1]).session_id;
    break;
  }
}
controller.abort();

import { neon as sqlClient } from "@neondatabase/serverless";

async function check(branchId, text) {
  // The database and role are picked automatically when the branch has exactly one.
  const uri = await neon.postgres.connectionString({ projectId: project.id, branchId, pooled: true });
  const sql = sqlClient(uri);
  const [rows] = await sql.transaction([sql.query(text)], { readOnly: true });
  return rows;
}

// check(main.id,   "select count(*), count(distinct category) from products")  -> 30, 29
// check(attempt1,  ...)                                                         -> 22, 17
// check(attempt3,  ...)                                                         -> 22, 13

for (const loser of losers) {
  await fetch(`${A37}/instances/${loser.id}`, { method: "DELETE", headers: a37Headers });
  await neon.branches.delete({ projectId: project.id, branchId: loser.metadata.neon_branch_id });
}
await fetch(`${A37}/instances/${agent.id}`, { method: "DELETE", headers: a37Headers });
await neon.branches.setDefault({ projectId: project.id, branchId: winner.metadata.neon_branch_id });