signalwire-agents 0.1.37__py3-none-any.whl → 0.1.38__py3-none-any.whl

signalwire_agents/search/search_service.py

@@ -82,16 +82,21 @@ else:
             self.query_analysis = query_analysis
 
 class SearchService:
-    """Local search service with HTTP API"""
+    """Local search service with HTTP API supporting both SQLite and pgvector backends"""
     
     def __init__(self, port: int = 8001, indexes: Dict[str, str] = None, 
                  basic_auth: Optional[Tuple[str, str]] = None,
-                 config_file: Optional[str] = None):
+                 config_file: Optional[str] = None,
+                 backend: str = 'sqlite',
+                 connection_string: Optional[str] = None):
         # Load configuration first
         self._load_config(config_file)
         
         # Override with constructor params if provided
         self.port = port
+        self.backend = backend
+        self.connection_string = connection_string
+        
         if indexes is not None:
             self.indexes = indexes
         
@@ -119,6 +124,8 @@ class SearchService:
         """Load configuration from file if available"""
         # Initialize defaults
         self.indexes = {}
+        self.backend = 'sqlite'
+        self.connection_string = None
         
         # Find config file
         if not config_file:
@@ -140,6 +147,12 @@ class SearchService:
             if 'port' in service_config:
                 self.port = int(service_config['port'])
             
+            if 'backend' in service_config:
+                self.backend = service_config['backend']
+                
+            if 'connection_string' in service_config:
+                self.connection_string = service_config['connection_string']
+            
             if 'indexes' in service_config and isinstance(service_config['indexes'], dict):
                 self.indexes = service_config['indexes']
     
@@ -225,9 +238,11 @@ class SearchService:
         async def health():
             return {
                 "status": "healthy", 
+                "backend": self.backend,
                 "indexes": list(self.indexes.keys()),
                 "ssl_enabled": self.security.ssl_enabled,
-                "auth_required": bool(security)
+                "auth_required": bool(security),
+                "connection_string": self.connection_string if self.backend == 'pgvector' else None
             }
         
         @self.app.post("/reload_index")
@@ -236,47 +251,83 @@ class SearchService:
             index_path: str,
             credentials: HTTPBasicCredentials = None if not security else Depends(security)
         ):
-            """Reload or add new index"""
+            """Reload or add new index/collection"""
             if security:
                 self._get_current_username(credentials)
-                
-            self.indexes[index_name] = index_path
-            self.search_engines[index_name] = SearchEngine(index_path, self.model)
-            return {"status": "reloaded", "index": index_name}
+            
+            if self.backend == 'pgvector':
+                # For pgvector, index_path is actually the collection name
+                self.indexes[index_name] = index_path
+                try:
+                    self.search_engines[index_name] = SearchEngine(
+                        backend='pgvector',
+                        connection_string=self.connection_string,
+                        collection_name=index_path
+                    )
+                    return {"status": "reloaded", "index": index_name, "backend": "pgvector"}
+                except Exception as e:
+                    raise HTTPException(status_code=500, detail=f"Failed to load pgvector collection: {e}")
+            else:
+                # SQLite backend
+                self.indexes[index_name] = index_path
+                self.search_engines[index_name] = SearchEngine(index_path, self.model)
+                return {"status": "reloaded", "index": index_name, "backend": "sqlite"}
     
     def _load_resources(self):
         """Load embedding model and search indexes"""
-        # Load model (shared across all indexes)
-        if self.indexes and SentenceTransformer:
-            # Get model name from first index
-            sample_index = next(iter(self.indexes.values()))
-            model_name = self._get_model_name(sample_index)
-            try:
-                self.model = SentenceTransformer(model_name)
-            except Exception as e:
-                logger.warning(f"Could not load sentence transformer model: {e}")
-                self.model = None
-        
-        # Load search engines for each index
-        for index_name, index_path in self.indexes.items():
-            try:
-                self.search_engines[index_name] = SearchEngine(index_path, self.model)
-            except Exception as e:
-                logger.error(f"Error loading search engine for {index_name}: {e}")
+        if self.backend == 'pgvector':
+            # For pgvector, we don't need to load a model locally
+            # The embeddings are already stored in the database
+            # Load search engines for each collection
+            for collection_name in self.indexes.keys():
+                try:
+                    self.search_engines[collection_name] = SearchEngine(
+                        backend='pgvector',
+                        connection_string=self.connection_string,
+                        collection_name=collection_name
+                    )
+                    logger.info(f"Loaded pgvector collection: {collection_name}")
+                except Exception as e:
+                    logger.error(f"Error loading pgvector collection {collection_name}: {e}")
+        else:
+            # SQLite backend - original behavior
+            # Load model (shared across all indexes)
+            if self.indexes and SentenceTransformer:
+                # Get model name from first index
+                sample_index = next(iter(self.indexes.values()))
+                model_name = self._get_model_name(sample_index)
+                try:
+                    self.model = SentenceTransformer(model_name)
+                except Exception as e:
+                    logger.warning(f"Could not load sentence transformer model: {e}")
+                    self.model = None
+            
+            # Load search engines for each index
+            for index_name, index_path in self.indexes.items():
+                try:
+                    self.search_engines[index_name] = SearchEngine(index_path, self.model)
+                except Exception as e:
+                    logger.error(f"Error loading search engine for {index_name}: {e}")
     
     def _get_model_name(self, index_path: str) -> str:
         """Get embedding model name from index config"""
-        try:
-            import sqlite3
-            conn = sqlite3.connect(index_path)
-            cursor = conn.cursor()
-            cursor.execute("SELECT value FROM config WHERE key = 'embedding_model'")
-            result = cursor.fetchone()
-            conn.close()
-            return result[0] if result else 'sentence-transformers/all-mpnet-base-v2'
-        except Exception as e:
-            logger.warning(f"Could not get model name from index: {e}")
+        if self.backend == 'pgvector':
+            # For pgvector, we might want to store model info in the database
+            # For now, return default model
             return 'sentence-transformers/all-mpnet-base-v2'
+        else:
+            # SQLite backend
+            try:
+                import sqlite3
+                conn = sqlite3.connect(index_path)
+                cursor = conn.cursor()
+                cursor.execute("SELECT value FROM config WHERE key = 'embedding_model'")
+                result = cursor.fetchone()
+                conn.close()
+                return result[0] if result else 'sentence-transformers/all-mpnet-base-v2'
+            except Exception as e:
+                logger.warning(f"Could not get model name from index: {e}")
+                return 'sentence-transformers/all-mpnet-base-v2'
     
     async def _handle_search(self, request: SearchRequest) -> SearchResponse:
         """Handle search request"""

signalwire_agents/skills/api_ninjas_trivia/skill.py

@@ -198,4 +198,40 @@ class ApiNinjasTriviaSkill(SkillBase):
             }
         }
         
-        return [tool] 
+        return [tool]
+    
+    @classmethod
+    def get_parameter_schema(cls) -> Dict[str, Dict[str, Any]]:
+        """
+        Get the parameter schema for the API Ninjas Trivia skill.
+        
+        Returns parameter definitions for GUI configuration.
+        """
+        schema = super().get_parameter_schema()
+        
+        # Build categories enum description
+        category_options = []
+        for key, desc in cls.VALID_CATEGORIES.items():
+            category_options.append(f"{key} ({desc})")
+        
+        schema.update({
+            "api_key": {
+                "type": "string",
+                "description": "API Ninjas API key",
+                "required": True,
+                "hidden": True,
+                "env_var": "API_NINJAS_KEY"
+            },
+            "categories": {
+                "type": "array",
+                "description": "List of trivia categories to enable. Available: " + ", ".join(category_options),
+                "default": list(cls.VALID_CATEGORIES.keys()),
+                "required": False,
+                "items": {
+                    "type": "string",
+                    "enum": list(cls.VALID_CATEGORIES.keys())
+                }
+            }
+        })
+        
+        return schema 

signalwire_agents/skills/datasphere/skill.py

@@ -26,6 +26,88 @@ class DataSphereSkill(SkillBase):
     # Enable multiple instances support
     SUPPORTS_MULTIPLE_INSTANCES = True
     
+    @classmethod
+    def get_parameter_schema(cls) -> Dict[str, Dict[str, Any]]:
+        """Get parameter schema for DataSphere skill"""
+        schema = super().get_parameter_schema()
+        schema.update({
+            "space_name": {
+                "type": "string",
+                "description": "SignalWire space name (e.g., 'mycompany' from mycompany.signalwire.com)",
+                "required": True
+            },
+            "project_id": {
+                "type": "string",
+                "description": "SignalWire project ID",
+                "required": True,
+                "env_var": "SIGNALWIRE_PROJECT_ID"
+            },
+            "token": {
+                "type": "string",
+                "description": "SignalWire API token",
+                "required": True,
+                "hidden": True,
+                "env_var": "SIGNALWIRE_TOKEN"
+            },
+            "document_id": {
+                "type": "string",
+                "description": "DataSphere document ID to search within",
+                "required": True
+            },
+            "count": {
+                "type": "integer",
+                "description": "Number of search results to return",
+                "default": 1,
+                "required": False,
+                "minimum": 1,
+                "maximum": 10
+            },
+            "distance": {
+                "type": "number",
+                "description": "Maximum distance threshold for results (lower is more relevant)",
+                "default": 3.0,
+                "required": False,
+                "minimum": 0.0,
+                "maximum": 10.0
+            },
+            "tags": {
+                "type": "array",
+                "description": "Tags to filter search results",
+                "required": False,
+                "items": {
+                    "type": "string"
+                }
+            },
+            "language": {
+                "type": "string",
+                "description": "Language code for query expansion (e.g., 'en', 'es')",
+                "required": False
+            },
+            "pos_to_expand": {
+                "type": "array",
+                "description": "Parts of speech to expand with synonyms",
+                "required": False,
+                "items": {
+                    "type": "string",
+                    "enum": ["NOUN", "VERB", "ADJ", "ADV"]
+                }
+            },
+            "max_synonyms": {
+                "type": "integer",
+                "description": "Maximum number of synonyms to use for query expansion",
+                "required": False,
+                "minimum": 1,
+                "maximum": 10
+            },
+            "no_results_message": {
+                "type": "string",
+                "description": "Message to return when no results are found",
+                "default": "I couldn't find any relevant information for '{query}' in the knowledge base. Try rephrasing your question or asking about a different topic.",
+                "required": False
+            }
+        })
+        return schema
+    
     def get_instance_key(self) -> str:
         """
         Get the key used to track this skill instance

signalwire_agents/skills/datasphere_serverless/skill.py

@@ -26,6 +26,88 @@ class DataSphereServerlessSkill(SkillBase):
     # Enable multiple instances support
     SUPPORTS_MULTIPLE_INSTANCES = True
     
+    @classmethod
+    def get_parameter_schema(cls) -> Dict[str, Dict[str, Any]]:
+        """Get parameter schema for DataSphere Serverless skill"""
+        schema = super().get_parameter_schema()
+        schema.update({
+            "space_name": {
+                "type": "string",
+                "description": "SignalWire space name (e.g., 'mycompany' from mycompany.signalwire.com)",
+                "required": True
+            },
+            "project_id": {
+                "type": "string",
+                "description": "SignalWire project ID",
+                "required": True,
+                "env_var": "SIGNALWIRE_PROJECT_ID"
+            },
+            "token": {
+                "type": "string",
+                "description": "SignalWire API token",
+                "required": True,
+                "hidden": True,
+                "env_var": "SIGNALWIRE_TOKEN"
+            },
+            "document_id": {
+                "type": "string",
+                "description": "DataSphere document ID to search within",
+                "required": True
+            },
+            "count": {
+                "type": "integer",
+                "description": "Number of search results to return",
+                "default": 1,
+                "required": False,
+                "minimum": 1,
+                "maximum": 10
+            },
+            "distance": {
+                "type": "number",
+                "description": "Maximum distance threshold for results (lower is more relevant)",
+                "default": 3.0,
+                "required": False,
+                "minimum": 0.0,
+                "maximum": 10.0
+            },
+            "tags": {
+                "type": "array",
+                "description": "Tags to filter search results",
+                "required": False,
+                "items": {
+                    "type": "string"
+                }
+            },
+            "language": {
+                "type": "string",
+                "description": "Language code for query expansion (e.g., 'en', 'es')",
+                "required": False
+            },
+            "pos_to_expand": {
+                "type": "array",
+                "description": "Parts of speech to expand with synonyms",
+                "required": False,
+                "items": {
+                    "type": "string",
+                    "enum": ["NOUN", "VERB", "ADJ", "ADV"]
+                }
+            },
+            "max_synonyms": {
+                "type": "integer",
+                "description": "Maximum number of synonyms to use for query expansion",
+                "required": False,
+                "minimum": 1,
+                "maximum": 10
+            },
+            "no_results_message": {
+                "type": "string",
+                "description": "Message to return when no results are found",
+                "default": "I couldn't find any relevant information for '{query}' in the knowledge base. Try rephrasing your question or asking about a different topic.",
+                "required": False
+            }
+        })
+        return schema
+    
     def get_instance_key(self) -> str:
         """
         Get the key used to track this skill instance

signalwire_agents/skills/joke/skill.py

@@ -23,6 +23,27 @@ class JokeSkill(SkillBase):
     REQUIRED_PACKAGES = []  # DataMap doesn't require local packages
     REQUIRED_ENV_VARS = []  # API key comes from parameters
     
+    @classmethod
+    def get_parameter_schema(cls) -> Dict[str, Dict[str, Any]]:
+        """Get parameter schema for joke skill"""
+        schema = super().get_parameter_schema()
+        schema.update({
+            "api_key": {
+                "type": "string",
+                "description": "API Ninjas API key for joke service",
+                "required": True,
+                "hidden": True,
+                "env_var": "API_NINJAS_KEY"
+            },
+            "tool_name": {
+                "type": "string",
+                "description": "Custom name for the joke tool",
+                "default": "get_joke",
+                "required": False
+            }
+        })
+        return schema
+        
     def setup(self) -> bool:
         """Setup the joke skill"""
         # Validate required parameters

signalwire_agents/skills/mcp_gateway/skill.py

@@ -33,6 +33,88 @@ class MCPGatewaySkill(SkillBase):
     REQUIRED_PACKAGES = ["requests"]
     REQUIRED_ENV_VARS = []
     
+    @classmethod
+    def get_parameter_schema(cls) -> Dict[str, Dict[str, Any]]:
+        """Get parameter schema for MCP Gateway skill"""
+        schema = super().get_parameter_schema()
+        schema.update({
+            "gateway_url": {
+                "type": "string",
+                "description": "URL of the MCP Gateway service",
+                "required": True
+            },
+            "auth_token": {
+                "type": "string",
+                "description": "Bearer token for authentication (alternative to basic auth)",
+                "required": False,
+                "hidden": True,
+                "env_var": "MCP_GATEWAY_AUTH_TOKEN"
+            },
+            "auth_user": {
+                "type": "string",
+                "description": "Username for basic authentication (required if auth_token not provided)",
+                "required": False,
+                "env_var": "MCP_GATEWAY_AUTH_USER"
+            },
+            "auth_password": {
+                "type": "string",
+                "description": "Password for basic authentication (required if auth_token not provided)",
+                "required": False,
+                "hidden": True,
+                "env_var": "MCP_GATEWAY_AUTH_PASSWORD"
+            },
+            "services": {
+                "type": "array",
+                "description": "List of MCP services to connect to (empty for all available)",
+                "default": [],
+                "required": False,
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "name": {
+                            "type": "string",
+                            "description": "Service name"
+                        },
+                        "tools": {
+                            "type": ["string", "array"],
+                            "description": "Tools to expose ('*' for all, or list of tool names)"
+                        }
+                    }
+                }
+            },
+            "session_timeout": {
+                "type": "integer",
+                "description": "Session timeout in seconds",
+                "default": 300,
+                "required": False
+            },
+            "tool_prefix": {
+                "type": "string",
+                "description": "Prefix for registered SWAIG function names",
+                "default": "mcp_",
+                "required": False
+            },
+            "retry_attempts": {
+                "type": "integer",
+                "description": "Number of retry attempts for failed requests",
+                "default": 3,
+                "required": False
+            },
+            "request_timeout": {
+                "type": "integer",
+                "description": "Request timeout in seconds",
+                "default": 30,
+                "required": False
+            },
+            "verify_ssl": {
+                "type": "boolean",
+                "description": "Verify SSL certificates",
+                "default": True,
+                "required": False
+            }
+        })
+        return schema
+    
     def setup(self) -> bool:
         """Setup and validate skill configuration"""
         # Check for auth method - either token or basic auth