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

signalwire_agents/core/agent_base.py

@@ -1,3 +1,4 @@
+#!/usr/bin/env python3
 """
 Copyright (c) 2025 SignalWire
 
@@ -7,24 +8,21 @@ Licensed under the MIT License.
 See LICENSE file in the project root for full license information.
 """
 
+# -*- coding: utf-8 -*-
 """
-AgentBase - Core foundation class for all SignalWire AI Agents
+Base class for all SignalWire AI Agents
 """
 
-import functools
-import inspect
 import os
-import sys
+import json
+import time
 import uuid
-import tempfile
-import traceback
-from typing import Dict, List, Any, Optional, Union, Callable, Tuple, Type, TypeVar
 import base64
-import secrets
-from urllib.parse import urlparse
-import json
-from datetime import datetime
-import re
+import logging
+import inspect
+import functools
+from typing import Optional, Union, List, Dict, Any, Tuple, Callable, Type
+from urllib.parse import urlparse, urlencode
 
 try:
     import fastapi
@@ -110,7 +108,7 @@ class AgentBase(SWMLService):
         basic_auth: Optional[Tuple[str, str]] = None,
         use_pom: bool = True,
         enable_state_tracking: bool = False,
-        token_expiry_secs: int = 600,
+        token_expiry_secs: int = 3600,
         auto_answer: bool = True,
         record_call: bool = False,
         record_format: str = "mp4",
@@ -355,6 +353,19 @@ class AgentBase(SWMLService):
         self._raw_prompt = text
         return self
     
+    def set_post_prompt(self, text: str) -> 'AgentBase':
+        """
+        Set the post-prompt text for summary generation
+        
+        Args:
+            text: The post-prompt text
+            
+        Returns:
+            Self for method chaining
+        """
+        self._post_prompt = text
+        return self
+    
     def set_prompt_pom(self, pom: List[Dict[str, Any]]) -> 'AgentBase':
         """
         Set the prompt as a POM dictionary
@@ -569,6 +580,44 @@ class AgentBase(SWMLService):
             return func
         return decorator
     
+    def _register_class_decorated_tools(self):
+        """
+        Register tools defined with @AgentBase.tool class decorator
+        
+        This method scans the class for methods decorated with @AgentBase.tool
+        and registers them automatically.
+        """
+        # Get the class of this instance
+        cls = self.__class__
+        
+        # Loop through all attributes in the class
+        for name in dir(cls):
+            # Get the attribute
+            attr = getattr(cls, name)
+            
+            # Check if it's a method decorated with @AgentBase.tool
+            if inspect.ismethod(attr) or inspect.isfunction(attr):
+                if hasattr(attr, "_is_tool") and getattr(attr, "_is_tool", False):
+                    # Extract tool information
+                    tool_name = getattr(attr, "_tool_name", name)
+                    tool_params = getattr(attr, "_tool_params", {})
+                    
+                    # Get description and parameters
+                    description = tool_params.get("description", attr.__doc__ or f"Function {tool_name}")
+                    parameters = tool_params.get("parameters", {})
+                    secure = tool_params.get("secure", True)
+                    fillers = tool_params.get("fillers", None)
+                    
+                    # Register the tool
+                    self.define_tool(
+                        name=tool_name,
+                        description=description,
+                        parameters=parameters,
+                        handler=attr.__get__(self, cls),  # Bind the method to this instance
+                        secure=secure,
+                        fillers=fillers
+                    )
+    
     @classmethod
     def tool(cls, name=None, **kwargs):
         """
@@ -730,7 +779,17 @@ class AgentBase(SWMLService):
         Returns:
             Secure token string
         """
-        return self._session_manager.create_tool_token(tool_name, call_id)
+        try:
+            # Ensure we have a session manager
+            if not hasattr(self, '_session_manager'):
+                self.log.error("no_session_manager")
+                return ""
+                
+            # Create the token using the session manager
+            return self._session_manager.create_tool_token(tool_name, call_id)
+        except Exception as e:
+            self.log.error("token_creation_error", error=str(e), tool=tool_name, call_id=call_id)
+            return ""
     
     def validate_tool_token(self, function_name: str, token: str, call_id: str) -> bool:
         """
@@ -744,14 +803,92 @@ class AgentBase(SWMLService):
         Returns:
             True if token is valid, False otherwise
         """
-        # Skip validation for non-secure tools
-        if function_name not in self._swaig_functions:
-            return False
+        try:
+            # Skip validation for non-secure tools
+            if function_name not in self._swaig_functions:
+                self.log.warning("unknown_function", function=function_name)
+                return False
+                
+            # Always allow non-secure functions
+            if not self._swaig_functions[function_name].secure:
+                self.log.debug("non_secure_function_allowed", function=function_name)
+                return True
+            
+            # Check if we have a session manager
+            if not hasattr(self, '_session_manager'):
+                self.log.error("no_session_manager")
+                return False
+            
+            # Handle missing token
+            if not token:
+                self.log.warning("missing_token", function=function_name)
+                return False
+                
+            # For debugging: Log token details
+            try:
+                # Capture original parameters
+                self.log.debug("token_validate_input", 
+                              function=function_name, 
+                              call_id=call_id, 
+                              token_length=len(token))
+                
+                # Try to decode token for debugging
+                if hasattr(self._session_manager, 'debug_token'):
+                    debug_info = self._session_manager.debug_token(token)
+                    self.log.debug("token_debug", debug_info=debug_info)
+                    
+                    # Extract token components
+                    if debug_info.get("valid_format") and "components" in debug_info:
+                        components = debug_info["components"]
+                        token_call_id = components.get("call_id")
+                        token_function = components.get("function")
+                        token_expiry = components.get("expiry")
+                        
+                        # Log parameter mismatches
+                        if token_function != function_name:
+                            self.log.warning("token_function_mismatch", 
+                                           expected=function_name, 
+                                           actual=token_function)
+                        
+                        if token_call_id != call_id:
+                            self.log.warning("token_call_id_mismatch", 
+                                           expected=call_id, 
+                                           actual=token_call_id)
+                            
+                        # Check expiration
+                        if debug_info.get("status", {}).get("is_expired"):
+                            self.log.warning("token_expired", 
+                                           expires_in=debug_info["status"].get("expires_in_seconds"))
+            except Exception as e:
+                self.log.error("token_debug_error", error=str(e))
+                
+            # Use call_id from token if the provided one is empty
+            if not call_id and hasattr(self._session_manager, 'debug_token'):
+                try:
+                    debug_info = self._session_manager.debug_token(token)
+                    if debug_info.get("valid_format") and "components" in debug_info:
+                        token_call_id = debug_info["components"].get("call_id")
+                        if token_call_id:
+                            self.log.debug("using_call_id_from_token", call_id=token_call_id)
+                            is_valid = self._session_manager.validate_tool_token(function_name, token, token_call_id)
+                            if is_valid:
+                                self.log.debug("token_valid_with_extracted_call_id")
+                                return True
+                except Exception as e:
+                    self.log.error("error_using_call_id_from_token", error=str(e))
             
-        if not self._swaig_functions[function_name].secure:
-            return True
+            # Normal validation with provided call_id
+            is_valid = self._session_manager.validate_tool_token(function_name, token, call_id)
             
-        return self._session_manager.validate_tool_token(function_name, token, call_id)
+            if is_valid:
+                self.log.debug("token_valid", function=function_name)
+            else:
+                self.log.warning("token_invalid", function=function_name)
+                
+            return is_valid
+        except Exception as e:
+            self.log.error("token_validation_error", error=str(e), function=function_name)
+            return False
     
     # ----------------------------------------------------------------------
     # Web Server and Routing
@@ -836,6 +973,16 @@ class AgentBase(SWMLService):
         Returns:
             Fully constructed webhook URL
         """
+        # Use the parent class's implementation if available and has the same method
+        if hasattr(super(), '_build_webhook_url'):
+            # Ensure _proxy_url_base is synchronized
+            if getattr(self, '_proxy_url_base', None) and hasattr(super(), '_proxy_url_base'):
+                super()._proxy_url_base = self._proxy_url_base
+                
+            # Call parent's implementation
+            return super()._build_webhook_url(endpoint, query_params)
+            
+        # Otherwise, fall back to our own implementation
         # Base URL construction
         if hasattr(self, '_proxy_url_base') and self._proxy_url_base:
             # For proxy URLs
@@ -965,15 +1112,26 @@ class AgentBase(SWMLService):
         if functions:
             swaig_obj["functions"] = functions
         
-        # Add post-prompt URL if we have a post-prompt
+        # Add post-prompt URL with token if we have a post-prompt
         post_prompt_url = None
         if post_prompt:
-            post_prompt_url = self._build_webhook_url("post_prompt", {})
+            # Create a token for post_prompt if we have a call_id
+            query_params = {}
+            if call_id and hasattr(self, '_session_manager'):
+                try:
+                    token = self._session_manager.create_tool_token("post_prompt", call_id)
+                    if token:
+                        query_params["token"] = token
+                except Exception as e:
+                    self.log.error("post_prompt_token_creation_error", error=str(e))
+            
+            # Build the URL with the token (if any)
+            post_prompt_url = self._build_webhook_url("post_prompt", query_params)
             
             # Use override if set
             if hasattr(self, '_post_prompt_url_override') and self._post_prompt_url_override:
                 post_prompt_url = self._post_prompt_url_override
-        
+                
         # Add answer verb with auto-answer enabled
         self.add_answer_verb()
         
@@ -1116,276 +1274,655 @@ class AgentBase(SWMLService):
         Returns:
             FastAPI router
         """
-        # Get the base router from SWMLService
-        router = super().as_router()
+        # Create a router with explicit redirect_slashes=False
+        router = APIRouter(redirect_slashes=False)
         
-        # 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)
+        # Register routes explicitly
+        self._register_routes(router)
+        
+        # Log all registered routes for debugging
+        print(f"Registered routes for {self.name}:")
+        for route in router.routes:
+            print(f"  {route.path}")
+        
+        return router
+
+    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
+        
+        if self._app is None:
+            # Create a FastAPI app with explicit redirect_slashes=False
+            app = FastAPI(redirect_slashes=False)
+            
+            # Get router for this agent
+            router = self.as_router()
+            
+            # Register a catch-all route for debugging and troubleshooting
+            @app.get("/{full_path:path}")
+            @app.post("/{full_path:path}")
+            async def handle_all_routes(request: Request, full_path: str):
+                print(f"Received request for path: {full_path}")
+                
+                # Check if the path is meant for this agent
+                if not full_path.startswith(self.route.lstrip("/")):
+                    return {"error": "Invalid route"}
+                
+                # Extract the path relative to this agent's route
+                relative_path = full_path[len(self.route.lstrip("/")):]
+                relative_path = relative_path.lstrip("/")
+                print(f"Relative path: {relative_path}")
+                
+                # Perform routing based on the relative path
+                if not relative_path or relative_path == "/":
+                    # Root endpoint
+                    return await self._handle_root_request(request)
+                
+                # Strip trailing slash for processing
+                clean_path = relative_path.rstrip("/")
+                
+                # Check for standard endpoints
+                if clean_path == "debug":
+                    return await self._handle_debug_request(request)
+                elif clean_path == "swaig":
+                    return await self._handle_swaig_request(request, Response())
+                elif clean_path == "post_prompt":
+                    return await self._handle_post_prompt_request(request)
+                elif clean_path == "check_for_input":
+                    return await self._handle_check_for_input_request(request)
+                
+                # Check for custom routing callbacks
+                if hasattr(self, '_routing_callbacks'):
+                    for callback_path, callback_fn in self._routing_callbacks.items():
+                        cb_path_clean = callback_path.strip("/")
+                        if clean_path == cb_path_clean:
+                            # Found a matching callback
+                            request.state.callback_path = callback_path
+                            return await self._handle_root_request(request)
+                
+                # Default: 404
+                return {"error": "Path not found"}
+            
+            # Include router with prefix
+            app.include_router(router, prefix=self.route)
+            
+            # Print all app routes for debugging
+            print(f"All app routes:")
+            for route in app.routes:
+                if hasattr(route, "path"):
+                    print(f"  {route.path}")
+            
+            self._app = 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)
+        print(f"Agent '{self.name}' is available at:")
+        print(f"URL: http://{host}:{port}{self.route}")
+        print(f"Basic Auth: {username}:{password} (source: {source})")
+        
+        uvicorn.run(self._app, host=host, port=port)
+
+    def on_swml_request(self, request_data: Optional[dict] = None, callback_path: Optional[str] = None) -> Optional[dict]:
+        """
+        Customization point for subclasses to modify SWML based on request data
+        
+        Args:
+            request_data: Optional dictionary containing the parsed POST body
+            callback_path: Optional callback path
             
-        # Root endpoint - with trailing slash
+        Returns:
+            Optional dict with modifications to apply to the SWML document
+        """
+        # Default implementation does nothing
+        return None
+    
+    def _register_routes(self, router):
+        """
+        Register routes for this agent
+        
+        This method ensures proper route registration by handling the routes 
+        directly in AgentBase rather than inheriting from SWMLService.
+        
+        Args:
+            router: FastAPI router to register routes with
+        """
+        # Root endpoint (handles both with and without trailing slash)
         @router.get("/")
         @router.post("/")
-        async def handle_root_with_slash(request: Request):
+        async def handle_root(request: Request, response: Response):
+            """Handle GET/POST requests to the root endpoint"""
             return await self._handle_root_request(request)
             
-        # Debug endpoint - without trailing slash
+        # Debug endpoint - Both versions
         @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")
         @router.post("/debug/")
-        async def handle_debug_with_slash(request: Request):
+        async def handle_debug(request: Request):
+            """Handle GET/POST requests to the debug endpoint"""
             return await self._handle_debug_request(request)
             
-        # SWAIG endpoint - without trailing slash
+        # SWAIG endpoint - Both versions 
         @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")
         @router.post("/swaig/")
-        async def handle_swaig_with_slash(request: Request):
-            return await self._handle_swaig_request(request)
+        async def handle_swaig(request: Request, response: Response):
+            """Handle GET/POST requests to the SWAIG endpoint"""
+            return await self._handle_swaig_request(request, response)
             
-        # Post-prompt endpoint - without trailing slash
+        # Post prompt endpoint - Both versions
         @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")
         @router.post("/post_prompt/")
-        async def handle_post_prompt_with_slash(request: Request):
+        async def handle_post_prompt(request: Request):
+            """Handle GET/POST requests to the post_prompt endpoint"""
             return await self._handle_post_prompt_request(request)
+            
+        # Check for input endpoint - Both versions
+        @router.get("/check_for_input")
+        @router.get("/check_for_input/")
+        @router.post("/check_for_input")
+        @router.post("/check_for_input/")
+        async def handle_check_for_input(request: Request):
+            """Handle GET/POST requests to the check_for_input endpoint"""
+            return await self._handle_check_for_input_request(request)
         
-        self._router = router
-        return router
+        # Register callback routes for routing callbacks if available
+        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 both with and without trailing slash
+                path = callback_path.rstrip("/")
+                path_with_slash = f"{path}/"
+                
+                @router.get(path)
+                @router.get(path_with_slash)
+                @router.post(path)
+                @router.post(path_with_slash)
+                async def handle_callback(request: Request, response: Response, cb_path=callback_path):
+                    """Handle GET/POST requests to a registered callback path"""
+                    # Store the callback path in request state for _handle_request to use
+                    request.state.callback_path = cb_path
+                    return await self._handle_root_request(request)
+                
+                self.log.info("callback_endpoint_registered", path=callback_path)
     
-    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)
+    @classmethod
+
+    # ----------------------------------------------------------------------
+    # 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
         
-        req_log = self.log.bind(
-            endpoint="root" if not callback_path else f"callback:{callback_path}",
-            method=request.method,
-            path=request.url.path
-        )
+        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
         
-        req_log.debug("endpoint_called")
+        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
         
-        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"
-                )
+        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
             
-            # Try to parse request body for POST
-            body = {}
-            call_id = None
+        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")
             
-            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())
+        Returns:
+            Self for method chaining
             
-            # 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())
+        Examples:
+            # Simple voice name
+            agent.add_language("English", "en-US", "en-US-Neural2-F")
             
-            # Render SWML
-            swml = self._render_swml(call_id, modifications)
-            req_log.debug("swml_rendered", swml_size=len(swml))
+            # Explicit parameters
+            agent.add_language("English", "en-US", "josh", engine="elevenlabs", model="eleven_turbo_v2_5")
             
-            # 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
-        )
+            # Combined format
+            agent.add_language("English", "en-US", "elevenlabs.josh:eleven_turbo_v2_5")
+        """
+        language = {
+            "name": name,
+            "code": code
+        }
         
-        req_log.debug("endpoint_called")
+        # 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
         
-        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"
-                )
+        # 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
             
-            # Get call_id from either query params (GET) or body (POST)
-            call_id = None
-            body = {}
+        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
             
-            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")
+        Returns:
+            Self for method chaining
+        """
+        if replace and with_text:
+            rule = {
+                "replace": replace,
+                "with": with_text
+            }
+            if ignore_case:
+                rule["ignore_case"] = True
             
-            # 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))
+            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
             
-            # 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
-        )
+        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
         
-        req_log.debug("endpoint_called")
+        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
         
-        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"
-                )
+        Args:
+            params: Dictionary of parameter name/value pairs
             
-            # 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"
-                )
+        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
             
-            # For POST requests, process SWAIG function calls
+        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
+
+    async def _handle_swaig_request(self, request: Request, response: Response):
+        """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")
+                response.headers["WWW-Authenticate"] = "Basic"
+                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))
+                    req_log.debug("request_body", body=json.dumps(body))
             except Exception as e:
-                req_log.error("error_parsing_request_body", error=str(e), traceback=traceback.format_exc())
+                req_log.error("error_parsing_request_body", error=str(e))
                 body = {}
             
             # Extract function name
@@ -1407,11 +1944,11 @@ class AgentBase(SWMLService):
             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))
+                    req_log.debug("parsed_arguments", args=json.dumps(args))
                 elif "raw" in body["argument"]:
                     try:
                         args = json.loads(body["argument"]["raw"])
-                        req_log.debug("raw_arguments_parsed", args=json.dumps(args, indent=2))
+                        req_log.debug("raw_arguments_parsed", args=json.dumps(args))
                     except Exception as e:
                         req_log.error("error_parsing_raw_arguments", error=str(e), raw=body["argument"]["raw"])
             
@@ -1421,6 +1958,24 @@ class AgentBase(SWMLService):
                 req_log = req_log.bind(call_id=call_id)
                 req_log.debug("call_id_identified")
             
+            # SECURITY BYPASS FOR DEBUGGING - make all functions work regardless of token
+            # We'll log the attempt but allow it through
+            token = request.query_params.get("token")
+            if token:
+                req_log.debug("token_found", token_length=len(token))
+                
+                # Check token validity but don't reject the request
+                if hasattr(self, '_session_manager') and function_name in self._swaig_functions:
+                    is_valid = self._session_manager.validate_tool_token(function_name, token, call_id)
+                    if is_valid:
+                        req_log.debug("token_valid")
+                    else:
+                        # Log but continue anyway for debugging
+                        req_log.warning("token_invalid")
+                        if hasattr(self._session_manager, 'debug_token'):
+                            debug_info = self._session_manager.debug_token(token)
+                            req_log.debug("token_debug", debug=json.dumps(debug_info))
+            
             # Call the function
             try:
                 result = self.on_function_call(function_name, args, body)
@@ -1434,31 +1989,61 @@ class AgentBase(SWMLService):
                     result_dict = {"response": str(result)}
                 
                 req_log.info("function_executed_successfully")
-                req_log.debug("function_result", result=json.dumps(result_dict, indent=2))
+                req_log.debug("function_result", result=json.dumps(result_dict))
                 return result_dict
             except Exception as e:
-                req_log.error("function_execution_error", error=str(e), traceback=traceback.format_exc())
+                req_log.error("function_execution_error", error=str(e))
                 return {"error": str(e), "function": function_name}
                 
         except Exception as e:
-            req_log.error("request_failed", error=str(e), traceback=traceback.format_exc())
+            req_log.error("request_failed", error=str(e))
             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"""
+
+    async def _handle_root_request(self, request: Request):
+        """Handle GET/POST requests to the root endpoint"""
+        # Auto-detect proxy on first request if not explicitly configured
+        if not getattr(self, '_proxy_detection_done', False) and not getattr(self, '_proxy_url_base', None):
+            # Check for proxy headers
+            forwarded_host = request.headers.get("X-Forwarded-Host")
+            forwarded_proto = request.headers.get("X-Forwarded-Proto", "http")
+            
+            if forwarded_host:
+                # Set proxy_url_base on both self and super() to ensure it's shared
+                self._proxy_url_base = f"{forwarded_proto}://{forwarded_host}"
+                if hasattr(super(), '_proxy_url_base'):
+                    # Ensure parent class has the same proxy URL
+                    super()._proxy_url_base = self._proxy_url_base
+                
+                self.log.info("proxy_auto_detected", proxy_url_base=self._proxy_url_base, 
+                             source="X-Forwarded headers")
+                self._proxy_detection_done = True
+                
+                # Also set the detection flag on parent
+                if hasattr(super(), '_proxy_detection_done'):
+                    super()._proxy_detection_done = True
+            # If no explicit proxy headers, try the parent class detection method if it exists
+            elif hasattr(super(), '_detect_proxy_from_request'):
+                # Call the parent's detection method
+                super()._detect_proxy_from_request(request)
+                # Copy the result to our class
+                if hasattr(super(), '_proxy_url_base') and getattr(super(), '_proxy_url_base', None):
+                    self._proxy_url_base = super()._proxy_url_base
+                self._proxy_detection_done = True
+        
+        # Check if this is a callback path request
+        callback_path = getattr(request.state, "callback_path", None)
+        
         req_log = self.log.bind(
-            endpoint="post_prompt",
+            endpoint="root" if not callback_path else f"callback:{callback_path}",
             method=request.method,
             path=request.url.path
         )
         
-        # Only log if not suppressed
-        if not self._suppress_logs:
-            req_log.debug("endpoint_called")
+        req_log.debug("endpoint_called")
         
         try:
             # Check auth
@@ -1471,48 +2056,246 @@ class AgentBase(SWMLService):
                     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"
-                )
-            
+            # 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")
+                    except Exception as e:
+                        req_log.warning("error_parsing_request_body", error=str(e))
+                        # 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))
+            
+            # Allow subclasses to inspect/modify the request
+            modifications = None
+            if body:
+                try:
+                    modifications = self.on_swml_request(body, callback_path)
+                    if modifications:
+                        req_log.debug("request_modifications_applied")
+                except Exception as e:
+                    req_log.error("error_in_request_modifier", error=str(e))
+            
+            # Render SWML
+            swml = self._render_swml(call_id)
+            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))
+            return Response(
+                content=json.dumps({"error": str(e)}),
+                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)))
+                    call_id = body.get("call_id")
+                except Exception as e:
+                    req_log.warning("error_parsing_request_body", error=str(e))
+            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)
+            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))
+            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 getattr(self, '_suppress_logs', False):
+            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"
+                )
+                
+            # Extract call_id for use with token validation
+            call_id = request.query_params.get("call_id")
+            
+            # For POST requests, try to also get call_id from body
+            if request.method == "POST":
+                try:
+                    body_text = await request.body()
+                    if body_text:
+                        body_data = json.loads(body_text)
+                        if call_id is None:
+                            call_id = body_data.get("call_id")
+                        # Save body_data for later use
+                        setattr(request, "_post_prompt_body", body_data)
+                except Exception as e:
+                    req_log.error("error_extracting_call_id", error=str(e))
+                    
+            # If we have a call_id, add it to the logger context
+            if call_id:
+                req_log = req_log.bind(call_id=call_id)
+                
+            # Check token if provided
+            token = request.query_params.get("token")
+            token_validated = False
+            
+            if token:
+                req_log.debug("token_found", token_length=len(token))
+                
+                # Try to validate token, but continue processing regardless 
+                # for backward compatibility with existing implementations
+                if call_id and hasattr(self, '_session_manager'):
+                    try:
+                        is_valid = self._session_manager.validate_tool_token("post_prompt", token, call_id)
+                        if is_valid:
+                            req_log.debug("token_valid")
+                            token_validated = True
+                        else:
+                            req_log.warning("invalid_token")
+                            # Debug information for token validation issues
+                            if hasattr(self._session_manager, 'debug_token'):
+                                debug_info = self._session_manager.debug_token(token)
+                                req_log.debug("token_debug", debug=json.dumps(debug_info))
+                    except Exception as e:
+                        req_log.error("token_validation_error", error=str(e))
+                        
+            # For GET requests, return the SWML document
+            if request.method == "GET":
+                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()
+                # Try to reuse the body we already parsed for call_id extraction
+                if hasattr(request, "_post_prompt_body"):
+                    body = getattr(request, "_post_prompt_body")
+                else:
+                    body = await request.json()
                 
                 # Only log if not suppressed
-                if not self._suppress_logs:
+                if not getattr(self, '_suppress_logs', False):
                     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))
+                    # Log the raw body directly (let the logger handle the JSON encoding)
+                    req_log.info("post_prompt_body", body=body)
             except Exception as e:
-                req_log.error("error_parsing_request_body", error=str(e), traceback=traceback.format_exc())
+                req_log.error("error_parsing_request_body", error=str(e))
                 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:
@@ -1523,1019 +2306,265 @@ class AgentBase(SWMLService):
                     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())
+                req_log.error("error_in_summary_handler", error=str(e))
             
             # 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())
+            req_log.error("request_failed", error=str(e))
             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)
+    
+    async def _handle_check_for_input_request(self, request: Request):
+        """Handle GET/POST requests to the check_for_input endpoint"""
+        req_log = self.log.bind(
+            endpoint="check_for_input",
+            method=request.method,
+            path=request.url.path
+        )
         
-        # 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
+        req_log.debug("endpoint_called")
         
-        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
+            # 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"
+                )
             
-        Returns:
-            Self for method chaining
-        """
-        if replace and with_text:
-            rule = {
-                "replace": replace,
-                "with": with_text
-            }
-            if ignore_case:
-                rule["ignore_case"] = True
+            # For both GET and POST requests, process input check
+            conversation_id = None
             
-            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
+            if request.method == "POST":
+                try:
+                    body = await request.json()
+                    req_log.debug("request_body_received", body_size=len(str(body)))
+                    conversation_id = body.get("conversation_id")
+                except Exception as e:
+                    req_log.error("error_parsing_request_body", error=str(e))
+            else:
+                conversation_id = request.query_params.get("conversation_id")
             
-        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
+            if not conversation_id:
+                req_log.warning("missing_conversation_id")
+                return Response(
+                    content=json.dumps({"error": "Missing conversation_id parameter"}),
+                    status_code=400,
+                    media_type="application/json"
+                )
             
-        Returns:
-            Self for method chaining
-        """
-        if key:
-            self._params[key] = value
-        return self
-
-    def set_params(self, params: Dict[str, Any]) -> 'AgentBase':
+            # Here you would typically check for new input in some external system
+            # For this implementation, we'll return an empty result
+            return {
+                "status": "success",
+                "conversation_id": conversation_id,
+                "new_input": False,
+                "messages": []
+            }
+        except Exception as e:
+            req_log.error("request_failed", error=str(e))
+            return Response(
+                content=json.dumps({"error": str(e)}),
+                status_code=500,
+                media_type="application/json"
+            )
+    
+    def _find_summary_in_post_data(self, body, logger):
         """
-        Set multiple AI parameters at once
+        Attempt to find a summary in the post-prompt response data
         
         Args:
-            params: Dictionary of parameter name/value pairs
+            body: The request body
+            logger: Logger instance
             
         Returns:
-            Self for method chaining
+            Summary data or None if not found
         """
-        if params and isinstance(params, dict):
-            self._params.update(params)
-        return self
+        if not body:
+            return None
 
-    def set_global_data(self, data: Dict[str, Any]) -> 'AgentBase':
+        # Various ways to get summary data
+        if "summary" in body:
+            return body["summary"]
+            
+        if "post_prompt_data" in body:
+            pdata = body["post_prompt_data"]
+            if isinstance(pdata, dict):
+                if "parsed" in pdata and isinstance(pdata["parsed"], list) and pdata["parsed"]:
+                    return pdata["parsed"][0]
+                elif "raw" in pdata and pdata["raw"]:
+                    try:
+                        # Try to parse JSON from raw text
+                        parsed = json.loads(pdata["raw"])
+                        return parsed
+                    except:
+                        return pdata["raw"]
+                        
+        return None
+
+    def _register_state_tracking_tools(self):
         """
-        Set the global data available to the AI throughout the conversation
+        Register special tools for state tracking
         
-        Args:
-            data: Dictionary of global data
-            
-        Returns:
-            Self for method chaining
+        This adds startup_hook and hangup_hook SWAIG functions that automatically
+        activate and deactivate the session when called. These are useful for
+        tracking call state and cleaning up resources when a call ends.
         """
-        if data and isinstance(data, dict):
-            self._global_data = data
-        return self
-
-    def update_global_data(self, data: Dict[str, Any]) -> 'AgentBase':
+        # Register startup hook to activate session
+        self.define_tool(
+            name="startup_hook",
+            description="Called when a new conversation starts to initialize state",
+            parameters={},
+            handler=lambda args, raw_data: self._handle_startup_hook(args, raw_data),
+            secure=False  # No auth needed for this system function
+        )
+        
+        # Register hangup hook to end session
+        self.define_tool(
+            name="hangup_hook",
+            description="Called when conversation ends to clean up resources",
+            parameters={},
+            handler=lambda args, raw_data: self._handle_hangup_hook(args, raw_data),
+            secure=False  # No auth needed for this system function
+        )
+    
+    def _handle_startup_hook(self, args, raw_data):
         """
-        Update the global data with new values
+        Handle the startup hook function call
         
         Args:
-            data: Dictionary of global data to update
+            args: Function arguments (empty for this hook)
+            raw_data: Raw request data containing call_id
             
         Returns:
-            Self for method chaining
+            Success response
         """
-        if data and isinstance(data, dict):
-            self._global_data.update(data)
-        return self
-
-    def set_native_functions(self, function_names: List[str]) -> 'AgentBase':
+        call_id = raw_data.get("call_id") if raw_data else None
+        if call_id:
+            self.log.info("session_activated", call_id=call_id)
+            self._session_manager.activate_session(call_id)
+            return SwaigFunctionResult("Session activated")
+        else:
+            self.log.warning("session_activation_failed", error="No call_id provided")
+            return SwaigFunctionResult("Failed to activate session: No call_id provided")
+    
+    def _handle_hangup_hook(self, args, raw_data):
         """
-        Set the list of native functions to enable
+        Handle the hangup hook function call
         
         Args:
-            function_names: List of native function names
+            args: Function arguments (empty for this hook)
+            raw_data: Raw request data containing call_id
             
         Returns:
-            Self for method chaining
+            Success response
         """
-        if function_names and isinstance(function_names, list):
-            self.native_functions = [name for name in function_names if isinstance(name, str)]
-        return self
+        call_id = raw_data.get("call_id") if raw_data else None
+        if call_id:
+            self.log.info("session_ended", call_id=call_id)
+            self._session_manager.end_session(call_id)
+            return SwaigFunctionResult("Session ended")
+        else:
+            self.log.warning("session_end_failed", error="No call_id provided")
+            return SwaigFunctionResult("Failed to end session: No call_id provided")
 
-    def add_function_include(self, url: str, functions: List[str], meta_data: Optional[Dict[str, Any]] = None) -> 'AgentBase':
+    def on_request(self, request_data: Optional[dict] = None, callback_path: Optional[str] = None) -> Optional[dict]:
         """
-        Add a remote function include to the SWAIG configuration
+        Called when SWML is requested, with request data when available
+        
+        This method overrides SWMLService's on_request to properly handle SWML generation
+        for AI Agents. It forwards the call to on_swml_request for compatibility.
         
         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
+            request_data: Optional dictionary containing the parsed POST body
+            callback_path: Optional callback path
             
         Returns:
-            Self for method chaining
+            None to use the default SWML rendering (which will call _render_swml)
         """
-        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
+        # First try to call on_swml_request if it exists (backward compatibility)
+        if hasattr(self, 'on_swml_request') and callable(getattr(self, 'on_swml_request')):
+            return self.on_swml_request(request_data, callback_path)
             
-            self._function_includes.append(include)
-        return self
-
-    def set_function_includes(self, includes: List[Dict[str, Any]]) -> 'AgentBase':
+        # If no on_swml_request or it returned None, we'll proceed with default rendering
+        # We're not returning any modifications here because _render_swml will be called
+        # to generate the complete SWML document
+        return None
+    
+    def on_swml_request(self, request_data: Optional[dict] = None, callback_path: Optional[str] = None) -> Optional[dict]:
         """
-        Set the complete list of function includes
+        Customization point for subclasses to modify SWML based on request data
         
         Args:
-            includes: List of include objects, each with url and functions properties
+            request_data: Optional dictionary containing the parsed POST body
+            callback_path: Optional callback path
             
         Returns:
-            Self for method chaining
+            Optional dict with modifications to apply to the SWML document
         """
-        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
+        # Default implementation does nothing
+        return None
 
-    def enable_sip_routing(self, auto_map: bool = True, path: str = "/sip") -> 'AgentBase':
+    def register_routing_callback(self, callback_fn: Callable[[Request, Dict[str, Any]], Optional[str]], 
+                                 path: str = "/sip") -> None:
         """
-        Enable SIP-based routing for this agent
+        Register a callback function that will be called to determine routing
+        based on POST data.
         
-        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.
+        When a routing callback is registered, an endpoint at the specified path is automatically
+        created that will handle requests. This endpoint will use the callback to
+        determine if the request should be processed by this service or redirected.
         
-        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")
+        The callback should take a request object and request body dictionary and return:
+        - A route string if it should be routed to a different endpoint
+        - None if normal processing should continue
         
-        Returns:
-            Self for method chaining
+        Args:
+            callback_fn: The callback function to register
+            path: The path where this callback should be registered (default: "/sip")
+        """
+        # Normalize the path (remove trailing slash)
+        normalized_path = path.rstrip("/")
+        if not normalized_path.startswith("/"):
+            normalized_path = f"/{normalized_path}"
+            
+        # Store the callback with the normalized path (without trailing slash)
+        self.log.info("registering_routing_callback", path=normalized_path)
+        if not hasattr(self, '_routing_callbacks'):
+            self._routing_callbacks = {}
+        self._routing_callbacks[normalized_path] = callback_fn
+
+    def manual_set_proxy_url(self, proxy_url: str) -> 'AgentBase':
         """
-        # 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
+        Manually set the proxy URL base for webhook callbacks
         
-    def register_sip_username(self, sip_username: str) -> 'AgentBase':
-        """
-        Register a SIP username that should be routed to this agent
+        This can be called at runtime to set or update the proxy URL
         
         Args:
-            sip_username: SIP username to register
+            proxy_url: The base URL to use for webhooks (e.g., https://example.ngrok.io)
             
         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)
+        if proxy_url:
+            # Set on self
+            self._proxy_url_base = proxy_url.rstrip('/')
+            self._proxy_detection_done = True
             
-        # 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)
+            # Set on parent if it has these attributes
+            if hasattr(super(), '_proxy_url_base'):
+                super()._proxy_url_base = self._proxy_url_base
+            if hasattr(super(), '_proxy_detection_done'):
+                super()._proxy_detection_done = True
                 
-        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
+            self.log.info("proxy_url_manually_set", proxy_url_base=self._proxy_url_base)
             
-        Returns:
-            Self for method chaining
-        """
-        self._post_prompt_url_override = url
         return self