Edges

from kapso.builder import Agent
from kapso.builder.nodes import DefaultNode, SubagentNode, WarmEndNode
from kapso.builder.agent.constants import START_NODE, END_NODE

agent = Agent(name="customer_service")

# Add nodes
agent.add_node(START_NODE)
agent.add_node(END_NODE)

triage = DefaultNode(name="triage", prompt="Understand what the user needs")
orders = SubagentNode(name="orders", prompt="Handle order inquiries")
support = SubagentNode(name="support", prompt="Provide technical support")
goodbye = WarmEndNode(name="goodbye", timeout_minutes=5)

agent.add_node(triage)
agent.add_node(orders)
agent.add_node(support)
agent.add_node(goodbye)

# Create edge flow with conditions
agent.add_edge(START_NODE, "triage")

# From triage to specialized handlers
agent.add_edge("triage", "orders", 
    condition="user asks about orders, shipping, or tracking")
agent.add_edge("triage", "support", 
    condition="user has technical issues or needs help")
agent.add_edge("triage", "goodbye", 
    condition="user just saying hi or bye")

# From handlers to end
agent.add_edge("orders", "goodbye", 
    condition="order inquiry resolved")
agent.add_edge("support", "goodbye", 
    condition="support issue resolved")

# Final edge
agent.add_edge("goodbye", END_NODE)

# Validate the complete flow
agent.validate()

agent.add_edge(source, target, condition=None)

from kapso.builder.agent.constants import START_NODE, END_NODE

# Connect START to greeting node
agent.add_edge(START_NODE, "greeting")

# Connect greeting to END
agent.add_edge("greeting", END_NODE)

# Multiple paths from one node
agent.add_edge("greeting", "order_status", 
    condition="user asks about their order or shipment")

agent.add_edge("greeting", "product_info", 
    condition="user asks about products or pricing")

agent.add_edge("greeting", "support", 
    condition="user has a problem or complaint")

# Default path (no condition)
agent.add_edge("greeting", "general_help")

from kapso.builder import Edge, create_edge

# Using the Edge class directly
edge = Edge(
    source="node1",
    target="node2",
    condition="user confirms"
)

# Using the factory function
edge = create_edge(
    source="node1",
    target="node2",
    condition="user confirms"
)

# ✅ Correct
agent.add_edge(START_NODE, "first_node")

# ❌ Wrong - Multiple edges from START
agent.add_edge(START_NODE, "node1")
agent.add_edge(START_NODE, "node2")  # Error!

# ❌ Wrong - Condition on START edge
agent.add_edge(START_NODE, "node1", condition="some condition")  # Error!

# ✅ Correct - Multiple paths to END
agent.add_edge("success", END_NODE)
agent.add_edge("failure", END_NODE)
agent.add_edge("cancelled", END_NODE)

# Global node - no edges needed
handoff = HandoffNode(
    name="human",
    global_=True,
    global_condition="user requests human"
)
agent.add_node(handoff)
# No add_edge() calls needed!

# ✅ Good - Natural, clear conditions
agent.add_edge("menu", "orders", 
    condition="user selects option 1 or asks about orders")

# ❌ Avoid - Technical or code-like conditions
agent.add_edge("menu", "orders", 
    condition="input == '1' || contains(message, 'order')")

# ✅ Good - Clear, non-overlapping conditions
agent.add_edge("triage", "billing", 
    condition="user has billing or payment questions")

agent.add_edge("triage", "technical", 
    condition="user has technical issues or error messages")

agent.add_edge("triage", "general", 
    condition="user has general questions or other inquiries")

# Specific conditions first
agent.add_edge("router", "urgent", 
    condition="user mentions emergency or urgent")

agent.add_edge("router", "appointment", 
    condition="user wants to schedule or reschedule")

# Default catch-all (no condition)
agent.add_edge("router", "general_inquiry")

# Simple A → B → C flow
agent.add_edge("collect_info", "process_request")
agent.add_edge("process_request", "show_results")
agent.add_edge("show_results", "end")

# User choice determines path
agent.add_edge("menu", "option_a", condition="user chooses A")
agent.add_edge("menu", "option_b", condition="user chooses B")
agent.add_edge("menu", "option_c", condition="user chooses C")

# All paths converge
agent.add_edge("option_a", "confirmation")
agent.add_edge("option_b", "confirmation")
agent.add_edge("option_c", "confirmation")

# Retry pattern
agent.add_edge("input", "validation")
agent.add_edge("validation", "input", 
    condition="validation failed, ask user to try again")
agent.add_edge("validation", "success", 
    condition="validation passed")

# Complex routing logic
agent.add_edge("analyze_request", "urgent_human", 
    condition="high priority AND complex issue")

agent.add_edge("analyze_request", "automated_urgent", 
    condition="high priority AND simple issue")

agent.add_edge("analyze_request", "queue", 
    condition="normal priority")

agent.add_edge("analyze_request", "self_service", 
    condition="low priority OR informational request")

# This will fail validation - node2 is unreachable
agent.add_edge(START_NODE, "node1")
agent.add_edge("node1", END_NODE)
agent.add_node(DefaultNode("node2"))  # No edges to/from node2!

# This will fail - no path to END_NODE
agent.add_edge(START_NODE, "node1")
agent.add_edge("node1", "node2")
agent.add_edge("node2", "node1")  # Infinite loop!

# This will fail validation
agent.add_edge(START_NODE, "path1")
agent.add_edge(START_NODE, "path2")  # Error!

# During development, print the graph structure
for edge in agent.edges:
    print(f"{edge.source} → {edge.target}")
    if edge.condition:
        print(f"  Condition: {edge.condition}")

# Create test scenarios for each edge condition
test_cases = [
    ("I need help with my order", "order_support"),
    ("What products do you have?", "product_info"),
    ("I want to speak to a human", "handoff")
]