Multi-Agent Routing Workflow with Language Detection

"""
Routing workflow implementation using OpenAI Agents SDK.

Demonstrates intelligent request distribution to specialized language agents.
The triage agent analyzes incoming queries and routes them to the appropriate
language specialist (French, Spanish, or English) using the handoff pattern.
"""

from datetime import timedelta

from agents import Agent, RunConfig, Runner, TResponseInputItem, trace
from temporalio import workflow

# Task queue name for this workflow pattern
TASK_QUEUE = "routing-workflow-queue"


def french_agent() -> Agent:
    """Create a French language specialist agent."""
    return Agent(
        name="French Agent",
        instructions="You only speak French. Respond naturally to user queries in French.",
        model="gpt-4",
    )


def spanish_agent() -> Agent:
    """Create a Spanish language specialist agent."""
    return Agent(
        name="Spanish Agent",
        instructions="You only speak Spanish. Respond naturally to user queries in Spanish.",
        model="gpt-4",
    )


def english_agent() -> Agent:
    """Create an English language specialist agent."""
    return Agent(
        name="English Agent",
        instructions="You only speak English. Respond naturally to user queries in English.",
        model="gpt-4",
    )


def triage_agent() -> Agent:
    """
    Create a triage agent that routes requests to language specialists.

    The handoff pattern enables multi-agent architectures where different
    agents have different specializations and can collaborate on tasks.
    """
    return Agent(
        name="Triage Agent",
        instructions=(
            "Identify the primary language of the user's message. "
            "Never answer directly. "
            "Immediately hand off using one of the following rules: "
            "- French → French Agent "
            "- Spanish → Spanish Agent "
            "- English → English Agent "
            "If detection is uncertain or the language is unsupported, hand off to English Agent."
        ),
        handoffs=[french_agent(), spanish_agent(), english_agent()],
        model="gpt-4",
    )


@workflow.defn
class RoutingWorkflow:
    @workflow.run
    async def run(self, msg: str) -> str:
        config = RunConfig()

        with trace("Routing example"):
            inputs: list[TResponseInputItem] = [{"content": msg, "role": "user"}]

            # Run the triage agent to determine which language agent to handoff to
            result = await Runner.run(
                triage_agent(),
                input=inputs,
                run_config=config,
            )

            # 10-second pause to demonstrate Temporal durability:
            # kill the worker here and restart it to see the workflow resume
            # from this point without re-running the triage agent.
            workflow.logger.info("⏸️  Pausing for 10 seconds to demonstrate durability...")
            await workflow.sleep(timedelta(seconds=10))

            workflow.logger.info("Handoff completed")
            return f"Response: {result.final_output}"