signalwire-agents 0.1.6__py3-none-any.whl → 1.0.7__py3-none-any.whl

signalwire_agents/core/agent_base.py

@@ -1,3 +1,4 @@
+#!/usr/bin/env python3
 """
 Copyright (c) 2025 SignalWire
 
@@ -7,24 +8,24 @@ Licensed under the MIT License.
 See LICENSE file in the project root for full license information.
 """
 
+# -*- coding: utf-8 -*-
 """
-AgentBase - Core foundation class for all SignalWire AI Agents
+Base class for all SignalWire AI Agents
 """
 
-import functools
-import inspect
 import os
-import sys
+import json
+import time
 import uuid
-import tempfile
-import traceback
-from typing import Dict, List, Any, Optional, Union, Callable, Tuple, Type, TypeVar
 import base64
-import secrets
-from urllib.parse import urlparse
-import json
-from datetime import datetime
+import logging
+import inspect
+import functools
 import re
+import signal
+import sys
+from typing import Optional, Union, List, Dict, Any, Tuple, Callable, Type
+from urllib.parse import urlparse, urlencode, urlunparse
 
 try:
     import fastapi
@@ -43,45 +44,47 @@ except ImportError:
         "uvicorn is required. Install it with: pip install uvicorn"
     )
 
-try:
-    import structlog
-    # Configure structlog only if not already configured
-    if not structlog.is_configured():
-        structlog.configure(
-            processors=[
-                structlog.stdlib.filter_by_level,
-                structlog.stdlib.add_logger_name,
-                structlog.stdlib.add_log_level,
-                structlog.stdlib.PositionalArgumentsFormatter(),
-                structlog.processors.TimeStamper(fmt="iso"),
-                structlog.processors.StackInfoRenderer(),
-                structlog.processors.format_exc_info,
-                structlog.processors.UnicodeDecoder(),
-                structlog.processors.JSONRenderer()
-            ],
-            context_class=dict,
-            logger_factory=structlog.stdlib.LoggerFactory(),
-            wrapper_class=structlog.stdlib.BoundLogger,
-            cache_logger_on_first_use=True,
-        )
-except ImportError:
-    raise ImportError(
-        "structlog is required. Install it with: pip install structlog"
-    )
-
 from signalwire_agents.core.pom_builder import PomBuilder
 from signalwire_agents.core.swaig_function import SWAIGFunction
 from signalwire_agents.core.function_result import SwaigFunctionResult
 from signalwire_agents.core.swml_renderer import SwmlRenderer
 from signalwire_agents.core.security.session_manager import SessionManager
-from signalwire_agents.core.state import StateManager, FileStateManager
 from signalwire_agents.core.swml_service import SWMLService
 from signalwire_agents.core.swml_handler import AIVerbHandler
+from signalwire_agents.core.skill_manager import SkillManager
+from signalwire_agents.utils.schema_utils import SchemaUtils
+from signalwire_agents.core.logging_config import get_logger, get_execution_mode
+
+# Import refactored components
+from signalwire_agents.core.agent.prompt.manager import PromptManager
+from signalwire_agents.core.agent.tools.registry import ToolRegistry
+from signalwire_agents.core.agent.tools.decorator import ToolDecorator
+
+# Import all mixins
+from signalwire_agents.core.mixins.prompt_mixin import PromptMixin
+from signalwire_agents.core.mixins.tool_mixin import ToolMixin
+from signalwire_agents.core.mixins.web_mixin import WebMixin
+from signalwire_agents.core.mixins.auth_mixin import AuthMixin
+from signalwire_agents.core.mixins.skill_mixin import SkillMixin
+from signalwire_agents.core.mixins.ai_config_mixin import AIConfigMixin
+from signalwire_agents.core.mixins.serverless_mixin import ServerlessMixin
+from signalwire_agents.core.mixins.state_mixin import StateMixin
 
-# Create a logger
-logger = structlog.get_logger("agent_base")
+# Create a logger using centralized system
+logger = get_logger("agent_base")
 
-class AgentBase(SWMLService):
+
+class AgentBase(
+    AuthMixin,
+    WebMixin,
+    SWMLService,
+    PromptMixin,
+    ToolMixin,
+    SkillMixin,
+    AIConfigMixin,
+    ServerlessMixin,
+    StateMixin
+):
     """
     Base class for all SignalWire AI Agents.
     
@@ -109,18 +112,19 @@ class AgentBase(SWMLService):
         port: int = 3000,
         basic_auth: Optional[Tuple[str, str]] = None,
         use_pom: bool = True,
-        enable_state_tracking: bool = False,
-        token_expiry_secs: int = 600,
+        token_expiry_secs: int = 3600,
         auto_answer: bool = True,
         record_call: bool = False,
         record_format: str = "mp4",
         record_stereo: bool = True,
-        state_manager: Optional[StateManager] = None,
         default_webhook_url: Optional[str] = None,
         agent_id: Optional[str] = None,
         native_functions: Optional[List[str]] = None,
         schema_path: Optional[str] = None,
-        suppress_logs: bool = False
+                suppress_logs: bool = False,
+        enable_post_prompt_override: bool = False,
+        check_for_input_override: bool = False,
+        config_file: Optional[str] = None
     ):
         """
         Initialize a new agent
@@ -132,18 +136,19 @@ class AgentBase(SWMLService):
             port: Port to bind the web server to
             basic_auth: Optional (username, password) tuple for basic auth
             use_pom: Whether to use POM for prompt building
-            enable_state_tracking: Whether to register startup_hook and hangup_hook SWAIG functions to track conversation state
             token_expiry_secs: Seconds until tokens expire
             auto_answer: Whether to automatically answer calls
             record_call: Whether to record calls
             record_format: Recording format
             record_stereo: Whether to record in stereo
-            state_manager: Optional state manager for this agent
             default_webhook_url: Optional default webhook URL for all SWAIG functions
             agent_id: Optional unique ID for this agent, generated if not provided
             native_functions: Optional list of native functions to include in the SWAIG object
             schema_path: Optional path to the schema file
             suppress_logs: Whether to suppress structured logs
+            enable_post_prompt_override: Whether to enable post-prompt override
+            check_for_input_override: Whether to enable check-for-input override
+            config_file: Optional path to configuration file
         """
         # Import SWMLService here to avoid circular imports
         from signalwire_agents.core.swml_service import SWMLService
@@ -151,19 +156,29 @@ class AgentBase(SWMLService):
         # If schema_path is not provided, we'll let SWMLService find it through its _find_schema_path method
         # which will be called in its __init__
         
+        # Load service configuration from config file before initializing SWMLService
+        service_config = self._load_service_config(config_file, name)
+        
+        # Apply service config values, with constructor parameters taking precedence
+        final_route = route if route != "/" else service_config.get('route', route)
+        final_host = host if host != "0.0.0.0" else service_config.get('host', host)
+        final_port = port if port != 3000 else service_config.get('port', port)
+        final_name = service_config.get('name', name)
+        
         # Initialize the SWMLService base class
         super().__init__(
-            name=name,
-            route=route,
-            host=host,
-            port=port,
+            name=final_name,
+            route=final_route,
+            host=final_host,
+            port=final_port,
             basic_auth=basic_auth,
-            schema_path=schema_path
+            schema_path=schema_path,
+            config_file=config_file
         )
         
         # Log the schema path if found and not suppressing logs
         if self.schema_utils and self.schema_utils.schema_path and not suppress_logs:
-            print(f"Using schema.json at: {self.schema_utils.schema_path}")
+            self.log.debug("using_schema_path", path=self.schema_utils.schema_path)
         
         # Setup logger for this instance
         self.log = logger.bind(agent=name)
@@ -181,8 +196,6 @@ class AgentBase(SWMLService):
         
         # Initialize prompt handling
         self._use_pom = use_pom
-        self._raw_prompt = None
-        self._post_prompt = None
         
         # Initialize POM if needed
         if self._use_pom:
@@ -198,11 +211,9 @@ class AgentBase(SWMLService):
             self.pom = None
         
         # Initialize tool registry (separate from SWMLService verb registry)
-        self._swaig_functions: Dict[str, SWAIGFunction] = {}
         
         # Initialize session manager
         self._session_manager = SessionManager(token_expiry_secs=token_expiry_secs)
-        self._enable_state_tracking = enable_state_tracking
         
         # URL override variables
         self._web_hook_url_override = None
@@ -217,21 +228,20 @@ class AgentBase(SWMLService):
         self._record_format = record_format
         self._record_stereo = record_stereo
         
+        # Initialize refactored managers early
+        self._prompt_manager = PromptManager(self)
+        self._tool_registry = ToolRegistry(self)
+        
         # Process declarative PROMPT_SECTIONS if defined in subclass
         self._process_prompt_sections()
         
-        # Initialize state manager
-        self._state_manager = state_manager or FileStateManager()
         
         # Process class-decorated tools (using @AgentBase.tool)
-        self._register_class_decorated_tools()
+        self._tool_registry.register_class_decorated_tools()
         
         # Add native_functions parameter
         self.native_functions = native_functions or []
         
-        # Register state tracking tools if enabled
-        if enable_state_tracking:
-            self._register_state_tracking_tools()
         
         # Initialize new configuration containers
         self._hints = []
@@ -240,646 +250,464 @@ class AgentBase(SWMLService):
         self._params = {}
         self._global_data = {}
         self._function_includes = []
+        # Initialize LLM params as empty - only send if explicitly set
+        self._prompt_llm_params = {}
+        self._post_prompt_llm_params = {}
+        
+        # Dynamic configuration callback
+        self._dynamic_config_callback = None
+        
+        # Initialize skill manager
+        self.skill_manager = SkillManager(self)
+        
+        # Initialize contexts system
+        self._contexts_builder = None
+        self._contexts_defined = False
+        
+        # Initialize SWAIG query params for dynamic config
+        self._swaig_query_params = {}
+
+        # Initialize verb insertion points for call flow customization
+        self._pre_answer_verbs = []    # Verbs to run before answer (e.g., ringback, screening)
+        self._answer_config = {}        # Configuration for the answer verb
+        self._post_answer_verbs = []    # Verbs to run after answer, before AI (e.g., announcements)
+        self._post_ai_verbs = []        # Verbs to run after AI ends (e.g., cleanup, transfers)
+
+    # Verb categories for pre-answer validation
+    _PRE_ANSWER_SAFE_VERBS = {
+        "transfer", "execute", "return", "label", "goto", "request",
+        "switch", "cond", "if", "eval", "set", "unset", "hangup",
+        "send_sms", "sleep", "stop_record_call", "stop_denoise", "stop_tap"
+    }
+    _AUTO_ANSWER_VERBS = {"play", "connect"}
+
+    @staticmethod
+    def _load_service_config(config_file: Optional[str], service_name: str) -> dict:
+        """Load service configuration from config file if available"""
+        from signalwire_agents.core.config_loader import ConfigLoader
+        
+        # Find config file
+        if not config_file:
+            config_file = ConfigLoader.find_config_file(service_name)
+        
+        if not config_file:
+            return {}
+            
+        # Load config
+        config_loader = ConfigLoader([config_file])
+        if not config_loader.has_config():
+            return {}
+        
+        # Get service section
+        service_config = config_loader.get_section('service')
+        if service_config:
+            return service_config
+            
+        return {}
     
-    def _process_prompt_sections(self):
+    def get_name(self) -> str:
         """
-        Process declarative PROMPT_SECTIONS attribute from a subclass
+        Get agent name
         
-        This auto-vivifies section methods and bootstraps the prompt
-        from class declaration, allowing for declarative agents.
+        Returns:
+            Agent name
         """
-        # Skip if no PROMPT_SECTIONS defined or not using POM
-        cls = self.__class__
-        if not hasattr(cls, 'PROMPT_SECTIONS') or cls.PROMPT_SECTIONS is None or not self._use_pom:
-            return
-            
-        sections = cls.PROMPT_SECTIONS
-        
-        # If sections is a dictionary mapping section names to content
-        if isinstance(sections, dict):
-            for title, content in sections.items():
-                # Handle different content types
-                if isinstance(content, str):
-                    # Plain text - add as body
-                    self.prompt_add_section(title, body=content)
-                elif isinstance(content, list) and content:  # Only add if non-empty
-                    # List of strings - add as bullets
-                    self.prompt_add_section(title, bullets=content)
-                elif isinstance(content, dict):
-                    # Dictionary with body/bullets/subsections
-                    body = content.get('body', '')
-                    bullets = content.get('bullets', [])
-                    numbered = content.get('numbered', False)
-                    numbered_bullets = content.get('numberedBullets', False)
-                    
-                    # Only create section if it has content
-                    if body or bullets or 'subsections' in content:
-                        # Create the section
-                        self.prompt_add_section(
-                            title, 
-                            body=body, 
-                            bullets=bullets if bullets else None,
-                            numbered=numbered,
-                            numbered_bullets=numbered_bullets
-                        )
-                        
-                        # Process subsections if any
-                        subsections = content.get('subsections', [])
-                        for subsection in subsections:
-                            if 'title' in subsection:
-                                sub_title = subsection['title']
-                                sub_body = subsection.get('body', '')
-                                sub_bullets = subsection.get('bullets', [])
-                                
-                                # Only add subsection if it has content
-                                if sub_body or sub_bullets:
-                                    self.prompt_add_subsection(
-                                        title, 
-                                        sub_title,
-                                        body=sub_body,
-                                        bullets=sub_bullets if sub_bullets else None
-                                    )
-        # If sections is a list of section objects, use the POM format directly
-        elif isinstance(sections, list):
-            if self.pom:
-                # Process each section using auto-vivifying methods
-                for section in sections:
-                    if 'title' in section:
-                        title = section['title']
-                        body = section.get('body', '')
-                        bullets = section.get('bullets', [])
-                        numbered = section.get('numbered', False)
-                        numbered_bullets = section.get('numberedBullets', False)
-                        
-                        # Only create section if it has content
-                        if body or bullets or 'subsections' in section:
-                            self.prompt_add_section(
-                                title,
-                                body=body,
-                                bullets=bullets if bullets else None,
-                                numbered=numbered,
-                                numbered_bullets=numbered_bullets
-                            )
-                            
-                            # Process subsections if any
-                            subsections = section.get('subsections', [])
-                            for subsection in subsections:
-                                if 'title' in subsection:
-                                    sub_title = subsection['title']
-                                    sub_body = subsection.get('body', '')
-                                    sub_bullets = subsection.get('bullets', [])
-                                    
-                                    # Only add subsection if it has content
-                                    if sub_body or sub_bullets:
-                                        self.prompt_add_subsection(
-                                            title,
-                                            sub_title,
-                                            body=sub_body,
-                                            bullets=sub_bullets if sub_bullets else None
-                                        )
-    
-    # ----------------------------------------------------------------------
-    # Prompt Building Methods
-    # ----------------------------------------------------------------------
+        return self.name
     
-    def set_prompt_text(self, text: str) -> 'AgentBase':
+    def get_full_url(self, include_auth: bool = False) -> str:
         """
-        Set the prompt as raw text instead of using POM
+        Get the full URL for this agent's endpoint
         
         Args:
-            text: The raw prompt text
+            include_auth: Whether to include authentication credentials in the URL
             
+        Returns:
+            Full URL including host, port, and route (with auth if requested)
+        """
+        mode = get_execution_mode()
+
+        if mode == 'cgi':
+            protocol = 'https' if os.getenv('HTTPS') == 'on' else 'http'
+            host = os.getenv('HTTP_HOST') or os.getenv('SERVER_NAME') or 'localhost'
+            script_name = os.getenv('SCRIPT_NAME', '')
+            base_url = f"{protocol}://{host}{script_name}"
+        elif mode == 'lambda':
+            # AWS Lambda Function URL format
+            lambda_url = os.getenv('AWS_LAMBDA_FUNCTION_URL')
+            if lambda_url:
+                base_url = lambda_url.rstrip('/')
+            else:
+                # Fallback construction for Lambda
+                region = os.getenv('AWS_REGION', 'us-east-1')
+                function_name = os.getenv('AWS_LAMBDA_FUNCTION_NAME', 'unknown')
+                base_url = f"https://{function_name}.lambda-url.{region}.on.aws"
+        elif mode == 'google_cloud_function':
+            # Google Cloud Functions URL format
+            project_id = os.getenv('GOOGLE_CLOUD_PROJECT') or os.getenv('GCP_PROJECT')
+            region = os.getenv('FUNCTION_REGION') or os.getenv('GOOGLE_CLOUD_REGION', 'us-central1')
+            service_name = os.getenv('K_SERVICE') or os.getenv('FUNCTION_TARGET', 'unknown')
+            
+            if project_id:
+                base_url = f"https://{region}-{project_id}.cloudfunctions.net/{service_name}"
+            else:
+                # Fallback for local testing or incomplete environment
+                base_url = f"https://localhost:8080"
+        elif mode == 'azure_function':
+            # Azure Functions URL format
+            function_app_name = os.getenv('WEBSITE_SITE_NAME') or os.getenv('AZURE_FUNCTIONS_APP_NAME')
+            function_name = os.getenv('AZURE_FUNCTION_NAME', 'unknown')
+            
+            if function_app_name:
+                base_url = f"https://{function_app_name}.azurewebsites.net/api/{function_name}"
+            else:
+                # Fallback for local testing
+                base_url = f"https://localhost:7071/api/{function_name}"
+        else:
+            # Server mode - use the SWMLService's unified URL building
+            # Build the full URL using the parent's method
+            base_url = self._build_full_url(endpoint="", include_auth=include_auth)
+            return base_url
+        
+        # For serverless modes, add authentication if requested
+        if include_auth:
+            username, password = self.get_basic_auth_credentials()
+            if username and password:
+                # Parse URL to insert auth
+                from urllib.parse import urlparse, urlunparse
+                parsed = urlparse(base_url)
+                # Reconstruct with auth
+                base_url = urlunparse((
+                    parsed.scheme,
+                    f"{username}:{password}@{parsed.netloc}",
+                    parsed.path,
+                    parsed.params,
+                    parsed.query,
+                    parsed.fragment
+                ))
+        
+        # Add route for serverless modes
+        if self.route and self.route != "/" and not base_url.endswith(self.route):
+            base_url = f"{base_url}/{self.route.lstrip('/')}"
+        
+        return base_url
+    
+    def on_summary(self, summary: Optional[Dict[str, Any]], raw_data: Optional[Dict[str, Any]] = None) -> None:
+        """
+        Called when a post-prompt summary is received
+
+        Args:
+            summary: The summary object or None if no summary was found
+            raw_data: The complete raw POST data from the request
+        """
+        # Default implementation does nothing
+        pass
+
+    # ==================== Call Flow Verb Insertion Methods ====================
+
+    def add_pre_answer_verb(self, verb_name: str, config: Dict[str, Any]) -> 'AgentBase':
+        """
+        Add a verb to run before the call is answered.
+
+        Pre-answer verbs execute while the call is still ringing. Only certain
+        verbs are safe to use before answering:
+
+        Safe verbs: transfer, execute, return, label, goto, request, switch,
+                   cond, if, eval, set, unset, hangup, send_sms, sleep,
+                   stop_record_call, stop_denoise, stop_tap
+
+        Verbs with auto_answer option (play, connect): Must include
+        "auto_answer": False in config to prevent automatic answering.
+
+        Args:
+            verb_name: The SWML verb name (e.g., "play", "sleep", "request")
+            config: Verb configuration dictionary
+
         Returns:
             Self for method chaining
+
+        Raises:
+            ValueError: If verb is not safe for pre-answer use
+
+        Example:
+            # Play ringback tone before answering
+            agent.add_pre_answer_verb("play", {
+                "urls": ["ring:us"],
+                "auto_answer": False
+            })
         """
-        self._raw_prompt = text
+        # Validate verb is safe for pre-answer use
+        if verb_name in self._AUTO_ANSWER_VERBS:
+            if not config.get("auto_answer") is False:
+                self.log.warning(
+                    "pre_answer_verb_will_answer",
+                    verb=verb_name,
+                    hint=f"Add 'auto_answer': False to prevent {verb_name} from answering the call"
+                )
+        elif verb_name not in self._PRE_ANSWER_SAFE_VERBS:
+            raise ValueError(
+                f"Verb '{verb_name}' is not safe for pre-answer use. "
+                f"Safe verbs: {', '.join(sorted(self._PRE_ANSWER_SAFE_VERBS))}"
+            )
+
+        self._pre_answer_verbs.append((verb_name, config))
         return self
-    
-    def set_prompt_pom(self, pom: List[Dict[str, Any]]) -> 'AgentBase':
+
+    def add_answer_verb(self, config: Optional[Dict[str, Any]] = None) -> 'AgentBase':
         """
-        Set the prompt as a POM dictionary
-        
+        Configure the answer verb.
+
+        The answer verb connects the call. Use this method to customize
+        answer behavior, such as setting max_duration.
+
         Args:
-            pom: POM dictionary structure
-            
+            config: Optional answer verb configuration (e.g., {"max_duration": 3600})
+
         Returns:
             Self for method chaining
+
+        Example:
+            # Set maximum call duration to 1 hour
+            agent.add_answer_verb({"max_duration": 3600})
         """
-        if self._use_pom:
-            self.pom = pom
-        else:
-            raise ValueError("use_pom must be True to use set_prompt_pom")
+        self._answer_config = config or {}
         return self
-    
-    def prompt_add_section(
-        self, 
-        title: str, 
-        body: str = "", 
-        bullets: Optional[List[str]] = None,
-        numbered: bool = False,
-        numbered_bullets: bool = False,
-        subsections: Optional[List[Dict[str, Any]]] = None
-    ) -> 'AgentBase':
+
+    def add_post_answer_verb(self, verb_name: str, config: Dict[str, Any]) -> 'AgentBase':
         """
-        Add a section to the prompt
-        
+        Add a verb to run after the call is answered but before the AI starts.
+
+        Post-answer verbs run after the call is connected. Common uses include
+        welcome messages, legal disclaimers, and hold music.
+
         Args:
-            title: Section title
-            body: Optional section body text
-            bullets: Optional list of bullet points
-            numbered: Whether this section should be numbered
-            numbered_bullets: Whether bullets should be numbered
-            subsections: Optional list of subsection objects
-            
+            verb_name: The SWML verb name (e.g., "play", "sleep")
+            config: Verb configuration dictionary
+
         Returns:
             Self for method chaining
+
+        Example:
+            # Play welcome message
+            agent.add_post_answer_verb("play", {
+                "url": "say:Welcome to Acme Corporation."
+            })
+            # Brief pause
+            agent.add_post_answer_verb("sleep", {"time": 500})
         """
-        if self._use_pom and self.pom:
-            # Create parameters for add_section based on what's supported
-            kwargs = {}
-            
-            # Start with basic parameters
-            kwargs['title'] = title
-            kwargs['body'] = body
-            if bullets:
-                kwargs['bullets'] = bullets
-            
-            # Add optional parameters if they look supported
-            if hasattr(self.pom, 'add_section'):
-                sig = inspect.signature(self.pom.add_section)
-                if 'numbered' in sig.parameters:
-                    kwargs['numbered'] = numbered
-                if 'numberedBullets' in sig.parameters:
-                    kwargs['numberedBullets'] = numbered_bullets
-            
-            # Create the section
-            section = self.pom.add_section(**kwargs)
-            
-            # Now add subsections if provided, by calling add_subsection on the section
-            if subsections:
-                for subsection in subsections:
-                    if 'title' in subsection:
-                        section.add_subsection(
-                            title=subsection.get('title'),
-                            body=subsection.get('body', ''),
-                            bullets=subsection.get('bullets', [])
-                        )
-                
+        self._post_answer_verbs.append((verb_name, config))
         return self
-        
-    def prompt_add_to_section(
-        self,
-        title: str,
-        body: Optional[str] = None,
-        bullet: Optional[str] = None,
-        bullets: Optional[List[str]] = None
-    ) -> 'AgentBase':
+
+    def add_post_ai_verb(self, verb_name: str, config: Dict[str, Any]) -> 'AgentBase':
         """
-        Add content to an existing section (creating it if needed)
-        
+        Add a verb to run after the AI conversation ends.
+
+        Post-AI verbs run when the AI completes its conversation. Common uses
+        include clean disconnects, transfers, and logging.
+
         Args:
-            title: Section title
-            body: Optional text to append to section body
-            bullet: Optional single bullet point to add
-            bullets: Optional list of bullet points to add
-            
+            verb_name: The SWML verb name (e.g., "hangup", "transfer", "request")
+            config: Verb configuration dictionary
+
         Returns:
             Self for method chaining
+
+        Example:
+            # Log call completion and hang up
+            agent.add_post_ai_verb("request", {
+                "url": "https://api.example.com/call-complete",
+                "method": "POST"
+            })
+            agent.add_post_ai_verb("hangup", {})
         """
-        if self._use_pom and self.pom:
-            self.pom.add_to_section(
-                title=title,
-                body=body,
-                bullet=bullet,
-                bullets=bullets
-            )
+        self._post_ai_verbs.append((verb_name, config))
         return self
-        
-    def prompt_add_subsection(
-        self,
-        parent_title: str,
-        title: str,
-        body: str = "",
-        bullets: Optional[List[str]] = None
-    ) -> 'AgentBase':
+
+    def clear_pre_answer_verbs(self) -> 'AgentBase':
+        """
+        Remove all pre-answer verbs.
+
+        Returns:
+            Self for method chaining
+        """
+        self._pre_answer_verbs = []
+        return self
+
+    def clear_post_answer_verbs(self) -> 'AgentBase':
+        """
+        Remove all post-answer verbs.
+
+        Returns:
+            Self for method chaining
+        """
+        self._post_answer_verbs = []
+        return self
+
+    def clear_post_ai_verbs(self) -> 'AgentBase':
+        """
+        Remove all post-AI verbs.
+
+        Returns:
+            Self for method chaining
+        """
+        self._post_ai_verbs = []
+        return self
+
+    # ==================== End Call Flow Verb Insertion Methods ====================
+
+    def enable_sip_routing(self, auto_map: bool = True, path: str = "/sip") -> 'AgentBase':
         """
-        Add a subsection to an existing section (creating parent if needed)
+        Enable SIP-based routing for this agent
+        
+        This allows the agent to automatically route SIP requests based on SIP usernames.
+        When enabled, an endpoint at the specified path is automatically created
+        that will handle SIP requests and deliver them to this agent.
         
         Args:
-            parent_title: Parent section title
-            title: Subsection title
-            body: Optional subsection body text
-            bullets: Optional list of bullet points
-            
+            auto_map: Whether to automatically map common SIP usernames to this agent
+                     (based on the agent name and route path)
+            path: The path to register the SIP routing endpoint (default: "/sip")
+        
         Returns:
             Self for method chaining
         """
-        if self._use_pom and self.pom:
-            # First find or create the parent section
-            parent_section = None
-            
-            # Try to find the parent section by title
-            if hasattr(self.pom, 'sections'):
-                for section in self.pom.sections:
-                    if hasattr(section, 'title') and section.title == parent_title:
-                        parent_section = section
-                        break
+        # Create a routing callback that handles SIP usernames
+        def sip_routing_callback(request: Request, body: Dict[str, Any]) -> Optional[str]:
+            # Extract SIP username from the request body
+            sip_username = self.extract_sip_username(body)
             
-            # If parent section not found, create it
-            if not parent_section:
-                parent_section = self.pom.add_section(title=parent_title)
+            if sip_username:
+                self.log.info("sip_username_extracted", username=sip_username)
+                
+                # Check if this username is registered with this agent
+                if hasattr(self, '_sip_usernames') and sip_username.lower() in self._sip_usernames:
+                    self.log.info("sip_username_matched", username=sip_username)
+                    # This route is already being handled by the agent, no need to redirect
+                    return None
+                else:
+                    self.log.info("sip_username_not_matched", username=sip_username)
+                    # Not registered with this agent, let routing continue
+                    
+            return None
             
-            # Now call add_subsection on the parent section object, not on POM
-            parent_section.add_subsection(
-                title=title,
-                body=body,
-                bullets=bullets or []
-            )
+        # Register the callback with the SWMLService, specifying the path
+        self.register_routing_callback(sip_routing_callback, path=path)
+        
+        # Auto-map common usernames if requested
+        if auto_map:
+            self.auto_map_sip_usernames()
             
         return self
     
-    # ----------------------------------------------------------------------
-    # Tool/Function Management
-    # ----------------------------------------------------------------------
-    
-    def define_tool(
-        self, 
-        name: str, 
-        description: str, 
-        parameters: Dict[str, Any], 
-        handler: Callable,
-        secure: bool = True,
-        fillers: Optional[Dict[str, List[str]]] = None
-    ) -> 'AgentBase':
+    def register_sip_username(self, sip_username: str) -> 'AgentBase':
         """
-        Define a SWAIG function that the AI can call
+        Register a SIP username that should be routed to this agent
         
         Args:
-            name: Function name (must be unique)
-            description: Function description for the AI
-            parameters: JSON Schema of parameters
-            handler: Function to call when invoked
-            secure: Whether to require token validation
-            fillers: Optional dict mapping language codes to arrays of filler phrases
+            sip_username: SIP username to register
             
         Returns:
             Self for method chaining
         """
-        if name in self._swaig_functions:
-            raise ValueError(f"Tool with name '{name}' already exists")
+        if not hasattr(self, '_sip_usernames'):
+            self._sip_usernames = set()
             
-        self._swaig_functions[name] = SWAIGFunction(
-            name=name,
-            description=description,
-            parameters=parameters,
-            handler=handler,
-            secure=secure,
-            fillers=fillers
-        )
+        self._sip_usernames.add(sip_username.lower())
+        self.log.info("sip_username_registered", username=sip_username)
+        
         return self
     
-    def _tool_decorator(self, name=None, **kwargs):
+    def auto_map_sip_usernames(self) -> 'AgentBase':
         """
-        Decorator for defining SWAIG tools in a class
-        
-        Used as:
+        Automatically register common SIP usernames based on this agent's 
+        name and route
         
-        @agent.tool(name="example_function", parameters={...})
-        def example_function(self, param1):
-            # ...
+        Returns:
+            Self for method chaining
         """
-        def decorator(func):
-            nonlocal name
-            if name is None:
-                name = func.__name__
-                
-            parameters = kwargs.get("parameters", {})
-            description = kwargs.get("description", func.__doc__ or f"Function {name}")
-            secure = kwargs.get("secure", True)
-            fillers = kwargs.get("fillers", None)
+        # Register username based on agent name
+        clean_name = re.sub(r'[^a-z0-9_]', '', self.name.lower())
+        if clean_name:
+            self.register_sip_username(clean_name)
             
-            self.define_tool(
-                name=name,
-                description=description,
-                parameters=parameters,
-                handler=func,
-                secure=secure,
-                fillers=fillers
-            )
-            return func
-        return decorator
-    
-    @classmethod
-    def tool(cls, name=None, **kwargs):
-        """
-        Class method decorator for defining SWAIG tools
-        
-        Used as:
-        
-        @AgentBase.tool(name="example_function", parameters={...})
-        def example_function(self, param1):
-            # ...
-        """
-        def decorator(func):
-            setattr(func, "_is_tool", True)
-            setattr(func, "_tool_name", name or func.__name__)
-            setattr(func, "_tool_params", kwargs)
-            return func
-        return decorator
-    
-    # ----------------------------------------------------------------------
-    # Override Points for Subclasses
-    # ----------------------------------------------------------------------
+        # Register username based on route (without slashes)
+        clean_route = re.sub(r'[^a-z0-9_]', '', self.route.lower())
+        if clean_route and clean_route != clean_name:
+            self.register_sip_username(clean_route)
+            
+        # Register common variations if they make sense
+        if len(clean_name) > 3:
+            # Register without vowels
+            no_vowels = re.sub(r'[aeiou]', '', clean_name)
+            if no_vowels != clean_name and len(no_vowels) > 2:
+                self.register_sip_username(no_vowels)
+                
+        return self
     
-    def get_name(self) -> str:
+    def set_web_hook_url(self, url: str) -> 'AgentBase':
         """
-        Get the agent name
+        Override the default web_hook_url with a supplied URL string
         
+        Args:
+            url: The URL to use for SWAIG function webhooks
+            
         Returns:
-            Agent name/identifier
+            Self for method chaining
         """
-        return self.name
+        self._web_hook_url_override = url
+        return self
     
-    def get_prompt(self) -> Union[str, List[Dict[str, Any]]]:
+    def set_post_prompt_url(self, url: str) -> 'AgentBase':
         """
-        Get the prompt for the agent
+        Override the default post_prompt_url with a supplied URL string
         
+        Args:
+            url: The URL to use for post-prompt summary delivery
+            
         Returns:
-            Either a string prompt or a POM object as list of dicts
+            Self for method chaining
         """
-        # If using POM, return the POM structure
-        if self._use_pom and self.pom:
-            try:
-                # Try different methods that might be available on the POM implementation
-                if hasattr(self.pom, 'render_dict'):
-                    return self.pom.render_dict()
-                elif hasattr(self.pom, 'to_dict'):
-                    return self.pom.to_dict()
-                elif hasattr(self.pom, 'to_list'):
-                    return self.pom.to_list()
-                elif hasattr(self.pom, 'render'):
-                    render_result = self.pom.render()
-                    # If render returns a string, we need to convert it to JSON
-                    if isinstance(render_result, str):
-                        try:
-                            import json
-                            return json.loads(render_result)
-                        except:
-                            # If we can't parse as JSON, fall back to raw text
-                            pass
-                    return render_result
-                else:
-                    # Last resort: attempt to convert the POM object directly to a list/dict
-                    # This assumes the POM object has a reasonable __str__ or __repr__ method
-                    pom_data = self.pom.__dict__
-                    if '_sections' in pom_data and isinstance(pom_data['_sections'], list):
-                        return pom_data['_sections']
-                    # Fall through to default if nothing worked
-            except Exception as e:
-                print(f"Error rendering POM: {e}")
-                # Fall back to raw text if POM fails
-                
-        # Return raw text (either explicitly set or default)
-        return self._raw_prompt or f"You are {self.name}, a helpful AI assistant."
+        self._post_prompt_url_override = url
+        return self
     
-    def get_post_prompt(self) -> Optional[str]:
+    def add_swaig_query_params(self, params: Dict[str, str]) -> 'AgentBase':
         """
-        Get the post-prompt for the agent
+        Add query parameters that will be included in all SWAIG webhook URLs
         
+        This is particularly useful for preserving dynamic configuration state
+        across SWAIG callbacks. For example, if your dynamic config adds skills
+        based on query parameters, you can pass those same parameters through
+        to the SWAIG webhook so the same configuration is applied.
+        
+        Args:
+            params: Dictionary of query parameters to add to SWAIG URLs
+            
         Returns:
-            Post-prompt text or None if not set
+            Self for method chaining
+            
+        Example:
+            def dynamic_config(query_params, body_params, headers, agent):
+                if query_params.get('tier') == 'premium':
+                    agent.add_skill('advanced_search')
+                    # Preserve the tier param so SWAIG callbacks work
+                    agent.add_swaig_query_params({'tier': 'premium'})
         """
-        return self._post_prompt
+        if params and isinstance(params, dict):
+            self._swaig_query_params.update(params)
+        return self
     
-    def define_tools(self) -> List[SWAIGFunction]:
+    def clear_swaig_query_params(self) -> 'AgentBase':
         """
-        Define the tools this agent can use
+        Clear all SWAIG query parameters
         
         Returns:
-            List of SWAIGFunction objects
-            
-        This method can be overridden by subclasses.
+            Self for method chaining
         """
-        return list(self._swaig_functions.values())
+        self._swaig_query_params = {}
+        return self
     
-    def on_summary(self, summary: Optional[Dict[str, Any]], raw_data: Optional[Dict[str, Any]] = None) -> None:
+    def _render_swml(self, call_id: str = None, modifications: Optional[dict] = None) -> str:
         """
-        Called when a post-prompt summary is received
-        
-        Args:
-            summary: The summary object or None if no summary was found
-            raw_data: The complete raw POST data from the request
-        """
-        # Default implementation does nothing
-        pass
-    
-    def on_function_call(self, name: str, args: Dict[str, Any], raw_data: Optional[Dict[str, Any]] = None) -> Any:
-        """
-        Called when a SWAIG function is invoked
-        
-        Args:
-            name: Function name
-            args: Function arguments
-            raw_data: Raw request data
-            
-        Returns:
-            Function result
-        """
-        # Check if the function is registered
-        if name not in self._swaig_functions:
-            # If the function is not found, return an error
-            return {"response": f"Function '{name}' not found"}
-            
-        # Get the function
-        func = self._swaig_functions[name]
-        
-        # Call the handler
-        try:
-            result = func.handler(args, raw_data)
-            if result is None:
-                # If the handler returns None, create a default response
-                result = SwaigFunctionResult("Function executed successfully")
-            return result
-        except Exception as e:
-            # If the handler raises an exception, return an error response
-            return {"response": f"Error executing function '{name}': {str(e)}"}
-    
-    def validate_basic_auth(self, username: str, password: str) -> bool:
-        """
-        Validate basic auth credentials
-        
-        Args:
-            username: Username from request
-            password: Password from request
-            
-        Returns:
-            True if valid, False otherwise
-            
-        This method can be overridden by subclasses.
-        """
-        return (username, password) == self._basic_auth
-    
-    def _create_tool_token(self, tool_name: str, call_id: str) -> str:
-        """
-        Create a secure token for a tool call
-        
-        Args:
-            tool_name: Name of the tool
-            call_id: Call ID for this session
-            
-        Returns:
-            Secure token string
-        """
-        return self._session_manager.create_tool_token(tool_name, call_id)
-    
-    def validate_tool_token(self, function_name: str, token: str, call_id: str) -> bool:
-        """
-        Validate a tool token
-        
-        Args:
-            function_name: Name of the function/tool
-            token: Token to validate
-            call_id: Call ID for the session
-            
-        Returns:
-            True if token is valid, False otherwise
-        """
-        # Skip validation for non-secure tools
-        if function_name not in self._swaig_functions:
-            return False
-            
-        if not self._swaig_functions[function_name].secure:
-            return True
-            
-        return self._session_manager.validate_tool_token(function_name, token, call_id)
-    
-    # ----------------------------------------------------------------------
-    # Web Server and Routing
-    # ----------------------------------------------------------------------
-    
-    def get_basic_auth_credentials(self, include_source: bool = False) -> Union[Tuple[str, str], Tuple[str, str, str]]:
-        """
-        Get the basic auth credentials
-        
-        Args:
-            include_source: Whether to include the source of the credentials
-            
-        Returns:
-            If include_source is False:
-                (username, password) tuple
-            If include_source is True:
-                (username, password, source) tuple, where source is one of:
-                "provided", "environment", or "generated"
-        """
-        username, password = self._basic_auth
-        
-        if not include_source:
-            return (username, password)
-            
-        # Determine source of credentials
-        env_user = os.environ.get('SWML_BASIC_AUTH_USER')
-        env_pass = os.environ.get('SWML_BASIC_AUTH_PASSWORD')
-        
-        # More robust source detection
-        if env_user and env_pass and username == env_user and password == env_pass:
-            source = "environment"
-        elif username.startswith("user_") and len(password) > 20:  # Format of generated credentials
-            source = "generated"
-        else:
-            source = "provided"
-            
-        return (username, password, source)
-    
-    def get_full_url(self, include_auth: bool = False) -> str:
-        """
-        Get the full URL for this agent's endpoint
-        
-        Args:
-            include_auth: Whether to include authentication credentials in the URL
-            
-        Returns:
-            Full URL including host, port, and route (with auth if requested)
-        """
-        # Start with the base URL (either proxy or local)
-        if self._proxy_url_base:
-            # Use the proxy URL base from environment, ensuring we don't duplicate the route
-            # Strip any trailing slashes from proxy base
-            proxy_base = self._proxy_url_base.rstrip('/')
-            # Make sure route starts with a slash for consistency
-            route = self.route if self.route.startswith('/') else f"/{self.route}"
-            base_url = f"{proxy_base}{route}"
-        else:
-            # Default local URL
-            if self.host in ("0.0.0.0", "127.0.0.1", "localhost"):
-                host = "localhost"
-            else:
-                host = self.host
-                
-            base_url = f"http://{host}:{self.port}{self.route}"
-            
-        # Add auth if requested
-        if include_auth:
-            username, password = self._basic_auth
-            url = urlparse(base_url)
-            return url._replace(netloc=f"{username}:{password}@{url.netloc}").geturl()
-        
-        return base_url
-        
-    def _build_webhook_url(self, endpoint: str, query_params: Optional[Dict[str, str]] = None) -> str:
-        """
-        Helper method to build webhook URLs consistently
-        
-        Args:
-            endpoint: The endpoint path (e.g., "swaig", "post_prompt")
-            query_params: Optional query parameters to append
-            
-        Returns:
-            Fully constructed webhook URL
-        """
-        # Base URL construction
-        if hasattr(self, '_proxy_url_base') and self._proxy_url_base:
-            # For proxy URLs
-            base = self._proxy_url_base.rstrip('/')
-            
-            # Always add auth credentials
-            username, password = self._basic_auth
-            url = urlparse(base)
-            base = url._replace(netloc=f"{username}:{password}@{url.netloc}").geturl()
-        else:
-            # For local URLs
-            if self.host in ("0.0.0.0", "127.0.0.1", "localhost"):
-                host = "localhost"
-            else:
-                host = self.host
-                
-            # Always include auth credentials
-            username, password = self._basic_auth
-            base = f"http://{username}:{password}@{host}:{self.port}"
-        
-        # Ensure the endpoint has a trailing slash to prevent redirects
-        if endpoint in ["swaig", "post_prompt"]:
-            endpoint = f"{endpoint}/"
-            
-        # Simple path - use the route directly with the endpoint
-        path = f"{self.route}/{endpoint}"
-            
-        # Construct full URL
-        url = f"{base}{path}"
-        
-        # Add query parameters if any (only if they have values)
-        # But NEVER add call_id parameter - it should be in the body, not the URL
-        if query_params:
-            # Remove any call_id from query params
-            filtered_params = {k: v for k, v in query_params.items() if k != "call_id" and v}
-            if filtered_params:
-                params = "&".join([f"{k}={v}" for k, v in filtered_params.items()])
-                url = f"{url}?{params}"
-            
-        return url
-
-    def _render_swml(self, call_id: str = None, modifications: Optional[dict] = None) -> str:
-        """
-        Render the complete SWML document using SWMLService methods
+        Render the complete SWML document using SWMLService methods
         
         Args:
             call_id: Optional call ID for session-specific tokens
@@ -888,136 +716,320 @@ class AgentBase(SWMLService):
         Returns:
             SWML document as a string
         """
+        self.log.debug("_render_swml_called", 
+                      call_id=call_id,
+                      has_modifications=bool(modifications),
+                      use_ephemeral=bool(modifications and modifications.get("__use_ephemeral_agent")),
+                      has_dynamic_callback=bool(self._dynamic_config_callback))
+        
+        # Check if we need to use an ephemeral agent for dynamic configuration
+        agent_to_use = self
+        if modifications and modifications.get("__use_ephemeral_agent"):
+            # Create an ephemeral copy for this request
+            self.log.debug("creating_ephemeral_agent", 
+                          original_sections=len(self._prompt_manager._sections) if hasattr(self._prompt_manager, '_sections') else 0)
+            agent_to_use = self._create_ephemeral_copy()
+            self.log.debug("ephemeral_agent_created", 
+                          ephemeral_sections=len(agent_to_use._prompt_manager._sections) if hasattr(agent_to_use._prompt_manager, '_sections') else 0)
+            
+            # Extract the request data
+            request = modifications.get("__request")
+            request_data = modifications.get("__request_data", {})
+            
+            if self._dynamic_config_callback:
+                try:
+                    # Extract request data
+                    if request:
+                        query_params = dict(request.query_params)
+                        headers = dict(request.headers)
+                    else:
+                        # No request object - use empty defaults
+                        query_params = {}
+                        headers = {}
+                    body_params = request_data
+                    
+                    # Call the dynamic config callback with the ephemeral agent
+                    # This allows FULL dynamic configuration including adding skills
+                    self.log.debug("calling_dynamic_config_on_ephemeral", has_request=bool(request))
+                    self._dynamic_config_callback(query_params, body_params, headers, agent_to_use)
+                    self.log.debug("dynamic_config_complete",
+                                  ephemeral_sections_after=len(agent_to_use._prompt_manager._sections) if hasattr(agent_to_use._prompt_manager, '_sections') else 0)
+                    
+                except Exception as e:
+                    self.log.error("dynamic_config_error", error=str(e))
+            
+            # Clear the special markers so they don't affect rendering
+            modifications = None
+        
         # Reset the document to a clean state
-        self.reset_document()
+        agent_to_use.reset_document()
         
         # Get prompt
-        prompt = self.get_prompt()
+        prompt = agent_to_use.get_prompt()
         prompt_is_pom = isinstance(prompt, list)
         
         # Get post-prompt
-        post_prompt = self.get_post_prompt()
+        post_prompt = agent_to_use.get_post_prompt()
         
         # Generate a call ID if needed
-        if self._enable_state_tracking and call_id is None:
-            call_id = self._session_manager.create_session()
+        if call_id is None:
+            call_id = agent_to_use._session_manager.create_session()
+            self.log.debug("generated_call_id", call_id=call_id)
+        else:
+            self.log.debug("using_provided_call_id", call_id=call_id)
             
-        # Empty query params - no need to include call_id in URLs
-        query_params = {}
+        # Start with any SWAIG query params that were set
+        query_params = agent_to_use._swaig_query_params.copy() if agent_to_use._swaig_query_params else {}
         
         # Get the default webhook URL with auth
-        default_webhook_url = self._build_webhook_url("swaig", query_params)
+        default_webhook_url = agent_to_use._build_webhook_url("swaig", query_params)
         
         # Use override if set
-        if hasattr(self, '_web_hook_url_override') and self._web_hook_url_override:
-            default_webhook_url = self._web_hook_url_override
+        if hasattr(agent_to_use, '_web_hook_url_override') and agent_to_use._web_hook_url_override:
+            default_webhook_url = agent_to_use._web_hook_url_override
         
         # Prepare SWAIG object (correct format)
         swaig_obj = {}
         
-        # Add defaults if we have functions
-        if self._swaig_functions:
-            swaig_obj["defaults"] = {
-                "web_hook_url": default_webhook_url
-            }
-            
         # Add native_functions if any are defined
-        if self.native_functions:
-            swaig_obj["native_functions"] = self.native_functions
+        if agent_to_use.native_functions:
+            swaig_obj["native_functions"] = agent_to_use.native_functions
         
         # Add includes if any are defined
-        if self._function_includes:
-            swaig_obj["includes"] = self._function_includes
+        if agent_to_use._function_includes:
+            swaig_obj["includes"] = agent_to_use._function_includes
+        
+        # Add internal_fillers if any are defined
+        if hasattr(agent_to_use, '_internal_fillers') and agent_to_use._internal_fillers:
+            swaig_obj["internal_fillers"] = agent_to_use._internal_fillers
         
         # Create functions array
         functions = []
         
+        # Debug logging to see what functions we have
+        self.log.debug("checking_swaig_functions", 
+                      agent_name=agent_to_use.name,
+                      is_ephemeral=getattr(agent_to_use, '_is_ephemeral', False),
+                      registry_id=id(agent_to_use._tool_registry),
+                      agent_id=id(agent_to_use),
+                      function_count=len(agent_to_use._tool_registry._swaig_functions) if hasattr(agent_to_use._tool_registry, '_swaig_functions') else 0,
+                      functions=list(agent_to_use._tool_registry._swaig_functions.keys()) if hasattr(agent_to_use._tool_registry, '_swaig_functions') else [])
+        
         # Add each function to the functions array
-        for name, func in self._swaig_functions.items():
-            # Get token for secure functions when we have a call_id
-            token = None
-            if func.secure and call_id:
-                token = self._create_tool_token(tool_name=name, call_id=call_id)
+        # Check if the registry has the _swaig_functions attribute
+        if not hasattr(agent_to_use._tool_registry, '_swaig_functions'):
+            self.log.warning("tool_registry_missing_swaig_functions",
+                           registry_id=id(agent_to_use._tool_registry),
+                           agent_id=id(agent_to_use))
+            agent_to_use._tool_registry._swaig_functions = {}
+        
+        for name, func in agent_to_use._tool_registry._swaig_functions.items():
+            if isinstance(func, dict):
+                # For raw dictionaries (DataMap functions), use the entire dictionary as-is
+                # This preserves data_map and any other special fields
+                function_entry = func.copy()
+                
+                # Ensure the function name is set correctly
+                function_entry["function"] = name
                 
-            # Prepare function entry
-            function_entry = {
-                "function": name,
-                "description": func.description,
-                "parameters": {
-                    "type": "object",
-                    "properties": func.parameters
+            else:
+                # For SWAIGFunction objects, build the entry manually
+                # Check if it's secure and get token for secure functions when we have a call_id
+                token = None
+                if func.secure and call_id:
+                    token = agent_to_use._create_tool_token(tool_name=name, call_id=call_id)
+                    self.log.debug("created_token_for_function", function=name, call_id=call_id, token_prefix=token[:20] if token else None)
+                    
+                # Prepare function entry
+                function_entry = {
+                    "function": name,
+                    "description": func.description,
+                    "parameters": func._ensure_parameter_structure()
                 }
-            }
-            
-            # Add fillers if present
-            if func.fillers:
-                function_entry["fillers"] = func.fillers
                 
-            # Add token to URL if we have one
-            if token:
-                # Create token params without call_id
-                token_params = {"token": token}
-                function_entry["web_hook_url"] = self._build_webhook_url("swaig", token_params)
+                # Add wait_file if present (audio/video file URL)
+                if hasattr(func, 'wait_file') and func.wait_file:
+                    wait_file_url = func.wait_file
+                    # If wait_file is a relative URL, convert it to absolute using agent's base URL
+                    if wait_file_url and not wait_file_url.startswith(('http://', 'https://', '//')):
+                        # Build full URL using the agent's base URL
+                        base_url = agent_to_use._get_base_url(include_auth=False)
+                        # Handle relative paths appropriately
+                        if not wait_file_url.startswith('/'):
+                            wait_file_url = '/' + wait_file_url
+                        wait_file_url = f"{base_url}{wait_file_url}"
+                    function_entry["wait_file"] = wait_file_url
                 
-            functions.append(function_entry)
+                # Add fillers if present (text phrases to say while processing)
+                if hasattr(func, 'fillers') and func.fillers:
+                    function_entry["fillers"] = func.fillers
+                
+                # Add wait_file_loops if present
+                if hasattr(func, 'wait_file_loops') and func.wait_file_loops is not None:
+                    function_entry["wait_file_loops"] = func.wait_file_loops
+                
+                # Handle webhook URL
+                if hasattr(func, 'webhook_url') and func.webhook_url:
+                    # External webhook function - use the provided URL directly
+                    function_entry["web_hook_url"] = func.webhook_url
+                elif token or agent_to_use._swaig_query_params:
+                    # Local function with token OR SWAIG query params - build local webhook URL
+                    # Start with SWAIG query params
+                    url_params = agent_to_use._swaig_query_params.copy() if agent_to_use._swaig_query_params else {}
+                    if token:
+                        url_params["__token"] = token  # Use __token to avoid collision
+                    function_entry["web_hook_url"] = agent_to_use._build_webhook_url("swaig", url_params)
             
+            functions.append(function_entry)
+        
         # Add functions array to SWAIG object if we have any
         if functions:
             swaig_obj["functions"] = functions
+            # Add defaults section now that we know we have functions
+            if "defaults" not in swaig_obj:
+                swaig_obj["defaults"] = {
+                    "web_hook_url": default_webhook_url
+                }
         
-        # Add post-prompt URL if we have a post-prompt
+        # Add post-prompt URL with token if we have a post-prompt
         post_prompt_url = None
         if post_prompt:
-            post_prompt_url = self._build_webhook_url("post_prompt", {})
+            # Create a token for post_prompt if we have a call_id
+            # Start with SWAIG query params
+            query_params = agent_to_use._swaig_query_params.copy() if agent_to_use._swaig_query_params else {}
+            if call_id and hasattr(agent_to_use, '_session_manager'):
+                try:
+                    token = agent_to_use._session_manager.create_tool_token("post_prompt", call_id)
+                    if token:
+                        query_params["__token"] = token  # Use __token to avoid collision
+                except Exception as e:
+                    agent_to_use.log.error("post_prompt_token_creation_error", error=str(e))
+            
+            # Build the URL with the token (if any)
+            post_prompt_url = agent_to_use._build_webhook_url("post_prompt", query_params)
             
             # Use override if set
-            if hasattr(self, '_post_prompt_url_override') and self._post_prompt_url_override:
-                post_prompt_url = self._post_prompt_url_override
-        
-        # Add answer verb with auto-answer enabled
-        self.add_answer_verb()
+            if hasattr(agent_to_use, '_post_prompt_url_override') and agent_to_use._post_prompt_url_override:
+                post_prompt_url = agent_to_use._post_prompt_url_override
+                
+        # ========== PHASE 1: PRE-ANSWER VERBS ==========
+        # These run while the call is still ringing
+        for verb_name, verb_config in agent_to_use._pre_answer_verbs:
+            agent_to_use.add_verb(verb_name, verb_config)
+
+        # ========== PHASE 2: ANSWER VERB ==========
+        # Only add answer verb if auto_answer is enabled
+        if agent_to_use._auto_answer:
+            agent_to_use.add_verb("answer", agent_to_use._answer_config)
+
+        # ========== PHASE 3: POST-ANSWER VERBS ==========
+        # These run after answer but before AI
+
+        # Add recording if enabled (this is a post-answer verb)
+        if agent_to_use._record_call:
+            agent_to_use.add_verb("record_call", {
+                "format": agent_to_use._record_format,
+                "stereo": agent_to_use._record_stereo
+            })
+
+        # Add user-defined post-answer verbs
+        for verb_name, verb_config in agent_to_use._post_answer_verbs:
+            agent_to_use.add_verb(verb_name, verb_config)
         
         # Use the AI verb handler to build and validate the AI verb config
         ai_config = {}
         
         # Get the AI verb handler
-        ai_handler = self.verb_registry.get_handler("ai")
+        ai_handler = agent_to_use.verb_registry.get_handler("ai")
         if ai_handler:
             try:
-                # Build AI config using the proper handler
-                ai_config = ai_handler.build_config(
-                    prompt_text=None if prompt_is_pom else prompt,
-                    prompt_pom=prompt if prompt_is_pom else None,
-                    post_prompt=post_prompt,
-                    post_prompt_url=post_prompt_url,
-                    swaig=swaig_obj if swaig_obj else None
-                )
+                # Check if we're in contexts mode
+                if agent_to_use._contexts_defined and agent_to_use._contexts_builder:
+                    # Generate contexts and combine with base prompt
+                    contexts_dict = agent_to_use._contexts_builder.to_dict()
+                    
+                    # Determine base prompt (required when using contexts)
+                    base_prompt_text = None
+                    base_prompt_pom = None
+                    
+                    if prompt_is_pom:
+                        base_prompt_pom = prompt
+                    elif prompt:
+                        base_prompt_text = prompt
+                    else:
+                        # Provide default base prompt if none exists
+                        base_prompt_text = f"You are {agent_to_use.name}, a helpful AI assistant that follows structured workflows."
+                    
+                    # Build AI config with base prompt + contexts
+                    ai_config = ai_handler.build_config(
+                        prompt_text=base_prompt_text,
+                        prompt_pom=base_prompt_pom,
+                        contexts=contexts_dict,
+                        post_prompt=post_prompt,
+                        post_prompt_url=post_prompt_url,
+                        swaig=swaig_obj if swaig_obj else None
+                    )
+                else:
+                    # Build AI config using the traditional prompt approach
+                    ai_config = ai_handler.build_config(
+                        prompt_text=None if prompt_is_pom else prompt,
+                        prompt_pom=prompt if prompt_is_pom else None,
+                        post_prompt=post_prompt,
+                        post_prompt_url=post_prompt_url,
+                        swaig=swaig_obj if swaig_obj else None
+                    )
                 
                 # Add new configuration parameters to the AI config
                 
                 # Add hints if any
-                if self._hints:
-                    ai_config["hints"] = self._hints
+                if agent_to_use._hints:
+                    ai_config["hints"] = agent_to_use._hints
                 
                 # Add languages if any
-                if self._languages:
-                    ai_config["languages"] = self._languages
+                if agent_to_use._languages:
+                    ai_config["languages"] = agent_to_use._languages
                 
                 # Add pronunciation rules if any
-                if self._pronounce:
-                    ai_config["pronounce"] = self._pronounce
+                if agent_to_use._pronounce:
+                    ai_config["pronounce"] = agent_to_use._pronounce
                 
                 # Add params if any
-                if self._params:
-                    ai_config["params"] = self._params
+                if agent_to_use._params:
+                    ai_config["params"] = agent_to_use._params
                 
                 # Add global_data if any
-                if self._global_data:
-                    ai_config["global_data"] = self._global_data
+                if agent_to_use._global_data:
+                    ai_config["global_data"] = agent_to_use._global_data
+                
+                # Always add LLM parameters to prompt
+                if "prompt" in ai_config:
+                    # Only add LLM params if explicitly set
+                    if agent_to_use._prompt_llm_params:
+                        if isinstance(ai_config["prompt"], dict):
+                            ai_config["prompt"].update(agent_to_use._prompt_llm_params)
+                        elif isinstance(ai_config["prompt"], str):
+                            # Convert string prompt to dict format
+                            ai_config["prompt"] = {
+                                "text": ai_config["prompt"],
+                                **agent_to_use._prompt_llm_params
+                            }
+                    
+                # Only add LLM parameters to post_prompt if explicitly set
+                if post_prompt and "post_prompt" in ai_config:
+                    # Only add LLM params if explicitly set
+                    if agent_to_use._post_prompt_llm_params:
+                        if isinstance(ai_config["post_prompt"], dict):
+                            ai_config["post_prompt"].update(agent_to_use._post_prompt_llm_params)
+                        elif isinstance(ai_config["post_prompt"], str):
+                            # Convert string post_prompt to dict format
+                            ai_config["post_prompt"] = {
+                                "text": ai_config["post_prompt"],
+                                **agent_to_use._post_prompt_llm_params
+                            }
                     
             except ValueError as e:
-                if not self._suppress_logs:
-                    print(f"Error building AI verb configuration: {str(e)}")
+                if not agent_to_use._suppress_logs:
+                    agent_to_use.log.error("ai_verb_config_error", error=str(e))
         else:
             # Fallback if no handler (shouldn't happen but just in case)
             ai_config = {
@@ -1035,274 +1047,286 @@ class AgentBase(SWMLService):
                 ai_config["SWAIG"] = swaig_obj
         
         # Add the new configurations if not already added by the handler
-        if self._hints and "hints" not in ai_config:
-            ai_config["hints"] = self._hints
+        if agent_to_use._hints and "hints" not in ai_config:
+            ai_config["hints"] = agent_to_use._hints
         
-        if self._languages and "languages" not in ai_config:
-            ai_config["languages"] = self._languages
+        if agent_to_use._languages and "languages" not in ai_config:
+            ai_config["languages"] = agent_to_use._languages
         
-        if self._pronounce and "pronounce" not in ai_config:
-            ai_config["pronounce"] = self._pronounce
+        if agent_to_use._pronounce and "pronounce" not in ai_config:
+            ai_config["pronounce"] = agent_to_use._pronounce
         
-        if self._params and "params" not in ai_config:
-            ai_config["params"] = self._params
-        
-        if self._global_data and "global_data" not in ai_config:
-            ai_config["global_data"] = self._global_data
+        if agent_to_use._params and "params" not in ai_config:
+            ai_config["params"] = agent_to_use._params
         
+        if agent_to_use._global_data and "global_data" not in ai_config:
+            ai_config["global_data"] = agent_to_use._global_data
+
+        # ========== PHASE 4: AI VERB ==========
         # Add the AI verb to the document
-        self.add_verb("ai", ai_config)
-        
-        # Apply any modifications from the callback
+        agent_to_use.add_verb("ai", ai_config)
+
+        # ========== PHASE 5: POST-AI VERBS ==========
+        # These run after the AI conversation ends
+        for verb_name, verb_config in agent_to_use._post_ai_verbs:
+            agent_to_use.add_verb(verb_name, verb_config)
+
+        # Apply any modifications from the callback to agent state
         if modifications and isinstance(modifications, dict):
-            # We need a way to apply modifications to the document
-            # Get the current document
-            document = self.get_document()
-            
-            # Simple recursive update function
-            def update_dict(target, source):
-                for key, value in source.items():
-                    if isinstance(value, dict) and key in target and isinstance(target[key], dict):
-                        update_dict(target[key], value)
-                    else:
-                        target[key] = value
-            
-            # Apply modifications to the document
-            update_dict(document, modifications)
-            
-            # Since we can't directly set the document in SWMLService, 
-            # we'll need to reset and rebuild if there are modifications
-            self.reset_document()
-            
-            # Add the modified document's sections
-            for section_name, section_content in document["sections"].items():
-                if section_name != "main":  # Main section is created by default
-                    self.add_section(section_name)
-                
-                # Add each verb to the section
-                for verb_obj in section_content:
-                    for verb_name, verb_config in verb_obj.items():
-                        self.add_verb_to_section(section_name, verb_name, verb_config)
+            # Handle global_data modifications by updating the AI config directly
+            if "global_data" in modifications:
+                if modifications["global_data"]:
+                    # Merge the modification global_data with existing global_data
+                    ai_config["global_data"] = {**ai_config.get("global_data", {}), **modifications["global_data"]}
+            
+            # Handle other modifications by updating the AI config
+            for key, value in modifications.items():
+                if key != "global_data":  # global_data handled above
+                    ai_config[key] = value
+            
+            # Clear and rebuild the document with the modified AI config
+            agent_to_use.reset_document()
+
+            # Rebuild with 5-phase approach
+            # PHASE 1: Pre-answer verbs
+            for verb_name, verb_config in agent_to_use._pre_answer_verbs:
+                agent_to_use.add_verb(verb_name, verb_config)
+
+            # PHASE 2: Answer verb (if auto_answer enabled)
+            if agent_to_use._auto_answer:
+                agent_to_use.add_verb("answer", agent_to_use._answer_config)
+
+            # PHASE 3: Post-answer verbs
+            if agent_to_use._record_call:
+                agent_to_use.add_verb("record_call", {
+                    "format": agent_to_use._record_format,
+                    "stereo": agent_to_use._record_stereo
+                })
+            for verb_name, verb_config in agent_to_use._post_answer_verbs:
+                agent_to_use.add_verb(verb_name, verb_config)
+
+            # PHASE 4: AI verb
+            agent_to_use.add_verb("ai", ai_config)
+
+            # PHASE 5: Post-AI verbs
+            for verb_name, verb_config in agent_to_use._post_ai_verbs:
+                agent_to_use.add_verb(verb_name, verb_config)
         
         # Return the rendered document as a string
-        return self.render_document()
+        return agent_to_use.render_document()
     
-    def _check_basic_auth(self, request: Request) -> bool:
+    def _build_webhook_url(self, endpoint: str, query_params: Optional[Dict[str, str]] = None) -> str:
         """
-        Check basic auth from a request
+        Helper method to build webhook URLs consistently
         
         Args:
-            request: FastAPI request object
+            endpoint: The endpoint path (e.g., "swaig", "post_prompt")
+            query_params: Optional query parameters to append
             
         Returns:
-            True if auth is valid, False otherwise
+            Fully constructed webhook URL
         """
-        auth_header = request.headers.get("Authorization")
-        if not auth_header or not auth_header.startswith("Basic "):
-            return False
+        # Check for serverless environment and use appropriate URL generation
+        mode = get_execution_mode()
+
+        if mode != 'server':
+            # In serverless mode, use the serverless-appropriate URL with auth
+            base_url = self.get_full_url(include_auth=True)
             
-        try:
-            # Decode the base64 credentials
-            credentials = base64.b64decode(auth_header[6:]).decode("utf-8")
-            username, password = credentials.split(":", 1)
-            return self.validate_basic_auth(username, password)
-        except Exception:
-            return False
+            # Ensure the endpoint has a trailing slash to prevent redirects
+            if endpoint in ["swaig", "post_prompt"]:
+                endpoint = f"{endpoint}/"
+                
+            # Build the full webhook URL
+            url = f"{base_url}/{endpoint}"
+            
+            # Add query parameters if any (only if they have values)
+            if query_params:
+                # Remove any call_id from query params
+                filtered_params = {k: v for k, v in query_params.items() if k != "call_id" and v}
+                if filtered_params:
+                    params = "&".join([f"{k}={v}" for k, v in filtered_params.items()])
+                    url = f"{url}?{params}"
+            
+            return url
+        
+        # Server mode - use the parent class's implementation from SWMLService
+        # which properly handles SWML_PROXY_URL_BASE environment variable
+        return super()._build_webhook_url(endpoint, query_params)
     
-    def as_router(self) -> APIRouter:
+    def _find_summary_in_post_data(self, body, logger):
         """
-        Get a FastAPI router for this agent
+        Attempt to find a summary in the post-prompt response data
         
+        Args:
+            body: The request body
+            logger: Logger instance
+            
         Returns:
-            FastAPI router
+            Summary data or None if not found
+        """
+        if not body:
+            return None
+
+        # Various ways to get summary data
+        if "summary" in body:
+            return body["summary"]
+            
+        if "post_prompt_data" in body:
+            pdata = body["post_prompt_data"]
+            if isinstance(pdata, dict):
+                if "parsed" in pdata and isinstance(pdata["parsed"], list) and pdata["parsed"]:
+                    return pdata["parsed"][0]
+                elif "raw" in pdata and pdata["raw"]:
+                    try:
+                        # Try to parse JSON from raw text
+                        parsed = json.loads(pdata["raw"])
+                        return parsed
+                    except:
+                        return pdata["raw"]
+                        
+        return None
+    
+    def _create_ephemeral_copy(self):
         """
-        # Get the base router from SWMLService
-        router = super().as_router()
+        Create a lightweight copy of this agent for ephemeral configuration.
         
-        # Override the root endpoint to use our SWML rendering
-        @router.get("/")
-        @router.post("/")
-        async def handle_root_no_slash(request: Request):
-            return await self._handle_root_request(request)
-            
-        # Root endpoint - with trailing slash
-        @router.get("/")
-        @router.post("/")
-        async def handle_root_with_slash(request: Request):
-            return await self._handle_root_request(request)
-            
-        # Debug endpoint - without trailing slash
-        @router.get("/debug")
-        @router.post("/debug")
-        async def handle_debug_no_slash(request: Request):
-            return await self._handle_debug_request(request)
-            
-        # Debug endpoint - with trailing slash
-        @router.get("/debug/")
-        @router.post("/debug/")
-        async def handle_debug_with_slash(request: Request):
-            return await self._handle_debug_request(request)
-            
-        # SWAIG endpoint - without trailing slash
-        @router.get("/swaig")
-        @router.post("/swaig")
-        async def handle_swaig_no_slash(request: Request):
-            return await self._handle_swaig_request(request)
-            
-        # SWAIG endpoint - with trailing slash
-        @router.get("/swaig/")
-        @router.post("/swaig/")
-        async def handle_swaig_with_slash(request: Request):
-            return await self._handle_swaig_request(request)
-            
-        # Post-prompt endpoint - without trailing slash
-        @router.get("/post_prompt")
-        @router.post("/post_prompt")
-        async def handle_post_prompt_no_slash(request: Request):
-            return await self._handle_post_prompt_request(request)
-            
-        # Post-prompt endpoint - with trailing slash
-        @router.get("/post_prompt/")
-        @router.post("/post_prompt/")
-        async def handle_post_prompt_with_slash(request: Request):
-            return await self._handle_post_prompt_request(request)
-        
-        self._router = router
-        return router
+        This creates a partial copy that shares most resources but has independent
+        configuration for SWML generation. Used when dynamic configuration callbacks
+        need to modify the agent without affecting the persistent state.
+        
+        Returns:
+            A lightweight copy of the agent suitable for ephemeral modifications
+        """
+        import copy
+        
+        # Create a new instance of the same class
+        cls = self.__class__
+        ephemeral_agent = cls.__new__(cls)
+        
+        # Copy all attributes as shallow references first
+        for key, value in self.__dict__.items():
+            setattr(ephemeral_agent, key, value)
+        
+        # Deep copy only the configuration that affects SWML generation
+        # These are the parts that dynamic config might modify
+        ephemeral_agent._params = copy.deepcopy(self._params)
+        ephemeral_agent._hints = copy.deepcopy(self._hints)
+        ephemeral_agent._languages = copy.deepcopy(self._languages)
+        ephemeral_agent._pronounce = copy.deepcopy(self._pronounce)
+        ephemeral_agent._global_data = copy.deepcopy(self._global_data)
+        ephemeral_agent._function_includes = copy.deepcopy(self._function_includes)
+
+        # Deep copy verb insertion points for call flow customization
+        ephemeral_agent._pre_answer_verbs = copy.deepcopy(self._pre_answer_verbs)
+        ephemeral_agent._answer_config = copy.deepcopy(self._answer_config)
+        ephemeral_agent._post_answer_verbs = copy.deepcopy(self._post_answer_verbs)
+        ephemeral_agent._post_ai_verbs = copy.deepcopy(self._post_ai_verbs)
+
+        # Deep copy LLM parameters
+        ephemeral_agent._prompt_llm_params = copy.deepcopy(self._prompt_llm_params)
+        ephemeral_agent._post_prompt_llm_params = copy.deepcopy(self._post_prompt_llm_params)
+        
+        # Copy internal fillers if they exist
+        if hasattr(self, '_internal_fillers'):
+            ephemeral_agent._internal_fillers = copy.deepcopy(self._internal_fillers)
+        
+        # Don't deep copy _contexts_builder - it has a circular reference to the agent
+        # The contexts are already copied via _prompt_manager._contexts (below)
+        # Just copy the flag indicating contexts are defined
+        if hasattr(self, '_contexts_defined'):
+            ephemeral_agent._contexts_defined = self._contexts_defined
+        
+        # Deep copy the POM object if it exists to prevent sharing prompt sections
+        if hasattr(self, 'pom') and self.pom:
+            ephemeral_agent.pom = copy.deepcopy(self.pom)
+        # Handle native_functions which might be stored as an attribute or property
+        if hasattr(self, '_native_functions'):
+            ephemeral_agent._native_functions = copy.deepcopy(self._native_functions)
+        elif hasattr(self, 'native_functions'):
+            ephemeral_agent.native_functions = copy.deepcopy(self.native_functions)
+        ephemeral_agent._swaig_query_params = copy.deepcopy(self._swaig_query_params)
+        
+        # Create new manager instances that point to the ephemeral agent
+        # This breaks the circular reference and allows independent modification
+        from signalwire_agents.core.agent.prompt.manager import PromptManager
+        from signalwire_agents.core.agent.tools.registry import ToolRegistry
+        
+        # Create new prompt manager for the ephemeral agent
+        ephemeral_agent._prompt_manager = PromptManager(ephemeral_agent)
+        # Copy ALL PromptManager state
+        if hasattr(self._prompt_manager, '_sections'):
+            ephemeral_agent._prompt_manager._sections = copy.deepcopy(self._prompt_manager._sections)
+        ephemeral_agent._prompt_manager._prompt_text = copy.deepcopy(self._prompt_manager._prompt_text)
+        ephemeral_agent._prompt_manager._post_prompt_text = copy.deepcopy(self._prompt_manager._post_prompt_text)
+        ephemeral_agent._prompt_manager._contexts = copy.deepcopy(self._prompt_manager._contexts)
+        
+        # Create new tool registry for the ephemeral agent
+        ephemeral_agent._tool_registry = ToolRegistry(ephemeral_agent)
+        # Copy the SWAIG functions - we need a shallow copy here because
+        # the functions themselves can be shared, we just need a new dict
+        if hasattr(self._tool_registry, '_swaig_functions'):
+            ephemeral_agent._tool_registry._swaig_functions = self._tool_registry._swaig_functions.copy()
+        if hasattr(self._tool_registry, '_tool_instances'):
+            ephemeral_agent._tool_registry._tool_instances = self._tool_registry._tool_instances.copy()
+        
+        # Create a new skill manager for the ephemeral agent
+        # This is important because skills register tools with the agent's registry
+        from signalwire_agents.core.skill_manager import SkillManager
+        ephemeral_agent.skill_manager = SkillManager(ephemeral_agent)
+        
+        # Copy any already loaded skills from the original agent
+        # This ensures skills loaded during __init__ are available in the ephemeral agent
+        if hasattr(self.skill_manager, 'loaded_skills'):
+            for skill_key, skill_instance in self.skill_manager.loaded_skills.items():
+                # Re-load the skill in the ephemeral agent's context
+                # We need to get the skill name and params from the existing instance
+                skill_name = skill_instance.SKILL_NAME
+                skill_params = getattr(skill_instance, 'params', {})
+                try:
+                    ephemeral_agent.skill_manager.load_skill(skill_name, type(skill_instance), skill_params)
+                except Exception as e:
+                    self.log.warning("failed_to_copy_skill_to_ephemeral", 
+                                   skill_name=skill_name, 
+                                   error=str(e))
+        
+        # Re-bind the tool decorator method to the new instance
+        ephemeral_agent.tool = ephemeral_agent._tool_decorator
+        
+        # Share the logger but bind it to indicate ephemeral copy
+        ephemeral_agent.log = self.log.bind(ephemeral=True)
+        
+        # Mark this as an ephemeral agent to prevent double application of dynamic config
+        ephemeral_agent._is_ephemeral = True
+        
+        return ephemeral_agent
     
-    async def _handle_root_request(self, request: Request):
-        """Handle GET/POST requests to the root endpoint"""
-        # Auto-detect proxy on first request if not explicitly configured
-        if not getattr(self, '_proxy_detection_done', False) and not getattr(self, '_proxy_url_base', None):
-            # Check for proxy headers
-            forwarded_host = request.headers.get("X-Forwarded-Host")
-            forwarded_proto = request.headers.get("X-Forwarded-Proto", "http")
-            
-            if forwarded_host:
-                self._proxy_url_base = f"{forwarded_proto}://{forwarded_host}"
-                self.log.info("proxy_auto_detected", proxy_url_base=self._proxy_url_base, 
-                            source="X-Forwarded headers")
-                self._proxy_detection_done = True
-            # If no explicit proxy headers, try the parent class detection method if it exists
-            elif hasattr(super(), '_detect_proxy_from_request'):
-                super()._detect_proxy_from_request(request)
-                self._proxy_detection_done = True
-        
-        # Check if this is a callback path request
-        callback_path = getattr(request.state, "callback_path", None)
-        
-        req_log = self.log.bind(
-            endpoint="root" if not callback_path else f"callback:{callback_path}",
-            method=request.method,
-            path=request.url.path
-        )
+    async def _handle_request(self, request: Request, response: Response):
+        """
+        Override SWMLService's _handle_request to use AgentBase's _render_swml
         
-        req_log.debug("endpoint_called")
+        This ensures that when routes are handled by SWMLService's router,
+        they still use AgentBase's SWML rendering logic.
+        """
+        # Use WebMixin's implementation if available
+        if hasattr(super(), '_handle_root_request'):
+            return await self._handle_root_request(request)
         
+        # Fallback to basic implementation
         try:
-            # Check auth
-            if not self._check_basic_auth(request):
-                req_log.warning("unauthorized_access_attempt")
-                return Response(
-                    content=json.dumps({"error": "Unauthorized"}),
-                    status_code=401,
-                    headers={"WWW-Authenticate": "Basic"},
-                    media_type="application/json"
-                )
-            
-            # Try to parse request body for POST
+            # Parse body if POST request
             body = {}
-            call_id = None
-            
             if request.method == "POST":
-                # Check if body is empty first
-                raw_body = await request.body()
-                if raw_body:
-                    try:
-                        body = await request.json()
-                        req_log.debug("request_body_received", body_size=len(str(body)))
-                        if body:
-                            req_log.debug("request_body", body=json.dumps(body, indent=2))
-                    except Exception as e:
-                        req_log.warning("error_parsing_request_body", error=str(e), traceback=traceback.format_exc())
-                        req_log.debug("raw_request_body", body=raw_body.decode('utf-8', errors='replace'))
-                        # Continue processing with empty body
-                        body = {}
-                else:
-                    req_log.debug("empty_request_body")
-                    
-                # Get call_id from body if present
-                call_id = body.get("call_id")
-            else:
-                # Get call_id from query params for GET
-                call_id = request.query_params.get("call_id")
-                
-            # Add call_id to logger if any
-            if call_id:
-                req_log = req_log.bind(call_id=call_id)
-                req_log.debug("call_id_identified")
-            
-            # Check if this is a callback path and we need to apply routing
-            if callback_path and hasattr(self, '_routing_callbacks') and callback_path in self._routing_callbacks:
-                callback_fn = self._routing_callbacks[callback_path]
-                
-                if request.method == "POST" and body:
-                    req_log.debug("processing_routing_callback", path=callback_path)
-                    # Call the routing callback
-                    try:
-                        route = callback_fn(request, body)
-                        if route is not None:
-                            req_log.info("routing_request", route=route)
-                            # Return a redirect to the new route
-                            return Response(
-                                status_code=307,  # 307 Temporary Redirect preserves the method and body
-                                headers={"Location": route}
-                            )
-                    except Exception as e:
-                        req_log.error("error_in_routing_callback", error=str(e), traceback=traceback.format_exc())
-            
-            # Allow subclasses to inspect/modify the request
-            modifications = None
-            if body:
                 try:
-                    modifications = self.on_swml_request(body)
-                    if modifications:
-                        req_log.debug("request_modifications_applied")
-                except Exception as e:
-                    req_log.error("error_in_request_modifier", error=str(e), traceback=traceback.format_exc())
+                    body = await request.json()
+                except:
+                    pass
             
-            # Render SWML
-            swml = self._render_swml(call_id, modifications)
-            req_log.debug("swml_rendered", swml_size=len(swml))
+            # Get call_id
+            call_id = body.get("call_id") if body else request.query_params.get("call_id")
             
-            # Return as JSON
-            req_log.info("request_successful")
-            return Response(
-                content=swml,
-                media_type="application/json"
-            )
-        except Exception as e:
-            req_log.error("request_failed", error=str(e), traceback=traceback.format_exc())
-            return Response(
-                content=json.dumps({"error": str(e), "traceback": traceback.format_exc()}),
-                status_code=500,
-                media_type="application/json"
-            )
-    
-    async def _handle_debug_request(self, request: Request):
-        """Handle GET/POST requests to the debug endpoint"""
-        req_log = self.log.bind(
-            endpoint="debug",
-            method=request.method,
-            path=request.url.path
-        )
-        
-        req_log.debug("endpoint_called")
-        
-        try:
             # Check auth
             if not self._check_basic_auth(request):
-                req_log.warning("unauthorized_access_attempt")
                 return Response(
                     content=json.dumps({"error": "Unauthorized"}),
                     status_code=401,
@@ -1310,1248 +1334,17 @@ class AgentBase(SWMLService):
                     media_type="application/json"
                 )
             
-            # Get call_id from either query params (GET) or body (POST)
-            call_id = None
-            body = {}
-            
-            if request.method == "POST":
-                try:
-                    body = await request.json()
-                    req_log.debug("request_body_received", body_size=len(str(body)))
-                    if body:
-                        req_log.debug("request_body", body=json.dumps(body, indent=2))
-                    call_id = body.get("call_id")
-                except Exception as e:
-                    req_log.warning("error_parsing_request_body", error=str(e), traceback=traceback.format_exc())
-                    try:
-                        body_text = await request.body()
-                        req_log.debug("raw_request_body", body=body_text.decode('utf-8', errors='replace'))
-                    except:
-                        pass
-            else:
-                call_id = request.query_params.get("call_id")
-            
-            # Add call_id to logger if any
-            if call_id:
-                req_log = req_log.bind(call_id=call_id)
-                req_log.debug("call_id_identified")
-                
-            # Allow subclasses to inspect/modify the request
-            modifications = None
-            if body:
-                modifications = self.on_swml_request(body)
-                if modifications:
-                    req_log.debug("request_modifications_applied")
-                
-            # Render SWML
-            swml = self._render_swml(call_id, modifications)
-            req_log.debug("swml_rendered", swml_size=len(swml))
+            # Render SWML using AgentBase's method
+            swml = self._render_swml(call_id)
             
-            # Return as JSON
-            req_log.info("request_successful")
             return Response(
                 content=swml,
-                media_type="application/json",
-                headers={"X-Debug": "true"}
+                media_type="application/json"
             )
         except Exception as e:
-            req_log.error("request_failed", error=str(e), traceback=traceback.format_exc())
             return Response(
-                content=json.dumps({"error": str(e), "traceback": traceback.format_exc()}),
+                content=json.dumps({"error": str(e)}),
                 status_code=500,
                 media_type="application/json"
             )
     
-    async def _handle_swaig_request(self, request: Request):
-        """Handle GET/POST requests to the SWAIG endpoint"""
-        req_log = self.log.bind(
-            endpoint="swaig",
-            method=request.method,
-            path=request.url.path
-        )
-        
-        req_log.debug("endpoint_called")
-        
-        try:
-            # Check auth
-            if not self._check_basic_auth(request):
-                req_log.warning("unauthorized_access_attempt")
-                return Response(
-                    content=json.dumps({"error": "Unauthorized"}),
-                    status_code=401,
-                    headers={"WWW-Authenticate": "Basic"},
-                    media_type="application/json"
-                )
-            
-            # Handle differently based on method
-            if request.method == "GET":
-                # For GET requests, return the SWML document (same as root endpoint)
-                call_id = request.query_params.get("call_id")
-                swml = self._render_swml(call_id)
-                req_log.debug("swml_rendered", swml_size=len(swml))
-                return Response(
-                    content=swml,
-                    media_type="application/json"
-                )
-            
-            # For POST requests, process SWAIG function calls
-            try:
-                body = await request.json()
-                req_log.debug("request_body_received", body_size=len(str(body)))
-                if body:
-                    req_log.debug("request_body", body=json.dumps(body, indent=2))
-            except Exception as e:
-                req_log.error("error_parsing_request_body", error=str(e), traceback=traceback.format_exc())
-                body = {}
-            
-            # Extract function name
-            function_name = body.get("function")
-            if not function_name:
-                req_log.warning("missing_function_name")
-                return Response(
-                    content=json.dumps({"error": "Missing function name"}),
-                    status_code=400,
-                    media_type="application/json"
-                )
-            
-            # Add function info to logger
-            req_log = req_log.bind(function=function_name)
-            req_log.debug("function_call_received")
-            
-            # Extract arguments
-            args = {}
-            if "argument" in body and isinstance(body["argument"], dict):
-                if "parsed" in body["argument"] and isinstance(body["argument"]["parsed"], list) and body["argument"]["parsed"]:
-                    args = body["argument"]["parsed"][0]
-                    req_log.debug("parsed_arguments", args=json.dumps(args, indent=2))
-                elif "raw" in body["argument"]:
-                    try:
-                        args = json.loads(body["argument"]["raw"])
-                        req_log.debug("raw_arguments_parsed", args=json.dumps(args, indent=2))
-                    except Exception as e:
-                        req_log.error("error_parsing_raw_arguments", error=str(e), raw=body["argument"]["raw"])
-            
-            # Get call_id from body
-            call_id = body.get("call_id")
-            if call_id:
-                req_log = req_log.bind(call_id=call_id)
-                req_log.debug("call_id_identified")
-            
-            # Call the function
-            try:
-                result = self.on_function_call(function_name, args, body)
-                
-                # Convert result to dict if needed
-                if isinstance(result, SwaigFunctionResult):
-                    result_dict = result.to_dict()
-                elif isinstance(result, dict):
-                    result_dict = result
-                else:
-                    result_dict = {"response": str(result)}
-                
-                req_log.info("function_executed_successfully")
-                req_log.debug("function_result", result=json.dumps(result_dict, indent=2))
-                return result_dict
-            except Exception as e:
-                req_log.error("function_execution_error", error=str(e), traceback=traceback.format_exc())
-                return {"error": str(e), "function": function_name}
-                
-        except Exception as e:
-            req_log.error("request_failed", error=str(e), traceback=traceback.format_exc())
-            return Response(
-                content=json.dumps({"error": str(e)}),
-                status_code=500,
-                media_type="application/json"
-            )
-            
-    async def _handle_post_prompt_request(self, request: Request):
-        """Handle GET/POST requests to the post_prompt endpoint"""
-        req_log = self.log.bind(
-            endpoint="post_prompt",
-            method=request.method,
-            path=request.url.path
-        )
-        
-        # Only log if not suppressed
-        if not self._suppress_logs:
-            req_log.debug("endpoint_called")
-        
-        try:
-            # Check auth
-            if not self._check_basic_auth(request):
-                req_log.warning("unauthorized_access_attempt")
-                return Response(
-                    content=json.dumps({"error": "Unauthorized"}),
-                    status_code=401,
-                    headers={"WWW-Authenticate": "Basic"},
-                    media_type="application/json"
-                )
-            
-            # For GET requests, return the SWML document (same as root endpoint)
-            if request.method == "GET":
-                call_id = request.query_params.get("call_id")
-                swml = self._render_swml(call_id)
-                req_log.debug("swml_rendered", swml_size=len(swml))
-                return Response(
-                    content=swml,
-                    media_type="application/json"
-                )
-            
-            # For POST requests, process the post-prompt data
-            try:
-                body = await request.json()
-                
-                # Only log if not suppressed
-                if not self._suppress_logs:
-                    req_log.debug("request_body_received", body_size=len(str(body)))
-                    # Log the raw body as properly formatted JSON (not Python dict representation)
-                    print("POST_PROMPT_BODY: " + json.dumps(body))
-            except Exception as e:
-                req_log.error("error_parsing_request_body", error=str(e), traceback=traceback.format_exc())
-                body = {}
-                
-            # Extract summary from the correct location in the request
-            summary = self._find_summary_in_post_data(body, req_log)
-            
-            # Save state if call_id is provided
-            call_id = body.get("call_id")
-            if call_id and summary:
-                req_log = req_log.bind(call_id=call_id)
-                
-                # Check if state manager has the right methods
-                try:
-                    if hasattr(self._state_manager, 'get_state'):
-                        state = self._state_manager.get_state(call_id) or {}
-                        state["summary"] = summary
-                        if hasattr(self._state_manager, 'update_state'):
-                            self._state_manager.update_state(call_id, state)
-                            req_log.debug("state_updated_with_summary")
-                except Exception as e:
-                    req_log.warning("state_update_failed", error=str(e))
-            
-            # Call the summary handler with the summary and the full body
-            try:
-                if summary:
-                    self.on_summary(summary, body)
-                    req_log.debug("summary_handler_called_successfully")
-                else:
-                    # If no summary found but still want to process the data
-                    self.on_summary(None, body)
-                    req_log.debug("summary_handler_called_with_null_summary")
-            except Exception as e:
-                req_log.error("error_in_summary_handler", error=str(e), traceback=traceback.format_exc())
-            
-            # Return success
-            req_log.info("request_successful")
-            return {"success": True}
-        except Exception as e:
-            req_log.error("request_failed", error=str(e), traceback=traceback.format_exc())
-            return Response(
-                content=json.dumps({"error": str(e)}),
-                status_code=500,
-                media_type="application/json"
-            )
-
-    def _find_summary_in_post_data(self, body, logger):
-        """
-        Extensive search for the summary in the post data
-        
-        Args:
-            body: The POST request body
-            logger: The logger instance to use
-            
-        Returns:
-            The summary if found, None otherwise
-        """
-        summary = None
-        
-        # Check all the locations where the summary might be found
-        
-        # 1. First check post_prompt_data.parsed array (new standard location)
-        post_prompt_data = body.get("post_prompt_data", {})
-        if post_prompt_data:
-            if not self._suppress_logs:
-                logger.debug("checking_post_prompt_data", data_type=type(post_prompt_data).__name__)
-            
-            # Check for parsed array first (this is the most common location)
-            if isinstance(post_prompt_data, dict) and "parsed" in post_prompt_data:
-                parsed = post_prompt_data.get("parsed")
-                if isinstance(parsed, list) and len(parsed) > 0:
-                    # The summary is the first item in the parsed array
-                    summary = parsed[0]
-                    print("SUMMARY_FOUND: " + json.dumps(summary))
-                    return summary
-            
-            # Check raw field - it might contain a JSON string
-            if isinstance(post_prompt_data, dict) and "raw" in post_prompt_data:
-                raw = post_prompt_data.get("raw")
-                if isinstance(raw, str):
-                    try:
-                        # Try to parse the raw field as JSON
-                        parsed_raw = json.loads(raw)
-                        if not self._suppress_logs:
-                            print("SUMMARY_FOUND_RAW: " + json.dumps(parsed_raw))
-                        return parsed_raw
-                    except:
-                        pass
-            
-            # Direct access to substituted field
-            if isinstance(post_prompt_data, dict) and "substituted" in post_prompt_data:
-                summary = post_prompt_data.get("substituted")
-                if not self._suppress_logs:
-                    print("SUMMARY_FOUND_SUBSTITUTED: " + json.dumps(summary) if isinstance(summary, (dict, list)) else f"SUMMARY_FOUND_SUBSTITUTED: {summary}")
-                return summary
-            
-            # Check for nested data structure
-            if isinstance(post_prompt_data, dict) and "data" in post_prompt_data:
-                data = post_prompt_data.get("data")
-                if isinstance(data, dict):
-                    if "substituted" in data:
-                        summary = data.get("substituted")
-                        if not self._suppress_logs:
-                            print("SUMMARY_FOUND_DATA_SUBSTITUTED: " + json.dumps(summary) if isinstance(summary, (dict, list)) else f"SUMMARY_FOUND_DATA_SUBSTITUTED: {summary}")
-                        return summary
-                    
-                    # Try text field
-                    if "text" in data:
-                        summary = data.get("text")
-                        if not self._suppress_logs:
-                            print("SUMMARY_FOUND_DATA_TEXT: " + json.dumps(summary) if isinstance(summary, (dict, list)) else f"SUMMARY_FOUND_DATA_TEXT: {summary}")
-                        return summary
-        
-        # 2. Check ai_response (legacy location)
-        ai_response = body.get("ai_response", {})
-        if ai_response and isinstance(ai_response, dict):
-            if "summary" in ai_response:
-                summary = ai_response.get("summary")
-                if not self._suppress_logs:
-                    print("SUMMARY_FOUND_AI_RESPONSE: " + json.dumps(summary) if isinstance(summary, (dict, list)) else f"SUMMARY_FOUND_AI_RESPONSE: {summary}")
-                return summary
-        
-        # 3. Look for direct fields at the top level
-        for field in ["substituted", "summary", "content", "text", "result", "output"]:
-            if field in body:
-                summary = body.get(field)
-                if not self._suppress_logs:
-                    print(f"SUMMARY_FOUND_TOP_LEVEL_{field}: " + json.dumps(summary) if isinstance(summary, (dict, list)) else f"SUMMARY_FOUND_TOP_LEVEL_{field}: {summary}")
-                return summary
-        
-        # 4. Recursively search for summary-like fields up to 3 levels deep
-        def recursive_search(data, path="", depth=0):
-            if depth > 3 or not isinstance(data, dict):  # Limit recursion depth
-                return None
-            
-            # Check if any key looks like it might contain a summary
-            for key in data.keys():
-                if key.lower() in ["summary", "substituted", "output", "result", "content", "text"]:
-                    value = data.get(key)
-                    curr_path = f"{path}.{key}" if path else key
-                    if not self._suppress_logs:
-                        logger.info(f"potential_summary_found_at_{curr_path}", 
-                                  value_type=type(value).__name__)
-                    if isinstance(value, (str, dict, list)):
-                        return value
-                    
-            # Recursively check nested dictionaries
-            for key, value in data.items():
-                if isinstance(value, dict):
-                    curr_path = f"{path}.{key}" if path else key
-                    result = recursive_search(value, curr_path, depth + 1)
-                    if result:
-                        return result
-                    
-            return None
-        
-        # Perform recursive search
-        recursive_result = recursive_search(body)
-        if recursive_result:
-            summary = recursive_result
-            if not self._suppress_logs:
-                print("SUMMARY_FOUND_RECURSIVE: " + json.dumps(summary) if isinstance(summary, (dict, list)) else f"SUMMARY_FOUND_RECURSIVE: {summary}")
-            return summary
-        
-        # No summary found
-        if not self._suppress_logs:
-            print("NO_SUMMARY_FOUND")
-        return None
-
-    def _register_routes(self, app):
-        """Register all routes for the agent, with both slash variants and both HTTP methods"""
-        
-        self.log.info("registering_routes", path=self.route)
-        
-        # Root endpoint - without trailing slash
-        @app.get(f"{self.route}")
-        @app.post(f"{self.route}")
-        async def handle_root_no_slash(request: Request):
-            return await self._handle_root_request(request)
-            
-        # Root endpoint - with trailing slash
-        @app.get(f"{self.route}/")
-        @app.post(f"{self.route}/")
-        async def handle_root_with_slash(request: Request):
-            return await self._handle_root_request(request)
-            
-        # Debug endpoint - without trailing slash
-        @app.get(f"{self.route}/debug")
-        @app.post(f"{self.route}/debug")
-        async def handle_debug_no_slash(request: Request):
-            return await self._handle_debug_request(request)
-            
-        # Debug endpoint - with trailing slash
-        @app.get(f"{self.route}/debug/")
-        @app.post(f"{self.route}/debug/")
-        async def handle_debug_with_slash(request: Request):
-            return await self._handle_debug_request(request)
-            
-        # SWAIG endpoint - without trailing slash
-        @app.get(f"{self.route}/swaig")
-        @app.post(f"{self.route}/swaig")
-        async def handle_swaig_no_slash(request: Request):
-            return await self._handle_swaig_request(request)
-            
-        # SWAIG endpoint - with trailing slash
-        @app.get(f"{self.route}/swaig/")
-        @app.post(f"{self.route}/swaig/")
-        async def handle_swaig_with_slash(request: Request):
-            return await self._handle_swaig_request(request)
-        
-        # Post-prompt endpoint - without trailing slash
-        @app.get(f"{self.route}/post_prompt")
-        @app.post(f"{self.route}/post_prompt")
-        async def handle_post_prompt_no_slash(request: Request):
-            return await self._handle_post_prompt_request(request)
-            
-        # Post-prompt endpoint - with trailing slash
-        @app.get(f"{self.route}/post_prompt/")
-        @app.post(f"{self.route}/post_prompt/")
-        async def handle_post_prompt_with_slash(request: Request):
-            return await self._handle_post_prompt_request(request)
-        
-        # Register routes for all routing callbacks
-        if hasattr(self, '_routing_callbacks') and self._routing_callbacks:
-            for callback_path, callback_fn in self._routing_callbacks.items():
-                # Skip the root path as it's already handled
-                if callback_path == "/":
-                    continue
-                
-                # Register the endpoint without trailing slash
-                callback_route = callback_path
-                self.log.info("registering_callback_route", path=callback_route)
-                
-                @app.get(callback_route)
-                @app.post(callback_route)
-                async def handle_callback_no_slash(request: Request, path_param=callback_route):
-                    # Store the callback path in request state for _handle_root_request to use
-                    request.state.callback_path = path_param
-                    return await self._handle_root_request(request)
-                
-                # Register the endpoint with trailing slash if it doesn't already have one
-                if not callback_route.endswith('/'):
-                    slash_route = f"{callback_route}/"
-                    
-                    @app.get(slash_route)
-                    @app.post(slash_route)
-                    async def handle_callback_with_slash(request: Request, path_param=callback_route):
-                        # Store the callback path in request state for _handle_root_request to use
-                        request.state.callback_path = path_param
-                        return await self._handle_root_request(request)
-        
-        # Log all registered routes
-        routes = [f"{route.methods} {route.path}" for route in app.routes]
-        self.log.debug("routes_registered", routes=routes)
-
-    def _register_class_decorated_tools(self):
-        """
-        Register all tools decorated with @AgentBase.tool
-        """
-        for name in dir(self):
-            attr = getattr(self, name)
-            if callable(attr) and hasattr(attr, "_is_tool"):
-                # Get tool parameters
-                tool_name = getattr(attr, "_tool_name", name)
-                tool_params = getattr(attr, "_tool_params", {})
-                
-                # Extract parameters
-                parameters = tool_params.get("parameters", {})
-                description = tool_params.get("description", attr.__doc__ or f"Function {tool_name}")
-                secure = tool_params.get("secure", True)
-                fillers = tool_params.get("fillers", None)
-                
-                # Create a wrapper that binds the method to this instance
-                def make_wrapper(method):
-                    @functools.wraps(method)
-                    def wrapper(args, raw_data=None):
-                        return method(args, raw_data)
-                    return wrapper
-                
-                # Register the tool
-                self.define_tool(
-                    name=tool_name,
-                    description=description,
-                    parameters=parameters,
-                    handler=make_wrapper(attr),
-                    secure=secure,
-                    fillers=fillers
-                )
-
-    # State Management Methods
-    def get_state(self, call_id: str) -> Optional[Dict[str, Any]]:
-        """
-        Get the state for a call
-        
-        Args:
-            call_id: Call ID to get state for
-            
-        Returns:
-            Call state or None if not found
-        """
-        try:
-            if hasattr(self._state_manager, 'get_state'):
-                return self._state_manager.get_state(call_id)
-            return None
-        except Exception as e:
-            logger.warning("get_state_failed", error=str(e))
-            return None
-        
-    def set_state(self, call_id: str, data: Dict[str, Any]) -> bool:
-        """
-        Set the state for a call
-        
-        Args:
-            call_id: Call ID to set state for
-            data: State data to set
-            
-        Returns:
-            True if state was set, False otherwise
-        """
-        try:
-            if hasattr(self._state_manager, 'set_state'):
-                return self._state_manager.set_state(call_id, data)
-            return False
-        except Exception as e:
-            logger.warning("set_state_failed", error=str(e))
-            return False
-        
-    def update_state(self, call_id: str, data: Dict[str, Any]) -> bool:
-        """
-        Update the state for a call
-        
-        Args:
-            call_id: Call ID to update state for
-            data: State data to update
-            
-        Returns:
-            True if state was updated, False otherwise
-        """
-        try:
-            if hasattr(self._state_manager, 'update_state'):
-                return self._state_manager.update_state(call_id, data)
-            return self.set_state(call_id, data)
-        except Exception as e:
-            logger.warning("update_state_failed", error=str(e))
-            return False
-        
-    def clear_state(self, call_id: str) -> bool:
-        """
-        Clear the state for a call
-        
-        Args:
-            call_id: Call ID to clear state for
-            
-        Returns:
-            True if state was cleared, False otherwise
-        """
-        try:
-            if hasattr(self._state_manager, 'clear_state'):
-                return self._state_manager.clear_state(call_id)
-            return False
-        except Exception as e:
-            logger.warning("clear_state_failed", error=str(e))
-            return False
-        
-    def cleanup_expired_state(self) -> int:
-        """
-        Clean up expired state
-        
-        Returns:
-            Number of expired state entries removed
-        """
-        try:
-            if hasattr(self._state_manager, 'cleanup_expired'):
-                return self._state_manager.cleanup_expired()
-            return 0
-        except Exception as e:
-            logger.warning("cleanup_expired_state_failed", error=str(e))
-            return 0
-
-    def _register_state_tracking_tools(self):
-        """
-        Register tools for tracking conversation state
-        """
-        # Register startup hook
-        self.define_tool(
-            name="startup_hook",
-            description="Called when the conversation starts",
-            parameters={},
-            handler=self._startup_hook_handler,
-            secure=False
-        )
-        
-        # Register hangup hook
-        self.define_tool(
-            name="hangup_hook",
-            description="Called when the conversation ends",
-            parameters={},
-            handler=self._hangup_hook_handler,
-            secure=False
-        )
-    
-    def _startup_hook_handler(self, args, raw_data):
-        """
-        Handler for the startup hook
-        
-        Args:
-            args: Function arguments
-            raw_data: Raw request data
-            
-        Returns:
-            Function result
-        """
-        # Extract call ID
-        call_id = raw_data.get("call_id") if raw_data else None
-        if not call_id:
-            return SwaigFunctionResult("Error: Missing call_id")
-            
-        # Activate the session
-        self._session_manager.activate_session(call_id)
-        
-        # Initialize state
-        self.set_state(call_id, {
-            "start_time": datetime.now().isoformat(),
-            "events": []
-        })
-        
-        return SwaigFunctionResult("Call started and session activated")
-    
-    def _hangup_hook_handler(self, args, raw_data):
-        """
-        Handler for the hangup hook
-        
-        Args:
-            args: Function arguments
-            raw_data: Raw request data
-            
-        Returns:
-            Function result
-        """
-        # Extract call ID
-        call_id = raw_data.get("call_id") if raw_data else None
-        if not call_id:
-            return SwaigFunctionResult("Error: Missing call_id")
-            
-        # End the session
-        self._session_manager.end_session(call_id)
-        
-        # Update state
-        state = self.get_state(call_id) or {}
-        state["end_time"] = datetime.now().isoformat()
-        self.update_state(call_id, state)
-        
-        return SwaigFunctionResult("Call ended and session deactivated")
-
-    def set_post_prompt(self, text: str) -> 'AgentBase':
-        """
-        Set the post-prompt for the agent
-        
-        Args:
-            text: Post-prompt text
-            
-        Returns:
-            Self for method chaining
-        """
-        self._post_prompt = text
-        return self
-        
-    def set_auto_answer(self, enabled: bool) -> 'AgentBase':
-        """
-        Set whether to automatically answer calls
-        
-        Args:
-            enabled: Whether to auto-answer
-            
-        Returns:
-            Self for method chaining
-        """
-        self._auto_answer = enabled
-        return self
-    
-    def set_call_recording(self, 
-                          enabled: bool, 
-                          format: str = "mp4", 
-                          stereo: bool = True) -> 'AgentBase':
-        """
-        Set call recording parameters
-        
-        Args:
-            enabled: Whether to record calls
-            format: Recording format
-            stereo: Whether to record in stereo
-            
-        Returns:
-            Self for method chaining
-        """
-        self._record_call = enabled
-        self._record_format = format
-        self._record_stereo = stereo
-        return self
-        
-    def add_native_function(self, function_name: str) -> 'AgentBase':
-        """
-        Add a native function to the list of enabled native functions
-        
-        Args:
-            function_name: Name of native function to enable
-            
-        Returns:
-            Self for method chaining
-        """
-        if function_name and isinstance(function_name, str):
-            if not self.native_functions:
-                self.native_functions = []
-            if function_name not in self.native_functions:
-                self.native_functions.append(function_name)
-        return self
-
-    def remove_native_function(self, function_name: str) -> 'AgentBase':
-        """
-        Remove a native function from the SWAIG object
-        
-        Args:
-            function_name: Name of the native function
-            
-        Returns:
-            Self for method chaining
-        """
-        if function_name in self.native_functions:
-            self.native_functions.remove(function_name)
-        return self
-        
-    def get_native_functions(self) -> List[str]:
-        """
-        Get the list of native functions
-        
-        Returns:
-            List of native function names
-        """
-        return self.native_functions.copy()
-
-    def has_section(self, title: str) -> bool:
-        """
-        Check if a section exists in the prompt
-        
-        Args:
-            title: Section title
-            
-        Returns:
-            True if the section exists, False otherwise
-        """
-        if not self._use_pom or not self.pom:
-            return False
-            
-        return self.pom.has_section(title)
-        
-    def on_swml_request(self, request_data: Optional[dict] = None) -> Optional[dict]:
-        """
-        Called when SWML is requested, with request data when available.
-        
-        Subclasses can override this to inspect or modify SWML based on the request.
-        
-        Args:
-            request_data: Optional dictionary containing the parsed POST body
-            
-        Returns:
-            Optional dict to modify/augment the SWML document
-        """
-        # Default implementation does nothing
-        return None
-
-    def serve(self, host: Optional[str] = None, port: Optional[int] = None) -> None:
-        """
-        Start a web server for this agent
-        
-        Args:
-            host: Optional host to override the default
-            port: Optional port to override the default
-        """
-        import uvicorn
-        
-        # Create a FastAPI app with no automatic redirects
-        app = FastAPI(redirect_slashes=False)
-        
-        # Register all routes
-        self._register_routes(app)
-        
-        host = host or self.host
-        port = port or self.port
-        
-        # Print the auth credentials with source
-        username, password, source = self.get_basic_auth_credentials(include_source=True)
-        self.log.info("starting_server", 
-                     url=f"http://{host}:{port}{self.route}",
-                     username=username,
-                     password="*" * len(password),
-                     auth_source=source)
-        
-        print(f"Agent '{self.name}' is available at:")
-        print(f"URL: http://{host}:{port}{self.route}")
-        print(f"Basic Auth: {username}:{password} (source: {source})")
-        
-        # Check if SIP usernames are registered and print that info
-        if hasattr(self, '_sip_usernames') and self._sip_usernames:
-            print(f"Registered SIP usernames: {', '.join(sorted(self._sip_usernames))}")
-        
-        # Check if callback endpoints are registered and print them
-        if hasattr(self, '_routing_callbacks') and self._routing_callbacks:
-            for path in sorted(self._routing_callbacks.keys()):
-                if hasattr(self, '_sip_usernames') and path == "/sip":
-                    print(f"SIP endpoint: http://{host}:{port}{path}")
-                else:
-                    print(f"Callback endpoint: http://{host}:{port}{path}")
-        
-        # Configure Uvicorn for production
-        uvicorn_log_config = uvicorn.config.LOGGING_CONFIG
-        uvicorn_log_config["formatters"]["access"]["fmt"] = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-        uvicorn_log_config["formatters"]["default"]["fmt"] = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-        
-        # Start the server
-        try:
-            # Run the server
-            uvicorn.run(
-                app, 
-                host=host, 
-                port=port,
-                log_config=uvicorn_log_config
-            )
-        except KeyboardInterrupt:
-            self.log.info("server_shutdown")
-            print("\nStopping the agent.")
-
-    # ----------------------------------------------------------------------
-    # AI Verb Configuration Methods
-    # ----------------------------------------------------------------------
-
-    def add_hint(self, hint: str) -> 'AgentBase':
-        """
-        Add a simple string hint to help the AI agent understand certain words better
-        
-        Args:
-            hint: The hint string to add
-            
-        Returns:
-            Self for method chaining
-        """
-        if isinstance(hint, str) and hint:
-            self._hints.append(hint)
-        return self
-
-    def add_hints(self, hints: List[str]) -> 'AgentBase':
-        """
-        Add multiple string hints
-        
-        Args:
-            hints: List of hint strings
-            
-        Returns:
-            Self for method chaining
-        """
-        if hints and isinstance(hints, list):
-            for hint in hints:
-                if isinstance(hint, str) and hint:
-                    self._hints.append(hint)
-        return self
-
-    def add_pattern_hint(self, 
-                         hint: str, 
-                         pattern: str, 
-                         replace: str, 
-                         ignore_case: bool = False) -> 'AgentBase':
-        """
-        Add a complex hint with pattern matching
-        
-        Args:
-            hint: The hint to match
-            pattern: Regular expression pattern
-            replace: Text to replace the hint with
-            ignore_case: Whether to ignore case when matching
-            
-        Returns:
-            Self for method chaining
-        """
-        if hint and pattern and replace:
-            self._hints.append({
-                "hint": hint,
-                "pattern": pattern,
-                "replace": replace,
-                "ignore_case": ignore_case
-            })
-        return self
-
-    def add_language(self, 
-                     name: str, 
-                     code: str, 
-                     voice: str,
-                     speech_fillers: Optional[List[str]] = None,
-                     function_fillers: Optional[List[str]] = None,
-                     engine: Optional[str] = None,
-                     model: Optional[str] = None) -> 'AgentBase':
-        """
-        Add a language configuration to support multilingual conversations
-        
-        Args:
-            name: Name of the language (e.g., "English", "French")
-            code: Language code (e.g., "en-US", "fr-FR")
-            voice: TTS voice to use. Can be a simple name (e.g., "en-US-Neural2-F") 
-                  or a combined format "engine.voice:model" (e.g., "elevenlabs.josh:eleven_turbo_v2_5")
-            speech_fillers: Optional list of filler phrases for natural speech
-            function_fillers: Optional list of filler phrases during function calls
-            engine: Optional explicit engine name (e.g., "elevenlabs", "rime")
-            model: Optional explicit model name (e.g., "eleven_turbo_v2_5", "arcana")
-            
-        Returns:
-            Self for method chaining
-            
-        Examples:
-            # Simple voice name
-            agent.add_language("English", "en-US", "en-US-Neural2-F")
-            
-            # Explicit parameters
-            agent.add_language("English", "en-US", "josh", engine="elevenlabs", model="eleven_turbo_v2_5")
-            
-            # Combined format
-            agent.add_language("English", "en-US", "elevenlabs.josh:eleven_turbo_v2_5")
-        """
-        language = {
-            "name": name,
-            "code": code
-        }
-        
-        # Handle voice formatting (either explicit params or combined string)
-        if engine or model:
-            # Use explicit parameters if provided
-            language["voice"] = voice
-            if engine:
-                language["engine"] = engine
-            if model:
-                language["model"] = model
-        elif "." in voice and ":" in voice:
-            # Parse combined string format: "engine.voice:model"
-            try:
-                engine_voice, model_part = voice.split(":", 1)
-                engine_part, voice_part = engine_voice.split(".", 1)
-                
-                language["voice"] = voice_part
-                language["engine"] = engine_part
-                language["model"] = model_part
-            except ValueError:
-                # If parsing fails, use the voice string as-is
-                language["voice"] = voice
-        else:
-            # Simple voice string
-            language["voice"] = voice
-        
-        # Add fillers if provided
-        if speech_fillers and function_fillers:
-            language["speech_fillers"] = speech_fillers
-            language["function_fillers"] = function_fillers
-        elif speech_fillers or function_fillers:
-            # If only one type of fillers is provided, use the deprecated "fillers" field
-            fillers = speech_fillers or function_fillers
-            language["fillers"] = fillers
-        
-        self._languages.append(language)
-        return self
-
-    def set_languages(self, languages: List[Dict[str, Any]]) -> 'AgentBase':
-        """
-        Set all language configurations at once
-        
-        Args:
-            languages: List of language configuration dictionaries
-            
-        Returns:
-            Self for method chaining
-        """
-        if languages and isinstance(languages, list):
-            self._languages = languages
-        return self
-
-    def add_pronunciation(self, 
-                         replace: str, 
-                         with_text: str, 
-                         ignore_case: bool = False) -> 'AgentBase':
-        """
-        Add a pronunciation rule to help the AI speak certain words correctly
-        
-        Args:
-            replace: The expression to replace
-            with_text: The phonetic spelling to use instead
-            ignore_case: Whether to ignore case when matching
-            
-        Returns:
-            Self for method chaining
-        """
-        if replace and with_text:
-            rule = {
-                "replace": replace,
-                "with": with_text
-            }
-            if ignore_case:
-                rule["ignore_case"] = True
-            
-            self._pronounce.append(rule)
-        return self
-
-    def set_pronunciations(self, pronunciations: List[Dict[str, Any]]) -> 'AgentBase':
-        """
-        Set all pronunciation rules at once
-        
-        Args:
-            pronunciations: List of pronunciation rule dictionaries
-            
-        Returns:
-            Self for method chaining
-        """
-        if pronunciations and isinstance(pronunciations, list):
-            self._pronounce = pronunciations
-        return self
-
-    def set_param(self, key: str, value: Any) -> 'AgentBase':
-        """
-        Set a single AI parameter
-        
-        Args:
-            key: Parameter name
-            value: Parameter value
-            
-        Returns:
-            Self for method chaining
-        """
-        if key:
-            self._params[key] = value
-        return self
-
-    def set_params(self, params: Dict[str, Any]) -> 'AgentBase':
-        """
-        Set multiple AI parameters at once
-        
-        Args:
-            params: Dictionary of parameter name/value pairs
-            
-        Returns:
-            Self for method chaining
-        """
-        if params and isinstance(params, dict):
-            self._params.update(params)
-        return self
-
-    def set_global_data(self, data: Dict[str, Any]) -> 'AgentBase':
-        """
-        Set the global data available to the AI throughout the conversation
-        
-        Args:
-            data: Dictionary of global data
-            
-        Returns:
-            Self for method chaining
-        """
-        if data and isinstance(data, dict):
-            self._global_data = data
-        return self
-
-    def update_global_data(self, data: Dict[str, Any]) -> 'AgentBase':
-        """
-        Update the global data with new values
-        
-        Args:
-            data: Dictionary of global data to update
-            
-        Returns:
-            Self for method chaining
-        """
-        if data and isinstance(data, dict):
-            self._global_data.update(data)
-        return self
-
-    def set_native_functions(self, function_names: List[str]) -> 'AgentBase':
-        """
-        Set the list of native functions to enable
-        
-        Args:
-            function_names: List of native function names
-            
-        Returns:
-            Self for method chaining
-        """
-        if function_names and isinstance(function_names, list):
-            self.native_functions = [name for name in function_names if isinstance(name, str)]
-        return self
-
-    def add_function_include(self, url: str, functions: List[str], meta_data: Optional[Dict[str, Any]] = None) -> 'AgentBase':
-        """
-        Add a remote function include to the SWAIG configuration
-        
-        Args:
-            url: URL to fetch remote functions from
-            functions: List of function names to include
-            meta_data: Optional metadata to include with the function include
-            
-        Returns:
-            Self for method chaining
-        """
-        if url and functions and isinstance(functions, list):
-            include = {
-                "url": url,
-                "functions": functions
-            }
-            if meta_data and isinstance(meta_data, dict):
-                include["meta_data"] = meta_data
-            
-            self._function_includes.append(include)
-        return self
-
-    def set_function_includes(self, includes: List[Dict[str, Any]]) -> 'AgentBase':
-        """
-        Set the complete list of function includes
-        
-        Args:
-            includes: List of include objects, each with url and functions properties
-            
-        Returns:
-            Self for method chaining
-        """
-        if includes and isinstance(includes, list):
-            # Validate each include has required properties
-            valid_includes = []
-            for include in includes:
-                if isinstance(include, dict) and "url" in include and "functions" in include:
-                    if isinstance(include["functions"], list):
-                        valid_includes.append(include)
-            
-            self._function_includes = valid_includes
-        return self
-
-    def enable_sip_routing(self, auto_map: bool = True, path: str = "/sip") -> 'AgentBase':
-        """
-        Enable SIP-based routing for this agent
-        
-        This allows the agent to automatically route SIP requests based on SIP usernames.
-        When enabled, an endpoint at the specified path is automatically created
-        that will handle SIP requests and deliver them to this agent.
-        
-        Args:
-            auto_map: Whether to automatically map common SIP usernames to this agent
-                     (based on the agent name and route path)
-            path: The path to register the SIP routing endpoint (default: "/sip")
-        
-        Returns:
-            Self for method chaining
-        """
-        # Create a routing callback that handles SIP usernames
-        def sip_routing_callback(request: Request, body: Dict[str, Any]) -> Optional[str]:
-            # Extract SIP username from the request body
-            sip_username = self.extract_sip_username(body)
-            
-            if sip_username:
-                self.log.info("sip_username_extracted", username=sip_username)
-                
-                # Check if this username is registered with this agent
-                if hasattr(self, '_sip_usernames') and sip_username.lower() in self._sip_usernames:
-                    self.log.info("sip_username_matched", username=sip_username)
-                    # This route is already being handled by the agent, no need to redirect
-                    return None
-                else:
-                    self.log.info("sip_username_not_matched", username=sip_username)
-                    # Not registered with this agent, let routing continue
-                    
-            return None
-            
-        # Register the callback with the SWMLService, specifying the path
-        self.register_routing_callback(sip_routing_callback, path=path)
-        
-        # Auto-map common usernames if requested
-        if auto_map:
-            self.auto_map_sip_usernames()
-            
-        return self
-        
-    def register_sip_username(self, sip_username: str) -> 'AgentBase':
-        """
-        Register a SIP username that should be routed to this agent
-        
-        Args:
-            sip_username: SIP username to register
-            
-        Returns:
-            Self for method chaining
-        """
-        if not hasattr(self, '_sip_usernames'):
-            self._sip_usernames = set()
-            
-        self._sip_usernames.add(sip_username.lower())
-        self.log.info("sip_username_registered", username=sip_username)
-        
-        return self
-        
-    def auto_map_sip_usernames(self) -> 'AgentBase':
-        """
-        Automatically register common SIP usernames based on this agent's 
-        name and route
-        
-        Returns:
-            Self for method chaining
-        """
-        # Register username based on agent name
-        clean_name = re.sub(r'[^a-z0-9_]', '', self.name.lower())
-        if clean_name:
-            self.register_sip_username(clean_name)
-            
-        # Register username based on route (without slashes)
-        clean_route = re.sub(r'[^a-z0-9_]', '', self.route.lower())
-        if clean_route and clean_route != clean_name:
-            self.register_sip_username(clean_route)
-            
-        # Register common variations if they make sense
-        if len(clean_name) > 3:
-            # Register without vowels
-            no_vowels = re.sub(r'[aeiou]', '', clean_name)
-            if no_vowels != clean_name and len(no_vowels) > 2:
-                self.register_sip_username(no_vowels)
-                
-        return self
-
-    def set_web_hook_url(self, url: str) -> 'AgentBase':
-        """
-        Override the default web_hook_url with a supplied URL string
-        
-        Args:
-            url: The URL to use for SWAIG function webhooks
-            
-        Returns:
-            Self for method chaining
-        """
-        self._web_hook_url_override = url
-        return self
-        
-    def set_post_prompt_url(self, url: str) -> 'AgentBase':
-        """
-        Override the default post_prompt_url with a supplied URL string
-        
-        Args:
-            url: The URL to use for post-prompt summary delivery
-            
-        Returns:
-            Self for method chaining
-        """
-        self._post_prompt_url_override = url
-        return self