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

signalwire_agents/skills/math/skill.py

@@ -0,0 +1,88 @@
+"""
+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 re
+from typing import List, Dict, Any
+
+from signalwire_agents.core.skill_base import SkillBase
+from signalwire_agents.core.function_result import SwaigFunctionResult
+
+class MathSkill(SkillBase):
+    """Provides basic mathematical calculation capabilities"""
+    
+    SKILL_NAME = "math"
+    SKILL_DESCRIPTION = "Perform basic mathematical calculations"
+    SKILL_VERSION = "1.0.0"
+    REQUIRED_PACKAGES = []
+    REQUIRED_ENV_VARS = []
+    
+    def setup(self) -> bool:
+        """Setup the math skill"""
+        return True
+        
+    def register_tools(self) -> None:
+        """Register math tools with the agent"""
+        
+        self.agent.define_tool(
+            name="calculate",
+            description="Perform a mathematical calculation with basic operations (+, -, *, /, %, **)",
+            parameters={
+                "expression": {
+                    "type": "string",
+                    "description": "Mathematical expression to evaluate (e.g., '2 + 3 * 4', '(10 + 5) / 3')"
+                }
+            },
+            handler=self._calculate_handler
+        )
+        
+    def _calculate_handler(self, args, raw_data):
+        """Handler for calculate tool"""
+        expression = args.get("expression", "").strip()
+        
+        if not expression:
+            return SwaigFunctionResult("Please provide a mathematical expression to calculate.")
+        
+        # Security: only allow safe mathematical operations
+        safe_chars = re.compile(r'^[0-9+\-*/().\s%**]+$')
+        if not safe_chars.match(expression):
+            return SwaigFunctionResult(
+                "Invalid expression. Only numbers and basic math operators (+, -, *, /, %, **, parentheses) are allowed."
+            )
+        
+        try:
+            # Evaluate the expression safely
+            result = eval(expression, {"__builtins__": {}}, {})
+            
+            return SwaigFunctionResult(f"{expression} = {result}")
+            
+        except ZeroDivisionError:
+            return SwaigFunctionResult("Error: Division by zero is not allowed.")
+        except Exception as e:
+            return SwaigFunctionResult(f"Error calculating '{expression}': Invalid expression")
+        
+    def get_hints(self) -> List[str]:
+        """Return speech recognition hints"""
+        return [
+            "calculate", "math", "plus", "minus", "times", "multiply", 
+            "divide", "equals", "percent", "power", "squared"
+        ]
+        
+    def get_prompt_sections(self) -> List[Dict[str, Any]]:
+        """Return prompt sections to add to agent"""
+        return [
+            {
+                "title": "Mathematical Calculations",
+                "body": "You can perform mathematical calculations for users.",
+                "bullets": [
+                    "Use the calculate tool for any math expressions",
+                    "Supports basic operations: +, -, *, /, %, ** (power)",
+                    "Can handle parentheses for complex expressions"
+                ]
+            }
+        ] 

signalwire_agents/skills/registry.py

@@ -0,0 +1,98 @@
+"""
+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 os
+import importlib
+import importlib.util
+import inspect
+from typing import Dict, List, Type, Optional
+from pathlib import Path
+import logging
+
+from signalwire_agents.core.skill_base import SkillBase
+
+class SkillRegistry:
+    """Global registry for discovering and managing skills"""
+    
+    def __init__(self):
+        self._skills: Dict[str, Type[SkillBase]] = {}
+        self.logger = logging.getLogger("skill_registry")
+        self._discovered = False
+    
+    def discover_skills(self) -> None:
+        """Discover skills from the skills directory"""
+        if self._discovered:
+            return
+            
+        # Get the skills directory path
+        skills_dir = Path(__file__).parent
+        
+        # Scan for skill directories
+        for item in skills_dir.iterdir():
+            if item.is_dir() and not item.name.startswith('__'):
+                self._load_skill_from_directory(item)
+        
+        self._discovered = True
+        self.logger.info(f"Discovered {len(self._skills)} skills")
+    
+    def _load_skill_from_directory(self, skill_dir: Path) -> None:
+        """Load a skill from a directory"""
+        skill_file = skill_dir / "skill.py"
+        if not skill_file.exists():
+            return
+            
+        try:
+            # Import the skill module
+            module_name = f"signalwire_agents.skills.{skill_dir.name}.skill"
+            spec = importlib.util.spec_from_file_location(module_name, skill_file)
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            
+            # Find SkillBase subclasses in the module
+            for name, obj in inspect.getmembers(module):
+                if (inspect.isclass(obj) and 
+                    issubclass(obj, SkillBase) and 
+                    obj != SkillBase and
+                    obj.SKILL_NAME is not None):
+                    
+                    self.register_skill(obj)
+                    
+        except Exception as e:
+            self.logger.error(f"Failed to load skill from {skill_dir}: {e}")
+    
+    def register_skill(self, skill_class: Type[SkillBase]) -> None:
+        """Register a skill class"""
+        if skill_class.SKILL_NAME in self._skills:
+            self.logger.warning(f"Skill '{skill_class.SKILL_NAME}' already registered")
+            return
+            
+        self._skills[skill_class.SKILL_NAME] = skill_class
+        self.logger.debug(f"Registered skill '{skill_class.SKILL_NAME}'")
+    
+    def get_skill_class(self, skill_name: str) -> Optional[Type[SkillBase]]:
+        """Get skill class by name"""
+        self.discover_skills()  # Ensure skills are discovered
+        return self._skills.get(skill_name)
+    
+    def list_skills(self) -> List[Dict[str, str]]:
+        """List all registered skills with metadata"""
+        self.discover_skills()
+        return [
+            {
+                "name": skill_class.SKILL_NAME,
+                "description": skill_class.SKILL_DESCRIPTION,
+                "version": skill_class.SKILL_VERSION,
+                "required_packages": skill_class.REQUIRED_PACKAGES,
+                "required_env_vars": skill_class.REQUIRED_ENV_VARS
+            }
+            for skill_class in self._skills.values()
+        ]
+
+# Global registry instance
+skill_registry = SkillRegistry() 

signalwire_agents/skills/web_search/__init__.py

@@ -0,0 +1 @@
+"""Web Search Skill for SignalWire Agents""" 

signalwire_agents/skills/web_search/skill.py

@@ -0,0 +1,240 @@
+"""
+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 os
+import requests
+import time
+from urllib.parse import urljoin, urlparse
+from bs4 import BeautifulSoup
+import json
+from typing import Optional, List, Dict, Any
+
+from signalwire_agents.core.skill_base import SkillBase
+from signalwire_agents.core.function_result import SwaigFunctionResult
+
+class GoogleSearchScraper:
+    """Google Search and Web Scraping functionality"""
+    
+    def __init__(self, api_key: str, search_engine_id: str):
+        self.api_key = api_key
+        self.search_engine_id = search_engine_id
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        })
+
+    def search_google(self, query: str, num_results: int = 5) -> list:
+        """Search Google using Custom Search JSON API"""
+        url = "https://www.googleapis.com/customsearch/v1"
+        
+        params = {
+            'key': self.api_key,
+            'cx': self.search_engine_id,
+            'q': query,
+            'num': min(num_results, 10)
+        }
+        
+        try:
+            response = self.session.get(url, params=params)
+            response.raise_for_status()
+            data = response.json()
+            
+            if 'items' not in data:
+                return []
+            
+            results = []
+            for item in data['items'][:num_results]:
+                results.append({
+                    'title': item.get('title', ''),
+                    'url': item.get('link', ''),
+                    'snippet': item.get('snippet', '')
+                })
+            
+            return results
+            
+        except Exception as e:
+            return []
+
+    def extract_text_from_url(self, url: str, timeout: int = 10) -> str:
+        """Scrape a URL and extract readable text content"""
+        try:
+            response = self.session.get(url, timeout=timeout)
+            response.raise_for_status()
+            
+            soup = BeautifulSoup(response.content, 'html.parser')
+            
+            # Remove unwanted elements
+            for script in soup(["script", "style", "nav", "footer", "header", "aside"]):
+                script.decompose()
+            
+            text = soup.get_text()
+            
+            # Clean up the text
+            lines = (line.strip() for line in text.splitlines())
+            chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+            text = ' '.join(chunk for chunk in chunks if chunk)
+            
+            # Limit text length
+            if len(text) > 2000:
+                text = text[:2000] + "... [Content truncated]"
+            
+            return text
+            
+        except Exception as e:
+            return ""
+
+    def search_and_scrape(self, query: str, num_results: int = 3, delay: float = 0.5) -> str:
+        """Main function: search Google and scrape the resulting pages"""
+        search_results = self.search_google(query, num_results)
+        
+        if not search_results:
+            return f"No search results found for query: {query}"
+        
+        all_text = []
+        
+        for i, result in enumerate(search_results, 1):
+            text_content = f"=== RESULT {i} ===\n"
+            text_content += f"Title: {result['title']}\n"
+            text_content += f"URL: {result['url']}\n"
+            text_content += f"Snippet: {result['snippet']}\n"
+            text_content += f"Content:\n"
+            
+            page_text = self.extract_text_from_url(result['url'])
+            
+            if page_text:
+                text_content += page_text
+            else:
+                text_content += "Failed to extract content from this page."
+            
+            text_content += f"\n{'='*50}\n\n"
+            all_text.append(text_content)
+            
+            if i < len(search_results):
+                time.sleep(delay)
+        
+        return '\n'.join(all_text)
+
+
+class WebSearchSkill(SkillBase):
+    """Web search capability using Google Custom Search API"""
+    
+    SKILL_NAME = "web_search"
+    SKILL_DESCRIPTION = "Search the web for information using Google Custom Search API"
+    SKILL_VERSION = "1.0.0"
+    REQUIRED_PACKAGES = ["bs4", "requests"]
+    REQUIRED_ENV_VARS = ["GOOGLE_SEARCH_API_KEY", "GOOGLE_SEARCH_ENGINE_ID"]
+    
+    def setup(self) -> bool:
+        """Setup the web search skill"""
+        if not self.validate_env_vars() or not self.validate_packages():
+            return False
+            
+        # Set default parameters
+        self.default_num_results = self.params.get('num_results', 1)
+        self.default_delay = self.params.get('delay', 0)
+        
+        # Initialize the search scraper
+        self.search_scraper = GoogleSearchScraper(
+            api_key=os.getenv('GOOGLE_SEARCH_API_KEY'),
+            search_engine_id=os.getenv('GOOGLE_SEARCH_ENGINE_ID')
+        )
+        
+        return True
+        
+    def register_tools(self) -> None:
+        """Register web search tool with the agent"""
+        self.agent.define_tool(
+            name="web_search",
+            description="Search the web for information on any topic and return detailed results with content from multiple sources",
+            parameters={
+                "query": {
+                    "type": "string",
+                    "description": "The search query - what you want to find information about"
+                },
+                "num_results": {
+                    "type": "integer", 
+                    "description": f"Number of web pages to search and extract content from (1-10, default: {self.default_num_results})",
+                    "minimum": 1,
+                    "maximum": 10
+                }
+            },
+            handler=self._web_search_handler
+        )
+        
+    def _web_search_handler(self, args, raw_data):
+        """Handler for web search tool"""
+        query = args.get("query", "").strip()
+        num_results = args.get("num_results", self.default_num_results)
+        
+        if not query:
+            return SwaigFunctionResult(
+                "Please provide a search query. What would you like me to search for?"
+            )
+        
+        # Validate num_results
+        try:
+            num_results = int(num_results)
+            num_results = max(1, min(num_results, 10))
+        except (ValueError, TypeError):
+            num_results = self.default_num_results
+        
+        self.logger.info(f"Web search requested: '{query}' ({num_results} results)")
+        
+        # Perform the search
+        try:
+            search_results = self.search_scraper.search_and_scrape(
+                query=query,
+                num_results=num_results,
+                delay=self.default_delay
+            )
+            
+            if not search_results or "No search results found" in search_results:
+                return SwaigFunctionResult(
+                    f"I couldn't find any results for '{query}'. "
+                    "This might be due to a very specific query or temporary issues. "
+                    "Try rephrasing your search or asking about a different topic."
+                )
+            
+            response = f"I found {num_results} results for '{query}':\n\n{search_results}"
+            return SwaigFunctionResult(response)
+            
+        except Exception as e:
+            self.logger.error(f"Error performing web search: {e}")
+            return SwaigFunctionResult(
+                "Sorry, I encountered an error while searching. Please try again later."
+            )
+        
+    def get_hints(self) -> List[str]:
+        """Return speech recognition hints"""
+        return [
+            "Google", "search", "internet", "web", "information",
+            "find", "look up", "research", "query", "results"
+        ]
+        
+    def get_global_data(self) -> Dict[str, Any]:
+        """Return global data for agent context"""
+        return {
+            "web_search_enabled": True,
+            "search_provider": "Google Custom Search"
+        }
+        
+    def get_prompt_sections(self) -> List[Dict[str, Any]]:
+        """Return prompt sections to add to agent"""
+        return [
+            {
+                "title": "Web Search Capability",
+                "body": "You can search the internet for current, accurate information on any topic.",
+                "bullets": [
+                    "Use the web_search tool when users ask for information you need to look up",
+                    "Search for news, current events, product information, or any current data",
+                    "Summarize search results in a clear, helpful way",
+                    "Include relevant URLs so users can read more if interested"
+                ]
+            }
+        ] 

{signalwire_agents-0.1.7.dist-info → signalwire_agents-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalwire_agents
-Version: 0.1.7
+Version: 0.1.9
 Summary: SignalWire AI Agents SDK
 Author-email: SignalWire Team <info@signalwire.com>
 Project-URL: Homepage, https://github.com/signalwire/signalwire-ai-agents
@@ -24,6 +24,8 @@ Requires-Dist: setuptools==66.1.1
 Requires-Dist: signalwire_pom==2.7.1
 Requires-Dist: structlog==25.3.0
 Requires-Dist: uvicorn==0.34.2
+Requires-Dist: beautifulsoup4==4.12.3
+Requires-Dist: pytz==2023.3
 Dynamic: license-file
 
 # SignalWire AI Agent SDK
@@ -35,12 +37,54 @@ A Python SDK for creating, hosting, and securing SignalWire AI agents as microse
 - **Self-Contained Agents**: Each agent is both a web app and an AI persona
 - **Prompt Object Model**: Structured prompt composition using POM
 - **SWAIG Integration**: Easily define and handle AI tools/functions
+- **Dynamic Configuration**: Configure agents per-request for multi-tenant apps and personalization
 - **Custom Routing**: Dynamic request handling for different paths and content
 - **SIP Integration**: Route SIP calls to agents based on SIP usernames
 - **Security Built-In**: Session management, function-specific security tokens, and basic auth
 - **State Management**: Persistent conversation state with automatic tracking
 - **Prefab Archetypes**: Ready-to-use agent types for common scenarios
 - **Multi-Agent Support**: Host multiple agents on a single server
+- **Modular Skills System**: Add capabilities to agents with simple one-liner calls
+
+## Skills System
+
+The SignalWire Agents SDK includes a powerful modular skills system that allows you to add complex capabilities to your agents with simple one-liner calls:
+
+```python
+from signalwire_agents import AgentBase
+
+# Create an agent
+agent = AgentBase("My Assistant", route="/assistant")
+
+# Add skills with one-liners
+agent.add_skill("web_search")   # Web search capability
+agent.add_skill("datetime")     # Current date/time info  
+agent.add_skill("math")         # Mathematical calculations
+
+# Configure skills with parameters
+agent.add_skill("web_search", {
+    "num_results": 3,  # Get 3 search results
+    "delay": 0.5       # Small delay between requests
+})
+
+agent.serve()
+```
+
+### Available Built-in Skills
+
+- **web_search**: Google Custom Search API integration with web scraping
+- **datetime**: Current date and time with timezone support
+- **math**: Safe mathematical expression evaluation
+
+### Benefits
+
+- **One-liner integration**: `agent.add_skill("skill_name")`
+- **Configurable parameters**: `agent.add_skill("skill_name", {"param": "value"})`
+- **Automatic discovery**: Skills are automatically found from the skills directory
+- **Dependency validation**: Clear error messages for missing requirements
+- **Modular architecture**: Skills are self-contained and reusable
+
+For detailed documentation, see [Skills System README](docs/SKILLS_SYSTEM_README.md).
 
 ## Installation
 
@@ -165,6 +209,73 @@ Available prefabs include:
 - `FAQBotAgent`: Answers questions based on a knowledge base
 - `ConciergeAgent`: Routes users to specialized agents
 - `SurveyAgent`: Conducts structured surveys with questions and rating scales
+- `ReceptionistAgent`: Greets callers and transfers them to appropriate departments
+
+## Dynamic Agent Configuration
+
+Configure agents dynamically based on request parameters for multi-tenant applications, A/B testing, and personalization.
+
+### Static vs Dynamic Configuration
+
+- **Static**: Agent configured once at startup (traditional approach)
+- **Dynamic**: Agent configured fresh for each request based on parameters
+
+### Basic Example
+
+```python
+from signalwire_agents import AgentBase
+
+class DynamicAgent(AgentBase):
+    def __init__(self):
+        super().__init__(name="dynamic-agent", route="/dynamic")
+        
+        # Set up dynamic configuration callback
+        self.set_dynamic_config_callback(self.configure_per_request)
+    
+    def configure_per_request(self, query_params, body_params, headers, agent):
+        """Configure agent based on request parameters"""
+        
+        # Extract parameters from request
+        tier = query_params.get('tier', 'standard')
+        language = query_params.get('language', 'en')
+        customer_id = query_params.get('customer_id')
+        
+        # Configure voice and language
+        if language == 'es':
+            agent.add_language("Spanish", "es-ES", "rime.spore:mistv2")
+        else:
+            agent.add_language("English", "en-US", "rime.spore:mistv2")
+        
+        # Configure based on service tier
+        if tier == 'premium':
+            agent.set_params({"end_of_speech_timeout": 300})  # Faster response
+            agent.prompt_add_section("Service Level", "You provide premium support.")
+        else:
+            agent.set_params({"end_of_speech_timeout": 500})  # Standard response
+            agent.prompt_add_section("Service Level", "You provide standard support.")
+        
+        # Personalize with customer data
+        global_data = {"tier": tier, "language": language}
+        if customer_id:
+            global_data["customer_id"] = customer_id
+        agent.set_global_data(global_data)
+
+# Usage examples:
+# curl "http://localhost:3000/dynamic?tier=premium&language=es&customer_id=123"
+# curl "http://localhost:3000/dynamic?tier=standard&language=en"
+```
+
+### Use Cases
+
+- **Multi-tenant SaaS**: Different configurations per customer/organization
+- **A/B Testing**: Test different agent behaviors with different user groups
+- **Personalization**: Customize voice, prompts, and behavior per user
+- **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.
+
+For detailed documentation and advanced examples, see the [Agent Guide](docs/agent_guide.md#dynamic-agent-configuration).
 
 ## Configuration
 
@@ -189,7 +300,7 @@ To enable HTTPS directly (without a reverse proxy), set `SWML_SSL_ENABLED` to "t
 
 The package includes comprehensive documentation in the `docs/` directory:
 
-- [Agent Guide](docs/agent_guide.md) - Detailed guide to creating and customizing agents
+- [Agent Guide](docs/agent_guide.md) - Detailed guide to creating and customizing agents, including dynamic configuration
 - [Architecture](docs/architecture.md) - Overview of the SDK architecture and core concepts
 - [SWML Service Guide](docs/swml_service_guide.md) - Guide to the underlying SWML service
 

{signalwire_agents-0.1.7.dist-info → signalwire_agents-0.1.9.dist-info}/RECORD

@@ -1,12 +1,14 @@
-signalwire_agents/__init__.py,sha256=WMXWZxEE3QuDgEKy6MBcL6hxdSDA3_gFd2XAQYmEwMg,800
+signalwire_agents/__init__.py,sha256=aEEMPduIWEbHA41lbgxI6lOVAOmYI1C0nFc8_35bLj8,870
 signalwire_agents/agent_server.py,sha256=se_YzOQE5UUoRUKCbTnOg9qr4G3qN7iVuQLutwXEwFU,12850
 signalwire_agents/schema.json,sha256=M8Mn6pQda2P9jhbmkALrLr1wt-fRuhYRqdmEi9Rbhqk,178075
 signalwire_agents/core/__init__.py,sha256=mVDLbpq1pg_WwiqsQR28NNZwJ6-VUXFIfg-vN7pk0ew,806
-signalwire_agents/core/agent_base.py,sha256=D8ZiRRYDxF24cOjXoT253SWODEvmDZ-l8kwWMnr18Bw,103118
-signalwire_agents/core/function_result.py,sha256=vD8eBDJBQNNnss1jShadfogCZw_prODB6eBkTuVgZKA,3538
+signalwire_agents/core/agent_base.py,sha256=sQHFKzOHtQrmMn9TGSda-BzfLsqNV9JgG9npUPUrovE,114016
+signalwire_agents/core/function_result.py,sha256=OXzm4GOvA6TKbzZFsdz3iBU5vQs9LXxsmQue7zWVolE,43538
 signalwire_agents/core/pom_builder.py,sha256=ywuiIfP8BeLBPo_G4X1teZlG6zTCMkW71CZnmyoDTAQ,6636
+signalwire_agents/core/skill_base.py,sha256=4IPSP422iKricMRcKWx0rIjy3XS5qaRUf5OSM_x_0QU,3015
+signalwire_agents/core/skill_manager.py,sha256=kW17EOUR4u9mePo_90qKoCP6rusXDWzqZvJA0_FB-q4,5486
 signalwire_agents/core/swaig_function.py,sha256=WoHGQuCmU9L9k39pttRunmfRtIa_PnNRn9W0Xq3MfIk,6316
-signalwire_agents/core/swml_builder.py,sha256=Y_eHThVVso-_Hz4f73eEuu3HJstsM9PtBl-36GvAXhI,6594
+signalwire_agents/core/swml_builder.py,sha256=Q1ikU9pedgjW888mjbqDFv-jMDvDZ-tZgfyMfu4qQN0,6719
 signalwire_agents/core/swml_handler.py,sha256=KvphI_YY47VWGVXaix_N3SuQSyygHEUr9We6xESQK44,7002
 signalwire_agents/core/swml_renderer.py,sha256=iobMWWoBR7dkHndI3Qlwf4C0fg2p7DmAU2Rb7ZmmLhA,13891
 signalwire_agents/core/swml_service.py,sha256=4zTtpIKDtL59MzKgkBdpPmBCT6s1wVIikWEzZ1hqnyc,49309
@@ -18,17 +20,25 @@ signalwire_agents/core/state/state_manager.py,sha256=76B4mDutMb826dK4c_IJhOXH09B
 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=NkRc6FSaslDMhvF3a2rAvTqD9V8t17OV6_awwtQPPRM,10219
-signalwire_agents/prefabs/receptionist.py,sha256=Bpb_okc5MnxEdrrO-PkXXo5Zp9awgyt4bvYJOahSbYE,10555
+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/skills/__init__.py,sha256=xfxrQ0i-aTRomHiCsqelU4RlNlHPJFPgPu-UBDaBOqA,340
+signalwire_agents/skills/registry.py,sha256=XffqhZQ4ZbAMRssMW8vnK5-Qk8oJBmiEoPwFCMcz1Gc,3515
+signalwire_agents/skills/datetime/__init__.py,sha256=coPaY-k2EyZWuYckGunhSJ65Y1Jwz66h-iOo0QWb5WY,43
+signalwire_agents/skills/datetime/skill.py,sha256=XtT-tvr-X07q15B96X1bmVCjFvWdXm3J0ZfJ1kxSJe4,3746
+signalwire_agents/skills/math/__init__.py,sha256=lGAFWEmJH2fuwkuZUdDTY5dmucrIwtjfNT8bE2hOSP8,39
+signalwire_agents/skills/math/skill.py,sha256=Li0oN_pSL3jlC36FGILeZO_P0txf1TVOMoKu1Hrnp_Q,3215
+signalwire_agents/skills/web_search/__init__.py,sha256=wJlptYDExYw-nxZJVzlTLOgkKkDOLUUt1ZdoLt44ixs,45
+signalwire_agents/skills/web_search/skill.py,sha256=whjY2v3k8hsHxn1KSyTibYl_rtkdVbi0kWAPZuegR5w,9018
 signalwire_agents/utils/__init__.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_PumJ35Xds,191
 signalwire_agents/utils/pom_utils.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_PumJ35Xds,191
 signalwire_agents/utils/schema_utils.py,sha256=LvFCFvJTQk_xYK0B-NXbkXKEF7Zmv-LqpV_vfpPnOb4,13473
 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.7.data/data/schema.json,sha256=M8Mn6pQda2P9jhbmkALrLr1wt-fRuhYRqdmEi9Rbhqk,178075
-signalwire_agents-0.1.7.dist-info/licenses/LICENSE,sha256=NYvAsB-rTcSvG9cqHt9EUHAWLiA9YzM4Qfz-mPdvDR0,1067
-signalwire_agents-0.1.7.dist-info/METADATA,sha256=rlAExY7ealJ5HzZIx-IOHnH9MZn3zfXcuISBgnIRJbw,7486
-signalwire_agents-0.1.7.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-signalwire_agents-0.1.7.dist-info/top_level.txt,sha256=kDGS6ZYv84K9P5Kyg9_S8P_pbUXoHkso0On_DB5bbWc,18
-signalwire_agents-0.1.7.dist-info/RECORD,,
+signalwire_agents-0.1.9.data/data/schema.json,sha256=M8Mn6pQda2P9jhbmkALrLr1wt-fRuhYRqdmEi9Rbhqk,178075
+signalwire_agents-0.1.9.dist-info/licenses/LICENSE,sha256=NYvAsB-rTcSvG9cqHt9EUHAWLiA9YzM4Qfz-mPdvDR0,1067
+signalwire_agents-0.1.9.dist-info/METADATA,sha256=APX6OmsEYOL3iOdR6jwc5spU7pxy9lC8G1rSolR4SHU,12040
+signalwire_agents-0.1.9.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+signalwire_agents-0.1.9.dist-info/top_level.txt,sha256=kDGS6ZYv84K9P5Kyg9_S8P_pbUXoHkso0On_DB5bbWc,18
+signalwire_agents-0.1.9.dist-info/RECORD,,

{signalwire_agents-0.1.7.dist-info → signalwire_agents-0.1.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any