signalwire-agents 0.1.1__py3-none-any.whl → 0.1.5__py3-none-any.whl

signalwire_agents/core/agent_base.py

@@ -0,0 +1,2541 @@
+"""
+Copyright (c) 2025 SignalWire
+
+This file is part of the SignalWire AI Agents SDK.
+
+Licensed under the MIT License.
+See LICENSE file in the project root for full license information.
+"""
+
+"""
+AgentBase - Core foundation class for all SignalWire AI Agents
+"""
+
+import functools
+import inspect
+import os
+import sys
+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 re
+
+try:
+    import fastapi
+    from fastapi import FastAPI, APIRouter, Depends, HTTPException, Query, Body, Request, Response
+    from fastapi.security import HTTPBasic, HTTPBasicCredentials
+    from pydantic import BaseModel
+except ImportError:
+    raise ImportError(
+        "fastapi is required. Install it with: pip install fastapi"
+    )
+
+try:
+    import uvicorn
+except ImportError:
+    raise 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
+
+# Create a logger
+logger = structlog.get_logger("agent_base")
+
+class AgentBase(SWMLService):
+    """
+    Base class for all SignalWire AI Agents.
+    
+    This class extends SWMLService and provides enhanced functionality for building agents including:
+    - Prompt building and customization
+    - SWML rendering
+    - SWAIG function definition and execution
+    - Web service for serving SWML and handling webhooks
+    - Security and session management
+    
+    Subclassing options:
+    1. Simple override of get_prompt() for raw text
+    2. Using prompt_* methods for structured prompts
+    3. Declarative PROMPT_SECTIONS class attribute
+    """
+    
+    # Subclasses can define this to declaratively set prompt sections
+    PROMPT_SECTIONS = None
+    
+    def __init__(
+        self,
+        name: str,
+        route: str = "/",
+        host: str = "0.0.0.0",
+        port: int = 3000,
+        basic_auth: Optional[Tuple[str, str]] = None,
+        use_pom: bool = True,
+        enable_state_tracking: bool = False,
+        token_expiry_secs: int = 600,
+        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
+    ):
+        """
+        Initialize a new agent
+        
+        Args:
+            name: Agent name/identifier
+            route: HTTP route path for this agent
+            host: Host to bind the web server to
+            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
+        """
+        # Import SWMLService here to avoid circular imports
+        from signalwire_agents.core.swml_service import 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__
+        
+        # Initialize the SWMLService base class
+        super().__init__(
+            name=name,
+            route=route,
+            host=host,
+            port=port,
+            basic_auth=basic_auth,
+            schema_path=schema_path
+        )
+        
+        # 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}")
+        
+        # Setup logger for this instance
+        self.log = logger.bind(agent=name)
+        self.log.info("agent_initializing", route=route, host=host, port=port)
+        
+        # Store agent-specific parameters
+        self._default_webhook_url = default_webhook_url
+        self._suppress_logs = suppress_logs
+        
+        # Generate or use the provided agent ID
+        self.agent_id = agent_id or str(uuid.uuid4())
+        
+        # Check for proxy URL base in environment
+        self._proxy_url_base = os.environ.get('SWML_PROXY_URL_BASE')
+        
+        # Initialize prompt handling
+        self._use_pom = use_pom
+        self._raw_prompt = None
+        self._post_prompt = None
+        
+        # Initialize POM if needed
+        if self._use_pom:
+            try:
+                from signalwire_pom.pom import PromptObjectModel
+                self.pom = PromptObjectModel()
+            except ImportError:
+                raise ImportError(
+                    "signalwire-pom package is required for use_pom=True. "
+                    "Install it with: pip install signalwire-pom"
+                )
+        else:
+            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
+        self._post_prompt_url_override = None
+        
+        # Register the tool decorator on this instance
+        self.tool = self._tool_decorator
+        
+        # Call settings
+        self._auto_answer = auto_answer
+        self._record_call = record_call
+        self._record_format = record_format
+        self._record_stereo = record_stereo
+        
+        # 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()
+        
+        # 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 = []
+        self._languages = []
+        self._pronounce = []
+        self._params = {}
+        self._global_data = {}
+        self._function_includes = []
+    
+    def _process_prompt_sections(self):
+        """
+        Process declarative PROMPT_SECTIONS attribute from a subclass
+        
+        This auto-vivifies section methods and bootstraps the prompt
+        from class declaration, allowing for declarative agents.
+        """
+        # 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
+    # ----------------------------------------------------------------------
+    
+    def set_prompt_text(self, text: str) -> 'AgentBase':
+        """
+        Set the prompt as raw text instead of using POM
+        
+        Args:
+            text: The raw prompt text
+            
+        Returns:
+            Self for method chaining
+        """
+        self._raw_prompt = text
+        return self
+    
+    def set_prompt_pom(self, pom: List[Dict[str, Any]]) -> 'AgentBase':
+        """
+        Set the prompt as a POM dictionary
+        
+        Args:
+            pom: POM dictionary structure
+            
+        Returns:
+            Self for method chaining
+        """
+        if self._use_pom:
+            self.pom = pom
+        else:
+            raise ValueError("use_pom must be True to use set_prompt_pom")
+        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':
+        """
+        Add a section to the prompt
+        
+        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
+            
+        Returns:
+            Self for method chaining
+        """
+        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', [])
+                        )
+                
+        return self
+        
+    def prompt_add_to_section(
+        self,
+        title: str,
+        body: Optional[str] = None,
+        bullet: Optional[str] = None,
+        bullets: Optional[List[str]] = None
+    ) -> 'AgentBase':
+        """
+        Add content to an existing section (creating it if needed)
+        
+        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
+            
+        Returns:
+            Self for method chaining
+        """
+        if self._use_pom and self.pom:
+            self.pom.add_to_section(
+                title=title,
+                body=body,
+                bullet=bullet,
+                bullets=bullets
+            )
+        return self
+        
+    def prompt_add_subsection(
+        self,
+        parent_title: str,
+        title: str,
+        body: str = "",
+        bullets: Optional[List[str]] = None
+    ) -> 'AgentBase':
+        """
+        Add a subsection to an existing section (creating parent if needed)
+        
+        Args:
+            parent_title: Parent section title
+            title: Subsection title
+            body: Optional subsection body text
+            bullets: Optional list of bullet points
+            
+        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
+            
+            # If parent section not found, create it
+            if not parent_section:
+                parent_section = self.pom.add_section(title=parent_title)
+            
+            # Now call add_subsection on the parent section object, not on POM
+            parent_section.add_subsection(
+                title=title,
+                body=body,
+                bullets=bullets or []
+            )
+            
+        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':
+        """
+        Define a SWAIG function that the AI can call
+        
+        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
+            
+        Returns:
+            Self for method chaining
+        """
+        if name in self._swaig_functions:
+            raise ValueError(f"Tool with name '{name}' already exists")
+            
+        self._swaig_functions[name] = SWAIGFunction(
+            name=name,
+            description=description,
+            parameters=parameters,
+            handler=handler,
+            secure=secure,
+            fillers=fillers
+        )
+        return self
+    
+    def _tool_decorator(self, name=None, **kwargs):
+        """
+        Decorator for defining SWAIG tools in a class
+        
+        Used as:
+        
+        @agent.tool(name="example_function", parameters={...})
+        def example_function(self, param1):
+            # ...
+        """
+        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)
+            
+            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
+    # ----------------------------------------------------------------------
+    
+    def get_name(self) -> str:
+        """
+        Get the agent name
+        
+        Returns:
+            Agent name/identifier
+        """
+        return self.name
+    
+    def get_prompt(self) -> Union[str, List[Dict[str, Any]]]:
+        """
+        Get the prompt for the agent
+        
+        Returns:
+            Either a string prompt or a POM object as list of dicts
+        """
+        # 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."
+    
+    def get_post_prompt(self) -> Optional[str]:
+        """
+        Get the post-prompt for the agent
+        
+        Returns:
+            Post-prompt text or None if not set
+        """
+        return self._post_prompt
+    
+    def define_tools(self) -> List[SWAIGFunction]:
+        """
+        Define the tools this agent can use
+        
+        Returns:
+            List of SWAIGFunction objects
+            
+        This method can be overridden by subclasses.
+        """
+        return list(self._swaig_functions.values())
+    
+    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
+    
+    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
+        
+        Args:
+            call_id: Optional call ID for session-specific tokens
+            modifications: Optional dict of modifications to apply to the SWML
+            
+        Returns:
+            SWML document as a string
+        """
+        # Reset the document to a clean state
+        self.reset_document()
+        
+        # Get prompt
+        prompt = self.get_prompt()
+        prompt_is_pom = isinstance(prompt, list)
+        
+        # Get post-prompt
+        post_prompt = self.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()
+            
+        # Empty query params - no need to include call_id in URLs
+        query_params = {}
+        
+        # Get the default webhook URL with auth
+        default_webhook_url = self._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
+        
+        # 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
+        
+        # Add includes if any are defined
+        if self._function_includes:
+            swaig_obj["includes"] = self._function_includes
+        
+        # Create functions array
+        functions = []
+        
+        # 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)
+                
+            # Prepare function entry
+            function_entry = {
+                "function": name,
+                "description": func.description,
+                "parameters": {
+                    "type": "object",
+                    "properties": func.parameters
+                }
+            }
+            
+            # 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)
+                
+            functions.append(function_entry)
+            
+        # Add functions array to SWAIG object if we have any
+        if functions:
+            swaig_obj["functions"] = functions
+        
+        # Add post-prompt URL if we have a post-prompt
+        post_prompt_url = None
+        if post_prompt:
+            post_prompt_url = self._build_webhook_url("post_prompt", {})
+            
+            # 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()
+        
+        # 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")
+        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
+                )
+                
+                # Add new configuration parameters to the AI config
+                
+                # Add hints if any
+                if self._hints:
+                    ai_config["hints"] = self._hints
+                
+                # Add languages if any
+                if self._languages:
+                    ai_config["languages"] = self._languages
+                
+                # Add pronunciation rules if any
+                if self._pronounce:
+                    ai_config["pronounce"] = self._pronounce
+                
+                # Add params if any
+                if self._params:
+                    ai_config["params"] = self._params
+                
+                # Add global_data if any
+                if self._global_data:
+                    ai_config["global_data"] = self._global_data
+                    
+            except ValueError as e:
+                if not self._suppress_logs:
+                    print(f"Error building AI verb configuration: {str(e)}")
+        else:
+            # Fallback if no handler (shouldn't happen but just in case)
+            ai_config = {
+                "prompt": {
+                    "text" if not prompt_is_pom else "pom": prompt
+                }
+            }
+            
+            if post_prompt:
+                ai_config["post_prompt"] = {"text": post_prompt}
+                if post_prompt_url:
+                    ai_config["post_prompt_url"] = post_prompt_url
+                
+            if swaig_obj:
+                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 self._languages and "languages" not in ai_config:
+            ai_config["languages"] = self._languages
+        
+        if self._pronounce and "pronounce" not in ai_config:
+            ai_config["pronounce"] = self._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
+        
+        # Add the AI verb to the document
+        self.add_verb("ai", ai_config)
+        
+        # Apply any modifications from the callback
+        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)
+        
+        # Return the rendered document as a string
+        return self.render_document()
+    
+    def _check_basic_auth(self, request: Request) -> bool:
+        """
+        Check basic auth from a request
+        
+        Args:
+            request: FastAPI request object
+            
+        Returns:
+            True if auth is valid, False otherwise
+        """
+        auth_header = request.headers.get("Authorization")
+        if not auth_header or not auth_header.startswith("Basic "):
+            return False
+            
+        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
+    
+    def as_router(self) -> APIRouter:
+        """
+        Get a FastAPI router for this agent
+        
+        Returns:
+            FastAPI router
+        """
+        # Get the base router from SWMLService
+        router = super().as_router()
+        
+        # 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
+    
+    async def _handle_root_request(self, request: Request):
+        """Handle GET/POST requests to the root endpoint"""
+        # 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
+        )
+        
+        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"
+                )
+            
+            # Try to parse request body for POST
+            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())
+            
+            # Render SWML
+            swml = self._render_swml(call_id, modifications)
+            req_log.debug("swml_rendered", swml_size=len(swml))
+            
+            # 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,
+                    headers={"WWW-Authenticate": "Basic"},
+                    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))
+            
+            # Return as JSON
+            req_log.info("request_successful")
+            return Response(
+                content=swml,
+                media_type="application/json",
+                headers={"X-Debug": "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), "traceback": traceback.format_exc()}),
+                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