Agents

from criogenai import Agent, FakeModel, FakeReply, ToolContext, ToolError, tool


@tool(destructive=True)
def issue_refund(order_id: str, amount: float, note: Optional[str] = None, ctx: Optional[ToolContext] = None) -> dict:
    """Refund an order."""
    # Arguments arrive already checked against the schema built from the type hints.
    if amount > 200:
        raise ToolError("Refunds over 200 need a manager")
    return {"refunded": amount}


class Resolution(BaseModel):
    category: Literal["billing", "shipping", "other"]
    refund: bool


agent = Agent(
    "openai:gpt-5-mini",
    instructions="You are a support agent.",
    tools=[issue_refund],
    output=Resolution,  # result.output is a Resolution
    limits={"model_calls": 10, "tool_calls": 20},
)

# In tests: scripted replies, no network, the same answer every time.
test_agent = Agent(
    FakeModel([FakeReply.tool_call("issue_refund", {"order_id": "A-1001", "amount": 24}), "Refunded."]),
    tools=[issue_refund],
)
result = test_agent.run_sync("Refund my order")
assert result.text == "Refunded."

import { Agent, FakeModel, FakeReply, ToolError, tool } from "criogenai";

const issueRefund = tool<{ orderId: string; amount: number }>({
  name: "issue_refund",
  description: "Refund an order.",
  destructive: true,
  input: {
    type: "object",
    properties: {
      orderId: { type: "string" },
      amount: { type: "number", minimum: 0, maximum: 500 },
    },
    required: ["orderId", "amount"],
  },
  run: ({ amount }) => {
    // Arguments arrive already checked against the schema.
    if (amount > 200) throw new ToolError("Refunds over 200 need a manager");
    return { refunded: amount };
  },
});

const agent = new Agent<{ category: string; refund: boolean }>({
  model: "openai:gpt-5-mini",
  instructions: "You are a support agent.",
  tools: [issueRefund],
  output: {
    type: "object",
    properties: { category: { enum: ["billing", "shipping", "other"] }, refund: { type: "boolean" } },
    required: ["category", "refund"],
  },
  limits: { modelCalls: 10, toolCalls: 20 },
});

// In tests: scripted replies, no network, the same answer every time.
const testAgent = new Agent({
  model: new FakeModel([FakeReply.toolCall("issue_refund", { orderId: "A-1001", amount: 24 }), "Refunded."]),
  tools: [issueRefund],
});
const result = await testAgent.run("Refund my order");

use criogenai_agent::{Agent, Limits, ToolError, tool_fn};
use criogenai_providers::ToolSpec;
use serde_json::json;

let refund = tool_fn(
    ToolSpec::new(
        "issue_refund",
        "Refund an order.",
        json!({
            "type": "object",
            "properties": {
                "order_id": {"type": "string"},
                "amount": {"type": "number", "minimum": 0, "maximum": 500}
            },
            "required": ["order_id", "amount"]
        }),
    ),
    |args, _ctx| async move {
        // Arguments arrive already checked against the schema.
        if args["amount"].as_f64() > Some(200.0) {
            // The model sees this and can explain or try another way.
            return Err(ToolError::new("Refunds over 200 need a manager"));
        }
        Ok(json!({"refunded": args["amount"]}))
    },
);

let agent = Agent::builder(model()?)
    .instructions("You are a support agent.")
    .tool(refund)
    .limits(Limits::default().model_calls(10).tool_calls(20))
    .build()?;

from criogenai import Agent

researcher = Agent("openai:gpt-5-mini", instructions="Find facts about orders. Be precise.")
support = Agent(
    "openai:gpt-5-mini",
    instructions="You are a support agent.",
    # The researcher becomes a tool: it takes {"input": text} and answers.
    tools=[researcher.as_tool("research", "Looks up facts about an order")],
)

const researcher = new Agent({ model: "openai:gpt-5-mini", instructions: "Find facts about orders. Be precise." });
const support = new Agent({
  model: "openai:gpt-5-mini",
  instructions: "You are a support agent.",
  // The researcher becomes a tool: it takes { input } and answers.
  tools: [researcher.asTool("research", "Looks up facts about an order")],
});

use criogenai_agent::Agent;

let researcher = Agent::builder(model()?)
    .instructions("Find facts about orders. Be precise.")
    .build()?;
let support = Agent::builder(model()?)
    .instructions("You are a support agent.")
    // The researcher becomes a tool: it takes {"input": text} and answers.
    .tool(researcher.as_tool("research", "Looks up facts about an order"))
    .build()?;