signalwire-agents 0.1.47__py3-none-any.whl → 0.1.48__py3-none-any.whl

signalwire_agents/search/search_service.py

@@ -31,7 +31,7 @@ try:
 except ImportError:
     SentenceTransformer = None
 
-from .query_processor import preprocess_query
+from .query_processor import preprocess_query, set_global_model
 from .search_engine import SearchEngine
 from signalwire_agents.core.security_config import SecurityConfig
 from signalwire_agents.core.config_loader import ConfigLoader
@@ -39,6 +39,11 @@ from signalwire_agents.core.logging_config import get_logger
 
 logger = get_logger("search_service")
 
+# Simple LRU cache for query results
+from functools import lru_cache
+import hashlib
+import json
+
 # Pydantic models for API
 if BaseModel:
     class SearchRequest(BaseModel):
@@ -81,6 +86,17 @@ else:
             self.results = results
             self.query_analysis = query_analysis
 
+def _cache_key(query: str, index_name: str, count: int, tags: Optional[List[str]] = None) -> str:
+    """Generate cache key for query results"""
+    key_data = {
+        'query': query.lower().strip(),
+        'index': index_name,
+        'count': count,
+        'tags': sorted(tags) if tags else []
+    }
+    key_str = json.dumps(key_data, sort_keys=True)
+    return hashlib.md5(key_str.encode()).hexdigest()
+
 class SearchService:
     """Local search service with HTTP API supporting both SQLite and pgvector backends"""
     
@@ -102,6 +118,8 @@ class SearchService:
         
         self.search_engines = {}
         self.model = None
+        self._query_cache = {}  # Simple query result cache
+        self._cache_size = 100  # Max number of cached queries
         
         # Load security configuration with optional config file
         self.security = SecurityConfig(config_file=config_file, service_name="search")
@@ -270,7 +288,11 @@ class SearchService:
             else:
                 # SQLite backend
                 self.indexes[index_name] = index_path
-                self.search_engines[index_name] = SearchEngine(index_path, self.model)
+                self.search_engines[index_name] = SearchEngine(
+                    backend='sqlite',
+                    index_path=index_path,
+                    model=self.model
+                )
                 return {"status": "reloaded", "index": index_name, "backend": "sqlite"}
     
     def _load_resources(self):
@@ -298,6 +320,8 @@ class SearchService:
                 model_name = self._get_model_name(sample_index)
                 try:
                     self.model = SentenceTransformer(model_name)
+                    # Set the global model for query processor to avoid reloading
+                    set_global_model(self.model)
                 except Exception as e:
                     logger.warning(f"Could not load sentence transformer model: {e}")
                     self.model = None
@@ -305,7 +329,11 @@ class SearchService:
             # 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)
+                    self.search_engines[index_name] = SearchEngine(
+                        backend='sqlite',
+                        index_path=index_path,
+                        model=self.model
+                    )
                 except Exception as e:
                     logger.error(f"Error loading search engine for {index_name}: {e}")
     
@@ -330,21 +358,34 @@ class SearchService:
                 return 'sentence-transformers/all-mpnet-base-v2'
     
     async def _handle_search(self, request: SearchRequest) -> SearchResponse:
-        """Handle search request"""
+        """Handle search request with caching"""
         if request.index_name not in self.search_engines:
             if HTTPException:
                 raise HTTPException(status_code=404, detail=f"Index '{request.index_name}' not found")
             else:
                 raise ValueError(f"Index '{request.index_name}' not found")
         
+        # Check cache first
+        cache_key = _cache_key(request.query, request.index_name, request.count, request.tags)
+        if cache_key in self._query_cache:
+            logger.info(f"Cache hit for query: {request.query[:50]}...")
+            return self._query_cache[cache_key]
+        
         search_engine = self.search_engines[request.index_name]
         
+        # Get model name from the search engine config
+        model_name = None
+        if hasattr(search_engine, 'config') and search_engine.config:
+            # pgvector uses 'model_name', sqlite uses 'embedding_model'
+            model_name = search_engine.config.get('model_name') or search_engine.config.get('embedding_model')
+        
         # Enhance query
         try:
             enhanced = preprocess_query(
                 request.query,
                 language=request.language or 'auto',
-                vector=True
+                vector=True,
+                model_name=model_name  # Pass the correct model!
             )
         except Exception as e:
             logger.error(f"Error preprocessing query: {e}")
@@ -377,7 +418,7 @@ class SearchService:
             for result in results
         ]
         
-        return SearchResponse(
+        response = SearchResponse(
             results=search_results,
             query_analysis={
                 'original_query': request.query,
@@ -386,6 +427,15 @@ class SearchService:
                 'pos_analysis': enhanced.get('POS')
             }
         )
+        
+        # Cache the result
+        if len(self._query_cache) >= self._cache_size:
+            # Simple FIFO eviction
+            first_key = next(iter(self._query_cache))
+            del self._query_cache[first_key]
+        self._query_cache[cache_key] = response
+        
+        return response
     
     def search_direct(self, query: str, index_name: str = "default", count: int = 3, 
                      distance: float = 0.0, tags: Optional[List[str]] = None, 

signalwire_agents/skills/native_vector_search/skill.py

@@ -136,6 +136,11 @@ class NativeVectorSearchSkill(SkillBase):
                 "default": "",
                 "required": False
             },
+            "response_format_callback": {
+                "type": "callable",
+                "description": "Optional callback function to format/transform the response. Called with (response, agent, query, results, args). Must return a string.",
+                "required": False
+            },
             "description": {
                 "type": "string",
                 "description": "Tool description",
@@ -192,6 +197,26 @@ class NativeVectorSearchSkill(SkillBase):
                 "description": "Enable verbose logging",
                 "default": False,
                 "required": False
+            },
+            "keyword_weight": {
+                "type": "number",
+                "description": "Manual keyword weight (0.0-1.0). Overrides automatic weight detection",
+                "default": None,
+                "required": False,
+                "minimum": 0.0,
+                "maximum": 1.0
+            },
+            "model_name": {
+                "type": "string",
+                "description": "Embedding model to use. Options: 'mini' (fastest, 384 dims), 'base' (balanced, 768 dims), 'large' (same as base). Or specify full model name like 'sentence-transformers/all-MiniLM-L6-v2'",
+                "default": "mini",
+                "required": False
+            },
+            "overwrite": {
+                "type": "boolean",
+                "description": "Overwrite existing pgvector collection when building index (pgvector backend only)",
+                "default": False,
+                "required": False
             }
         })
         return schema
@@ -226,11 +251,29 @@ class NativeVectorSearchSkill(SkillBase):
         )
         self.response_prefix = self.params.get('response_prefix', '')
         self.response_postfix = self.params.get('response_postfix', '')
+        self.response_format_callback = self.params.get('response_format_callback')
+        self.keyword_weight = self.params.get('keyword_weight')
+        self.model_name = self.params.get('model_name', 'mini')
         
         # Remote search server configuration
-        self.remote_url = self.params.get('remote_url')  # e.g., "http://localhost:8001"
+        self.remote_url = self.params.get('remote_url')  # e.g., "http://user:pass@localhost:8001"
         self.index_name = self.params.get('index_name', 'default')  # For remote searches
         
+        # Parse auth from URL if present
+        self.remote_auth = None
+        self.remote_base_url = self.remote_url
+        if self.remote_url:
+            from urllib.parse import urlparse
+            parsed = urlparse(self.remote_url)
+            if parsed.username and parsed.password:
+                self.remote_auth = (parsed.username, parsed.password)
+                # Reconstruct URL without auth for display
+                self.remote_base_url = f"{parsed.scheme}://{parsed.hostname}"
+                if parsed.port:
+                    self.remote_base_url += f":{parsed.port}"
+                if parsed.path:
+                    self.remote_base_url += parsed.path
+        
         # SWAIG fields for function fillers
         self.swaig_fields = self.params.get('swaig_fields', {})
         
@@ -244,11 +287,20 @@ class NativeVectorSearchSkill(SkillBase):
             # Test remote connection (lightweight check)
             try:
                 import requests
-                response = requests.get(f"{self.remote_url}/health", timeout=5)
+                # Use parsed base URL and auth
+                response = requests.get(
+                    f"{self.remote_base_url}/health", 
+                    auth=self.remote_auth,
+                    timeout=5
+                )
                 if response.status_code == 200:
-                    self.logger.info("Remote search server is available")
+                    self.logger.info(f"Remote search server is available at {self.remote_base_url}")
                     self.search_available = True
                     return True  # Success - skip all local setup
+                elif response.status_code == 401:
+                    self.logger.error("Authentication failed for remote search server. Check credentials.")
+                    self.search_available = False
+                    return False
                 else:
                     self.logger.error(f"Remote search server returned status {response.status_code}")
                     self.search_available = False
@@ -295,32 +347,72 @@ class NativeVectorSearchSkill(SkillBase):
         
         # 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),
-                        index_nlp_backend=self.index_nlp_backend
-                    )
-                    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
+            # Handle auto-build for different backends
+            if self.backend == 'sqlite':
+                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
+                        
+                        # Resolve model alias if needed
+                        from signalwire_agents.search.models import resolve_model_alias
+                        model_to_use = resolve_model_alias(self.model_name)
+                        
+                        builder = IndexBuilder(
+                            model_name=model_to_use,
+                            verbose=self.params.get('verbose', False),
+                            index_nlp_backend=self.index_nlp_backend
+                        )
+                        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
+                        
+            elif self.backend == 'pgvector':
+                # Auto-build for pgvector
+                if self.connection_string and self.collection_name:
+                    try:
+                        self.logger.info(f"Building pgvector index from {self.source_dir}...")
+                        from signalwire_agents.search import IndexBuilder
+                        from signalwire_agents.search.models import resolve_model_alias
+                        
+                        model_to_use = resolve_model_alias(self.model_name)
+                        
+                        builder = IndexBuilder(
+                            backend='pgvector',
+                            connection_string=self.connection_string,
+                            model_name=model_to_use,
+                            verbose=self.params.get('verbose', False),
+                            index_nlp_backend=self.index_nlp_backend
+                        )
+                        
+                        builder.build_index(
+                            source_dir=self.source_dir,
+                            output_file=self.collection_name,  # pgvector uses this as collection name
+                            file_types=self.params.get('file_types', ['md', 'txt']),
+                            exclude_patterns=self.params.get('exclude_patterns'),
+                            tags=self.params.get('global_tags'),
+                            overwrite=self.params.get('overwrite', False)
+                        )
+                        self.logger.info(f"pgvector collection created: {self.collection_name}")
+                    except Exception as e:
+                        self.logger.error(f"Failed to build pgvector index: {e}")
+                        # Don't set search_available to False - we might be connecting to existing collection
+                else:
+                    self.logger.warning("pgvector auto-build requires connection_string and collection_name")
         
         # Initialize local search engine
         self.search_engine = None
@@ -347,6 +439,12 @@ class NativeVectorSearchSkill(SkillBase):
                 try:
                     from signalwire_agents.search import SearchEngine
                     self.search_engine = SearchEngine(backend='sqlite', index_path=self.index_file)
+                    # The SearchEngine will auto-detect the model from the index
+                    # Get the model name from config for query processing
+                    if hasattr(self.search_engine, 'config'):
+                        index_model = self.search_engine.config.get('embedding_model')
+                        if index_model:
+                            self.logger.info(f"Using model from index: {index_model}")
                 except Exception as e:
                     self.logger.error(f"Failed to load search index {self.index_file}: {e}")
                     self.search_available = False
@@ -451,13 +549,29 @@ class NativeVectorSearchSkill(SkillBase):
             else:
                 # For local searches, preprocess the query locally
                 from signalwire_agents.search.query_processor import preprocess_query
-                enhanced = preprocess_query(query, language='en', vector=True, query_nlp_backend=self.query_nlp_backend)
+                
+                # Get model name from index config if available
+                model_for_query = None
+                if hasattr(self.search_engine, 'config'):
+                    model_for_query = self.search_engine.config.get('embedding_model')
+                
+                enhanced = preprocess_query(
+                    query, 
+                    language='en', 
+                    vector=True, 
+                    query_nlp_backend=self.query_nlp_backend,
+                    model_name=model_for_query,  # Use model from index
+                    preserve_original=True,  # Keep original query terms
+                    max_synonyms=2  # Reduce synonym expansion
+                )
                 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
+                    tags=self.tags,
+                    keyword_weight=self.keyword_weight,
+                    original_query=query  # Pass original for exact match boosting
                 )
             
             if not results:
@@ -466,6 +580,25 @@ class NativeVectorSearchSkill(SkillBase):
                     no_results_msg = f"{self.response_prefix} {no_results_msg}"
                 if self.response_postfix:
                     no_results_msg = f"{no_results_msg} {self.response_postfix}"
+                
+                # Apply custom formatting callback for no results case
+                if self.response_format_callback and callable(self.response_format_callback):
+                    try:
+                        callback_context = {
+                            'response': no_results_msg,
+                            'agent': self.agent,
+                            'query': query,
+                            'results': [],  # Empty results
+                            'args': args,
+                            'count': count,
+                            'skill': self
+                        }
+                        formatted_response = self.response_format_callback(**callback_context)
+                        if isinstance(formatted_response, str):
+                            no_results_msg = formatted_response
+                    except Exception as e:
+                        self.logger.error(f"Error in response_format_callback (no results): {e}", exc_info=True)
+                
                 return SwaigFunctionResult(no_results_msg)
             
             # Format results
@@ -483,9 +616,20 @@ class NativeVectorSearchSkill(SkillBase):
                 score = result['score']
                 content = result['content']
                 
+                # Get tags from either top level or metadata
+                tags = result.get('tags', [])
+                if not tags and 'metadata' in result['metadata'] and 'tags' in result['metadata']['metadata']:
+                    # Handle double-nested metadata from older indexes
+                    tags = result['metadata']['metadata']['tags']
+                elif not tags and 'tags' in result['metadata']:
+                    # Check in metadata directly
+                    tags = result['metadata']['tags']
+                
                 result_text = f"**Result {i}** (from {filename}"
                 if section:
                     result_text += f", section: {section}"
+                if tags:
+                    result_text += f", tags: {', '.join(tags)}"
                 result_text += f", relevance: {score:.2f})\n{content}\n"
                 
                 response_parts.append(result_text)
@@ -494,7 +638,37 @@ class NativeVectorSearchSkill(SkillBase):
             if self.response_postfix:
                 response_parts.append(self.response_postfix)
             
-            return SwaigFunctionResult("\n".join(response_parts))
+            # Build the initial response
+            response = "\n".join(response_parts)
+            
+            # Apply custom formatting callback if provided
+            if self.response_format_callback and callable(self.response_format_callback):
+                try:
+                    # Prepare callback context
+                    callback_context = {
+                        'response': response,
+                        'agent': self.agent,
+                        'query': query,
+                        'results': results,
+                        'args': args,
+                        'count': count,
+                        'skill': self
+                    }
+                    
+                    # Call the callback
+                    formatted_response = self.response_format_callback(**callback_context)
+                    
+                    # Validate callback returned a string
+                    if isinstance(formatted_response, str):
+                        response = formatted_response
+                    else:
+                        self.logger.warning(f"response_format_callback returned non-string type: {type(formatted_response)}")
+                        
+                except Exception as e:
+                    self.logger.error(f"Error in response_format_callback: {e}", exc_info=True)
+                    # Continue with original response if callback fails
+            
+            return SwaigFunctionResult(response)
             
         except Exception as e:
             # Log the full error details for debugging
@@ -531,8 +705,9 @@ class NativeVectorSearchSkill(SkillBase):
             }
             
             response = requests.post(
-                f"{self.remote_url}/search",
+                f"{self.remote_base_url}/search",
                 json=search_request,
+                auth=self.remote_auth,
                 timeout=30
             )
             

{signalwire_agents-0.1.47.dist-info → signalwire_agents-0.1.48.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalwire_agents
-Version: 0.1.47
+Version: 0.1.48
 Summary: SignalWire AI Agents SDK
 Author-email: SignalWire Team <info@signalwire.com>
 License: MIT

{signalwire_agents-0.1.47.dist-info → signalwire_agents-0.1.48.dist-info}/RECORD

@@ -1,9 +1,9 @@
-signalwire_agents/__init__.py,sha256=VjQ0bhIJ_R2wvxwnWiIyZzzGP7hVFpdeOoAgEuhZ_gg,5031
+signalwire_agents/__init__.py,sha256=Y3xbhZP88Av8BKn1LIevDlrYWfFDg773OjLTcMBxAvo,5031
 signalwire_agents/agent_server.py,sha256=x9HyWia8D3r6KMqY-Q4DtNVivfJWLTx8B-KzUI8okuA,26880
 signalwire_agents/schema.json,sha256=6-7ccbt39iM1CO36dOfvupRPfd0gnQ0XoAdyo-EFyjo,238042
 signalwire_agents/agents/bedrock.py,sha256=J582gooNtxtep4xdVOfyDzRtHp_XrurPMS93xf2Xod0,10836
 signalwire_agents/cli/__init__.py,sha256=XbxAQFaCIdGXIXJiriVBWoFPOJsC401u21588nO4TG8,388
-signalwire_agents/cli/build_search.py,sha256=UXKyW27Xr-gGO7ooztMLb3YD_tEdJO6ptDSIUGgwZ0w,32035
+signalwire_agents/cli/build_search.py,sha256=Yh5hNM0ur88UMuKo5ZDoN_bAzBGpj2RG1Ys1_3xlfUc,54144
 signalwire_agents/cli/config.py,sha256=2i4e0BArdKsaXxjeueYYRNke7GWicHPYC2wuitVrP7A,2541
 signalwire_agents/cli/swaig_test_wrapper.py,sha256=t63HQpEc1Up5AcysEHP1OsEQcgSMKH-9H1L2IhFso18,1533
 signalwire_agents/cli/test_swaig.py,sha256=-v-XjTUWZNxmMJuOF5_cB1Jz8x8emJoqgqS_8jLeT4Y,31487
@@ -69,13 +69,15 @@ signalwire_agents/prefabs/faq_bot.py,sha256=cUuHhnDB8S4aVg-DiQe4jBmCAPrYQrND_Mff
 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=Q6EDRu9GKJkWLeJREvppAuxuZ5wSiZXoolp7CgKK2f4,47941
-signalwire_agents/search/index_builder.py,sha256=bjctP8SVG8QMIJyiqRnjZEi_OKohx2jyuk2vneERslk,29276
-signalwire_agents/search/pgvector_backend.py,sha256=7OerJvzCGQigbb_RnV2M5PEOHR2EUMBn4n2bHML08I0,19172
-signalwire_agents/search/query_processor.py,sha256=WMm_jjArQ6-Jpy0Cc0sUI4saidOtDRKx_XLv0qi3N3k,16739
-signalwire_agents/search/search_engine.py,sha256=rGRTs8qRX4biXhsOg7jnt6YvoetoN_KG3ByKwtX7h6o,16635
-signalwire_agents/search/search_service.py,sha256=lni6tRFonv0EHNpSI2gsdoCrSi9D3Khxi_wLy9X3JyY,18310
+signalwire_agents/search/__init__.py,sha256=cb8Rtg4Jut9ZhuSbiaHl79G0iWgMhJkLu84urkY0lRc,4215
+signalwire_agents/search/document_processor.py,sha256=zDih-xBWq2kEQkQblh4xXZE1uIQ9aBBFLjjsi3CYfRU,48196
+signalwire_agents/search/index_builder.py,sha256=v1LGhbzzKlCilO4g6nqQJVYEAWvInP2j5B1QrAEj4V8,33772
+signalwire_agents/search/migration.py,sha256=UZPrpUOMZeLVNO1cEDp3tnZYG6ys8-VCFlZXmzig_E0,16582
+signalwire_agents/search/models.py,sha256=isYOYwQT0eWCVdcYSSd8w6z2gFYUobtC8BAUhV7FUVI,840
+signalwire_agents/search/pgvector_backend.py,sha256=waneT_cBmWGE79kpN5Ie4ax6VDuyWb7QmjzXzGFjY7w,28400
+signalwire_agents/search/query_processor.py,sha256=qpUFQqxobx8IymcXBTdPUirfawZVCKtRdSlMHw3nA0s,19656
+signalwire_agents/search/search_engine.py,sha256=dHwhAknIw0paAVQx3ccgVOkaiFqMpDOAriH8lQrBYm8,55671
+signalwire_agents/search/search_service.py,sha256=KV0luon18gPBcoyQ8L_Lagi1CgkJSOwGWshpCjvj1ks,20360
 signalwire_agents/skills/README.md,sha256=sM1_08IsKdRDCzYHPLzppJbaK5MvRelsVL6Kd9A9Ubo,12193
 signalwire_agents/skills/__init__.py,sha256=9AMEcyk2tDaGiUjwVIson_tVWxV4oU_2NnGGNTbHuyQ,533
 signalwire_agents/skills/registry.py,sha256=zURdeAaccZyUSwLRl8K4ILXICMV3ouYQIA4rUBq6b5E,20792
@@ -102,7 +104,7 @@ signalwire_agents/skills/mcp_gateway/__init__.py,sha256=zLgOa7s0sIQphTNJjvasIAW7
 signalwire_agents/skills/mcp_gateway/skill.py,sha256=rtXs8CayjWH8WOrpjGMbbG11dJCNK2RUA06Ysc1cK8g,17167
 signalwire_agents/skills/native_vector_search/README.md,sha256=eFVRoDwZlZwbBXUKyKrvfC6AL4T8MXj0B-IgIdBZF70,5526
 signalwire_agents/skills/native_vector_search/__init__.py,sha256=RofpN3Sd-vyWeUCTYH2dRVrl7h6YuyG5OK772UQ-KFk,220
-signalwire_agents/skills/native_vector_search/skill.py,sha256=OK1dMRG04iaqKS-wuOJh4ye8Vkw4gmrU7aHGLUOtl_M,26890
+signalwire_agents/skills/native_vector_search/skill.py,sha256=ltIFXwxxyqYkTSG2exUsSuJB4tOAiTwYrG7PYtVDCJw,36208
 signalwire_agents/skills/play_background_file/README.md,sha256=omJ_jY5Co6Mk-gJt_hoSl40wemmTbzae3DBll6HL0B4,7026
 signalwire_agents/skills/play_background_file/__init__.py,sha256=iETc6e-0Cai3RUTQWhg9BieWi3NF3_DWWBKdYXcd4ok,273
 signalwire_agents/skills/play_background_file/skill.py,sha256=HgPc2FIvXKJHZ7gO2QEzQe6-uUBPrw_6sRJJpU83GTY,8822
@@ -128,9 +130,9 @@ signalwire_agents/utils/token_generators.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663
 signalwire_agents/utils/validators.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_PumJ35Xds,191
 signalwire_agents/web/__init__.py,sha256=XE_pSTY9Aalzr7J7wqFth1Zr3cccQHPPcF5HWNrOpz8,383
 signalwire_agents/web/web_service.py,sha256=a2PSHJgX1tlZr0Iz1A1UouZjXEePJAZL632evvLVM38,21071
-signalwire_agents-0.1.47.dist-info/licenses/LICENSE,sha256=NYvAsB-rTcSvG9cqHt9EUHAWLiA9YzM4Qfz-mPdvDR0,1067
-signalwire_agents-0.1.47.dist-info/METADATA,sha256=-QAbmvCBQGH41IiHCUu8OKpWp3prVNguEf0xeITLPwY,41596
-signalwire_agents-0.1.47.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-signalwire_agents-0.1.47.dist-info/entry_points.txt,sha256=ZDT65zfTO_YyDzi_hwQbCxIhrUfu_t8RpNXMMXlUPWI,144
-signalwire_agents-0.1.47.dist-info/top_level.txt,sha256=kDGS6ZYv84K9P5Kyg9_S8P_pbUXoHkso0On_DB5bbWc,18
-signalwire_agents-0.1.47.dist-info/RECORD,,
+signalwire_agents-0.1.48.dist-info/licenses/LICENSE,sha256=NYvAsB-rTcSvG9cqHt9EUHAWLiA9YzM4Qfz-mPdvDR0,1067
+signalwire_agents-0.1.48.dist-info/METADATA,sha256=OA3_K04wu-qQvWV6uhzRnfAn7HWuf_lvIE_R_7y_fI8,41596
+signalwire_agents-0.1.48.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+signalwire_agents-0.1.48.dist-info/entry_points.txt,sha256=ZDT65zfTO_YyDzi_hwQbCxIhrUfu_t8RpNXMMXlUPWI,144
+signalwire_agents-0.1.48.dist-info/top_level.txt,sha256=kDGS6ZYv84K9P5Kyg9_S8P_pbUXoHkso0On_DB5bbWc,18
+signalwire_agents-0.1.48.dist-info/RECORD,,