signalwire-agents 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

signalwire_agents/skills/native_vector_search/skill.py

@@ -0,0 +1,352 @@
+"""
+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 tempfile
+import shutil
+from typing import Dict, Any, Optional, List
+from pathlib import Path
+
+from signalwire_agents.core.skill_base import SkillBase
+from signalwire_agents.core.function_result import SwaigFunctionResult
+
+class NativeVectorSearchSkill(SkillBase):
+    """Native vector search capability using local document indexes or remote search servers"""
+    
+    SKILL_NAME = "native_vector_search"
+    SKILL_DESCRIPTION = "Search document indexes using vector similarity and keyword search (local or remote)"
+    SKILL_VERSION = "1.0.0"
+    REQUIRED_PACKAGES = []  # Optional packages checked at runtime
+    REQUIRED_ENV_VARS = []  # No required env vars since all config comes from params
+    
+    # Enable multiple instances support
+    SUPPORTS_MULTIPLE_INSTANCES = True
+    
+    def get_instance_key(self) -> str:
+        """
+        Get the key used to track this skill instance
+        
+        For native vector search, we use the tool name to differentiate instances
+        """
+        tool_name = self.params.get('tool_name', 'search_knowledge')
+        index_file = self.params.get('index_file', 'default')
+        return f"{self.SKILL_NAME}_{tool_name}_{index_file}"
+    
+    def setup(self) -> bool:
+        """Setup the native vector search skill"""
+        
+        # Check if search functionality is available
+        try:
+            from signalwire_agents.search import IndexBuilder, SearchEngine
+            from signalwire_agents.search.query_processor import preprocess_query
+            self.search_available = True
+        except ImportError as e:
+            self.search_available = False
+            self.import_error = str(e)
+            self.logger.warning(f"Search dependencies not available: {e}")
+            # Don't fail setup - we'll provide helpful error messages at runtime
+        
+        # Get configuration
+        self.tool_name = self.params.get('tool_name', 'search_knowledge')
+        self.index_file = self.params.get('index_file')
+        self.build_index = self.params.get('build_index', False)
+        self.source_dir = self.params.get('source_dir')
+        self.count = self.params.get('count', 5)
+        self.distance_threshold = self.params.get('distance_threshold', 0.0)
+        self.tags = self.params.get('tags', [])
+        self.no_results_message = self.params.get(
+            'no_results_message', 
+            "No information found for '{query}'"
+        )
+        self.response_prefix = self.params.get('response_prefix', '')
+        self.response_postfix = self.params.get('response_postfix', '')
+        
+        # Remote search server configuration
+        self.remote_url = self.params.get('remote_url')  # e.g., "http://localhost:8001"
+        self.index_name = self.params.get('index_name', 'default')  # For remote searches
+        
+        # SWAIG fields for function fillers
+        self.swaig_fields = self.params.get('swaig_fields', {})
+        
+        # NLP backend configuration
+        self.nlp_backend = self.params.get('nlp_backend', 'nltk')  # Default to faster NLTK
+        if self.nlp_backend not in ['nltk', 'spacy']:
+            self.logger.warning(f"Invalid nlp_backend '{self.nlp_backend}', using 'nltk'")
+            self.nlp_backend = 'nltk'
+        
+        # Auto-build index if requested and search is available
+        if self.build_index and self.source_dir and self.search_available:
+            if not self.index_file:
+                # Generate index filename from source directory
+                source_name = Path(self.source_dir).name
+                self.index_file = f"{source_name}.swsearch"
+            
+            # Build index if it doesn't exist
+            if not os.path.exists(self.index_file):
+                try:
+                    self.logger.info(f"Building search index from {self.source_dir}...")
+                    from signalwire_agents.search import IndexBuilder
+                    
+                    builder = IndexBuilder(verbose=self.params.get('verbose', False))
+                    builder.build_index(
+                        source_dir=self.source_dir,
+                        output_file=self.index_file,
+                        file_types=self.params.get('file_types', ['md', 'txt']),
+                        exclude_patterns=self.params.get('exclude_patterns'),
+                        tags=self.params.get('global_tags')
+                    )
+                    self.logger.info(f"Search index created: {self.index_file}")
+                except Exception as e:
+                    self.logger.error(f"Failed to build search index: {e}")
+                    self.search_available = False
+        
+        # Initialize search engine
+        self.search_engine = None
+        if self.search_available and self.index_file and os.path.exists(self.index_file):
+            try:
+                from signalwire_agents.search import SearchEngine
+                self.search_engine = SearchEngine(self.index_file)
+            except Exception as e:
+                self.logger.error(f"Failed to load search index {self.index_file}: {e}")
+                self.search_available = False
+        
+        # Check if we should use remote search mode
+        self.use_remote = bool(self.remote_url)
+        if self.use_remote:
+            self.logger.info(f"Using remote search server: {self.remote_url}")
+            # Test remote connection
+            try:
+                import requests
+                response = requests.get(f"{self.remote_url}/health", timeout=5)
+                if response.status_code == 200:
+                    self.logger.info("Remote search server is available")
+                    self.search_available = True
+                else:
+                    self.logger.error(f"Remote search server returned status {response.status_code}")
+                    self.search_available = False
+            except Exception as e:
+                self.logger.error(f"Failed to connect to remote search server: {e}")
+                self.search_available = False
+        
+        return True
+        
+    def register_tools(self) -> None:
+        """Register native vector search tool with the agent"""
+        
+        # Get description from params or use default
+        description = self.params.get(
+            'description', 
+            'Search the local knowledge base for information'
+        )
+        
+        self.agent.define_tool(
+            name=self.tool_name,
+            description=description,
+            parameters={
+                "query": {
+                    "type": "string",
+                    "description": "Search query or question"
+                },
+                "count": {
+                    "type": "integer",
+                    "description": f"Number of results to return (default: {self.count})",
+                    "default": self.count
+                }
+            },
+            handler=self._search_handler,
+            **self.swaig_fields
+        )
+        
+    def _search_handler(self, args, raw_data):
+        """Handle search requests"""
+        
+        if not self.search_available:
+            return SwaigFunctionResult(
+                f"Search functionality is not available. {getattr(self, 'import_error', '')}\n"
+                f"Install with: pip install signalwire-agents[search]"
+            )
+        
+        if not self.use_remote and not self.search_engine:
+            return SwaigFunctionResult(
+                f"Search index not available. "
+                f"{'Index file not found: ' + (self.index_file or 'not specified') if self.index_file else 'No index file configured'}"
+            )
+        
+        query = args.get('query', '').strip()
+        if not query:
+            return SwaigFunctionResult("Please provide a search query.")
+        
+        count = args.get('count', self.count)
+        
+        try:
+            # Preprocess the query
+            from signalwire_agents.search.query_processor import preprocess_query
+            enhanced = preprocess_query(query, language='en', vector=True, nlp_backend=self.nlp_backend)
+            
+            # Perform search (local or remote)
+            if self.use_remote:
+                results = self._search_remote(query, enhanced, count)
+            else:
+                results = self.search_engine.search(
+                    query_vector=enhanced.get('vector', []),
+                    enhanced_text=enhanced['enhanced_text'],
+                    count=count,
+                    distance_threshold=self.distance_threshold,
+                    tags=self.tags
+                )
+            
+            if not results:
+                no_results_msg = self.no_results_message.format(query=query)
+                if self.response_prefix:
+                    no_results_msg = f"{self.response_prefix} {no_results_msg}"
+                if self.response_postfix:
+                    no_results_msg = f"{no_results_msg} {self.response_postfix}"
+                return SwaigFunctionResult(no_results_msg)
+            
+            # Format results
+            response_parts = []
+            
+            # Add response prefix if configured
+            if self.response_prefix:
+                response_parts.append(self.response_prefix)
+            
+            response_parts.append(f"Found {len(results)} relevant results for '{query}':\n")
+            
+            for i, result in enumerate(results, 1):
+                filename = result['metadata']['filename']
+                section = result['metadata'].get('section', '')
+                score = result['score']
+                content = result['content']
+                
+                result_text = f"**Result {i}** (from {filename}"
+                if section:
+                    result_text += f", section: {section}"
+                result_text += f", relevance: {score:.2f})\n{content}\n"
+                
+                response_parts.append(result_text)
+            
+            # Add response postfix if configured
+            if self.response_postfix:
+                response_parts.append(self.response_postfix)
+            
+            return SwaigFunctionResult("\n".join(response_parts))
+            
+        except Exception as e:
+            return SwaigFunctionResult(f"Search error: {str(e)}")
+    
+    def _search_remote(self, query: str, enhanced: dict, count: int) -> list:
+        """Perform search using remote search server"""
+        try:
+            import requests
+            
+            search_request = {
+                "query": query,
+                "index_name": self.index_name,
+                "count": count,
+                "distance": self.distance_threshold,
+                "tags": self.tags,
+                "language": "en"
+            }
+            
+            response = requests.post(
+                f"{self.remote_url}/search",
+                json=search_request,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                # Convert remote response format to local format
+                results = []
+                for result in data.get('results', []):
+                    results.append({
+                        'content': result['content'],
+                        'score': result['score'],
+                        'metadata': result['metadata']
+                    })
+                return results
+            else:
+                self.logger.error(f"Remote search failed with status {response.status_code}: {response.text}")
+                return []
+                
+        except Exception as e:
+            self.logger.error(f"Remote search error: {e}")
+            return []
+    
+    def get_hints(self) -> List[str]:
+        """Return speech recognition hints for this skill"""
+        hints = [
+            "search",
+            "find",
+            "look up",
+            "documentation",
+            "knowledge base"
+        ]
+        
+        # Add custom hints from params
+        custom_hints = self.params.get('hints', [])
+        hints.extend(custom_hints)
+        
+        return hints
+        
+    def get_global_data(self) -> Dict[str, Any]:
+        """Return data to add to agent's global context"""
+        global_data = {}
+        
+        if self.search_engine:
+            try:
+                stats = self.search_engine.get_stats()
+                global_data['search_stats'] = stats
+            except:
+                pass
+        
+        return global_data
+        
+    def get_prompt_sections(self) -> List[Dict[str, Any]]:
+        """Return prompt sections to add to agent"""
+        search_mode = "remote search server" if self.use_remote else "local document indexes"
+        return [
+            {
+                "title": "Document Search",
+                "body": f"You can search {search_mode} using the {self.tool_name} tool.",
+                "bullets": [
+                    f"Use the {self.tool_name} tool when users ask questions about topics that might be in the indexed documents",
+                    "Search for relevant information using clear, specific queries",
+                    "Provide helpful summaries of the search results",
+                    "If no results are found, suggest the user try rephrasing their question or ask about different topics"
+                ]
+            }
+        ]
+    
+    def _add_prompt_section(self, agent):
+        """Add prompt section to agent (called during skill loading)"""
+        try:
+            agent.prompt_add_section(
+                title="Local Document Search",
+                body=f"You can search local document indexes using the {self.tool_name} tool.",
+                bullets=[
+                    f"Use the {self.tool_name} tool when users ask questions about topics that might be in the indexed documents",
+                    "Search for relevant information using clear, specific queries", 
+                    "Provide helpful summaries of the search results",
+                    "If no results are found, suggest the user try rephrasing their question or ask about different topics"
+                ]
+            )
+        except Exception as e:
+            self.logger.error(f"Failed to add prompt section: {e}")
+            # Continue without the prompt section
+    
+    def cleanup(self) -> None:
+        """Cleanup when skill is removed or agent shuts down"""
+        # Clean up any temporary files if we created them
+        if hasattr(self, '_temp_dirs'):
+            for temp_dir in self._temp_dirs:
+                try:
+                    shutil.rmtree(temp_dir)
+                except:
+                    pass 

signalwire_agents/skills/registry.py

@@ -11,18 +11,19 @@ import os
 import importlib
 import importlib.util
 import inspect
+import sys
 from typing import Dict, List, Type, Optional
 from pathlib import Path
-import logging
 
 from signalwire_agents.core.skill_base import SkillBase
+from signalwire_agents.core.logging_config import get_logger
 
 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.logger = get_logger("skill_registry")
         self._discovered = False
     
     def discover_skills(self) -> None:
@@ -39,7 +40,11 @@ class SkillRegistry:
                 self._load_skill_from_directory(item)
         
         self._discovered = True
-        self.logger.info(f"Discovered {len(self._skills)} skills")
+        
+        # Check if we're in raw mode (used by swaig-test --raw) and suppress logging
+        is_raw_mode = "--raw" in sys.argv
+        if not is_raw_mode:
+            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"""
@@ -89,7 +94,8 @@ class SkillRegistry:
                 "description": skill_class.SKILL_DESCRIPTION,
                 "version": skill_class.SKILL_VERSION,
                 "required_packages": skill_class.REQUIRED_PACKAGES,
-                "required_env_vars": skill_class.REQUIRED_ENV_VARS
+                "required_env_vars": skill_class.REQUIRED_ENV_VARS,
+                "supports_multiple_instances": skill_class.SUPPORTS_MULTIPLE_INSTANCES
             }
             for skill_class in self._skills.values()
         ]

signalwire_agents/skills/web_search/skill.py

@@ -21,9 +21,10 @@ 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):
+    def __init__(self, api_key: str, search_engine_id: str, max_content_length: int = 2000):
         self.api_key = api_key
         self.search_engine_id = search_engine_id
+        self.max_content_length = max_content_length
         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'
@@ -81,8 +82,8 @@ class GoogleSearchScraper:
             text = ' '.join(chunk for chunk in chunks if chunk)
             
             # Limit text length
-            if len(text) > 2000:
-                text = text[:2000] + "... [Content truncated]"
+            if len(text) > self.max_content_length:
+                text = text[:self.max_content_length] + "... [Content truncated]"
             
             return text
             
@@ -128,29 +129,63 @@ class WebSearchSkill(SkillBase):
     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"]
+    REQUIRED_ENV_VARS = []  # No required env vars since all config comes from params
+    
+    # Enable multiple instances support
+    SUPPORTS_MULTIPLE_INSTANCES = True
+    
+    def get_instance_key(self) -> str:
+        """
+        Get the key used to track this skill instance
+        
+        For web search, we use the search_engine_id to differentiate instances
+        """
+        search_engine_id = self.params.get('search_engine_id', 'default')
+        tool_name = self.params.get('tool_name', 'web_search')
+        return f"{self.SKILL_NAME}_{search_engine_id}_{tool_name}"
     
     def setup(self) -> bool:
         """Setup the web search skill"""
-        if not self.validate_env_vars() or not self.validate_packages():
+        # Validate required parameters
+        required_params = ['api_key', 'search_engine_id']
+        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
+        
+        if not self.validate_packages():
             return False
             
+        # Set parameters from config
+        self.api_key = self.params['api_key']
+        self.search_engine_id = self.params['search_engine_id']
+        
         # Set default parameters
         self.default_num_results = self.params.get('num_results', 1)
         self.default_delay = self.params.get('delay', 0)
+        self.max_content_length = self.params.get('max_content_length', 2000)
+        self.no_results_message = self.params.get('no_results_message', 
+            "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."
+        )
+        
+        # Tool name (for multiple instances)
+        self.tool_name = self.params.get('tool_name', 'web_search')
         
         # 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')
+            api_key=self.api_key,
+            search_engine_id=self.search_engine_id,
+            max_content_length=self.max_content_length
         )
         
         return True
         
     def register_tools(self) -> None:
         """Register web search tool with the agent"""
-        self.define_tool_with_swaig_fields(
-            name="web_search",
+        self.agent.define_tool(
+            name=self.tool_name,
             description="Search the web for information on any topic and return detailed results with content from multiple sources",
             parameters={
                 "query": {
@@ -158,7 +193,8 @@ class WebSearchSkill(SkillBase):
                     "description": "The search query - what you want to find information about"
                 }
             },
-            handler=self._web_search_handler
+            handler=self._web_search_handler,
+            **self.swaig_fields
         )
         
     def _web_search_handler(self, args, raw_data):
@@ -184,11 +220,9 @@ class WebSearchSkill(SkillBase):
             )
             
             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."
-                )
+                # Format the no results message with the query if it contains a placeholder
+                formatted_message = self.no_results_message.format(query=query) if '{query}' in self.no_results_message else self.no_results_message
+                return SwaigFunctionResult(formatted_message)
             
             response = f"I found {num_results} results for '{query}':\n\n{search_results}"
             return SwaigFunctionResult(response)
@@ -201,10 +235,12 @@ class WebSearchSkill(SkillBase):
         
     def get_hints(self) -> List[str]:
         """Return speech recognition hints"""
-        return [
-            "Google", "search", "internet", "web", "information",
-            "find", "look up", "research", "query", "results"
-        ]
+        # Currently no hints provided, but you could add them like:
+        # return [
+        #     "Google", "search", "internet", "web", "information",
+        #     "find", "look up", "research", "query", "results"
+        # ]
+        return []
         
     def get_global_data(self) -> Dict[str, Any]:
         """Return global data for agent context"""
@@ -218,9 +254,9 @@ class WebSearchSkill(SkillBase):
         return [
             {
                 "title": "Web Search Capability",
-                "body": "You can search the internet for current, accurate information on any topic.",
+                "body": f"You can search the internet for current, accurate information on any topic using the {self.tool_name} tool.",
                 "bullets": [
-                    "Use the web_search tool when users ask for information you need to look up",
+                    f"Use the {self.tool_name} 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/skills/wikipedia/__init__.py

@@ -0,0 +1,9 @@
+"""
+Wikipedia Search Skill
+
+This skill provides Wikipedia search capabilities using the Wikipedia API.
+"""
+
+from .skill import WikipediaSearchSkill
+
+__all__ = ['WikipediaSearchSkill']