pixie-examples 0.1.1.dev5__tar.gz → 0.1.1.dev14__tar.gz

{pixie_examples-0.1.1.dev5 → pixie_examples-0.1.1.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pixie-examples
-Version: 0.1.1.dev5
+Version: 0.1.1.dev14
 Summary: examples for using Pixie
 License: MIT
 License-File: LICENSE
@@ -24,7 +24,7 @@ Requires-Dist: openinference-instrumentation-crewai (>=0.1.17,<0.2.0)
 Requires-Dist: openinference-instrumentation-dspy (>=0.1.33,<0.2.0)
 Requires-Dist: openinference-instrumentation-google-adk (>=0.1.8,<0.2.0)
 Requires-Dist: openinference-instrumentation-openai-agents (>=1.4.0,<2.0.0)
-Requires-Dist: pixie-sdk (>=0.1.1.dev13,<0.2.0)
+Requires-Dist: pixie-sdk (>=0.1.1.dev36,<0.2.0)
 Requires-Dist: pydantic (>=2.7.4,<3.0.0)
 Requires-Dist: pydantic-ai-slim (>=1.39.0,<2.0.0)
 Requires-Dist: pymarkdownlnt (>=0.9.34,<0.10.0)

{pixie_examples-0.1.1.dev5 → pixie_examples-0.1.1.dev14}/examples/langchain/basic_agent.py

@@ -12,6 +12,15 @@ from langfuse.langchain import CallbackHandler
 import pixie
 
 
+basic_weather_agent_prompt = pixie.create_prompt(
+    "basic_weather_agent",
+    description="Helpful weather assistant",
+)
+interactive_weather_agent_prompt = pixie.create_prompt(
+    "interactive_weather_agent",
+    description="Interactive weather assistant that answers questions about weather",
+)
+
 langfuse_handler = CallbackHandler()
 
 
@@ -37,7 +46,7 @@ async def langchain_basic_weather_agent(query: str) -> str:
     agent = create_agent(
         model=model,
         tools=[get_weather],
-        system_prompt="You are a helpful weather assistant",
+        system_prompt=basic_weather_agent_prompt.compile(),
     )
 
     # Run the agent
@@ -66,7 +75,7 @@ async def langchain_interactive_weather_agent() -> pixie.PixieGenerator[str, str
     agent = create_agent(
         model=model,
         tools=[get_weather],
-        system_prompt="You are a helpful weather assistant that answers questions about weather.",
+        system_prompt=interactive_weather_agent_prompt.compile(),
     )
 
     # Send welcome message

{pixie_examples-0.1.1.dev5 → pixie_examples-0.1.1.dev14}/examples/langchain/customer_support.py

@@ -7,7 +7,7 @@ as it moves through different states of a workflow.
 Based on: https://docs.langchain.com/oss/python/langchain/multi-agent/handoffs-customer-support
 """
 
-from typing import Literal, NotRequired
+from typing import Literal, NotRequired, cast
 from langchain.agents import create_agent, AgentState
 from langchain.chat_models import init_chat_model
 from langchain.tools import tool, ToolRuntime
@@ -17,6 +17,9 @@ from langgraph.types import Command
 from typing import Callable
 
 from langfuse.langchain import CallbackHandler
+from langchain_core.messages import (
+    SystemMessage,
+)
 import pixie
 
 
@@ -90,54 +93,42 @@ def provide_solution(solution: str) -> str:
     return f"Solution provided: {solution}"
 
 
-# Step prompts
-WARRANTY_COLLECTOR_PROMPT = """You are a customer support agent collecting warranty information.
+class IssueClassifierPromptVariables(pixie.PromptVariables):
+    warranty_status: Literal["in_warranty", "out_of_warranty"]
 
-CURRENT STAGE: Warranty Verification
 
-Ask the customer if their device is under warranty. Once you have this information,
-use the record_warranty_status tool to record it and move to the next step.
+class ResolutionSpecialistPromptVariables(IssueClassifierPromptVariables):
+    issue_type: Literal["hardware", "software"]
 
-Be polite and professional."""
-
-ISSUE_CLASSIFIER_PROMPT = """You are a customer support agent classifying technical issues.
-
-CURRENT STAGE: Issue Classification
-CUSTOMER INFO: Warranty status is {warranty_status}
-
-Ask the customer to describe their issue, then determine if it's:
-- HARDWARE: Physical problems (cracked screen, battery, ports, buttons)
-- SOFTWARE: App crashes, performance, settings, updates
-
-Use record_issue_type to record the classification and move to resolution."""
-
-RESOLUTION_SPECIALIST_PROMPT = """You are a customer support agent helping with device issues.
-
-CURRENT STAGE: Resolution
-CUSTOMER INFO: Warranty status is {warranty_status}, issue type is {issue_type}
-
-At this step, you need to:
-1. For SOFTWARE issues: provide troubleshooting steps using provide_solution
-2. For HARDWARE issues:
-   - If IN WARRANTY: explain warranty repair process using provide_solution
-   - If OUT OF WARRANTY: escalate_to_human for paid repair options
-
-Be specific and helpful in your solutions."""
 
+warranty_collector_prompt = pixie.create_prompt(
+    "warranty_collector_agent",
+    description="Customer support agent that collects warranty information",
+)
+issue_classifier_prompt = pixie.create_prompt(
+    "issue_classifier_agent",
+    IssueClassifierPromptVariables,
+    description="Customer support agent that classifies technical issues as hardware or software",
+)
+resolution_specialist_prompt = pixie.create_prompt(
+    "resolution_specialist_agent",
+    ResolutionSpecialistPromptVariables,
+    description="Customer support agent that provides resolutions based on issue type and warranty status",
+)
 # Step configuration
 STEP_CONFIG = {
     "warranty_collector": {
-        "prompt": WARRANTY_COLLECTOR_PROMPT,
+        "prompt": warranty_collector_prompt,
         "tools": [record_warranty_status],
         "requires": [],
     },
     "issue_classifier": {
-        "prompt": ISSUE_CLASSIFIER_PROMPT,
+        "prompt": issue_classifier_prompt,
         "tools": [record_issue_type],
         "requires": ["warranty_status"],
     },
     "resolution_specialist": {
-        "prompt": RESOLUTION_SPECIALIST_PROMPT,
+        "prompt": resolution_specialist_prompt,
         "tools": [provide_solution, escalate_to_human],
         "requires": ["warranty_status", "issue_type"],
     },
@@ -165,7 +156,14 @@ def apply_step_config(
     # Note: In a production implementation, you would inject the formatted prompt
     # and tools into the request. For simplicity, we'll let the handler process
     # the request and handle tool selection based on state.
-    _ = stage_config["prompt"].format(**request.state)
+    prompt = cast(pixie.Prompt, stage_config["prompt"])
+    if prompt.variables_definition:
+        vars = prompt.variables_definition(**request.state)
+        prompt_txt = prompt.compile(vars)
+    else:
+        prompt_txt = prompt.compile(None)
+
+    request.system_message = SystemMessage(prompt_txt)
 
     # The middleware pattern here would need deeper integration with LangChain's
     # internal APIs. For now, we pass through to the handler.

{pixie_examples-0.1.1.dev5 → pixie_examples-0.1.1.dev14}/examples/langchain/personal_assistant.py

@@ -16,6 +16,19 @@ from langfuse.langchain import CallbackHandler
 import pixie
 
 
+calendar_agent_prompt = pixie.create_prompt(
+    "calendar_agent",
+    description="Calendar scheduling assistant that parses natural language requests",
+)
+email_agent_prompt = pixie.create_prompt(
+    "email_agent",
+    description="Email assistant that composes and sends professional emails",
+)
+supervisor_agent_prompt = pixie.create_prompt(
+    "supervisor_agent",
+    description="Personal assistant coordinator that handles calendar and email tasks",
+)
+
 langfuse_handler = CallbackHandler()
 
 
@@ -46,32 +59,6 @@ def send_email(to: list[str], subject: str, body: str, cc: list[str] = []) -> st
     return f"Email sent to {', '.join(to)} - Subject: {subject}"
 
 
-# System prompts for specialized agents
-CALENDAR_AGENT_PROMPT = (
-    "You are a calendar scheduling assistant. "
-    "Parse natural language scheduling requests (e.g., 'next Tuesday at 2pm') "
-    "into proper ISO datetime formats. "
-    "Use get_available_time_slots to check availability when needed. "
-    "Use create_calendar_event to schedule events. "
-    "Always confirm what was scheduled in your final response."
-)
-
-EMAIL_AGENT_PROMPT = (
-    "You are an email assistant. "
-    "Compose professional emails based on natural language requests. "
-    "Extract recipient information and craft appropriate subject lines and body text. "
-    "Use send_email to send the message. "
-    "Always confirm what was sent in your final response."
-)
-
-SUPERVISOR_PROMPT = (
-    "You are a helpful personal assistant. "
-    "You can schedule calendar events and send emails. "
-    "Break down user requests into appropriate tool calls and coordinate the results. "
-    "When a request involves multiple actions, use multiple tools in sequence."
-)
-
-
 @pixie.app
 async def langchain_personal_assistant() -> pixie.PixieGenerator[str, str]:
     """Multi-agent personal assistant with calendar and email subagents.
@@ -90,14 +77,14 @@ async def langchain_personal_assistant() -> pixie.PixieGenerator[str, str]:
     calendar_agent = create_agent(
         model,
         tools=[create_calendar_event, get_available_time_slots],
-        system_prompt=CALENDAR_AGENT_PROMPT,
+        system_prompt=calendar_agent_prompt.compile(),
     )
 
     # Create email subagent
     email_agent = create_agent(
         model,
         tools=[send_email],
-        system_prompt=EMAIL_AGENT_PROMPT,
+        system_prompt=email_agent_prompt.compile(),
     )
 
     # Wrap subagents as tools for the supervisor
@@ -131,7 +118,7 @@ async def langchain_personal_assistant() -> pixie.PixieGenerator[str, str]:
     supervisor_agent = create_agent(
         model,
         tools=[schedule_event, manage_email],
-        system_prompt=SUPERVISOR_PROMPT,
+        system_prompt=supervisor_agent_prompt.compile(),
         checkpointer=InMemorySaver(),
     )
 

{pixie_examples-0.1.1.dev5 → pixie_examples-0.1.1.dev14}/examples/langchain/sql_agent.py

@@ -26,32 +26,18 @@ import pixie
 from ..sql_utils import SQLDatabase, SQLDatabaseToolkit
 
 
-langfuse_handler = CallbackHandler()
-
-
-# System prompt for SQL agent
-SQL_AGENT_PROMPT = """
-You are an agent designed to interact with a SQL database.
-Given an input question, create a syntactically correct {dialect} query to run,
-then look at the results of the query and return the answer. Unless the user
-specifies a specific number of examples they wish to obtain, always limit your
-query to at most {top_k} results.
-
-You can order the results by a relevant column to return the most interesting
-examples in the database. Never query for all the columns from a specific table,
-only ask for the relevant columns given the question.
-
-You MUST double check your query before executing it. If you get an error while
-executing a query, rewrite the query and try again.
+class SqlAgentPromptVariables(pixie.PromptVariables):
+    dialect: str
+    top_k: int
 
-DO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the
-database.
 
-To start you should ALWAYS look at the tables in the database to see what you
-can query. Do NOT skip this step.
+sql_agent_prompt = pixie.create_prompt(
+    "langchain_sql_agent",
+    SqlAgentPromptVariables,
+    description="SQL agent that interacts with databases and creates queries based on natural language",
+)
 
-Then you should query the schema of the most relevant tables.
-"""
+langfuse_handler = CallbackHandler()
 
 
 def setup_database():
@@ -99,7 +85,9 @@ async def langchain_sql_query_agent(question: str) -> str:
     tools = toolkit.get_tools()
 
     # Format system prompt with database info
-    system_prompt = SQL_AGENT_PROMPT.format(dialect=db.dialect, top_k=5)
+    system_prompt = sql_agent_prompt.compile(
+        SqlAgentPromptVariables(dialect=db.dialect, top_k=5)
+    )
 
     # Create agent
     agent = create_agent(model, tools, system_prompt=system_prompt)
@@ -134,7 +122,9 @@ async def langchain_interactive_sql_agent() -> pixie.PixieGenerator[str, str]:
     tools = toolkit.get_tools()
 
     # Format system prompt
-    system_prompt = SQL_AGENT_PROMPT.format(dialect=db.dialect, top_k=5)
+    system_prompt = sql_agent_prompt.compile(
+        SqlAgentPromptVariables(dialect=db.dialect, top_k=5)
+    )
 
     # Create agent with checkpointer for conversation memory
     agent = create_agent(

{pixie_examples-0.1.1.dev5 → pixie_examples-0.1.1.dev14}/examples/langgraph/langgraph_rag.py

@@ -11,7 +11,7 @@ Based on: https://docs.langchain.com/oss/python/langgraph/agentic-rag
 """
 
 from pydantic import BaseModel, Field
-from typing import Literal
+from typing import Literal, cast
 from langchain.chat_models import init_chat_model
 from langchain.tools import tool
 from langchain.messages import HumanMessage
@@ -28,6 +28,36 @@ import requests
 from bs4 import BeautifulSoup
 
 
+class GradePromptVariables(pixie.PromptVariables):
+    context: str
+    question: str
+
+
+class RewritePromptVariables(pixie.PromptVariables):
+    question: str
+
+
+class GeneratePromptVariables(pixie.PromptVariables):
+    question: str
+    context: str
+
+
+rag_grade_prompt = pixie.create_prompt(
+    "rag_grade_documents",
+    GradePromptVariables,
+    description="Grades relevance of retrieved documents to user questions",
+)
+rag_rewrite_prompt = pixie.create_prompt(
+    "rag_rewrite_question",
+    RewritePromptVariables,
+    description="Rewrites questions to improve semantic understanding",
+)
+rag_generate_prompt = pixie.create_prompt(
+    "rag_generate_answer",
+    GeneratePromptVariables,
+    description="Generates concise answers from retrieved context",
+)
+
 langfuse_handler = CallbackHandler()
 
 
@@ -102,14 +132,6 @@ def create_rag_graph(retriever, model):
             description="Relevance score: 'yes' if relevant, or 'no' if not relevant"
         )
 
-    GRADE_PROMPT = (
-        "You are a grader assessing relevance of a retrieved document to a user question. \n "
-        "Here is the retrieved document: \n\n {context} \n\n"
-        "Here is the user question: {question} \n"
-        "If the document contains keyword(s) or semantic meaning related to the user question, grade it as relevant. \n"
-        "Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question."
-    )
-
     grader_model = init_chat_model("gpt-4o", temperature=0)
 
     # Conditional edge: Grade documents
@@ -117,10 +139,12 @@ def create_rag_graph(retriever, model):
         state: MessagesState,
     ) -> Literal["generate_answer", "rewrite_question"]:
         """Determine whether the retrieved documents are relevant to the question."""
-        question = state["messages"][0].content
-        context = state["messages"][-1].content
+        question = cast(str, state["messages"][0].content)
+        context = cast(str, state["messages"][-1].content)
 
-        prompt = GRADE_PROMPT.format(question=question, context=context)
+        prompt = rag_grade_prompt.compile(
+            GradePromptVariables(question=question, context=context)
+        )
         response = grader_model.with_structured_output(GradeDocuments).invoke(
             [{"role": "user", "content": prompt}],
             config={"callbacks": [langfuse_handler]},
@@ -133,20 +157,11 @@ def create_rag_graph(retriever, model):
             return "rewrite_question"
 
     # Node: Rewrite question
-    REWRITE_PROMPT = (
-        "Look at the input and try to reason about the underlying semantic intent / meaning.\n"
-        "Here is the initial question:"
-        "\n ------- \n"
-        "{question}"
-        "\n ------- \n"
-        "Formulate an improved question:"
-    )
-
     def rewrite_question(state: MessagesState):
         """Rewrite the original user question."""
         messages = state["messages"]
-        question = messages[0].content
-        prompt = REWRITE_PROMPT.format(question=question)
+        question = cast(str, messages[0].content)
+        prompt = rag_rewrite_prompt.compile(RewritePromptVariables(question=question))
         response = model.invoke(
             [{"role": "user", "content": prompt}],
             config={"callbacks": [langfuse_handler]},
@@ -154,20 +169,13 @@ def create_rag_graph(retriever, model):
         return {"messages": [HumanMessage(content=response.content)]}
 
     # Node: Generate answer
-    GENERATE_PROMPT = (
-        "You are an assistant for question-answering tasks. "
-        "Use the following pieces of retrieved context to answer the question. "
-        "If you don't know the answer, just say that you don't know. "
-        "Use three sentences maximum and keep the answer concise.\n"
-        "Question: {question} \n"
-        "Context: {context}"
-    )
-
     def generate_answer(state: MessagesState):
         """Generate an answer."""
-        question = state["messages"][0].content
-        context = state["messages"][-1].content
-        prompt = GENERATE_PROMPT.format(question=question, context=context)
+        question = cast(str, state["messages"][0].content)
+        context = cast(str, state["messages"][-1].content)
+        prompt = rag_generate_prompt.compile(
+            GeneratePromptVariables(question=question, context=context)
+        )
         response = model.invoke(
             [{"role": "user", "content": prompt}],
             config={"callbacks": [langfuse_handler]},

{pixie_examples-0.1.1.dev5 → pixie_examples-0.1.1.dev14}/examples/langgraph/langgraph_sql_agent.py

@@ -22,6 +22,21 @@ from langfuse.langchain import CallbackHandler
 import pixie
 
 
+class LanggraphSqlPromptVariables(pixie.PromptVariables):
+    dialect: str
+
+
+langgraph_sql_generate_prompt = pixie.create_prompt(
+    "langgraph_sql_generate_query",
+    LanggraphSqlPromptVariables,
+    description="Generates SQL queries from natural language questions",
+)
+langgraph_sql_check_prompt = pixie.create_prompt(
+    "langgraph_sql_check_query",
+    LanggraphSqlPromptVariables,
+    description="Reviews and validates SQL queries for common mistakes",
+)
+
 langfuse_handler = CallbackHandler()
 
 
@@ -84,22 +99,11 @@ def create_sql_graph(db: SQLDatabase, model):
         return {"messages": [response]}
 
     # Node: Generate query
-    generate_query_prompt = f"""
-You are an agent designed to interact with a SQL database.
-Given an input question, create a syntactically correct {db.dialect} query to run,
-then look at the results of the query and return the answer. Unless the user
-specifies a specific number of examples they wish to obtain, always limit your
-query to at most 5 results.
-
-You can order the results by a relevant column to return the most interesting
-examples in the database. Never query for all the columns from a specific table,
-only ask for the relevant columns given the question.
-
-DO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database.
-"""
-
     def generate_query(state: MessagesState):
-        system_message = {"role": "system", "content": generate_query_prompt}
+        generate_query_prompt_text = langgraph_sql_generate_prompt.compile(
+            LanggraphSqlPromptVariables(dialect=db.dialect)
+        )
+        system_message = {"role": "system", "content": generate_query_prompt_text}
         llm_with_tools = model.bind_tools([run_query_tool])
         response = llm_with_tools.invoke(
             [system_message] + state["messages"],
@@ -108,28 +112,13 @@ DO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the databa
         return {"messages": [response]}
 
     # Node: Check query
-    check_query_prompt = f"""
-You are a SQL expert with a strong attention to detail.
-Double check the {db.dialect} query for common mistakes, including:
-- Using NOT IN with NULL values
-- Using UNION when UNION ALL should have been used
-- Using BETWEEN for exclusive ranges
-- Data type mismatch in predicates
-- Properly quoting identifiers
-- Using the correct number of arguments for functions
-- Casting to the correct data type
-- Using the proper columns for joins
-
-If there are any of the above mistakes, rewrite the query. If there are no mistakes,
-just reproduce the original query.
-
-You will call the appropriate tool to execute the query after running this check.
-"""
-
     def check_query(state: MessagesState):
         from langchain.messages import AIMessage as AI
 
-        system_message = {"role": "system", "content": check_query_prompt}
+        check_query_prompt_text = langgraph_sql_check_prompt.compile(
+            LanggraphSqlPromptVariables(dialect=db.dialect)
+        )
+        system_message = {"role": "system", "content": check_query_prompt_text}
         last_message = state["messages"][-1]
         # Only AIMessage has tool_calls
         if isinstance(last_message, AI) and last_message.tool_calls:

{pixie_examples-0.1.1.dev5 → pixie_examples-0.1.1.dev14}/examples/openai_agents_sdk/customer_service.py

@@ -26,10 +26,23 @@ from agents import (
     function_tool,
     handoff,
 )
-from agents.extensions.handoff_prompt import RECOMMENDED_PROMPT_PREFIX
 import pixie
 
 
+faq_agent_prompt = pixie.create_prompt(
+    "airline_faq_agent",
+    description="FAQ agent that answers customer questions using knowledge base lookup",
+)
+seat_booking_agent_prompt = pixie.create_prompt(
+    "airline_seat_booking_agent",
+    description="Seat booking agent that updates flight seat assignments",
+)
+triage_agent_prompt = pixie.create_prompt(
+    "airline_triage_agent",
+    description="Triage agent that delegates customer inquiries to appropriate specialists",
+)
+
+
 # ============================================================================
 # CONTEXT
 # ============================================================================
@@ -134,62 +147,58 @@ async def on_seat_booking_handoff(
 
 
 # ============================================================================
-# AGENTS
+# AGENTS (Lazy initialization to avoid compile() at module import time)
 # ============================================================================
 
-faq_agent = Agent[AirlineAgentContext](
-    name="FAQ Agent",
-    handoff_description="A helpful agent that can answer questions about the airline.",
-    instructions=f"""{RECOMMENDED_PROMPT_PREFIX}
+_faq_agent: Agent[AirlineAgentContext] | None = None
+_seat_booking_agent: Agent[AirlineAgentContext] | None = None
+_triage_agent: Agent[AirlineAgentContext] | None = None
+_agents_initialized: bool = False
 
-    You are an FAQ agent. If you are speaking to a customer, you probably were
-    transferred to from the triage agent.
 
-    Use the following routine to support the customer.
+def _initialize_agents() -> None:
+    """Initialize all agents with proper handoffs."""
+    global _faq_agent, _seat_booking_agent, _triage_agent, _agents_initialized
 
-    # Routine
-    1. Identify the last question asked by the customer.
-    2. Use the faq lookup tool to answer the question. Do not rely on your own knowledge.
-    3. If you cannot answer the question, transfer back to the triage agent.""",
-    tools=[faq_lookup_tool],
-)
+    if _agents_initialized:
+        return
 
-seat_booking_agent = Agent[AirlineAgentContext](
-    name="Seat Booking Agent",
-    handoff_description="A helpful agent that can update a seat on a flight.",
-    instructions=f"""{RECOMMENDED_PROMPT_PREFIX}
+    _faq_agent = Agent[AirlineAgentContext](
+        name="FAQ Agent",
+        handoff_description="A helpful agent that can answer questions about the airline.",
+        instructions=faq_agent_prompt.compile(),
+        tools=[faq_lookup_tool],
+    )
 
-    You are a seat booking agent. If you are speaking to a customer, you probably were
-    transferred to from the triage agent.
+    _seat_booking_agent = Agent[AirlineAgentContext](
+        name="Seat Booking Agent",
+        handoff_description="A helpful agent that can update a seat on a flight.",
+        instructions=seat_booking_agent_prompt.compile(),
+        tools=[update_seat],
+    )
 
-    Use the following routine to support the customer.
+    _triage_agent = Agent[AirlineAgentContext](
+        name="Triage Agent",
+        handoff_description="A triage agent that can delegate a customer's request to the appropriate agent.",
+        instructions=triage_agent_prompt.compile(),
+        handoffs=[
+            _faq_agent,
+            handoff(agent=_seat_booking_agent, on_handoff=on_seat_booking_handoff),
+        ],
+    )
 
-    # Routine
-    1. Ask for their confirmation number.
-    2. Ask the customer what their desired seat number is.
-    3. Use the update seat tool to update the seat on the flight.
+    # Set up bidirectional handoffs
+    _faq_agent.handoffs.append(_triage_agent)
+    _seat_booking_agent.handoffs.append(_triage_agent)
 
-    If the customer asks a question that is not related to the routine, transfer back to the
-    triage agent.""",
-    tools=[update_seat],
-)
+    _agents_initialized = True
 
-triage_agent = Agent[AirlineAgentContext](
-    name="Triage Agent",
-    handoff_description="A triage agent that can delegate a customer's request to the appropriate agent.",
-    instructions=(
-        f"{RECOMMENDED_PROMPT_PREFIX} "
-        "You are a helpful triaging agent. You can use your tools to delegate questions to other appropriate agents."
-    ),
-    handoffs=[
-        faq_agent,
-        handoff(agent=seat_booking_agent, on_handoff=on_seat_booking_handoff),
-    ],
-)
 
-# Set up bidirectional handoffs
-faq_agent.handoffs.append(triage_agent)
-seat_booking_agent.handoffs.append(triage_agent)
+def get_triage_agent() -> Agent[AirlineAgentContext]:
+    """Get the triage agent (entry point)."""
+    _initialize_agents()
+    assert _triage_agent is not None
+    return _triage_agent
 
 
 @pixie.app
@@ -210,7 +219,7 @@ async def openai_agents_airline_customer_service() -> pixie.PixieGenerator[str,
     Receives:
         User messages via InputRequired
     """
-    current_agent: Agent[AirlineAgentContext] = triage_agent
+    current_agent: Agent[AirlineAgentContext] = get_triage_agent()
     input_items: list[TResponseInputItem] = []
     context = AirlineAgentContext()