Patterns, specialists and web search

from criogenai import patterns

# A model for the specialists: pass one, or set CRIOGEN_MODEL="openai:gpt-5-mini".
flow = patterns.quick("researcher > writer", model="openai:gpt-5-mini")
result = await flow.run("Write about solar panels")
print(result)             # the answer
print(result.explain())   # each step, in order

import { patterns } from "criogenai";

// A model for the specialists: pass one, or set CRIOGEN_MODEL="openai:gpt-5-mini".
const flow = patterns.quick("researcher > writer", { model: "openai:gpt-5-mini" });
const result = await flow.run("Write about solar panels");
console.log(String(result));      // the answer
console.log(result.explain());    // each step, in order

use criogenai_agent::patterns;

// Specialists need a model: pass an `Arc<dyn Model>` (Rust has no model strings).
let flow = patterns::quick("researcher > writer", model.clone())?;
let result = flow.run("Write about solar panels").await?;
println!("{result}");              // the answer
println!("{}", result.explain());  // each step, in order

def shout(text):                  # a plain function is a step too
    return text.upper()

flow = patterns.sequential([("research", my_agent), shout, "writer"], model=m)

const shout = (text: string) => text.toUpperCase();   // a plain function is a step too

const flow = patterns.sequential([["research", myAgent], shout, "writer"], { model: m });

let shout = Step::function(|text: String| async move { text.to_uppercase() });

let flow = patterns::sequential([
    Step::from(("research", my_agent)),
    shout.named("shout"),
    Step::registered("writer", model.clone())?,
])?;

from criogenai import specialists

agent = specialists.writer.build("openai:gpt-5-mini")

# Extend: a new recipe; the original is untouched.
careful = specialists.researcher.extend("careful-researcher", add="Always give two sources.")
specialists.register(careful)          # now "careful-researcher" works anywhere a step is expected

# Or write your own.
specialists.register(specialists.Specialist(
    "refund-triage", "Decides if a refund request is valid", "You decide whether ...", tools=[get_order],
))

import { specialists } from "criogenai";

const agent = specialists.writer.build("openai:gpt-5-mini");

// Extend: a new recipe; the original is untouched.
const careful = specialists.researcher.extend("careful-researcher", { add: "Always give two sources." });
specialists.register(careful);         // now "careful-researcher" works anywhere a step is expected

// Or write your own.
specialists.register(new specialists.Specialist(
  "refund-triage", "Decides if a refund request is valid", "You decide whether ...", { tools: [getOrder] },
));

use criogenai_agent::specialists::{self, Specialist};

let agent = specialists::writer().build(model.clone())?;

// Extend: a new recipe; the original is untouched.
let careful = specialists::researcher()
    .extend("careful-researcher")
    .append_instructions("Always give two sources.");
specialists::register(careful)?;       // now "careful-researcher" works anywhere a step is expected

// Or write your own.
specialists::register(
    Specialist::new("refund-triage", "Decides if a refund request is valid", "You decide whether ...")?
        .tool(get_order),
)?;

from criogenai import Agent, web

agent = Agent("openai:gpt-5-mini", tools=[web.search(), web.fetch()])

import { Agent, web } from "criogenai";

const agent = new Agent({ model: "openai:gpt-5-mini", tools: [web.search(), web.fetch()] });

// Cargo feature `web` (off by default): criogenai-agent = { version = "0.1", features = ["web"] }
use criogenai_agent::web;

let agent = Agent::builder(model)
    .tool(web::search()?)
    .tool(web::fetch())
    .build()?;

from criogenai import Storage

app = patterns.human_review(my_agent).compile(Storage("sqlite://app.db"))
await app.thread("release-1", actor="user:ada").run({"input": "Release the dataset?"})
# Days later, from another process:
await app.thread("release-1", actor="user:boss").resume({"review": "approve"})

flow.workflow.add_node(...)   # the plain Workflow, to add nodes and edges

import { Storage } from "criogenai";

const app = patterns.humanReview(myAgent).compile(new Storage({ url: "sqlite://app.db" }));
await app.thread("release-1", { actor: "user:ada" }).run({ input: "Release the dataset?" });
// Days later, from another process:
await app.thread("release-1", { actor: "user:boss" }).resume({ review: "approve" });

flow.workflow.addNode(/* ... */);   // the plain Workflow, to add nodes and edges

let flow = patterns::human_review(Step::from(my_agent))?;
let thread = flow.thread(&storage, "release-1");
// ... run it, and later, from another process:
let done = flow.resume(&paused, ReviewDecision::Approve).await?;

let flow = flow.extend(|workflow| { /* add nodes and edges */ })?;   // rebuilds and revalidates the graph