from praisonaiagents import AgentFlow, Agent

researcher = Agent(name="Researcher", instructions="Research topics")
writer = Agent(name="Writer", instructions="Write content")

workflow = AgentFlow(steps=[researcher, writer], output="verbose")
result = workflow.start("Research and write about AI")

from praisonaiagents import AgentFlow, Agent

workflow = AgentFlow(
    steps=[
        Agent(instructions="Research the topic"),
        Agent(instructions="Write a summary"),
    ],
    output="verbose"
)
result = workflow.start("AI trends")

from praisonaiagents import AgentFlow, Task

workflow = AgentFlow(
    steps=[
        Task(name="research", action="Research {{input}}"),
        Task(name="write", action="Write based on research", context=["research"]),
    ]
)

from praisonaiagents import Task

step = Task(
    name="validate",
    action="Generate content",
    guardrails="Ensure content is safe and accurate"
)

from praisonaiagents import AgentFlowContext

context = WorkflowContext(
    initial_data={"topic": "AI"},
    metadata={"user_id": "123"}
)

# Access data
context.set("key", "value")
value = context.get("key")

from praisonaiagents import StepResult

result = StepResult(
    success=True,
    output="Step completed",
    metadata={"duration": 1.5}
)

from praisonaiagents import AgentFlowManager

manager = WorkflowManager()
manager.register_workflow("content", content_workflow)
manager.register_workflow("analysis", analysis_workflow)

result = manager.run("content", input_data)

from praisonaiagents import Route, route

# Class-based
routing = Route(
    condition=lambda ctx: ctx.get("type"),
    routes={
        "technical": technical_agent,
        "creative": creative_agent
    },
    default=general_agent
)

# Function-based
@route(condition=lambda ctx: ctx.get("type"))
def my_router(ctx):
    if ctx.get("type") == "technical":
        return technical_agent
    return general_agent

from praisonaiagents import Parallel, parallel

# Class-based
parallel_steps = Parallel(
    steps=[agent1, agent2, agent3],
    merge_strategy="combine"  # or "first", "all"
)

# Function-based
@parallel(merge_strategy="combine")
def parallel_research():
    return [web_search, database_search, api_search]

from praisonaiagents import Loop, loop

# Class-based
refinement_loop = Loop(
    step=refine_agent,
    condition=lambda ctx: ctx.get("quality_score", 0) < 0.9,
    max_iterations=5
)

# Function-based
@loop(max_iterations=5)
def refine_until_good(ctx):
    return ctx.get("quality_score", 0) < 0.9

from praisonaiagents import Repeat, repeat

# Class-based
repeated = Repeat(
    step=generate_agent,
    times=3
)

# Function-based
@repeat(times=3)
def generate_variations():
    return generate_agent

from praisonaiagents import YAMLWorkflowParser

parser = YAMLWorkflowParser()
workflow = parser.parse("workflow.yaml")
result = workflow.run()

name: Content Pipeline
steps:
  - name: research
    agent: researcher
    task: Research the topic
    
  - name: write
    agent: writer
    task: Write article
    depends_on: research
    
  - name: review
    agent: reviewer
    task: Review and edit
    depends_on: write

from praisonaiagents import AgentFlow, Agent

researcher = Agent(name="Researcher")
writer = Agent(name="Writer")
editor = Agent(name="Editor")

workflow = AgentFlow(steps=[
    {"agent": researcher, "task": "Research {topic}"},
    {"agent": writer, "task": "Write article based on research"},
    {"agent": editor, "task": "Edit and polish the article"}
])

result = workflow.run(topic="Machine Learning")

from praisonaiagents import AgentFlow, Route

workflow = AgentFlow(steps=[
    {"agent": classifier, "task": "Classify the request"},
    Route(
        condition=lambda ctx: ctx.get("category"),
        routes={
            "technical": technical_agent,
            "billing": billing_agent,
            "general": general_agent
        }
    )
])

from praisonaiagents import AgentFlow, Parallel

workflow = AgentFlow(steps=[
    {"agent": planner, "task": "Create research plan"},
    Parallel(steps=[
        {"agent": web_researcher, "task": "Search web"},
        {"agent": db_researcher, "task": "Search database"},
        {"agent": api_researcher, "task": "Query APIs"}
    ]),
    {"agent": synthesizer, "task": "Combine all research"}
])

from praisonaiagents import AgentFlow, Loop

workflow = AgentFlow(steps=[
    {"agent": generator, "task": "Generate initial draft"},
    Loop(
        step={"agent": refiner, "task": "Improve the draft"},
        condition=lambda ctx: ctx.get("score", 0) < 0.9,
        max_iterations=3
    ),
    {"agent": finalizer, "task": "Finalize output"}
])