signalwire-agents 0.1.23__tar.gz → 0.1.24__tar.gz

signalwire_agents-0.1.24/CHANGELOG.md

@@ -0,0 +1,120 @@
+# Changelog
+
+## [0.1.24] - 2025-06-19
+
+- Version bump
+
+## [0.1.23] - 2025-06-17
+
+- Version bump
+
+## [0.1.22] - 2025-06-17
+
+- Version bump
+
+## [0.1.21] - 2025-06-12
+
+- Version bump
+
+## [0.1.20] - 2025-06-10
+
+- Version bump
+
+## [0.1.19] - 2025-06-09
+
+- Version bump
+
+## [0.1.18] - 2025-06-09
+
+- Version bump
+
+## [0.1.17] - 2025-06-02
+
+- Version bump
+
+## [0.1.16] - 2025-06-02
+
+- Version bump
+
+## [0.1.15] - 2025-05-30
+
+- Version bump
+
+## [0.1.14] - 2025-05-29
+
+- Version bump
+
+## [0.1.13] - 2025-05-29
+
+- Version bump
+
+## [0.1.12] - 2025-05-28
+
+- Version bump
+
+## [0.1.11] - 2025-05-28
+
+- Version bump
+
+## [0.1.10] - 2025-05-28
+
+- Version bump
+
+## [0.1.9] - 2025-05-24
+
+- Version bump
+
+## [0.1.8] - 2025-05-23
+
+- Version bump
+
+## [0.1.7] - 2025-05-17
+
+- Version bump
+
+## [0.1.6] - 2025-05-16
+
+- Version bump
+
+## [0.1.5] - 2025-05-16
+
+- Version bump
+
+## [0.1.4] - 2025-05-16
+
+- Version bump
+
+## [Unreleased]
+
+### Added
+
+- **SIP Routing:** Added support for routing SIP requests based on username
+  - `SWMLService.extract_sip_username()` method for extracting SIP usernames from request bodies
+  - `register_routing_callback()` method for SWMLService to handle custom routing
+  - `enable_sip_routing()` method for AgentBase to automatically handle SIP requests
+  - `register_sip_username()` method for AgentBase to register custom SIP usernames
+  - `setup_sip_routing()` method for AgentServer to enable centralized SIP routing
+  - Added global `/sip` endpoint for both SWMLService and AgentBase when SIP routing is enabled
+  - Example: Added SIP routing to simple_agent.py
+  - Documentation: Added docs/sip_routing.md with full documentation
+
+### Fixed
+
+- Fixed the `sleep` verb auto-vivification to properly handle direct integer values
+
+### Changed
+
+- **Dynamic Method Generation:** Implemented auto-vivification in SWMLService class for more intuitive verb usage
+  - Now you can use `service.play(url="say:Hello")` instead of `service.add_verb("play", {"url": "say:Hello"})`
+  - All verbs from the schema are automatically available as methods
+  - Special handling for the `sleep` verb which takes a direct integer value
+
+## [0.1.2] - 2023-04-15
+
+### Added
+
+- Initial release of the SignalWire AI Agent SDK
+- Base classes for building and serving AI Agents
+- SWML document creation and manipulation
+- Web server for handling agent requests
+- Documentation and examples 

{signalwire_agents-0.1.23/signalwire_agents.egg-info → signalwire_agents-0.1.24}/PKG-INFO

@@ -1,9 +1,11 @@
 Metadata-Version: 2.4
 Name: signalwire_agents
-Version: 0.1.23
+Version: 0.1.24
 Summary: SignalWire AI Agents SDK
 Author-email: SignalWire Team <info@signalwire.com>
+License: MIT
 Project-URL: Homepage, https://github.com/signalwire/signalwire-agents
+Keywords: signalwire,ai,agents,voice,telephony,swaig,swml
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -26,6 +28,7 @@ Requires-Dist: structlog==25.3.0
 Requires-Dist: uvicorn==0.34.2
 Requires-Dist: beautifulsoup4==4.12.3
 Requires-Dist: pytz==2023.3
+Requires-Dist: lxml>=4.9.0
 Provides-Extra: search-queryonly
 Requires-Dist: numpy>=1.24.0; extra == "search-queryonly"
 Requires-Dist: scikit-learn>=1.3.0; extra == "search-queryonly"
@@ -735,7 +738,49 @@ class DynamicAgent(AgentBase):
 - **Localization**: Language and cultural adaptation based on user location
 - **Dynamic Pricing**: Adjust features and capabilities based on subscription tiers
 
-The `EphemeralAgentConfig` object provides all the same familiar methods as `AgentBase` (like `add_language()`, `prompt_add_section()`, `set_global_data()`) but applies them per-request instead of at startup.
+### Preserving Dynamic State in SWAIG Callbacks
+
+When using dynamic configuration to add skills or tools based on request parameters, there's a challenge: SWAIG webhook callbacks are separate HTTP requests that won't have the original query parameters. The SDK provides `add_swaig_query_params()` to solve this:
+
+```python
+class DynamicAgent(AgentBase):
+    def __init__(self):
+        super().__init__(name="dynamic-agent", route="/agent")
+        self.set_dynamic_config_callback(self.configure_per_request)
+    
+    def configure_per_request(self, query_params, body_params, headers, agent):
+        tier = query_params.get('tier', 'basic')
+        region = query_params.get('region', 'us-east')
+        
+        if tier == 'premium':
+            # Add premium skills dynamically
+            agent.add_skill('advanced_search', {
+                'api_key': 'your-api-key',
+                'num_results': 5
+            })
+            
+            # IMPORTANT: Preserve parameters for SWAIG callbacks
+            agent.add_swaig_query_params({
+                'tier': tier,
+                'region': region
+            })
+            
+            # Now when SignalWire calls the SWAIG webhook, these params
+            # will be included, triggering the same dynamic configuration
+
+# Initial request: GET /agent?tier=premium&region=eu-west
+# SWAIG callback: POST /swaig/?tier=premium&region=eu-west
+# Result: Premium skills are available in both requests!
+```
+
+**Key Points:**
+
+- **Problem**: Dynamically added skills/tools won't exist during SWAIG callbacks without the original request parameters
+- **Solution**: Use `add_swaig_query_params()` to include critical parameters in all SWAIG webhook URLs
+- **Clear State**: Use `clear_swaig_query_params()` if needed to reset parameters between requests
+- **Token Safety**: The SDK automatically renames security tokens from `token` to `__token` to avoid parameter collisions
+
+This ensures that any dynamic configuration based on request parameters is consistently applied across the initial SWML request and all subsequent SWAIG function callbacks.
 
 For detailed documentation and advanced examples, see the [Agent Guide](docs/agent_guide.md#dynamic-agent-configuration).
 

{signalwire_agents-0.1.23 → signalwire_agents-0.1.24}/README.md

@@ -664,7 +664,49 @@ class DynamicAgent(AgentBase):
 - **Localization**: Language and cultural adaptation based on user location
 - **Dynamic Pricing**: Adjust features and capabilities based on subscription tiers
 
-The `EphemeralAgentConfig` object provides all the same familiar methods as `AgentBase` (like `add_language()`, `prompt_add_section()`, `set_global_data()`) but applies them per-request instead of at startup.
+### Preserving Dynamic State in SWAIG Callbacks
+
+When using dynamic configuration to add skills or tools based on request parameters, there's a challenge: SWAIG webhook callbacks are separate HTTP requests that won't have the original query parameters. The SDK provides `add_swaig_query_params()` to solve this:
+
+```python
+class DynamicAgent(AgentBase):
+    def __init__(self):
+        super().__init__(name="dynamic-agent", route="/agent")
+        self.set_dynamic_config_callback(self.configure_per_request)
+    
+    def configure_per_request(self, query_params, body_params, headers, agent):
+        tier = query_params.get('tier', 'basic')
+        region = query_params.get('region', 'us-east')
+        
+        if tier == 'premium':
+            # Add premium skills dynamically
+            agent.add_skill('advanced_search', {
+                'api_key': 'your-api-key',
+                'num_results': 5
+            })
+            
+            # IMPORTANT: Preserve parameters for SWAIG callbacks
+            agent.add_swaig_query_params({
+                'tier': tier,
+                'region': region
+            })
+            
+            # Now when SignalWire calls the SWAIG webhook, these params
+            # will be included, triggering the same dynamic configuration
+
+# Initial request: GET /agent?tier=premium&region=eu-west
+# SWAIG callback: POST /swaig/?tier=premium&region=eu-west
+# Result: Premium skills are available in both requests!
+```
+
+**Key Points:**
+
+- **Problem**: Dynamically added skills/tools won't exist during SWAIG callbacks without the original request parameters
+- **Solution**: Use `add_swaig_query_params()` to include critical parameters in all SWAIG webhook URLs
+- **Clear State**: Use `clear_swaig_query_params()` if needed to reset parameters between requests
+- **Token Safety**: The SDK automatically renames security tokens from `token` to `__token` to avoid parameter collisions
+
+This ensures that any dynamic configuration based on request parameters is consistently applied across the initial SWML request and all subsequent SWAIG function callbacks.
 
 For detailed documentation and advanced examples, see the [Agent Guide](docs/agent_guide.md#dynamic-agent-configuration).
 

{signalwire_agents-0.1.23 → signalwire_agents-0.1.24}/pyproject.toml

@@ -1,15 +1,17 @@
 [build-system]
-requires = ["setuptools>=42", "wheel"]
+requires = ["setuptools>=61.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "signalwire_agents"
-version = "0.1.23"
+version = "0.1.24"
 description = "SignalWire AI Agents SDK"
 authors = [
     {name = "SignalWire Team", email = "info@signalwire.com"}
 ]
 readme = "README.md"
+license = {text = "MIT"}
+keywords = ["signalwire", "ai", "agents", "voice", "telephony", "swaig", "swml"]
 requires-python = ">=3.7"
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -33,6 +35,7 @@ dependencies = [
     "uvicorn==0.34.2",
     "beautifulsoup4==4.12.3",
     "pytz==2023.3",
+    "lxml>=4.9.0",
 ]
 
 # Optional dependencies for search functionality
@@ -98,7 +101,7 @@ search-all = [
 Homepage = "https://github.com/signalwire/signalwire-agents"
 
 [project.scripts]
-swaig-test = "signalwire_agents.cli.test_swaig:console_entry_point"
+swaig-test = "signalwire_agents.cli.test_swaig_main:main"
 sw-search = "signalwire_agents.cli.build_search:console_entry_point"
 
 [tool.setuptools]
@@ -106,7 +109,9 @@ packages = {find = {where = ["."], include = ["signalwire_agents*"]}}
 include-package-data = true
 
 [tool.setuptools.package-data]
-signalwire_agents = ["schema.json"]
-
-[tool.setuptools.data-files]
-"." = ["schema.json"] 
+signalwire_agents = [
+    "schema.json",
+    "**/*.json",
+    "skills/*/README.md",
+    "skills/README.md"
+] 

signalwire_agents-0.1.24/requirements-dev.txt

@@ -0,0 +1,16 @@
+# Development and Testing Dependencies
+pytest>=7.4.0
+pytest-cov>=4.1.0
+pytest-asyncio>=0.21.0
+pytest-mock>=3.11.0
+pytest-xdist>=3.3.0  # For parallel test execution
+pytest-html>=3.2.0   # For HTML test reports
+pytest-timeout>=2.1.0 # For test timeouts
+coverage>=7.2.0
+mock>=5.1.0
+responses>=0.23.0     # For mocking HTTP requests
+freezegun>=1.2.0      # For mocking datetime
+factory-boy>=3.3.0    # For test data factories
+faker>=19.0.0         # For generating fake data
+httpx>=0.24.0         # For async HTTP testing
+aiofiles>=23.0.0      # For async file operations in tests 

signalwire_agents-0.1.24/requirements.txt

@@ -0,0 +1,11 @@
+fastapi==0.115.12
+pydantic==2.11.4
+PyYAML==6.0.2
+Requests==2.32.3
+setuptools==66.1.1
+signalwire_pom==2.7.1
+structlog==25.3.0
+uvicorn==0.34.2
+beautifulsoup4==4.12.3
+pytz==2023.3
+lxml==5.3.0

{signalwire_agents-0.1.23 → signalwire_agents-0.1.24}/signalwire_agents/__init__.py

@@ -18,7 +18,7 @@ A package for building AI agents using SignalWire's AI and SWML capabilities.
 from .core.logging_config import configure_logging
 configure_logging()
 
-__version__ = "0.1.23"
+__version__ = "0.1.24"
 
 # Import core classes for easier access
 from .core.agent_base import AgentBase

{signalwire_agents-0.1.23 → signalwire_agents-0.1.24}/signalwire_agents/agent_server.py

@@ -610,8 +610,9 @@ class AgentServer:
         self.logger.info(f"Starting server on {protocol}://{display_host}")
         for route, agent in self.agents.items():
             username, password = agent.get_basic_auth_credentials()
+            agent_url = agent.get_full_url(include_auth=False)
             self.logger.info(f"Agent '{agent.get_name()}' available at:")
-            self.logger.info(f"URL: {protocol}://{display_host}{route}")
+            self.logger.info(f"URL: {agent_url}")
             self.logger.info(f"Basic Auth: {username}:{password}")
         
         # Start the server with or without SSL

signalwire_agents-0.1.24/signalwire_agents/cli/config.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""
+Configuration constants for the CLI tools
+"""
+
+# Default values for call configuration
+DEFAULT_CALL_TYPE = "webrtc"
+DEFAULT_CALL_DIRECTION = "inbound"
+DEFAULT_CALL_STATE = "created"
+DEFAULT_HTTP_METHOD = "POST"
+DEFAULT_TOKEN_EXPIRY = 3600
+
+# Default fake data values
+DEFAULT_PROJECT_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+DEFAULT_SPACE_ID = "zzzzzzzz-yyyy-xxxx-wwww-vvvvvvvvvvvv"
+DEFAULT_SPACE_NAME = "example-space"
+DEFAULT_ENVIRONMENT = "production"
+
+# Request timeouts
+HTTP_REQUEST_TIMEOUT = 30
+
+# Output formatting
+RESULT_LINE_SEP = "-" * 60
+
+# Platform-specific constants
+SERVERLESS_PLATFORMS = ["lambda", "cgi", "cloud_function", "azure_function"]
+
+# AWS Lambda defaults
+AWS_DEFAULT_REGION = "us-east-1"
+AWS_DEFAULT_STAGE = "prod"
+
+# Google Cloud defaults
+GCP_DEFAULT_REGION = "us-central1"
+
+# Error messages
+ERROR_MISSING_AGENT = "Error: Missing required argument."
+ERROR_MULTIPLE_AGENTS = "Multiple agents found in file. Please specify --agent-class"
+ERROR_NO_AGENTS = "No agents found in file: {file_path}"
+ERROR_AGENT_NOT_FOUND = "Agent class '{class_name}' not found in file: {file_path}"
+ERROR_FUNCTION_NOT_FOUND = "Function '{function_name}' not found in agent"
+ERROR_CGI_HOST_REQUIRED = "CGI simulation requires --cgi-host"
+
+# Help messages
+HELP_DESCRIPTION = "Test SWAIG functions and generate SWML documents for SignalWire AI agents"
+HELP_EPILOG_SHORT = """
+examples:
+  # Execute a function
+  %(prog)s agent.py --exec search --query "test" --limit 5
+  
+  # Generate SWML
+  %(prog)s agent.py --dump-swml --raw | jq '.'
+  
+  # Test with specific agent
+  %(prog)s multi_agent.py --agent-class MattiAgent --list-tools
+  
+  # Simulate serverless
+  %(prog)s agent.py --simulate-serverless lambda --exec my_function
+
+For platform-specific options: %(prog)s --help-platforms
+For more examples: %(prog)s --help-examples
+"""

signalwire_agents-0.1.24/signalwire_agents/cli/core/__init__.py

@@ -0,0 +1 @@
+"""Core functionality for CLI tools"""

signalwire_agents-0.1.24/signalwire_agents/cli/core/agent_loader.py

@@ -0,0 +1,254 @@
+#!/usr/bin/env python3
+"""
+Agent discovery and loading functionality
+"""
+
+import importlib.util
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+
+# Import after checking if available
+try:
+    from signalwire_agents.core.agent_base import AgentBase
+    AGENT_BASE_AVAILABLE = True
+except ImportError:
+    AgentBase = None
+    AGENT_BASE_AVAILABLE = False
+
+
+def discover_agents_in_file(agent_path: str) -> List[Dict[str, Any]]:
+    """
+    Discover all available agents in a Python file without instantiating them
+    
+    Args:
+        agent_path: Path to the Python file containing agents
+        
+    Returns:
+        List of dictionaries with agent information
+        
+    Raises:
+        ImportError: If the file cannot be imported
+        FileNotFoundError: If the file doesn't exist
+    """
+    if not AGENT_BASE_AVAILABLE:
+        raise ImportError("AgentBase not available. Please install signalwire-agents package.")
+    
+    agent_path = Path(agent_path).resolve()
+    
+    if not agent_path.exists():
+        raise FileNotFoundError(f"Agent file not found: {agent_path}")
+    
+    if not agent_path.suffix == '.py':
+        raise ValueError(f"Agent file must be a Python file (.py): {agent_path}")
+    
+    # Load the module, but prevent main() execution by setting __name__ to something other than "__main__"
+    spec = importlib.util.spec_from_file_location("agent_module", agent_path)
+    module = importlib.util.module_from_spec(spec)
+    
+    try:
+        # Set __name__ to prevent if __name__ == "__main__": blocks from running
+        module.__name__ = "agent_module"
+        spec.loader.exec_module(module)
+    except Exception as e:
+        raise ImportError(f"Failed to load agent module: {e}")
+    
+    agents_found = []
+    
+    # Look for AgentBase instances
+    for name, obj in vars(module).items():
+        if isinstance(obj, AgentBase):
+            agents_found.append({
+                'name': name,
+                'class_name': obj.__class__.__name__,
+                'type': 'instance',
+                'agent_name': getattr(obj, 'name', 'Unknown'),
+                'route': getattr(obj, 'route', 'Unknown'),
+                'description': obj.__class__.__doc__,
+                'object': obj
+            })
+    
+    # Look for AgentBase subclasses (that could be instantiated)
+    for name, obj in vars(module).items():
+        if (isinstance(obj, type) and 
+            issubclass(obj, AgentBase) and 
+            obj != AgentBase):
+            # Check if we already found an instance of this class
+            instance_found = any(agent['class_name'] == name for agent in agents_found)
+            if not instance_found:
+                try:
+                    # Try to get class information without instantiating
+                    agent_info = {
+                        'name': name,
+                        'class_name': name,
+                        'type': 'class',
+                        'agent_name': 'Unknown (not instantiated)',
+                        'route': 'Unknown (not instantiated)',
+                        'description': obj.__doc__,
+                        'object': obj
+                    }
+                    agents_found.append(agent_info)
+                except Exception:
+                    # If we can't get info, still record that the class exists
+                    agents_found.append({
+                        'name': name,
+                        'class_name': name,
+                        'type': 'class',
+                        'agent_name': 'Unknown (not instantiated)',
+                        'route': 'Unknown (not instantiated)',
+                        'description': obj.__doc__ or 'No description available',
+                        'object': obj
+                    })
+    
+    return agents_found
+
+
+def load_agent_from_file(agent_path: str, agent_class_name: Optional[str] = None) -> 'AgentBase':
+    """
+    Load an agent from a Python file
+    
+    Args:
+        agent_path: Path to the Python file containing the agent
+        agent_class_name: Optional name of the agent class to instantiate
+        
+    Returns:
+        AgentBase instance
+        
+    Raises:
+        ImportError: If the file cannot be imported
+        ValueError: If no agent is found in the file
+    """
+    if not AGENT_BASE_AVAILABLE:
+        raise ImportError("AgentBase not available. Please install signalwire-agents package.")
+    
+    agent_path = Path(agent_path).resolve()
+    
+    if not agent_path.exists():
+        raise FileNotFoundError(f"Agent file not found: {agent_path}")
+    
+    if not agent_path.suffix == '.py':
+        raise ValueError(f"Agent file must be a Python file (.py): {agent_path}")
+    
+    # Load the module, but prevent main() execution by setting __name__ to something other than "__main__"
+    spec = importlib.util.spec_from_file_location("agent_module", agent_path)
+    module = importlib.util.module_from_spec(spec)
+    
+    try:
+        # Set __name__ to prevent if __name__ == "__main__": blocks from running
+        module.__name__ = "agent_module"
+        spec.loader.exec_module(module)
+    except Exception as e:
+        raise ImportError(f"Failed to load agent module: {e}")
+    
+    # Find the agent instance
+    agent = None
+    
+    # If agent_class_name is specified, try to instantiate that specific class first
+    if agent_class_name:
+        if hasattr(module, agent_class_name):
+            obj = getattr(module, agent_class_name)
+            if isinstance(obj, type) and issubclass(obj, AgentBase) and obj != AgentBase:
+                try:
+                    agent = obj()
+                    if agent and not agent.route.endswith('dummy'):  # Avoid test agents with dummy routes
+                        pass  # Successfully created specific agent
+                    else:
+                        agent = obj()  # Create anyway if requested specifically
+                except Exception as e:
+                    raise ValueError(f"Failed to instantiate agent class '{agent_class_name}': {e}")
+            else:
+                raise ValueError(f"'{agent_class_name}' is not a valid AgentBase subclass")
+        else:
+            raise ValueError(f"Agent class '{agent_class_name}' not found in {agent_path}")
+    
+    # Strategy 1: Look for 'agent' variable (most common pattern)
+    if agent is None and hasattr(module, 'agent') and isinstance(module.agent, AgentBase):
+        agent = module.agent
+    
+    # Strategy 2: Look for any AgentBase instance in module globals
+    if agent is None:
+        agents_found = []
+        for name, obj in vars(module).items():
+            if isinstance(obj, AgentBase):
+                agents_found.append((name, obj))
+        
+        if len(agents_found) == 1:
+            agent = agents_found[0][1]
+        elif len(agents_found) > 1:
+            # Multiple agents found, prefer one named 'agent'
+            for name, obj in agents_found:
+                if name == 'agent':
+                    agent = obj
+                    break
+            # If no 'agent' variable, use the first one
+            if agent is None:
+                agent = agents_found[0][1]
+                print(f"Warning: Multiple agents found, using '{agents_found[0][0]}'")
+                print(f"Hint: Use --agent-class parameter to choose specific agent")
+    
+    # Strategy 3: Look for AgentBase subclass and try to instantiate it
+    if agent is None:
+        agent_classes_found = []
+        for name, obj in vars(module).items():
+            if (isinstance(obj, type) and 
+                issubclass(obj, AgentBase) and 
+                obj != AgentBase):
+                agent_classes_found.append((name, obj))
+        
+        if len(agent_classes_found) == 1:
+            try:
+                agent = agent_classes_found[0][1]()
+            except Exception as e:
+                print(f"Warning: Failed to instantiate {agent_classes_found[0][0]}: {e}")
+        elif len(agent_classes_found) > 1:
+            # Multiple agent classes found
+            class_names = [name for name, _ in agent_classes_found]
+            raise ValueError(f"Multiple agent classes found: {', '.join(class_names)}. "
+                           f"Please specify which agent class to use with --agent-class parameter. "
+                           f"Usage: swaig-test {agent_path} [tool_name] [args] --agent-class <AgentClassName>")
+        else:
+            # Try instantiating any AgentBase class we can find
+            for name, obj in vars(module).items():
+                if (isinstance(obj, type) and 
+                    issubclass(obj, AgentBase) and 
+                    obj != AgentBase):
+                    try:
+                        agent = obj()
+                        break
+                    except Exception as e:
+                        print(f"Warning: Failed to instantiate {name}: {e}")
+    
+    # Strategy 4: Try calling a modified main() function that doesn't start the server
+    if agent is None and hasattr(module, 'main'):
+        print("Warning: No agent instance found, attempting to call main() without server startup")
+        try:
+            # Temporarily patch AgentBase.serve to prevent server startup
+            original_serve = AgentBase.serve
+            captured_agent = []
+            
+            def mock_serve(self, *args, **kwargs):
+                captured_agent.append(self)
+                print(f"  (Intercepted serve() call, agent captured for testing)")
+                return self
+            
+            AgentBase.serve = mock_serve
+            
+            try:
+                result = module.main()
+                if isinstance(result, AgentBase):
+                    agent = result
+                elif captured_agent:
+                    agent = captured_agent[0]
+            finally:
+                # Restore original serve method
+                AgentBase.serve = original_serve
+                
+        except Exception as e:
+            print(f"Warning: Failed to call main() function: {e}")
+    
+    if agent is None:
+        raise ValueError(f"No agent found in {agent_path}. The file must contain either:\n"
+                        f"- An AgentBase instance (e.g., agent = MyAgent())\n"
+                        f"- An AgentBase subclass that can be instantiated\n"
+                        f"- A main() function that creates and returns an agent")
+    
+    return agent