signalwire-agents 0.1.27__py3-none-any.whl → 0.1.28__py3-none-any.whl

signalwire_agents/skills/mcp_gateway/skill.py

@@ -0,0 +1,339 @@
+"""
+Copyright (c) 2025 SignalWire
+
+This file is part of the SignalWire AI Agents SDK.
+
+Licensed under the MIT License.
+See LICENSE file in the project root for full license information.
+"""
+
+import json
+import requests
+import logging
+from typing import List, Dict, Any, Optional
+from requests.auth import HTTPBasicAuth
+
+from signalwire_agents.core.skill_base import SkillBase
+from signalwire_agents.core.function_result import SwaigFunctionResult
+
+logger = logging.getLogger(__name__)
+
+
+class MCPGatewaySkill(SkillBase):
+    """
+    MCP Gateway Skill - Bridge MCP servers with SWAIG functions
+    
+    This skill connects SignalWire agents to MCP (Model Context Protocol) servers
+    through a gateway service, dynamically creating SWAIG functions for MCP tools.
+    """
+    
+    SKILL_NAME = "mcp_gateway"
+    SKILL_DESCRIPTION = "Bridge MCP servers with SWAIG functions"
+    SKILL_VERSION = "1.0.0"
+    REQUIRED_PACKAGES = ["requests"]
+    REQUIRED_ENV_VARS = []
+    
+    def setup(self) -> bool:
+        """Setup and validate skill configuration"""
+        # Check for auth method - either token or basic auth
+        self.auth_token = self.params.get('auth_token')
+        if not self.auth_token:
+            # Require basic auth if no token
+            required_params = ['gateway_url', 'auth_user', 'auth_password']
+            missing_params = [param for param in required_params if not self.params.get(param)]
+            if missing_params:
+                self.logger.error(f"Missing required parameters: {missing_params}")
+                return False
+            self.auth = HTTPBasicAuth(self.params['auth_user'], self.params['auth_password'])
+        else:
+            # Just need gateway URL with token auth
+            if not self.params.get('gateway_url'):
+                self.logger.error("Missing required parameter: gateway_url")
+                return False
+            self.auth = None
+        
+        # Store configuration
+        self.gateway_url = self.params['gateway_url'].rstrip('/')
+        self.services = self.params.get('services', [])
+        self.session_timeout = self.params.get('session_timeout', 300)
+        self.tool_prefix = self.params.get('tool_prefix', 'mcp_')
+        self.retry_attempts = self.params.get('retry_attempts', 3)
+        self.request_timeout = self.params.get('request_timeout', 30)
+        self.verify_ssl = self.params.get('verify_ssl', True)
+        
+        # Session ID will be set from call_id when first tool is used
+        self.session_id = None
+        
+        # Validate gateway connection
+        try:
+            response = requests.get(
+                f"{self.gateway_url}/health",
+                timeout=self.request_timeout,
+                verify=self.verify_ssl
+            )
+            response.raise_for_status()
+            self.logger.info(f"Connected to MCP Gateway at {self.gateway_url}")
+        except Exception as e:
+            self.logger.error(f"Failed to connect to gateway: {e}")
+            return False
+        
+        return True
+    
+    def _make_request(self, method: str, url: str, **kwargs) -> requests.Response:
+        """Make HTTP request with appropriate authentication"""
+        headers = kwargs.get('headers', {})
+        if self.auth_token:
+            headers['Authorization'] = f'Bearer {self.auth_token}'
+        kwargs['headers'] = headers
+        
+        if not self.auth_token:
+            kwargs['auth'] = self.auth
+        
+        kwargs['timeout'] = kwargs.get('timeout', self.request_timeout)
+        kwargs['verify'] = kwargs.get('verify', self.verify_ssl)
+        
+        return requests.request(method, url, **kwargs)
+    
+    def register_tools(self) -> None:
+        """Register SWAIG tools from MCP services"""
+        # If no services specified, get all available
+        if not self.services:
+            try:
+                response = self._make_request('GET', f"{self.gateway_url}/services")
+                response.raise_for_status()
+                all_services = response.json()
+                self.services = [{"name": name} for name in all_services.keys()]
+            except Exception as e:
+                self.logger.error(f"Failed to list services: {e}")
+                return
+        
+        # Process each service
+        for service_config in self.services:
+            service_name = service_config.get('name')
+            if not service_name:
+                continue
+            
+            # Get tools for this service
+            try:
+                response = self._make_request('GET', f"{self.gateway_url}/services/{service_name}/tools")
+                response.raise_for_status()
+                tools_data = response.json()
+                tools = tools_data.get('tools', [])
+                
+                # Filter tools if specified
+                tool_filter = service_config.get('tools', '*')
+                if tool_filter != '*' and isinstance(tool_filter, list):
+                    tools = [t for t in tools if t['name'] in tool_filter]
+                
+                # Register each tool as a SWAIG function
+                for tool in tools:
+                    self._register_mcp_tool(service_name, tool)
+                    
+            except Exception as e:
+                self.logger.error(f"Failed to get tools for service '{service_name}': {e}")
+        
+        # Register the hangup hook for session cleanup
+        self.agent.define_tool(
+            name="_mcp_gateway_hangup",
+            description="Internal cleanup function for MCP sessions",
+            parameters={},
+            handler=self._hangup_handler,
+            is_hangup_hook=True
+        )
+    
+    def _register_mcp_tool(self, service_name: str, tool_def: Dict[str, Any]):
+        """Register a single MCP tool as a SWAIG function"""
+        tool_name = tool_def.get('name')
+        if not tool_name:
+            return
+        
+        # Create SWAIG function name
+        swaig_name = f"{self.tool_prefix}{service_name}_{tool_name}"
+        
+        # Build SWAIG parameters from MCP input schema
+        input_schema = tool_def.get('inputSchema', {})
+        properties = input_schema.get('properties', {})
+        required = input_schema.get('required', [])
+        
+        # Convert MCP schema to SWAIG parameters
+        swaig_params = {}
+        for prop_name, prop_def in properties.items():
+            param_def = {
+                "type": prop_def.get('type', 'string'),
+                "description": prop_def.get('description', '')
+            }
+            
+            # Add enum if present
+            if 'enum' in prop_def:
+                param_def['enum'] = prop_def['enum']
+            
+            # Add default if present and not required
+            if 'default' in prop_def and prop_name not in required:
+                param_def['default'] = prop_def['default']
+            
+            swaig_params[prop_name] = param_def
+        
+        # Create handler function
+        def handler(args, raw_data):
+            return self._call_mcp_tool(service_name, tool_name, args, raw_data)
+        
+        # Register the SWAIG function
+        self.agent.define_tool(
+            name=swaig_name,
+            description=f"[{service_name}] {tool_def.get('description', tool_name)}",
+            parameters=swaig_params,
+            handler=handler
+        )
+        
+        self.logger.info(f"Registered SWAIG function: {swaig_name}")
+    
+    def _call_mcp_tool(self, service_name: str, tool_name: str, args: Dict[str, Any], 
+                       raw_data: Dict[str, Any]) -> SwaigFunctionResult:
+        """Call an MCP tool through the gateway"""
+        # Check for mcp_call_id in global_data first, then fall back to top-level call_id
+        global_data = raw_data.get('global_data', {})
+        if 'mcp_call_id' in global_data:
+            self.session_id = global_data['mcp_call_id']
+            self.logger.info(f"Using session ID from global_data.mcp_call_id: {self.session_id}")
+        else:
+            self.session_id = raw_data.get('call_id', 'unknown')
+            self.logger.info(f"Using session ID from call_id: {self.session_id}")
+        self.logger.debug(f"Raw data keys: {list(raw_data.keys())}")
+        if 'global_data' in raw_data:
+            self.logger.debug(f"global_data keys: {list(global_data.keys())}")
+        
+        # Prepare request
+        request_data = {
+            "tool": tool_name,
+            "arguments": args,
+            "session_id": self.session_id,
+            "timeout": self.session_timeout,
+            "metadata": {
+                "agent_id": self.agent.name,
+                "timestamp": raw_data.get('timestamp'),
+                "call_id": raw_data.get('call_id')
+            }
+        }
+        
+        # Call the gateway with retries
+        last_error = None
+        for attempt in range(self.retry_attempts):
+            try:
+                response = self._make_request(
+                    'POST',
+                    f"{self.gateway_url}/services/{service_name}/call",
+                    json=request_data
+                )
+                
+                if response.status_code == 200:
+                    result_data = response.json()
+                    result_text = result_data.get('result', 'No response')
+                    
+                    # Create SWAIG result
+                    return SwaigFunctionResult(result_text)
+                
+                else:
+                    error_data = response.json()
+                    error_msg = error_data.get('error', f'HTTP {response.status_code}')
+                    last_error = error_msg
+                    
+                    if response.status_code >= 500:
+                        # Server error, retry
+                        self.logger.warning(f"Gateway error (attempt {attempt + 1}): {error_msg}")
+                        continue
+                    else:
+                        # Client error, don't retry
+                        break
+                        
+            except requests.exceptions.Timeout:
+                last_error = "Request timeout"
+                self.logger.warning(f"Timeout calling MCP tool (attempt {attempt + 1})")
+                
+            except requests.exceptions.ConnectionError:
+                last_error = "Connection error"
+                self.logger.warning(f"Connection error (attempt {attempt + 1})")
+                
+            except Exception as e:
+                last_error = str(e)
+                self.logger.error(f"Unexpected error: {e}")
+                break
+        
+        # All attempts failed
+        error_msg = f"Failed to call {service_name}.{tool_name}: {last_error}"
+        self.logger.error(error_msg)
+        return SwaigFunctionResult(error_msg)
+    
+    def _hangup_handler(self, args: Dict[str, Any], raw_data: Dict[str, Any]) -> SwaigFunctionResult:
+        """Handle call hangup - cleanup MCP session"""
+        # Check for mcp_call_id in global_data first, then fall back to top-level call_id
+        global_data = raw_data.get('global_data', {})
+        if 'mcp_call_id' in global_data:
+            session_id = global_data['mcp_call_id']
+            self.logger.info(f"Cleanup using session ID from global_data.mcp_call_id: {session_id}")
+        else:
+            session_id = raw_data.get('call_id', 'unknown')
+            self.logger.info(f"Cleanup using session ID from call_id: {session_id}")
+        
+        try:
+            response = self._make_request('DELETE', f"{self.gateway_url}/sessions/{session_id}")
+            
+            if response.status_code in [200, 404]:
+                self.logger.info(f"Cleaned up MCP session: {session_id}")
+            else:
+                self.logger.warning(f"Failed to cleanup session: HTTP {response.status_code}")
+                
+        except Exception as e:
+            self.logger.error(f"Error cleaning up session: {e}")
+        
+        return SwaigFunctionResult("Session cleanup complete")
+    
+    def get_hints(self) -> List[str]:
+        """Return speech recognition hints"""
+        hints = ["MCP", "gateway"]
+        
+        # Add service names as hints
+        for service in self.services:
+            if isinstance(service, dict) and 'name' in service:
+                hints.append(service['name'])
+        
+        return hints
+    
+    def get_global_data(self) -> Dict[str, Any]:
+        """Return global data for DataMap variables"""
+        return {
+            "mcp_gateway_url": self.gateway_url,
+            "mcp_session_id": self.session_id,
+            "mcp_services": [s.get('name') if isinstance(s, dict) else str(s) 
+                            for s in self.services]
+        }
+    
+    def get_prompt_sections(self) -> List[Dict[str, Any]]:
+        """Return prompt sections to add to agent"""
+        sections = []
+        
+        # Build service list for prompt
+        service_descriptions = []
+        for service in self.services:
+            if isinstance(service, dict):
+                name = service.get('name', 'Unknown')
+                tools = service.get('tools', '*')
+                if tools == '*':
+                    service_descriptions.append(f"{name} (all tools)")
+                elif isinstance(tools, list):
+                    service_descriptions.append(f"{name} ({len(tools)} tools)")
+            else:
+                service_descriptions.append(str(service))
+        
+        if service_descriptions:
+            sections.append({
+                "title": "MCP Gateway Integration",
+                "body": "You have access to external MCP (Model Context Protocol) services through a gateway.",
+                "bullets": [
+                    f"Connected to gateway at {self.gateway_url}",
+                    f"Available services: {', '.join(service_descriptions)}",
+                    f"Functions are prefixed with '{self.tool_prefix}' followed by service name",
+                    "Each service maintains its own session state throughout the call"
+                ]
+            })
+        
+        return sections

{signalwire_agents-0.1.27.dist-info → signalwire_agents-0.1.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalwire_agents
-Version: 0.1.27
+Version: 0.1.28
 Summary: SignalWire AI Agents SDK
 Author-email: SignalWire Team <info@signalwire.com>
 License: MIT
@@ -593,64 +593,6 @@ if __name__ == "__main__":
     agent.serve(host="0.0.0.0", port=8000)
 ```
 
-## Using State Management
-
-```python
-from signalwire_agents import AgentBase
-from signalwire_agents.core.function_result import SwaigFunctionResult
-from signalwire_agents.core.state import FileStateManager
-
-class StatefulAgent(AgentBase):
-    def __init__(self):
-        # Configure state management
-        state_manager = FileStateManager(storage_dir="./state_data")
-        
-        super().__init__(
-            name="stateful", 
-            route="/stateful",
-            enable_state_tracking=True,  # Enable state tracking
-            state_manager=state_manager  # Use custom state manager
-        )
-        
-        # When enable_state_tracking=True, startup_hook and hangup_hook
-        # are automatically registered to track session lifecycle
-    
-    # Custom tool for accessing and updating state
-    @AgentBase.tool(
-        name="save_preference",
-        description="Save a user preference",
-        parameters={
-            "preference_name": {
-                "type": "string",
-                "description": "Name of the preference to save"
-            },
-            "preference_value": {
-                "type": "string",
-                "description": "Value of the preference"
-            }
-        }
-    )
-    def save_preference(self, args, raw_data):
-        # Get the call ID from the raw data
-        call_id = raw_data.get("call_id")
-        
-        if call_id:
-            # Get current state or empty dict if none exists
-            state = self.get_state(call_id) or {}
-            
-            # Update the state
-            preferences = state.get("preferences", {})
-            preferences[args.get("preference_name")] = args.get("preference_value")
-            state["preferences"] = preferences
-            
-            # Save the updated state
-            self.update_state(call_id, state)
-            
-            return SwaigFunctionResult("Preference saved successfully")
-        else:
-            return SwaigFunctionResult("Could not save preference: No call ID")
-```
-
 ## Using Prefab Agents
 
 ```python

{signalwire_agents-0.1.27.dist-info → signalwire_agents-0.1.28.dist-info}/RECORD

@@ -1,10 +1,10 @@
-signalwire_agents/__init__.py,sha256=P611r1tfqaEgg2KJ1baYXlpR0AqLN2sg4PAfVNdaUlE,2707
+signalwire_agents/__init__.py,sha256=PxkP8XySZGQV2Gq8fjd_ChKOclw4elZi_Nr3wmVyW3U,2608
 signalwire_agents/agent_server.py,sha256=x9HyWia8D3r6KMqY-Q4DtNVivfJWLTx8B-KzUI8okuA,26880
 signalwire_agents/schema.json,sha256=AWhh6MoMU95roA_6RSdVdvbHDWPYqMavRoSnsVeMiw8,240965
 signalwire_agents/cli/__init__.py,sha256=Iy2BfWDWBEZoA1cyHTDsooBSVMx4vH5Ddhr3sEuFe8c,197
 signalwire_agents/cli/build_search.py,sha256=KLQJBqVSADFyGcKAi0KLwU_UoUd5rtRoKAdfcH91u70,28652
-signalwire_agents/cli/config.py,sha256=SeUcI7bNr_eCdn3oPfdEwDrVIkl7kdmqPvPbQgREm7Q,1862
-signalwire_agents/cli/test_swaig.py,sha256=5cYX7V5U5uwvOebi0zGdOQzD5zzC8kLPt3QdgkihtmI,30255
+signalwire_agents/cli/config.py,sha256=U5AhAzCaf7jkziaGTrnF_FYy8WVDDR_WXgbfyVGkST4,2350
+signalwire_agents/cli/test_swaig.py,sha256=8Z7OGK0P3NUMAIMYuM-1pxcSsGG0airWDxut1lYLV_E,30571
 signalwire_agents/cli/types.py,sha256=fjj3LV6upZDzplxqOYHyi3lxIkKKTWNPUtKt9yPGYXs,1619
 signalwire_agents/cli/core/__init__.py,sha256=hfGAdbsh-TWkN8KvQGAlfHIs9D-KfG5W6peP47pjV08,38
 signalwire_agents/cli/core/agent_loader.py,sha256=55wXgJhIZX8gDP0d-EVqTrVYiZgXDGBJq9wErwL46e8,10394
@@ -18,10 +18,10 @@ signalwire_agents/cli/output/output_formatter.py,sha256=MidaaCrhOuLJ3L_nsbNFTh92
 signalwire_agents/cli/output/swml_dump.py,sha256=S0lPhm1-XiZk0TU2SfOPTMRa5iGubStHI6MbQsiAXaw,6449
 signalwire_agents/cli/simulation/__init__.py,sha256=D-9DVP3Xat3eTxgX-L63cSdtM5X8nGA54bcPGlEm600,45
 signalwire_agents/cli/simulation/data_generation.py,sha256=ueQ8Ga5mng8jd87dzxN5rzwbbzboMpd6vB7_yUwjGHE,11727
-signalwire_agents/cli/simulation/data_overrides.py,sha256=nXJp2x7QsCRvCjrhwkaEq-kXu0aKOywhVcx02S6S7Hk,5959
+signalwire_agents/cli/simulation/data_overrides.py,sha256=EpWckF9-pc0AaZdh1C2msP3hcNxe0WoQO-n0VugE56k,6128
 signalwire_agents/cli/simulation/mock_env.py,sha256=S6uGDGEO-4dXAyCJEZO1hkwiyJmYXBZx5o8XT0as0fc,9950
 signalwire_agents/core/__init__.py,sha256=xjPq8DmUnWYUG28sd17n430VWPmMH9oZ9W14gYwG96g,806
-signalwire_agents/core/agent_base.py,sha256=5U_Wrcairdz42w6E9N_Sw5G3kPV8ad46v9qQDzbDoIg,44651
+signalwire_agents/core/agent_base.py,sha256=F0dL5bdWY_n3zIz9qVC8jWu3xxNXS6cO3dFW_RCyuro,43951
 signalwire_agents/core/contexts.py,sha256=NLMQ4ZxTbCXQgGHjTQ07tA-2hC-vdoYJHGl32kvDuqk,21314
 signalwire_agents/core/data_map.py,sha256=0qp3VcrRS0RtZPApoAaGgM-udLBb1ysnyMJuWd6sSew,17134
 signalwire_agents/core/function_result.py,sha256=MZZUoAHN8AXry-OBNA6Od5l-bKvMM2ruvnqHLbNhSiQ,44959
@@ -52,20 +52,17 @@ signalwire_agents/core/mixins/auth_mixin.py,sha256=Y9kR423-76U_pKL7KXzseeXX2a-4W
 signalwire_agents/core/mixins/prompt_mixin.py,sha256=2cAJpp3Ka-fmgpAg201xeTy-xps99k0vlP7YyqZiCnw,13374
 signalwire_agents/core/mixins/serverless_mixin.py,sha256=QIIbl_-16XFJi5aqrWpNzORbyCJQmhaplWXnW6U9i68,16137
 signalwire_agents/core/mixins/skill_mixin.py,sha256=Qz3RKPmq_iMY4NecyxOHk3dW3W-O4iEm2ahhMjAcqRs,1861
-signalwire_agents/core/mixins/state_mixin.py,sha256=GMYaPBCDqCj0O4Ol6owVnl7kK8OXe3l4BTd-ViOqDCg,9272
-signalwire_agents/core/mixins/tool_mixin.py,sha256=zVmBAfZpusdkZrYgSThTZt6O7YKi7UBQqZZEcWBDmvo,11333
+signalwire_agents/core/mixins/state_mixin.py,sha256=q3achpyUYZKuJaqKf12O22FXpSsNNsMEonSvlpSHCkA,6594
+signalwire_agents/core/mixins/tool_mixin.py,sha256=6CaNdaspHcfte0qSB_bSN8PTsqxRZzL_AXYk8QoWyXE,8660
 signalwire_agents/core/mixins/web_mixin.py,sha256=BUzmTkPIHGfitzbn1p94SDSqp-7x_IesjliypagB4oI,50324
 signalwire_agents/core/security/__init__.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_PumJ35Xds,191
 signalwire_agents/core/security/session_manager.py,sha256=s5hXYcFnrsYFoyo-zcN7EJy-wInZQI_cWTBHX9MxHR4,9164
-signalwire_agents/core/state/__init__.py,sha256=qpYIfQBApet6VQsy6diS3yu0lMxCBC6REOUk5l1McUw,379
-signalwire_agents/core/state/file_state_manager.py,sha256=52I_KVlmhHCbKIaHj74Q-ksP_-AF6ewYmOXCf4n5DTQ,7307
-signalwire_agents/core/state/state_manager.py,sha256=76B4mDutMb826dK4c_IJhOXH09BW1bJu6EZa6Mh_LB4,2511
 signalwire_agents/prefabs/__init__.py,sha256=MW11J63XH7KxF2MWguRsMFM9iqMWexaEO9ynDPL_PDM,715
-signalwire_agents/prefabs/concierge.py,sha256=FQxSUBAVH2ECtNs4GGa3f0EPiOrAKaz14h7byNFy5K8,10106
-signalwire_agents/prefabs/faq_bot.py,sha256=NrUn5AGmtdzYTyxTHPt8BZ14ZN1sh4xKA2SVQUlfPPQ,10834
-signalwire_agents/prefabs/info_gatherer.py,sha256=dr9UUgNGX7MIKdCMth3jDVLf6OrHov5G6_zIuNvnrOY,15468
-signalwire_agents/prefabs/receptionist.py,sha256=8EyQ6M0Egs3g7KKWukHFiO9UPoVUxT4MLkvyT3V8o64,10585
-signalwire_agents/prefabs/survey.py,sha256=IIIQfgvMlfVNjEEEdWUn4lAJqVsCDlBsIAkOJ1ckyAE,14796
+signalwire_agents/prefabs/concierge.py,sha256=XB-Ziy0tteYI5NHu7Sinx-N960nzkhq2m4v8Ei8UHas,9921
+signalwire_agents/prefabs/faq_bot.py,sha256=cUuHhnDB8S4aVg-DiQe4jBmCAPrYQrND_Mff9iaeEa0,10572
+signalwire_agents/prefabs/info_gatherer.py,sha256=0LpYTaU7C76Efp3yUIdNX6xzWH7mj5pBYewilpkCL5g,15189
+signalwire_agents/prefabs/receptionist.py,sha256=em0uk_F0tmePvzE6Hi9HFlL3MHChH0RaHHqSvww9pK0,10323
+signalwire_agents/prefabs/survey.py,sha256=a-0-xAnQYhdX4Lzgyna14lpNfaCV-rLUFkQF6QOCQAY,14534
 signalwire_agents/search/__init__.py,sha256=x7saU_MDbhoOIzcvCT1-gnqyH2rrMpzB4ZUqk-av-lI,3958
 signalwire_agents/search/document_processor.py,sha256=J4OG640qbqGslbVevvD4J2cbTmFCZiGJ1bLX2yDayaE,43699
 signalwire_agents/search/index_builder.py,sha256=MHqrLZfNjWAM7EtL1L4wqrS1ICXKI_GPrHtIFHn35kQ,25174
@@ -93,6 +90,9 @@ signalwire_agents/skills/joke/skill.py,sha256=AFaf6fMy0sxUPJHvcnf3CWMuPqpJP4ODsc
 signalwire_agents/skills/math/README.md,sha256=Nrv7PxkFPSxdnAN6856Fp1CfvsUwdncpRFFDERxmMe0,5335
 signalwire_agents/skills/math/__init__.py,sha256=lGAFWEmJH2fuwkuZUdDTY5dmucrIwtjfNT8bE2hOSP8,39
 signalwire_agents/skills/math/skill.py,sha256=5sErd5x1rFHJg2GlmdJB3LvrmvTNOrZsA2jRnG67Zw8,3342
+signalwire_agents/skills/mcp_gateway/README.md,sha256=t-71TTWlEvjgWLTcT3v4kMw9zlrKXTAC_sCjb1haNew,5826
+signalwire_agents/skills/mcp_gateway/__init__.py,sha256=w1XiSptNPQAoZe3ISvYzi7bUdNT_KrDrQYeKKGzy-4w,45
+signalwire_agents/skills/mcp_gateway/skill.py,sha256=iS5ET9jYKnwuYsuFd-aqUJfLUhvX--RG2FfCq8BZ340,14050
 signalwire_agents/skills/native_vector_search/__init__.py,sha256=buvncVoH5u8MJA0SLlz1JQgIuyBTQW5aql-ydnc7Wh8,29
 signalwire_agents/skills/native_vector_search/skill.py,sha256=Ck74rnlZ1HtnmEWRhZW1bSF_-PzpV3q-sNOu_LmeDQ0,18934
 signalwire_agents/skills/play_background_file/README.md,sha256=omJ_jY5Co6Mk-gJt_hoSl40wemmTbzae3DBll6HL0B4,7026
@@ -118,9 +118,9 @@ signalwire_agents/utils/pom_utils.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_Pu
 signalwire_agents/utils/schema_utils.py,sha256=i4okv_O9bUApwT_jJf4Yoij3bLCrGrW3DC-vzSy2RuY,16392
 signalwire_agents/utils/token_generators.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_PumJ35Xds,191
 signalwire_agents/utils/validators.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_PumJ35Xds,191
-signalwire_agents-0.1.27.dist-info/licenses/LICENSE,sha256=NYvAsB-rTcSvG9cqHt9EUHAWLiA9YzM4Qfz-mPdvDR0,1067
-signalwire_agents-0.1.27.dist-info/METADATA,sha256=7M8q5GHaeZzmsa2ieXymQRVbayHuyc-nkhJHdxpkzz8,37922
-signalwire_agents-0.1.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-signalwire_agents-0.1.27.dist-info/entry_points.txt,sha256=sfdeRaTSs9J56pqFdcZGRTxQcTuecb8IMx8gqleJ6s0,136
-signalwire_agents-0.1.27.dist-info/top_level.txt,sha256=kDGS6ZYv84K9P5Kyg9_S8P_pbUXoHkso0On_DB5bbWc,18
-signalwire_agents-0.1.27.dist-info/RECORD,,
+signalwire_agents-0.1.28.dist-info/licenses/LICENSE,sha256=NYvAsB-rTcSvG9cqHt9EUHAWLiA9YzM4Qfz-mPdvDR0,1067
+signalwire_agents-0.1.28.dist-info/METADATA,sha256=0RcVdgne8jSL6gROPQ4EzHcuU2scpNmVu4wqIjU19Rs,35907
+signalwire_agents-0.1.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+signalwire_agents-0.1.28.dist-info/entry_points.txt,sha256=sfdeRaTSs9J56pqFdcZGRTxQcTuecb8IMx8gqleJ6s0,136
+signalwire_agents-0.1.28.dist-info/top_level.txt,sha256=kDGS6ZYv84K9P5Kyg9_S8P_pbUXoHkso0On_DB5bbWc,18
+signalwire_agents-0.1.28.dist-info/RECORD,,

signalwire_agents/core/state/__init__.py

@@ -1,17 +0,0 @@
-"""
-Copyright (c) 2025 SignalWire
-
-This file is part of the SignalWire AI Agents SDK.
-
-Licensed under the MIT License.
-See LICENSE file in the project root for full license information.
-"""
-
-"""
-State management for SignalWire AI Agents
-"""
-
-from .state_manager import StateManager
-from .file_state_manager import FileStateManager
-
-__all__ = ['StateManager', 'FileStateManager']