JSPM

import { StateGraph, START, END, lastValue, appendList } from "@oni.bot/core";

type State = { query: string; answer: string; log: string[] };

const graph = new StateGraph<State>({
  channels: {
    query:  lastValue(() => ""),
    answer: lastValue(() => ""),
    log:    appendList(() => []),
  },
});

graph.addNode("think", async (state) => {
  return { answer: `Processed: ${state.query}`, log: ["think ran"] };
});

graph.addEdge(START, "think");
graph.addEdge("think", END);

const app = graph.compile();
const result = await app.invoke({ query: "What is ONI?" });
console.log(result.answer); // "Processed: What is ONI?"

import { SwarmGraph } from "@oni.bot/core/swarm";
import { defineAgent } from "@oni.bot/core/agents";
import { anthropic } from "@oni.bot/core/models";

const researcher = defineAgent({
  name: "researcher",
  model: anthropic("claude-sonnet-4-6"),
  systemPrompt: "You research topics thoroughly.",
  tools: [webSearch],
});

const writer = defineAgent({
  name: "writer",
  model: anthropic("claude-sonnet-4-6"),
  systemPrompt: "You write compelling content from research notes.",
});

const swarm = SwarmGraph.hierarchical({
  supervisor: { model: anthropic("claude-sonnet-4-6"), strategy: "llm", maxRounds: 10 },
  agents: [researcher, writer],
});

const app = swarm.compile();
const result = await app.invoke({ task: "Write a technical brief on quantum error correction" });

import { StateGraph, START, END } from "@oni.bot/core";             // Core engine
import { createReactAgent }       from "@oni.bot/core/prebuilt";     // Prebuilt agents
import { SwarmGraph }             from "@oni.bot/core/swarm";        // Swarm templates
import { interrupt }              from "@oni.bot/core/hitl";         // Human-in-the-loop
import { InMemoryStore }          from "@oni.bot/core/store";        // Cross-thread store
import { messagesChannel }        from "@oni.bot/core/messages";     // Message handling
import { SqliteCheckpointer }     from "@oni.bot/core/checkpointers";// Persistence
import { entrypoint, task }       from "@oni.bot/core/functional";   // Functional API
import { buildGraphDescriptor }   from "@oni.bot/core/inspect";      // Graph inspection
import { emitToken }              from "@oni.bot/core/streaming";    // Token streaming
import { anthropic, openai }      from "@oni.bot/core/models";       // LLM adapters
import { defineAgent }            from "@oni.bot/core/agents";       // Agent builder
import { RequestReplyBroker }     from "@oni.bot/core/coordination"; // Agent messaging
import { BudgetTracker }          from "@oni.bot/core/guardrails";   // Safety controls
import { defineTool }             from "@oni.bot/core/tools";        // Tool definitions
import { mockModel }              from "@oni.bot/core/testing";      // Test utilities

const app = graph.compile({
  circuitBreaker: { threshold: 5, resetAfter: 30_000 },
});

graph.addNode("llm_call", handler, { timeout: 10_000 }); // 10s deadline

graph.addNode("flaky_api", handler, {
  retry: { maxAttempts: 3, backoff: "exponential", initialDelay: 1000 },
});

const dlq = new DeadLetterQueue();
const app = graph.compile({ dlq });

// Later: inspect failures
const failures = dlq.list();

import { ONITracer } from "@oni.bot/core";
import { trace } from "@opentelemetry/api";

const tracer = new ONITracer(trace.getTracer("my-app"));
const app = graph.compile({ tracer });

import { SqliteCheckpointer } from "@oni.bot/core/checkpointers";

const checkpointer = new SqliteCheckpointer("./state.db");
const app = graph.compile({ checkpointer });

// Resume from any point
const history = await app.getHistory("thread-1");
const forked = await app.forkFrom("thread-1", history[2].checkpoint);

import { interrupt, getUserApproval } from "@oni.bot/core/hitl";

graph.addNode("review", async (state) => {
  const approved = await getUserApproval("Publish this draft?", {
    payload: state.draft,
  });
  if (!approved) return { status: "rejected" };
  return { status: "published" };
});

// Single mode
for await (const event of app.stream(input, { streamMode: "updates" })) {
  console.log(event.node, event.data);
}

// Multiple modes simultaneously
for await (const event of app.stream(input, { streamMode: ["values", "messages"] })) {
  if (event.mode === "messages") {
    process.stdout.write(event.data.chunk); // Token-by-token LLM output
  }
}

// Custom events from inside a node
import { getStreamWriter } from "@oni.bot/core";

graph.addNode("agent", async (state) => {
  const writer = getStreamWriter();
  writer.emit("progress", { step: 1, message: "Searching..." });
  // ...
});

import { entrypoint, task } from "@oni.bot/core/functional";
import { lastValue } from "@oni.bot/core";

const summarize = task("summarize", async (text: string) => {
  return await llm.chat({ messages: [{ role: "user", content: `Summarize: ${text}` }] });
});

const app = entrypoint(
  { channels: { query: lastValue(() => ""), answer: lastValue(() => "") } },
  async (state) => ({ answer: await summarize(state.query) }),
);

const result = await app.invoke({ query: "Explain quantum computing" });

import { mockModel, assertGraph, createTestHarness } from "@oni.bot/core/testing";

// Deterministic model responses
const model = mockModel([
  { role: "assistant", content: "Hello!" },
  { role: "assistant", content: "Goodbye!", toolCalls: [{ id: "1", name: "search", args: {} }] },
]);

// Structural graph assertions
assertGraph(graph, {
  hasNode: ["agent", "tools"],
  hasEdge: [["__start__", "agent"]],
  nodeCount: 2,
});

// Pre-wired test harness
const harness = createTestHarness(graph);
const result = await harness.invoke({ query: "test" });
const events = await harness.collectStream({ query: "test" }, "updates");