Give your agent framework a computer

import { randomUUID } from "node:crypto";

const API = process.env.GOBARE_API ?? "https://api.gobare.dev";
const headers = { authorization: `Bearer ${process.env.GOBARE_TOKEN}`, "content-type": "application/json" };

async function call(method: string, path: string, body?: unknown): Promise<any> {
  // One key per logical call, reused across its retries, so a retried POST cannot act twice.
  const key: Record<string, string> = method === "POST" ? { "idempotency-key": randomUUID() } : {};
  for (let attempt = 1; ; attempt++) {
    const res = await fetch(`${API}${path}`, { method, headers: { ...headers, ...key }, body: body === undefined ? undefined : JSON.stringify(body) }).catch(() => null);
    if (res && res.status < 500) {
      if (!res.ok) throw new Error(`${method} ${path} answered ${res.status}: ${await res.text()}`);
      return res.json();
    }
    if (attempt === 4) throw new Error(`${method} ${path}: ${res ? res.status : "network error"} after ${attempt} attempts`);
    await new Promise((r) => setTimeout(r, attempt * 2000));
  }
}

export interface SandboxResult {
  session_id: string;
  status: "completed" | "failed" | "cancelled" | "waiting";
  reply: string | null;
  question: string | null;
  files: string[];
}

const SETTLED = new Set(["completed", "failed", "cancelled"]);

export async function runInSandbox(task: string, sessionId?: string): Promise<SandboxResult> {
  let staleTurn: string | undefined;
  let answered: string | undefined;

  if (!sessionId) {
    sessionId = (await call("POST", "/v1/sessions", {
      title: task.slice(0, 80),
      agent: { instructions: "Write anything worth keeping under /workspace/outputs." },
      input: task,
    })).id as string;
  } else {
    const session = await call("GET", `/v1/sessions/${sessionId}`);
    const question = session.required_actions.find((a: any) => a.type === "question");
    if (question) {
      answered = question.call_id;
      await call("POST", `/v1/sessions/${sessionId}/events`, { events: [{ type: "input.question_answer", call_id: question.call_id, answer: task }] });
    } else {
      staleTurn = (await call("GET", `/v1/sessions/${sessionId}/turns?limit=1`)).data[0]?.id;
      await call("POST", `/v1/sessions/${sessionId}/events`, { events: [{ type: "input.message", content: [{ type: "input_text", text: task }] }] });
    }
  }

  for (;;) {
    await new Promise((resolve) => setTimeout(resolve, 2000));
    const session = await call("GET", `/v1/sessions/${sessionId}`);
    const question = session.required_actions.find((a: any) => a.type === "question" && a.call_id !== answered);
    if (question) return { session_id: sessionId, status: "waiting", reply: null, question: question.name, files: [] };

    const turn = (await call("GET", `/v1/sessions/${sessionId}/turns?limit=1`)).data[0];
    if (!turn || turn.id === staleTurn) continue;
    if (!SETTLED.has(turn.status) || turn.artifacts === "pending") continue;

    const items = await call("GET", `/v1/sessions/${sessionId}/items?limit=20`);
    const reply = items.data.find((item: any) => item.type === "message" && item.role === "assistant");
    const artifacts = await call("GET", `/v1/sessions/${sessionId}/artifacts?turn_id=${turn.id}`);
    return { session_id: sessionId, status: turn.status, reply: reply?.content ?? null, question: null, files: artifacts.data.map((a: any) => a.path) };
  }
}

import { generateText, stepCountIs, tool } from "ai";
import { z } from "zod";
import { runInSandbox } from "./sandbox.ts";

export const sandbox = tool({
  description:
    "Run a task on a real Linux computer with a shell, a filesystem, Node, Python and git. " +
    "Use it to execute code, transform files, or check facts by running things. " +
    "Pass session_id from a previous result to continue on the same computer. " +
    "If the result has status 'waiting', its question is for you: call again with your answer as the task and the same session_id.",
  inputSchema: z.object({
    task: z.string().describe("What to do, in plain language, including what to report back."),
    session_id: z.string().optional().describe("Continue on the computer a previous call used."),
  }),
  execute: async ({ task, session_id }) => runInSandbox(task, session_id),
});

export async function ask(model: Parameters<typeof generateText>[0]["model"], prompt: string) {
  return generateText({ model, prompt, tools: { sandbox }, stopWhen: stepCountIs(6) });
}

import { Agent, run, tool } from "@openai/agents";
import { z } from "zod";
import { runInSandbox } from "./sandbox.ts";

export const sandbox = tool({
  name: "sandbox",
  description:
    "Run a task on a real Linux computer with a shell, a filesystem, Node, Python and git. " +
    "Pass session_id from a previous result to continue on the same computer. " +
    "If the result has status 'waiting', its question is for you: call again with your answer as the task and the same session_id.",
  parameters: z.object({
    task: z.string(),
    session_id: z.string().nullable(),
  }),
  execute: async ({ task, session_id }) => JSON.stringify(await runInSandbox(task, session_id ?? undefined)),
});

export const analyst = new Agent({
  name: "analyst",
  instructions: "When a question needs computation or real data processing, use the sandbox tool rather than estimating.",
  tools: [sandbox],
});

export async function ask(prompt: string) {
  return (await run(analyst, prompt)).finalOutput;
}

curl -s -X DELETE $GOBARE_API/v1/sessions/$SESSION_ID -H "Authorization: Bearer $GOBARE_TOKEN"