from agent_framework import Workflow

# Workflow structure
workflow = Workflow(
    nodes={...},
    edges={...},
    start_node="entry_point"
)

from agent_framework import WorkflowBuilder

builder = WorkflowBuilder()
workflow = (
    builder
    .add_node("agent1", agent1)
    .add_node("agent2", agent2)
    .add_edge("agent1", "agent2")
    .build()
)

from agent_framework import Agent, SequentialOrchestrator
from agent_framework.openai import OpenAIChatClient

client = OpenAIChatClient(model_id="gpt-4")

# Create agents
researcher = Agent(
    client=client,
    name="researcher",
    instructions="Research the topic"
)

writer = Agent(
    client=client,
    name="writer",
    instructions="Write an article based on research"
)

# Create sequential workflow
workflow = SequentialOrchestrator(
    agents=[researcher, writer]
)

# Run workflow
result = await workflow.run("Write about AI agents")

from agent_framework import GroupChatOrchestrator

# Create multiple agents
agents = [
    Agent(client=client, name="analyst", instructions="Analyze data"),
    Agent(client=client, name="strategist", instructions="Develop strategy"),
    Agent(client=client, name="executor", instructions="Execute plan")
]

# Create group chat
group_chat = GroupChatOrchestrator(
    agents=agents,
    max_turns=10
)

result = await group_chat.run("Plan a marketing campaign")

from agent_framework import WorkflowBuilder

def router(result):
    """Route based on result."""
    if "technical" in result.text.lower():
        return "tech_agent"
    else:
        return "general_agent"

workflow = (
    WorkflowBuilder()
    .add_node("classifier", classifier_agent)
    .add_node("tech_agent", tech_agent)
    .add_node("general_agent", general_agent)
    .add_conditional_edge("classifier", router)
    .build()
)

result = await workflow.run("Explain quantum computing")

from agent_framework import Workflow, Checkpoint

# Create workflow with checkpointing
workflow = Workflow(
    nodes={...},
    checkpoint_enabled=True
)

# Run and save checkpoint
result = await workflow.run("Task")
checkpoint = workflow.get_checkpoint()

# Later, restore from checkpoint
restored_workflow = Workflow.from_checkpoint(checkpoint)
result = await restored_workflow.resume()

workflow = Workflow(
    nodes={...},
    initial_state={"context": "value"}
)

# State is passed between agents
result = await workflow.run("Task")
final_state = workflow.get_state()

async for event in workflow.run_stream("Task"):
    if event.type == "agent_start":
        print(f"Agent {event.agent_name} started")
    elif event.type == "agent_complete":
        print(f"Agent {event.agent_name} completed")

Agent1 -> Agent2 -> Agent3 -> Result

        -> Agent1 ->
       /            \
Start -> Agent2 -> Merge -> Result
       \            /
        -> Agent3 ->

        -> Agent1 (if condition1)
       /
Router -> Agent2 (if condition2)
       \
        -> Agent3 (otherwise)

Agent1 -> Condition -> Agent2
   ^                      |
   |______________________|  (loop back if needed)

from agent_framework import Executor

class CustomExecutor(Executor):
    async def execute_node(self, node, state):
        # Custom execution logic
        pass

workflow = Workflow(
    nodes={...},
    executor=CustomExecutor()
)

# Create sub-workflows
research_workflow = Workflow(...)
writing_workflow = Workflow(...)

# Compose into larger workflow
main_workflow = (
    WorkflowBuilder()
    .add_node("research", research_workflow)
    .add_node("writing", writing_workflow)
    .add_edge("research", "writing")
    .build()
)

def create_workflow(task_type):
    builder = WorkflowBuilder()
    
    if task_type == "research":
        builder.add_node("agent", research_agent)
    elif task_type == "writing":
        builder.add_node("agent", writing_agent)
    
    return builder.build()

workflow = create_workflow("research")