Agent frameworks

from typing import TypedDict

from langgraph.graph import END, START, StateGraph
from langgraph.types import interrupt

import agentos
from agentos.adapters import langgraph


class Payment(TypedDict, total=False):
    payee: str
    amount: str
    decision: dict
    paid: bool


def review(state: Payment) -> Payment:
    decision = interrupt({"intent": f"Pay {state['payee']}", "actions": ["approve", "edit", "reject"],
                          "items": [{"id": "payment", "title": f"{state['payee']} · {state['amount']}",
                                     "data": {"payee": state["payee"], "amount": state["amount"]}}]})
    return {"decision": decision}


def pay(state: Payment) -> Payment:
    item = (state["decision"]["items"] or [{}])[0]
    if item.get("action") not in ("approve", "edit"):
        return {"paid": False}
    return {"paid": True, **item["data"]}


builder = StateGraph(Payment)          # building the graph at module level is fine
builder.add_node(review)
builder.add_node(pay)
builder.add_edge(START, "review")
builder.add_edge("review", "pay")
builder.add_edge("pay", END)


def approve_payment(inv: agentos.Invocation):
    graph = builder.compile(checkpointer=langgraph.checkpointer())   # compile per invocation
    state = langgraph.run(inv, graph, dict(inv.input))
    return {"paid": state["paid"]}


agentos.serve({"approve_payment": approve_payment}, port=8080)

from agno.agent import Agent
from agno.tools import tool

import agentos
from agentos.adapters import agno


@tool(requires_confirmation=True)
def pay(payee: str, amount: str) -> str:
    """Pay a supplier. Amounts are text, e.g. "120.00"."""
    return f"paid {amount} to {payee}"


def pay_supplier(inv: agentos.Invocation):
    agent = Agent(model=agno.model(inv), tools=[pay], instructions="Pay suppliers with the pay tool.",
                  telemetry=False)
    output = agno.run(inv, agent, inv.input["request"], intent="Pay a supplier")
    return {"answer": output.content}


agentos.serve({"pay_supplier": pay_supplier}, port=8080)

import { serve, type Handlers } from "@agentos/sdk";
import { agentosModel, runWithApprovals } from "@agentos/sdk/ai-sdk";
import { stepCountIs, tool } from "ai";
import { z } from "zod";

const pay = tool({
  description: "Pay a supplier. Amounts are text, e.g. \"120.00\".",
  inputSchema: z.object({ payee: z.string(), amount: z.string() }),
  execute: async ({ payee, amount }) => `paid ${amount} to ${payee}`,
});

const handlers: Handlers = {
  pay_supplier: async (inv) => {
    const result = await runWithApprovals(inv, {
      model: agentosModel(inv), tools: { pay }, toolApproval: { pay: "user-approval" },
      stopWhen: stepCountIs(5), system: "Pay suppliers with the pay tool.",
      messages: [{ role: "user", content: inv.input.request }], intent: "Pay a supplier",
    });
    return { answer: result.text };
  },
};

await serve(handlers, { port: 8080 });

import { serve, type Handlers } from "@agentos/sdk";
import { runWorkflow } from "@agentos/sdk/mastra";
import { Mastra } from "@mastra/core";
import { InMemoryStore } from "@mastra/core/storage";
import { createStep, createWorkflow } from "@mastra/core/workflows";
import { z } from "zod";

const payment = z.object({ payee: z.string(), amount: z.string() });
const decision = z.object({ resolvedBy: z.string(), comment: z.string().nullable(), items: z.array(z.object({
  id: z.string(), action: z.string(), data: z.record(z.string(), z.unknown()).nullable(),
  comment: z.string().nullable() })) });

const review = createStep({
  id: "review", inputSchema: payment, resumeSchema: decision,
  outputSchema: payment.extend({ paid: z.boolean() }),
  execute: async ({ inputData, resumeData, suspend }) => {
    if (!resumeData) {
      return await suspend({ intent: `Pay ${inputData.payee}`, actions: ["approve", "edit", "reject"],
        items: [{ id: "payment", title: `${inputData.payee} · ${inputData.amount}`, data: inputData }] });
    }
    const item = resumeData.items[0];
    if (!item || !["approve", "edit"].includes(item.action)) return { ...inputData, paid: false };
    return { ...inputData, ...(item.data as { payee: string; amount: string }), paid: true };
  },
});

// built per invocation: a fresh in-memory store, as in a new process
function payments() {
  const workflow = createWorkflow({ id: "payments", inputSchema: payment,
    outputSchema: payment.extend({ paid: z.boolean() }) }).then(review).commit();
  return new Mastra({ workflows: { payments: workflow }, storage: new InMemoryStore(), logger: false });
}

const handlers: Handlers = {
  approve_payment: async (inv) => (await runWorkflow(inv, payments(), "payments", inv.input)).result,
};

await serve(handlers, { port: 8080 });