Persist and stream

import { Agent, type AgentState } from "stateweave";

type SessionRow = { revision: number; state?: AgentState };
const current: SessionRow | undefined = await store.load(sessionId);
const agent = new Agent({ model, tools, state: current?.state });

const result = await agent.run(input, { signal: request.signal });
await store.compareAndSet(sessionId, current?.revision ?? 0, {
  revision: (current?.revision ?? 0) + 1,
  state: result.state
});

return result.finalAnswer;

for await (const event of agent.streamEvents(input, { signal })) {
  if (event.type === "metadata") console.log(event.metadata.runId);
  if (event.type === "model_token") process.stdout.write(event.token);
  if (event.type === "model_metadata") console.log(event.metadata);
  if (event.type === "progress") {
    console.log(event.progress.phase, event.progress.detail);
    if (event.progress.graph) renderGraph(event.progress.graph);
  }
  if (event.type === "final") {
    await store.save(event.result.state);
    renderAnswer(event.result.finalAnswer);
  }
}

for await (const answer of agent.stream(input)) {
  console.log(answer);
}

const state = agent.getState(); // lossless persistence
const graph = agent.getGraph(); // bounded-text visualization view

import { graphToMermaid } from "stateweave";
console.log(graphToMermaid(agent.getGraph()));

import { AgentRunError } from "stateweave";

try {
  await agent.run(input, { signal });
} catch (error) {
  if (error instanceof AgentRunError) {
    audit.write({ trace: error.trace, metrics: error.metrics });
    // agent.getState() still returns the last successful commit
  }
  throw error;
}

const agent = new Agent({ model, tools, traceDir: ".stateweave/traces" });