Stream the agent's progress into your UI

import json, os, threading, urllib.request

API, TOKEN = os.environ["GOBARE_API"], os.environ["GOBARE_TOKEN"]
AUTH = {"Authorization": "Bearer " + TOKEN, "content-type": "application/json"}

def post(path, body):
    return json.load(urllib.request.urlopen(
        urllib.request.Request(API + path, data=json.dumps(body).encode(),
                               headers=AUTH, method="POST")))

def stream(session_id, on_frame, last_event_id=None, until="turn.ended"):
    """Read events until `until` arrives. Returns the cursor to resume from."""
    url = f"{API}/v1/sessions/{session_id}/events"
    if last_event_id is not None:
        url += f"?last_event_id={last_event_id}"
    cursor, event_id = last_event_id, None
    with urllib.request.urlopen(urllib.request.Request(url, headers=AUTH)) as r:
        for raw in r:
            line = raw.decode().rstrip("\n")
            if line.startswith("id: "):
                event_id = int(line[4:])       # durable: replayable on reconnect
            elif line.startswith("data: "):
                frame = json.loads(line[6:])
                on_frame(frame, event_id)
                if event_id is not None:
                    cursor = event_id          # only durable ids are resumable
                event_id = None
                if frame["type"] == until:
                    return cursor
    return cursor

def render(frame, event_id):
    kind, p = frame["type"], frame.get("payload") or {}
    at = "·" if event_id is None else str(event_id)   # · means transient
    if kind == "agent.text":         print(p.get("delta", ""), end="", flush=True)
    elif kind == "agent.message":    print(f"\n[{at}] ─ settled")
    elif kind == "agent.tool_call":  print(f"\n[{at}] $ {p.get('toolName')}")
    elif kind == "file.changed":     print(f"[{at}] ~ {p.get('path')}")
    elif kind == "artifact.created": print(f"[{at}] + {p.get('path')} ({p.get('size_bytes')} bytes)")
    elif kind == "preview.ready":    print(f"[{at}] ▶ {p.get('url')}")
    else:                            print(f"[{at}] {kind}")

sid = post("/v1/sessions", {"agent": {"model": "MiniMax-M3"}})["id"]

# Subscribe FIRST, then send. The other order loses the opening frames.
result = {}
reader = threading.Thread(
    target=lambda: result.update(cursor=stream(sid, render)), daemon=True)
reader.start()

post(f"/v1/sessions/{sid}/events", {"events": [{
    "type": "input.message",
    "content": "Write /workspace/app.py, a minimal HTTP service returning "
               "{\"ok\":true}. Run it once to prove it answers and write the "
               "output to /workspace/outputs/proof.txt.",
}]})
reader.join(timeout=300)
print("\n\nresume from:", result.get("cursor"))

const { GOBARE_API: API, GOBARE_TOKEN: TOKEN } = process.env as Record<string, string>;
const AUTH = { Authorization: `Bearer ${TOKEN}`, "content-type": "application/json" };

async function post(path: string, body: unknown) {
  const response = await fetch(API + path, { method: "POST", headers: AUTH, body: JSON.stringify(body) });
  if (!response.ok) throw new Error(`POST ${path} → ${response.status} ${await response.text()}`);
  return response.json();
}

/** Read events until `until` arrives. Returns the cursor to resume from. */
async function stream(
  sessionId: string,
  onFrame: (frame: any, eventId: number | null) => void,
  { lastEventId = null as number | null, until = "turn.ended" } = {},
) {
  let url = `${API}/v1/sessions/${sessionId}/events`;
  if (lastEventId !== null) url += `?last_event_id=${lastEventId}`;
  const response = await fetch(url, { headers: { Authorization: `Bearer ${TOKEN}` } });

  let cursor = lastEventId;
  let eventId: number | null = null;
  let buffer = "";
  const reader = response.body!.getReader();
  const decoder = new TextDecoder();

  for (;;) {
    const { done, value } = await reader.read();
    if (done) return cursor;
    buffer += decoder.decode(value, { stream: true });
    // A frame ends at a blank line; chunk boundaries fall anywhere, so the
    // remainder is kept rather than parsed.
    let split: number;
    while ((split = buffer.indexOf("\n\n")) !== -1) {
      const block = buffer.slice(0, split);
      buffer = buffer.slice(split + 2);
      for (const line of block.split("\n")) {
        if (line.startsWith("id: ")) eventId = Number(line.slice(4));  // durable
        else if (line.startsWith("data: ")) {
          const frame = JSON.parse(line.slice(6));
          onFrame(frame, eventId);
          if (eventId !== null) cursor = eventId;                      // only durable ids resume
          eventId = null;
          if (frame.type === until) {
            await reader.cancel();
            return cursor;
          }
        }
      }
    }
  }
}

function render(frame: any, eventId: number | null) {
  const p = frame.payload ?? {};
  const at = eventId === null ? "·" : String(eventId);   // · means transient
  if (frame.type === "agent.text") process.stdout.write(p.delta ?? "");
  else if (frame.type === "agent.message") console.log(`\n[${at}] ─ settled`);
  else if (frame.type === "agent.tool_call") console.log(`\n[${at}] $ ${p.toolName}`);
  else if (frame.type === "file.changed") console.log(`[${at}] ~ ${p.path}`);
  else if (frame.type === "artifact.created") console.log(`[${at}] + ${p.path} (${p.size_bytes} bytes)`);
  else if (frame.type === "preview.ready") console.log(`[${at}] ▶ ${p.url}`);
  else console.log(`[${at}] ${frame.type}`);
}

const session = await post("/v1/sessions", { agent: { model: "MiniMax-M3" } });

// Subscribe FIRST, then send. The other order loses the opening frames.
const watching = stream(session.id, render);

await post(`/v1/sessions/${session.id}/events`, {
  events: [{
    type: "input.message",
    content: 'Write /workspace/app.py, a minimal HTTP service returning {"ok":true}. ' +
             "Run it once to prove it answers and write the output to /workspace/outputs/proof.txt.",
  }],
});

console.log("\n\nresume from:", await watching);