Complete agent

import { z } from "zod";
import {
  Agent,
  AnthropicModel,
  AgentRunError,
  type AgentProgress,
  type AgentState,
  type Tool
} from "stateweave";

const statusArgs = z.object({ service: z.string().min(1).max(80) });

const statusStore = new Map([
  ["api", { ok: true, service: "api", status: "operational", version: "2026.07" }]
]);

const lookupService: Tool = {
  name: "lookup_service",
  description: "Return the current status of one known service.",
  schema: statusArgs,
  async execute(raw) {
    const { service } = statusArgs.parse(raw);
    return statusStore.get(service) ?? { ok: false, service, error: "unknown_service" };
  }
};

const model = new AnthropicModel({
  apiKey: process.env.ANTHROPIC_API_KEY!,
  model: process.env.ANTHROPIC_MODEL!,
  maxTokens: 4096,
  temperature: 0
});

type Session = { revision: number; state?: AgentState };
const rows = new Map<string, Session>();

const sessions = {
  async load(id: string): Promise<Session> {
    return structuredClone(rows.get(id) ?? { revision: 0 });
  },
  async compareAndSet(id: string, expected: number, next: Session) {
    const current = rows.get(id)?.revision ?? 0;
    if (current !== expected) throw new Error("session_conflict");
    rows.set(id, structuredClone(next));
  }
};

export async function answer(
  sessionId: string,
  input: string,
  signal: AbortSignal,
  onProgress: (p: AgentProgress) => void
) {
  const session = await sessions.load(sessionId);

  const agent = new Agent({
    model,
    tools: [lookupService],
    state: session.state,
    systemPrompt: "Answer operational questions from tool evidence. State uncertainty plainly.",
    nodeTypes: [
      { name: "preference", description: "A stable response or workflow preference." },
      { name: "decision", description: "A durable operational decision and rationale." }
    ],
    allowDynamicNodeTypes: false,
    enforceCompletionEvidence: false,
    maxIterations: 12,
    projectionTargetTokens: 16_000,
    maxPromptTokens: 64_000
  });

  try {
    const result = await agent.run(input, { signal, onProgress });
    await sessions.compareAndSet(sessionId, session.revision, {
      revision: session.revision + 1,
      state: result.state
    });
    return { answer: result.finalAnswer, state: result.state, graph: result.graph, run: result.metadata };
  } catch (error) {
    if (error instanceof AgentRunError) {
      console.error({ sessionId, trace: error.trace, metrics: error.metrics });
    }
    throw error;
  }
}

import { Agent, createFileSystemTools } from "stateweave";

const coding = new Agent({
  model,
  tools: createFileSystemTools({ rootDir: sandboxPath }),
  enforceCompletionEvidence: true,
  maxIterations: 30,
  traceDir: ".stateweave/traces"
});

const result = await coding.run(
  "Inspect the parser, fix the failing test, run the focused check, and report the evidence."
);

expect(result.metadata.engine).toBe("causal-weave-v3");
expect(result.state.nodes.some((n) => n.kind === "goal")).toBe(true);
expect(result.state.nodes.some((n) => n.kind === "answer")).toBe(true);
expect(result.state.frontier.length).toBeGreaterThan(0);

const answerNode = result.state.nodes.findLast((n) => n.kind === "answer")!;
expect(answerNode.parents.length).toBeGreaterThan(0);