signalwire-agents 0.1.50__py3-none-any.whl → 0.1.53__py3-none-any.whl

signalwire_agents/__init__.py

@@ -18,7 +18,7 @@ A package for building AI agents using SignalWire's AI and SWML capabilities.
 from .core.logging_config import configure_logging
 configure_logging()
 
-__version__ = "0.1.50"
+__version__ = "0.1.53"
 
 # Import core classes for easier access
 from .core.agent_base import AgentBase

signalwire_agents/cli/build_search.py

@@ -69,6 +69,16 @@ Examples:
   sw-search ./docs \\
     --chunking-strategy qa
 
+  # Markdown-aware chunking (preserves headers, detects code blocks, adds tags)
+  sw-search ./docs \\
+    --chunking-strategy markdown \\
+    --file-types md
+  # This strategy:
+  #  - Chunks at header boundaries (h1, h2, h3...)
+  #  - Detects code blocks and extracts language (python, bash, etc)
+  #  - Adds "code" tags to chunks with code for better search
+  #  - Preserves section hierarchy in metadata
+
   # Model selection examples (performance vs quality tradeoff)
   sw-search ./docs --model mini     # Fastest (~5x faster), 384 dims, good for most use cases
   sw-search ./docs --model base     # Balanced speed/quality, 768 dims (previous default)
@@ -128,16 +138,23 @@ Examples:
     --collection-name docs_collection
   sw-search migrate --info ./docs.swsearch
 
-  # PostgreSQL pgvector backend
+  # PostgreSQL pgvector backend (direct build to PostgreSQL)
   sw-search ./docs \\
     --backend pgvector \\
-    --connection-string "postgresql://user:pass@localhost/knowledge" \\
+    --connection-string "postgresql://user:pass@localhost:5432/knowledge" \\
     --output docs_collection
 
+  # pgvector with markdown strategy (best for documentation with code examples)
+  sw-search ./docs \\
+    --backend pgvector \\
+    --connection-string "postgresql://user:pass@localhost:5432/knowledge" \\
+    --output docs_collection \\
+    --chunking-strategy markdown
+
   # Overwrite existing pgvector collection
   sw-search ./docs \\
     --backend pgvector \\
-    --connection-string "postgresql://user:pass@localhost/knowledge" \\
+    --connection-string "postgresql://user:pass@localhost:5432/knowledge" \\
     --output docs_collection \\
     --overwrite
 
@@ -191,9 +208,9 @@ Examples:
     
     parser.add_argument(
         '--chunking-strategy',
-        choices=['sentence', 'sliding', 'paragraph', 'page', 'semantic', 'topic', 'qa', 'json'],
+        choices=['sentence', 'sliding', 'paragraph', 'page', 'semantic', 'topic', 'qa', 'json', 'markdown'],
         default='sentence',
-        help='Chunking strategy to use (default: sentence)'
+        help='Chunking strategy to use (default: sentence). Use "markdown" for documentation with code blocks.'
     )
     
     parser.add_argument(

signalwire_agents/core/skill_base.py

@@ -53,6 +53,26 @@ class SkillBase(ABC):
         """Register SWAIG tools with the agent"""
         pass
         
+    def define_tool(self, **kwargs) -> None:
+        """
+        Wrapper method that automatically includes swaig_fields when defining tools.
+        
+        This method delegates to self.agent.define_tool() but automatically merges
+        any swaig_fields configured for this skill. Skills should use this method
+        instead of calling self.agent.define_tool() directly.
+        
+        Args:
+            **kwargs: All arguments supported by agent.define_tool()
+                     (name, description, parameters, handler, etc.)
+        """
+        # Merge swaig_fields with any explicitly passed fields
+        # Explicit fields take precedence over swaig_fields
+        merged_kwargs = dict(self.swaig_fields)
+        merged_kwargs.update(kwargs)
+        
+        # Call the agent's define_tool with merged arguments
+        return self.agent.define_tool(**merged_kwargs)
+        
 
         
     def get_hints(self) -> List[str]:

signalwire_agents/schema.json

@@ -1937,9 +1937,13 @@
             {
               "type": "string",
               "const": "qwen3-235b-A22b-instruct"
+            },
+            {
+              "type": "string",
+              "const": "llama-3.1-8b-instruct-turbo@together.ai"
             }
           ],
-          "description": "The model to use for the AI. Allowed values are `gpt-4o-mini`, `gpt-4.1-mini`, `gpt-4.1-nano`, `nova-micro`, `nova-lite`, and `qwen3-235b-A22b-instruct`."
+          "description": "The model to use for the AI. Allowed values are `gpt-4o-mini`, `gpt-4.1-mini`, `gpt-4.1-nano`, `nova-micro`, `nova-lite`, and `qwen3-235b-A22b-instruct` and `qwen3-4b-instruct-2507@brian`."
         },
         "ai_volume": {
           "anyOf": [
@@ -7663,4 +7667,4 @@
     }
   },
   "unevaluatedProperties": false
-}
+}

signalwire_agents/search/document_processor.py

@@ -88,9 +88,18 @@ class DocumentProcessor:
     ):
         """
         Initialize document processor
-        
+
         Args:
-            chunking_strategy: Strategy for chunking documents ('sentence', 'sliding', 'paragraph', 'page', 'semantic', 'topic', 'qa')
+            chunking_strategy: Strategy for chunking documents:
+                - 'sentence': Sentence-based chunking with overlap
+                - 'sliding': Sliding window with word-based chunks
+                - 'paragraph': Natural paragraph boundaries
+                - 'page': Page-based chunking (for PDFs)
+                - 'semantic': Semantic similarity-based chunking
+                - 'topic': Topic modeling-based chunking
+                - 'qa': Question-answer optimized chunking
+                - 'json': JSON structure-aware chunking
+                - 'markdown': Markdown structure-aware chunking with code block detection
             max_sentences_per_chunk: For sentence strategy (default: 5)
             chunk_size: For sliding strategy - words per chunk (default: 50)
             chunk_overlap: For sliding strategy - overlap in words (default: 10)
@@ -142,6 +151,9 @@ class DocumentProcessor:
             return self._chunk_by_qa_optimization(content, filename, file_type)
         elif self.chunking_strategy == 'json':
             return self._chunk_from_json(content, filename, file_type)
+        elif self.chunking_strategy == 'markdown':
+            # Use markdown-aware chunking for better structure preservation
+            return self._chunk_markdown_enhanced(content, filename)
         else:
             # Fallback to sentence-based chunking
             return self._chunk_by_sentences(content, filename, file_type)
@@ -339,75 +351,114 @@ class DocumentProcessor:
         return chunks
     
     def _chunk_markdown_enhanced(self, content: str, filename: str) -> List[Dict[str, Any]]:
-        """Enhanced markdown chunking with better header handling"""
+        """Enhanced markdown chunking with code block detection and rich metadata
+
+        Features:
+        - Tracks header hierarchy for section paths
+        - Detects code blocks and extracts language
+        - Adds 'code' tags to chunks containing code
+        - Preserves markdown structure for better search
+        """
         chunks = []
         lines = content.split('\n')
-        
+
         current_section = None
         current_hierarchy = []  # Track header hierarchy
         current_chunk = []
         current_size = 0
         line_start = 1
-        
+        in_code_block = False
+        code_languages = []  # Track languages in current chunk
+        has_code = False
+
         for line_num, line in enumerate(lines, 1):
+            # Check for code block fences
+            code_fence_match = re.match(r'^```(\w+)?', line)
+            if code_fence_match:
+                in_code_block = not in_code_block
+                if in_code_block:
+                    # Starting code block
+                    has_code = True
+                    lang = code_fence_match.group(1)
+                    if lang and lang not in code_languages:
+                        code_languages.append(lang)
+
             # Check for headers with hierarchy tracking
-            header_match = re.match(r'^(#{1,6})\s+(.+)', line)
+            header_match = re.match(r'^(#{1,6})\s+(.+)', line) if not in_code_block else None
             if header_match:
                 header_level = len(header_match.group(1))
                 header_text = header_match.group(2).strip()
-                
+
                 # Save current chunk if it exists
                 if current_chunk:
+                    chunk_metadata = self._build_markdown_metadata(
+                        current_hierarchy, code_languages, has_code
+                    )
                     chunks.append(self._create_chunk(
                         content='\n'.join(current_chunk),
                         filename=filename,
                         section=self._build_section_path(current_hierarchy),
                         start_line=line_start,
-                        end_line=line_num - 1
+                        end_line=line_num - 1,
+                        metadata=chunk_metadata
                     ))
-                
+
                 # Update hierarchy
                 current_hierarchy = current_hierarchy[:header_level-1] + [header_text]
                 current_section = header_text
                 current_chunk = [line]
                 current_size = len(line)
                 line_start = line_num
-            
+                code_languages = []
+                has_code = False
+
             else:
                 current_chunk.append(line)
                 current_size += len(line) + 1
-                
+
                 # Check if chunk is getting too large - use smart splitting
-                if current_size >= self.chunk_size:
+                # But don't split inside code blocks
+                if current_size >= self.chunk_size and not in_code_block:
                     # Try to split at paragraph boundary first
                     split_point = self._find_best_split_point(current_chunk)
-                    
+
                     chunk_to_save = current_chunk[:split_point]
+                    chunk_metadata = self._build_markdown_metadata(
+                        current_hierarchy, code_languages, has_code
+                    )
                     chunks.append(self._create_chunk(
                         content='\n'.join(chunk_to_save),
                         filename=filename,
                         section=self._build_section_path(current_hierarchy),
                         start_line=line_start,
-                        end_line=line_start + split_point - 1
+                        end_line=line_start + split_point - 1,
+                        metadata=chunk_metadata
                     ))
-                    
+
                     # Start new chunk with overlap
                     overlap_lines = self._get_overlap_lines(chunk_to_save)
                     remaining_lines = current_chunk[split_point:]
                     current_chunk = overlap_lines + remaining_lines
                     current_size = sum(len(line) + 1 for line in current_chunk)
                     line_start = line_start + split_point - len(overlap_lines)
-        
+                    # Reset code tracking for new chunk
+                    code_languages = []
+                    has_code = False
+
         # Add final chunk
         if current_chunk:
+            chunk_metadata = self._build_markdown_metadata(
+                current_hierarchy, code_languages, has_code
+            )
             chunks.append(self._create_chunk(
                 content='\n'.join(current_chunk),
                 filename=filename,
                 section=self._build_section_path(current_hierarchy),
                 start_line=line_start,
-                end_line=len(lines)
+                end_line=len(lines),
+                metadata=chunk_metadata
             ))
-        
+
         return chunks
     
     def _chunk_python_enhanced(self, content: str, filename: str) -> List[Dict[str, Any]]:
@@ -575,6 +626,49 @@ class DocumentProcessor:
     def _build_section_path(self, hierarchy: List[str]) -> str:
         """Build hierarchical section path from header hierarchy"""
         return ' > '.join(hierarchy) if hierarchy else None
+
+    def _build_markdown_metadata(self, hierarchy: List[str], code_languages: List[str], has_code: bool) -> Dict[str, Any]:
+        """Build rich metadata for markdown chunks
+
+        Args:
+            hierarchy: Current header hierarchy (e.g., ['Installation', 'Requirements', 'Python'])
+            code_languages: List of code block languages found in chunk (e.g., ['python', 'bash'])
+            has_code: Whether chunk contains any code blocks
+
+        Returns:
+            Dictionary with markdown-specific metadata including tags
+        """
+        metadata = {
+            'chunk_type': 'markdown',
+        }
+
+        # Add header level metadata
+        if hierarchy:
+            for i, header in enumerate(hierarchy, 1):
+                metadata[f'h{i}'] = header
+
+        # Add code-related metadata
+        if has_code:
+            metadata['has_code'] = True
+            if code_languages:
+                metadata['code_languages'] = code_languages
+
+        # Build tags for enhanced searching
+        tags = []
+        if has_code:
+            tags.append('code')
+            # Add language-specific tags
+            for lang in code_languages:
+                tags.append(f'code:{lang}')
+
+        # Add tags for header levels (searchable by section depth)
+        if len(hierarchy) > 0:
+            tags.append(f'depth:{len(hierarchy)}')
+
+        if tags:
+            metadata['tags'] = tags
+
+        return metadata
     
     def _build_python_section(self, class_name: Optional[str], function_name: Optional[str]) -> str:
         """Build section name for Python code"""

signalwire_agents/search/search_engine.py

@@ -114,51 +114,48 @@ class SearchEngine:
             logger.error(f"Error converting query vector: {e}")
             return self._keyword_search_only(enhanced_text, count, tags, original_query)
         
-        # Stage 1: Collect candidates using fast methods
+        # HYBRID APPROACH: Search vector AND metadata in parallel
+        # Stage 1: Run both search types simultaneously
+        search_multiplier = 3
+
+        # Vector search (semantic similarity - primary ranking signal)
+        vector_results = self._vector_search(query_array, count * search_multiplier)
+
+        # Metadata/keyword searches (confirmation signals and backfill)
+        filename_results = self._filename_search(original_query or enhanced_text, count * search_multiplier)
+        metadata_results = self._metadata_search(original_query or enhanced_text, count * search_multiplier)
+        keyword_results = self._keyword_search(enhanced_text, count * search_multiplier, original_query)
+
+        logger.debug(f"Parallel search: vector={len(vector_results)}, filename={len(filename_results)}, "
+                    f"metadata={len(metadata_results)}, keyword={len(keyword_results)}")
+
+        # Stage 2: Merge all results into candidate pool
         candidates = {}
-        
-        # Fast searches - collect all potential matches
-        filename_results = self._filename_search(original_query or enhanced_text, count * 3)
-        metadata_results = self._metadata_search(original_query or enhanced_text, count * 2) 
-        keyword_results = self._keyword_search(enhanced_text, count * 2, original_query)
-        
-        logger.debug(f"Search for '{original_query}': filename={len(filename_results)}, metadata={len(metadata_results)}, keyword={len(keyword_results)}")
-        
-        # Merge candidates from different sources
-        for result_set, source_weight in [(filename_results, 2.0), 
-                                         (metadata_results, 1.5),
-                                         (keyword_results, 1.0)]:
+
+        # Add vector results first (primary signal)
+        for result in vector_results:
+            chunk_id = result['id']
+            candidates[chunk_id] = result
+            candidates[chunk_id]['vector_score'] = result['score']
+            candidates[chunk_id]['vector_distance'] = 1 - result['score']
+            candidates[chunk_id]['sources'] = {'vector': True}
+            candidates[chunk_id]['source_scores'] = {'vector': result['score']}
+
+        # Add metadata/keyword results (secondary signals that boost or backfill)
+        for result_set, source_type, source_weight in [(filename_results, 'filename', 2.0),
+                                                        (metadata_results, 'metadata', 1.5),
+                                                        (keyword_results, 'keyword', 1.0)]:
             for result in result_set:
                 chunk_id = result['id']
                 if chunk_id not in candidates:
+                    # New candidate from metadata/keyword (no vector match)
                     candidates[chunk_id] = result
-                    candidates[chunk_id]['sources'] = {}
-                    candidates[chunk_id]['source_scores'] = {}
-                
-                # Track which searches found this chunk
-                candidates[chunk_id]['sources'][result['search_type']] = True
-                candidates[chunk_id]['source_scores'][result['search_type']] = result['score'] * source_weight
-        
-        # Stage 2: Check if we have enough candidates
-        if len(candidates) < count * 2:
-            # Not enough candidates from fast searches - add full vector search
-            logger.debug(f"Only {len(candidates)} candidates from fast search, adding full vector search")
-            vector_results = self._vector_search(query_array, count * 3)
-            
-            for result in vector_results:
-                chunk_id = result['id']
-                if chunk_id not in candidates:
-                    candidates[chunk_id] = result
-                    candidates[chunk_id]['sources'] = {'vector': True}
-                    candidates[chunk_id]['source_scores'] = {}
-                
-                # Add vector score
-                candidates[chunk_id]['vector_score'] = result['score']
-                candidates[chunk_id]['vector_distance'] = 1 - result['score']
-        else:
-            # We have enough candidates - just re-rank them with vectors
-            logger.debug(f"Re-ranking {len(candidates)} candidates with vector similarity")
-            self._add_vector_scores_to_candidates(candidates, query_array, distance_threshold)
+                    candidates[chunk_id]['sources'] = {source_type: True}
+                    candidates[chunk_id]['source_scores'] = {source_type: result['score'] * source_weight}
+                else:
+                    # Exists in vector results - add metadata/keyword as confirmation signal
+                    candidates[chunk_id]['sources'][source_type] = True
+                    candidates[chunk_id]['source_scores'][source_type] = result['score'] * source_weight
         
         # Stage 3: Score and rank all candidates
         final_results = []
@@ -190,12 +187,12 @@ class SearchEngine:
         
         # Apply diversity penalties to prevent single-file dominance
         final_results = self._apply_diversity_penalties(final_results, count)
-            
+
         # Ensure 'score' field exists for CLI compatibility
         for r in final_results:
             if 'score' not in r:
                 r['score'] = r.get('final_score', 0.0)
-            
+
         return final_results[:count]
     
     def _keyword_search_only(self, enhanced_text: str, count: int, 
@@ -1038,70 +1035,55 @@ class SearchEngine:
             logger.error(f"Error in vector re-ranking: {e}")
     
     def _calculate_combined_score(self, candidate: Dict, distance_threshold: float) -> float:
-        """Calculate final score combining all signals with comprehensive match bonus"""
-        # Base scores from different sources
-        source_scores = candidate.get('source_scores', {})
-        
-        # Check for comprehensive matching (multiple signals)
+        """Calculate final score with hybrid vector + metadata weighting
+
+        Hybrid approach:
+        - Vector score is the primary ranking signal (semantic similarity)
+        - Metadata/keyword matches provide confirmation boost
+        - Multiple signal types indicate high relevance (confirmation bonus)
+        - Special boost for 'code' tag matches when query contains code-related terms
+        """
         sources = candidate.get('sources', {})
-        num_sources = len(sources)
-        
-        # Get match coverage information
-        match_coverage = candidate.get('match_coverage', 0)
-        fields_matched = candidate.get('fields_matched', 0)
-        
-        # Calculate base score with exponential boost for multiple sources
-        if num_sources > 1:
-            # Multiple signal matches are exponentially better
-            multi_signal_boost = 1.0 + (0.3 * (num_sources - 1))
-            base_score = sum(source_scores.values()) * multi_signal_boost
-        else:
-            base_score = sum(source_scores.values())
-        
-        # Apply comprehensive match bonus
-        if match_coverage > 0.5:  # More than 50% of query terms matched
-            coverage_bonus = 1.0 + (match_coverage - 0.5) * 0.5
-            base_score *= coverage_bonus
-        
-        # Apply field diversity bonus (matching in multiple metadata fields)
-        if fields_matched > 2:
-            field_bonus = 1.0 + (fields_matched - 2) * 0.1
-            base_score *= field_bonus
-        
-        # Apply vector similarity multiplier if available
+        source_scores = candidate.get('source_scores', {})
+
+        # Vector score is PRIMARY
         if 'vector_score' in candidate:
             vector_score = candidate['vector_score']
-            vector_distance = candidate.get('vector_distance', 1 - vector_score)
-            
-            # Distance-aware scoring
-            if distance_threshold > 0:
-                if vector_distance <= distance_threshold:
-                    # Within threshold - full vector score
-                    vector_multiplier = vector_score
-                elif vector_distance <= distance_threshold * 1.5:
-                    # Near threshold - gradual decay
-                    overflow = (vector_distance - distance_threshold) / (distance_threshold * 0.5)
-                    vector_multiplier = vector_score * (1 - overflow * 0.3)
-                else:
-                    # Beyond threshold - minimal contribution
-                    vector_multiplier = vector_score * 0.3
-            else:
-                vector_multiplier = vector_score
-            
-            # For chunks found by vector-only search, use vector score directly
-            if 'vector' in sources and len(sources) == 1:
-                base_score = vector_score
-            else:
-                # For chunks found by multiple methods, apply vector as quality check
-                base_score *= vector_multiplier
-        
-        # Special handling for strong metadata matches
-        if 'metadata' in sources:
-            metadata_matches = candidate.get('metadata_matches', {})
-            # Strong category or product match should boost significantly
-            if metadata_matches.get('category', 0) > 0.8 or metadata_matches.get('product', 0) > 0.8:
-                base_score *= 1.2
-        
+            base_score = vector_score
+
+            # Metadata/keyword matches provide confirmation boost
+            if len(sources) > 1:
+                # Has both vector AND metadata/keyword matches - strong confirmation signal
+                keyword_signals = sum(source_scores.get(k, 0) for k in ['keyword', 'filename', 'metadata'])
+                if keyword_signals > 0:
+                    # Normalize and apply boost (up to 30% for strong confirmation)
+                    keyword_boost = min(0.3, keyword_signals * 0.15)
+                    base_score = vector_score * (1.0 + keyword_boost)
+
+                    # Additional boost if multiple signal types confirm (2+ sources)
+                    num_metadata_sources = sum(1 for s in ['keyword', 'filename', 'metadata'] if s in sources)
+                    if num_metadata_sources >= 2:
+                        # Multiple confirmation signals - very high confidence
+                        base_score *= 1.1
+
+            # Check for code-related tags to boost code examples
+            tags = candidate.get('metadata', {}).get('tags', [])
+            if 'code' in tags:
+                # This chunk contains code - boost if query is code-related
+                # (metadata search would have found it if query mentioned code/example/python/etc)
+                if 'metadata' in sources or 'keyword' in sources:
+                    # Query matched code-related metadata - apply code boost
+                    base_score *= 1.2
+        else:
+            # No vector score - this is a keyword-only result (backfill)
+            # Use keyword scores but penalize for lack of semantic match
+            base_score = sum(source_scores.values()) * 0.6  # 40% penalty for no vector
+
+            # Still boost code chunks if metadata matched
+            tags = candidate.get('metadata', {}).get('tags', [])
+            if 'code' in tags and 'metadata' in sources:
+                base_score *= 1.15
+
         return base_score
     
     def _apply_diversity_penalties(self, results: List[Dict], target_count: int) -> List[Dict]:
@@ -1166,7 +1148,65 @@ class SearchEngine:
                 penalized_results[:target_count] = selected
         
         return penalized_results
-    
+
+    def _apply_match_type_diversity(self, results: List[Dict], target_count: int) -> List[Dict]:
+        """Ensure diversity of match types in final results
+
+        Ensures we have a mix of:
+        - Vector-only matches (semantic similarity, good for code examples)
+        - Keyword-only matches (exact term matches)
+        - Hybrid matches (both vector + keyword/metadata)
+        """
+        if not results or len(results) <= target_count:
+            return results
+
+        # Categorize results by match type
+        vector_only = []
+        keyword_only = []
+        hybrid = []
+
+        for result in results:
+            sources = result.get('sources', {})
+            has_vector = 'vector' in sources
+            has_keyword = any(k in sources for k in ['keyword', 'filename', 'metadata'])
+
+            if has_vector and not has_keyword:
+                vector_only.append(result)
+            elif has_keyword and not has_vector:
+                keyword_only.append(result)
+            else:
+                hybrid.append(result)
+
+        # Build diverse result set
+        # Target distribution: 40% hybrid, 40% vector-only, 20% keyword-only
+        # This ensures we include semantic matches (code examples) even if keywords don't match
+        diversified = []
+
+        # Take top hybrid matches first (best overall)
+        hybrid_target = max(1, int(target_count * 0.4))
+        diversified.extend(hybrid[:hybrid_target])
+
+        # Ensure we have vector-only matches (critical for code examples)
+        vector_target = max(1, int(target_count * 0.4))
+        diversified.extend(vector_only[:vector_target])
+
+        # Add keyword-only matches
+        keyword_target = max(1, int(target_count * 0.2))
+        diversified.extend(keyword_only[:keyword_target])
+
+        # Fill remaining slots with best remaining results regardless of type
+        remaining_slots = target_count - len(diversified)
+        if remaining_slots > 0:
+            # Get all unused results
+            used_ids = set(r['id'] for r in diversified)
+            unused = [r for r in results if r['id'] not in used_ids]
+            diversified.extend(unused[:remaining_slots])
+
+        # Sort by final score to maintain quality ordering
+        diversified.sort(key=lambda x: x['final_score'], reverse=True)
+
+        return diversified
+
     def get_stats(self) -> Dict[str, Any]:
         """Get statistics about the search index"""
         # Use pgvector backend if available

signalwire_agents/skills/datasphere/skill.py

@@ -159,7 +159,7 @@ class DataSphereSkill(SkillBase):
         
     def register_tools(self) -> None:
         """Register knowledge search tool with the agent"""
-        self.agent.define_tool(
+        self.define_tool(
             name=self.tool_name,
             description="Search the knowledge base for information on any topic and return relevant results",
             parameters={
@@ -168,8 +168,7 @@ class DataSphereSkill(SkillBase):
                     "description": "The search query - what information you're looking for in the knowledge base"
                 }
             },
-            handler=self._search_knowledge_handler,
-            **self.swaig_fields
+            handler=self._search_knowledge_handler
         )
         
     def _search_knowledge_handler(self, args, raw_data):

signalwire_agents/skills/datetime/skill.py

@@ -30,7 +30,7 @@ class DateTimeSkill(SkillBase):
     def register_tools(self) -> None:
         """Register datetime tools with the agent"""
         
-        self.agent.define_tool(
+        self.define_tool(
             name="get_current_time",
             description="Get the current time, optionally in a specific timezone",
             parameters={
@@ -39,11 +39,10 @@ class DateTimeSkill(SkillBase):
                     "description": "Timezone name (e.g., 'America/New_York', 'Europe/London'). Defaults to UTC."
                 }
             },
-            handler=self._get_time_handler,
-            **self.swaig_fields
+            handler=self._get_time_handler
         )
         
-        self.agent.define_tool(
+        self.define_tool(
             name="get_current_date",
             description="Get the current date",
             parameters={
@@ -52,8 +51,7 @@ class DateTimeSkill(SkillBase):
                     "description": "Timezone name for the date. Defaults to UTC."
                 }
             },
-            handler=self._get_date_handler,
-            **self.swaig_fields
+            handler=self._get_date_handler
         )
         
     def _get_time_handler(self, args, raw_data):

signalwire_agents/skills/math/skill.py

@@ -29,7 +29,7 @@ class MathSkill(SkillBase):
     def register_tools(self) -> None:
         """Register math tools with the agent"""
         
-        self.agent.define_tool(
+        self.define_tool(
             name="calculate",
             description="Perform a mathematical calculation with basic operations (+, -, *, /, %, **)",
             parameters={
@@ -38,8 +38,7 @@ class MathSkill(SkillBase):
                     "description": "Mathematical expression to evaluate (e.g., '2 + 3 * 4', '(10 + 5) / 3')"
                 }
             },
-            handler=self._calculate_handler,
-            **self.swaig_fields
+            handler=self._calculate_handler
         )
         
     def _calculate_handler(self, args, raw_data):

signalwire_agents/skills/mcp_gateway/skill.py

@@ -215,7 +215,7 @@ class MCPGatewaySkill(SkillBase):
                 self.logger.error(f"Failed to get tools for service '{service_name}': {e}")
         
         # Register the hangup hook for session cleanup
-        self.agent.define_tool(
+        self.define_tool(
             name="_mcp_gateway_hangup",
             description="Internal cleanup function for MCP sessions",
             parameters={},
@@ -260,7 +260,7 @@ class MCPGatewaySkill(SkillBase):
             return self._call_mcp_tool(service_name, tool_name, args, raw_data)
         
         # Register the SWAIG function
-        self.agent.define_tool(
+        self.define_tool(
             name=swaig_name,
             description=f"[{service_name}] {tool_def.get('description', tool_name)}",
             parameters=swaig_params,

signalwire_agents/skills/native_vector_search/skill.py

@@ -136,6 +136,13 @@ class NativeVectorSearchSkill(SkillBase):
                 "default": "",
                 "required": False
             },
+            "max_content_length": {
+                "type": "integer",
+                "description": "Maximum total response size in characters (distributed across all results)",
+                "default": 32768,
+                "required": False,
+                "minimum": 1000
+            },
             "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.",
@@ -251,6 +258,7 @@ class NativeVectorSearchSkill(SkillBase):
         )
         self.response_prefix = self.params.get('response_prefix', '')
         self.response_postfix = self.params.get('response_postfix', '')
+        self.max_content_length = self.params.get('max_content_length', 32768)
         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')
@@ -274,8 +282,8 @@ class NativeVectorSearchSkill(SkillBase):
                 if parsed.path:
                     self.remote_base_url += parsed.path
         
-        # SWAIG fields for function fillers
-        self.swaig_fields = self.params.get('swaig_fields', {})
+        # SWAIG fields are already extracted by SkillBase.__init__()
+        # No need to re-fetch from params - use self.swaig_fields inherited from parent
         
         # **EARLY REMOTE CHECK - Option 1**
         # If remote URL is configured, skip all heavy local imports and just validate remote connectivity
@@ -460,7 +468,7 @@ class NativeVectorSearchSkill(SkillBase):
             'Search the local knowledge base for information'
         )
         
-        self.agent.define_tool(
+        self.define_tool(
             name=self.tool_name,
             description=description,
             parameters={
@@ -474,8 +482,7 @@ class NativeVectorSearchSkill(SkillBase):
                     "default": self.count
                 }
             },
-            handler=self._search_handler,
-            **self.swaig_fields
+            handler=self._search_handler
         )
         
         # Add our tool to the Knowledge Search section
@@ -601,21 +608,36 @@ class NativeVectorSearchSkill(SkillBase):
                 
                 return SwaigFunctionResult(no_results_msg)
             
-            # Format results
+            # Format results with dynamic per-result truncation
             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")
-            
+
+            # Calculate per-result content budget
+            # Estimate overhead per result: metadata (~200 chars) + formatting (~100 chars)
+            estimated_overhead_per_result = 300
+            # Account for prefix/postfix/header in total overhead
+            prefix_postfix_overhead = len(self.response_prefix) + len(self.response_postfix) + 100
+            total_overhead = (len(results) * estimated_overhead_per_result) + prefix_postfix_overhead
+            available_for_content = self.max_content_length - total_overhead
+
+            # Ensure minimum of 500 chars per result
+            per_result_limit = max(500, available_for_content // len(results)) if len(results) > 0 else 1000
+
             for i, result in enumerate(results, 1):
                 filename = result['metadata']['filename']
                 section = result['metadata'].get('section', '')
                 score = result['score']
                 content = result['content']
-                
+
+                # Truncate content to per-result limit
+                if len(content) > per_result_limit:
+                    content = content[:per_result_limit] + "..."
+
                 # 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']:
@@ -624,16 +646,16 @@ class NativeVectorSearchSkill(SkillBase):
                 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)
-            
+
             # Add response postfix if configured
             if self.response_postfix:
                 response_parts.append(self.response_postfix)

signalwire_agents/skills/spider/skill.py

@@ -223,7 +223,7 @@ class SpiderSkill(SkillBase):
             tool_prefix = f"{tool_prefix}_"
         
         # Register scrape_url tool
-        self.agent.define_tool(
+        self.define_tool(
             name=f"{tool_prefix}scrape_url",
             description="Extract text content from a single web page",
             parameters={
@@ -233,12 +233,11 @@ class SpiderSkill(SkillBase):
                 }
             },
             required=["url"],
-            handler=self._scrape_url_handler,
-            **self.swaig_fields
+            handler=self._scrape_url_handler
         )
         
         # Register crawl_site tool
-        self.agent.define_tool(
+        self.define_tool(
             name=f"{tool_prefix}crawl_site",
             description="Crawl multiple pages starting from a URL",
             parameters={
@@ -248,12 +247,11 @@ class SpiderSkill(SkillBase):
                 }
             },
             required=["start_url"],
-            handler=self._crawl_site_handler,
-            **self.swaig_fields
+            handler=self._crawl_site_handler
         )
         
         # Register extract_structured_data tool
-        self.agent.define_tool(
+        self.define_tool(
             name=f"{tool_prefix}extract_structured_data",
             description="Extract specific data from a web page using selectors",
             parameters={
@@ -263,8 +261,7 @@ class SpiderSkill(SkillBase):
                 }
             },
             required=["url"],
-            handler=self._extract_structured_handler,
-            **self.swaig_fields
+            handler=self._extract_structured_handler
         )
     
     def _fetch_url(self, url: str) -> Optional[requests.Response]:

signalwire_agents/skills/web_search/skill.py

@@ -21,7 +21,7 @@ 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, max_content_length: int = 2000):
+    def __init__(self, api_key: str, search_engine_id: str, max_content_length: int = 32768):
         self.api_key = api_key
         self.search_engine_id = search_engine_id
         self.max_content_length = max_content_length
@@ -62,63 +62,84 @@ class GoogleSearchScraper:
         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"""
+    def extract_text_from_url(self, url: str, content_limit: int = None, timeout: int = 10) -> str:
+        """Scrape a URL and extract readable text content
+
+        Args:
+            url: URL to scrape
+            content_limit: Maximum characters to return (uses self.max_content_length if not provided)
+            timeout: Request timeout in seconds
+        """
         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) > self.max_content_length:
-                text = text[:self.max_content_length] + "... [Content truncated]"
-            
+            limit = content_limit if content_limit is not None else self.max_content_length
+            if len(text) > limit:
+                text = text[:limit]
+
             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"""
+        """Main function: search Google and scrape the resulting pages
+
+        Dynamically calculates per-result content limit based on total max_content_length
+        and number of results to ensure total response stays within bounds.
+        """
         search_results = self.search_google(query, num_results)
-        
+
         if not search_results:
             return f"No search results found for query: {query}"
-        
+
+        # Calculate per-result content budget
+        # Reserve ~300 chars per result for overhead (titles, URLs, snippets, formatting)
+        estimated_overhead_per_result = 300
+        total_overhead = num_results * estimated_overhead_per_result
+        available_for_content = self.max_content_length - total_overhead
+
+        # Ensure we have at least 1000 chars per result
+        per_result_limit = max(1000, available_for_content // num_results)
+
         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'])
-            
+
+            # Pass the calculated per-result limit
+            page_text = self.extract_text_from_url(result['url'], content_limit=per_result_limit)
+
             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)
 
 
@@ -163,7 +184,7 @@ class WebSearchSkill(SkillBase):
         # 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.max_content_length = self.params.get('max_content_length', 32768)
         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. "
@@ -184,7 +205,7 @@ class WebSearchSkill(SkillBase):
         
     def register_tools(self) -> None:
         """Register web search tool with the agent"""
-        self.agent.define_tool(
+        self.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={
@@ -193,8 +214,7 @@ class WebSearchSkill(SkillBase):
                     "description": "The search query - what you want to find information about"
                 }
             },
-            handler=self._web_search_handler,
-            **self.swaig_fields
+            handler=self._web_search_handler
         )
         
     def _web_search_handler(self, args, raw_data):
@@ -308,10 +328,10 @@ class WebSearchSkill(SkillBase):
             },
             "max_content_length": {
                 "type": "integer",
-                "description": "Maximum content length per scraped page (characters)",
-                "default": 2000,
+                "description": "Maximum total response size in characters (distributed across all results)",
+                "default": 32768,
                 "required": False,
-                "min": 100
+                "min": 1000
             },
             "no_results_message": {
                 "type": "string",
@@ -321,4 +341,4 @@ class WebSearchSkill(SkillBase):
             }
         })
         
-        return schema 
+        return schema 

signalwire_agents/skills/wikipedia_search/skill.py

@@ -84,7 +84,7 @@ class WikipediaSearchSkill(SkillBase):
         """
         Register the SWAIG tool for Wikipedia search.
         """
-        self.agent.define_tool(
+        self.define_tool(
             name="search_wiki",
             description="Search Wikipedia for information about a topic and get article summaries",
             parameters={
@@ -93,8 +93,7 @@ class WikipediaSearchSkill(SkillBase):
                     "description": "The search term or topic to look up on Wikipedia"
                 }
             },
-            handler=self._search_wiki_handler,
-            **self.swaig_fields
+            handler=self._search_wiki_handler
         )
     
     def _search_wiki_handler(self, args, raw_data):

{signalwire_agents-0.1.50.dist-info → signalwire_agents-0.1.53.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalwire_agents
-Version: 0.1.50
+Version: 0.1.53
 Summary: SignalWire AI Agents SDK
 Author-email: SignalWire Team <info@signalwire.com>
 License: MIT
@@ -18,16 +18,16 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: fastapi==0.115.12
-Requires-Dist: pydantic==2.11.4
-Requires-Dist: PyYAML==6.0.2
-Requires-Dist: Requests==2.32.3
-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
+Requires-Dist: fastapi>=0.115.12
+Requires-Dist: pydantic>=2.11.4
+Requires-Dist: PyYAML>=6.0.2
+Requires-Dist: Requests>=2.32.3
+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
 Requires-Dist: lxml>=4.9.0
 Provides-Extra: search-queryonly
 Requires-Dist: numpy>=1.24.0; extra == "search-queryonly"

{signalwire_agents-0.1.50.dist-info → signalwire_agents-0.1.53.dist-info}/RECORD

@@ -1,9 +1,9 @@
-signalwire_agents/__init__.py,sha256=PDuehLVjqOYw3h-LyVMikp-NYwtildUWXj56x4ri9cg,5031
+signalwire_agents/__init__.py,sha256=FNhNMJEBAOvXnnAw0S04cqxLRF4kW0uoASgIc6sglMs,5031
 signalwire_agents/agent_server.py,sha256=x9HyWia8D3r6KMqY-Q4DtNVivfJWLTx8B-KzUI8okuA,26880
-signalwire_agents/schema.json,sha256=D0Ui-VdLKNdMO8aYQBX_2NM3_JPnuhdVzhbLAPAWG1c,240423
+signalwire_agents/schema.json,sha256=rxXtjWsyCKokj0ONGIs0k-VnWMJrbR2w2ZsYoQmYjCc,240585
 signalwire_agents/agents/bedrock.py,sha256=J582gooNtxtep4xdVOfyDzRtHp_XrurPMS93xf2Xod0,10836
 signalwire_agents/cli/__init__.py,sha256=XbxAQFaCIdGXIXJiriVBWoFPOJsC401u21588nO4TG8,388
-signalwire_agents/cli/build_search.py,sha256=Yh5hNM0ur88UMuKo5ZDoN_bAzBGpj2RG1Ys1_3xlfUc,54144
+signalwire_agents/cli/build_search.py,sha256=_DcwRcrlr9uwmrI7FYp6WZT9aSU6KWgZmtcnimf1YnA,54925
 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
@@ -33,7 +33,7 @@ signalwire_agents/core/function_result.py,sha256=4CcbxwstlSRUQtbCty2evewvNZP35dW
 signalwire_agents/core/logging_config.py,sha256=x4d_RAjBjVpJOFA2vXnPP2dNr13BZHz091J5rGpC77Y,13142
 signalwire_agents/core/pom_builder.py,sha256=ywuiIfP8BeLBPo_G4X1teZlG6zTCMkW71CZnmyoDTAQ,6636
 signalwire_agents/core/security_config.py,sha256=iAnAzKEJQiXL6mMpDaYm3Sjkxwm4x2N9HD6DeWSI8yI,12536
-signalwire_agents/core/skill_base.py,sha256=1b_4ht_T1BVnfzHYqoILb3idrrPYMs5-G-adHo2IVss,6903
+signalwire_agents/core/skill_base.py,sha256=kCgzvlA9uu3CblLAigYuM-0LL-n0xEEoXV-JmNn-Beo,7795
 signalwire_agents/core/skill_manager.py,sha256=D4erpz0tmSYLqyfeteNNIY0VRWDtX0rDw3n7Z_f0W5U,10493
 signalwire_agents/core/swaig_function.py,sha256=KnUQ2g99kDSzOzD1PJ0Iqs8DeeZ6jDIIN54C5MA4TWw,7521
 signalwire_agents/core/swml_builder.py,sha256=tJBFDAVTENEfjGLp2h9_AKOYt5O9FrSYLI-nZZVwM1E,15604
@@ -70,13 +70,13 @@ signalwire_agents/prefabs/info_gatherer.py,sha256=0LpYTaU7C76Efp3yUIdNX6xzWH7mj5
 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=cb8Rtg4Jut9ZhuSbiaHl79G0iWgMhJkLu84urkY0lRc,4215
-signalwire_agents/search/document_processor.py,sha256=zDih-xBWq2kEQkQblh4xXZE1uIQ9aBBFLjjsi3CYfRU,48196
+signalwire_agents/search/document_processor.py,sha256=emlmYAgr34Qyhfqm4VppqTCpm1cj8Db6ziHoFuw4ekE,51929
 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_engine.py,sha256=SRUNXJlDBej_kK4JpsksY0bW-pDdnY6Cdpbu648ox9E,57445
 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
@@ -86,31 +86,31 @@ signalwire_agents/skills/api_ninjas_trivia/__init__.py,sha256=zN305bBQkzlJyUNsPU
 signalwire_agents/skills/api_ninjas_trivia/skill.py,sha256=ajJm0Vd07Oz3h0sHP0rRyckAXAbFRtcP7ws9GiAhfjw,8626
 signalwire_agents/skills/datasphere/README.md,sha256=7G5t0V04SlnJ39U-3zOoIOfkNFrVEo-s45lCUlYmJGo,7351
 signalwire_agents/skills/datasphere/__init__.py,sha256=SJJlmeMSeezjINPgkuWN1XzDPN_Z3GzZ_StzO1BtxQs,257
-signalwire_agents/skills/datasphere/skill.py,sha256=EQ7ODzTt591wBlTDTn4ogX8LTeygiU8YHFQTx3F0f2c,12682
+signalwire_agents/skills/datasphere/skill.py,sha256=OcDgmFSvIA3qy6a24E_fIgXrPKGRnLRHtPh9JeJ5YOY,12643
 signalwire_agents/skills/datasphere_serverless/README.md,sha256=FErV97NEdYD_N1wZxkLqy6DSml5B9mCJmEgCUdGxh6A,9299
 signalwire_agents/skills/datasphere_serverless/__init__.py,sha256=jpMNDcGiXsVbSCVUrc_AwLARqEtVu4dPYZPJSJ-K3rc,261
 signalwire_agents/skills/datasphere_serverless/skill.py,sha256=i57VkMo2gU5YE9Z2lIxFfZtYkvkwMpnek49eSSfMFS0,9882
 signalwire_agents/skills/datetime/README.md,sha256=95SzVz-Pcm9MPqZ4D3sSYKMwdpsDNwwCpWFRK027-Pc,4534
 signalwire_agents/skills/datetime/__init__.py,sha256=Irajm2sUhmQVFgais-J-q-3d58tNnJ4nbLmnphr90nI,234
-signalwire_agents/skills/datetime/skill.py,sha256=mA-dxBhZOIbMygBQ3Z4jmFCH-zsD8HnjcWC4asp6Gl0,4370
+signalwire_agents/skills/datetime/skill.py,sha256=-MnycSmhK2JWwuHAStxz0mHNuMIvvWCW-I9La44WDts,4292
 signalwire_agents/skills/joke/README.md,sha256=xUa2_0Pk9neli-UJxI4BPt3Fb1_5Xa3m8RuDlrkfBao,3594
 signalwire_agents/skills/joke/__init__.py,sha256=8Rc5_nj30bdga2n9H9JSI2WzMn40pjApd-y-tk5WIkI,244
 signalwire_agents/skills/joke/skill.py,sha256=BKPA50iht8I_mVBJ-PIQHjJJz1m0V2w5J69AfVMx23o,4092
 signalwire_agents/skills/math/README.md,sha256=Nrv7PxkFPSxdnAN6856Fp1CfvsUwdncpRFFDERxmMe0,5335
 signalwire_agents/skills/math/__init__.py,sha256=F7emZqBpAAkqJZxA3RNTzRSAXE5e2xu8PtFOPHebfKo,230
-signalwire_agents/skills/math/skill.py,sha256=-h0DRX_nFkeSzLfaiOKv0zHScdXiQuz4rkLShanKwmc,3800
+signalwire_agents/skills/math/skill.py,sha256=pfwlljnN_UoT9rzkggzPrgGWuoZ_wnovrph-aLG4ULY,3761
 signalwire_agents/skills/mcp_gateway/README.md,sha256=t-71TTWlEvjgWLTcT3v4kMw9zlrKXTAC_sCjb1haNew,5826
 signalwire_agents/skills/mcp_gateway/__init__.py,sha256=zLgOa7s0sIQphTNJjvasIAW7llxAApez7moC_e1tzP0,236
-signalwire_agents/skills/mcp_gateway/skill.py,sha256=rtXs8CayjWH8WOrpjGMbbG11dJCNK2RUA06Ysc1cK8g,17167
+signalwire_agents/skills/mcp_gateway/skill.py,sha256=bOdfBFsboRWSVoRA5X9vcmkH9OJIQxUllhMzhqHV1XI,17155
 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=ltIFXwxxyqYkTSG2exUsSuJB4tOAiTwYrG7PYtVDCJw,36208
+signalwire_agents/skills/native_vector_search/skill.py,sha256=SwJ3fkFbAdW-zkbhTkzdj_0VJGXm-j2bRxE89CLu4B8,37403
 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
 signalwire_agents/skills/spider/README.md,sha256=yBa09JzgLikG3STbDNbRCKUM3l3XU5-D923I2g8CTVc,6909
 signalwire_agents/skills/spider/__init__.py,sha256=bZcCGLX5Cz18qY8rOvAAync6BRtketxaU19l6YcA_iI,285
-signalwire_agents/skills/spider/skill.py,sha256=w4dj0M8RZSfJtzL-jPXvr_roqawwnFKQD5GDKreel1Y,23137
+signalwire_agents/skills/spider/skill.py,sha256=_gdw_fJO8wZhs1yx-JGdY8Tf-605NjOG-KH44-Js9Cc,23020
 signalwire_agents/skills/swml_transfer/README.md,sha256=2Y6CH5Bm9kI5IYCLczIQIYlaYUq6VX_S4Irct2CQMmQ,14681
 signalwire_agents/skills/swml_transfer/__init__.py,sha256=YyfxRpbgT4ZpEjGolwffKqjUzX4VqDNLdqfSoA0D0IY,238
 signalwire_agents/skills/swml_transfer/skill.py,sha256=_qzJRd9P5VN8flTDe9N-9cvsLU0sN7XuY5yjk-DNlv8,15363
@@ -119,10 +119,10 @@ signalwire_agents/skills/weather_api/__init__.py,sha256=WCS--GFBX8straIZPuGAmTDZ
 signalwire_agents/skills/weather_api/skill.py,sha256=LNJItYzgRSZYNYcH7Z37BOjjPy3aaM0OjMRnAxiUhOI,7204
 signalwire_agents/skills/web_search/README.md,sha256=Y95cxEScMzhmslUJF8u_Nh15FbEBuus4P-E8_kk2an0,5438
 signalwire_agents/skills/web_search/__init__.py,sha256=kv4CzmF1lldRZcL_HivieslP7gtTFvxcfprKG4n6b-Q,236
-signalwire_agents/skills/web_search/skill.py,sha256=EGu6ff9aAb2W323_XDCcVDW1wbAKTZYK8HQOT__iqtE,12660
+signalwire_agents/skills/web_search/skill.py,sha256=h1zrAUFhC5Ul2BaKQY4Fn05Pob8AG-9eaSwE3ko-g3Y,13459
 signalwire_agents/skills/wikipedia_search/README.md,sha256=KFIQ8XhqrTG8NRs72dIbjJacy2DlYEXLtxgy23gyRi4,7585
 signalwire_agents/skills/wikipedia_search/__init__.py,sha256=yJ6iYTSyJC96mwwUsI_FneFhDBcLYD4xEerBKlWLTb8,375
-signalwire_agents/skills/wikipedia_search/skill.py,sha256=4sirBiEXn0Sd1YOnyinUFjACFq0y-CtzbdnDGnGzOAA,7949
+signalwire_agents/skills/wikipedia_search/skill.py,sha256=peNxT3GHMJY5OFQ-weneO83NpSstGjcmrTN_ENzUsEo,7910
 signalwire_agents/utils/__init__.py,sha256=1KVsHzwgfktSXHe3vqSRGImjtIE58szwD2FHHoFBtvY,601
 signalwire_agents/utils/pom_utils.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_PumJ35Xds,191
 signalwire_agents/utils/schema_utils.py,sha256=i4okv_O9bUApwT_jJf4Yoij3bLCrGrW3DC-vzSy2RuY,16392
@@ -130,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.50.dist-info/licenses/LICENSE,sha256=NYvAsB-rTcSvG9cqHt9EUHAWLiA9YzM4Qfz-mPdvDR0,1067
-signalwire_agents-0.1.50.dist-info/METADATA,sha256=IKAyYdw0b9B6ZATtnnqiwOaloF2LbGGcpoZ0suslxME,41596
-signalwire_agents-0.1.50.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-signalwire_agents-0.1.50.dist-info/entry_points.txt,sha256=ZDT65zfTO_YyDzi_hwQbCxIhrUfu_t8RpNXMMXlUPWI,144
-signalwire_agents-0.1.50.dist-info/top_level.txt,sha256=kDGS6ZYv84K9P5Kyg9_S8P_pbUXoHkso0On_DB5bbWc,18
-signalwire_agents-0.1.50.dist-info/RECORD,,
+signalwire_agents-0.1.53.dist-info/licenses/LICENSE,sha256=NYvAsB-rTcSvG9cqHt9EUHAWLiA9YzM4Qfz-mPdvDR0,1067
+signalwire_agents-0.1.53.dist-info/METADATA,sha256=_6Ucazw9iFa0MnkICONuv0ckR6_5lkFMcUq5-yg46RY,41596
+signalwire_agents-0.1.53.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+signalwire_agents-0.1.53.dist-info/entry_points.txt,sha256=ZDT65zfTO_YyDzi_hwQbCxIhrUfu_t8RpNXMMXlUPWI,144
+signalwire_agents-0.1.53.dist-info/top_level.txt,sha256=kDGS6ZYv84K9P5Kyg9_S8P_pbUXoHkso0On_DB5bbWc,18
+signalwire_agents-0.1.53.dist-info/RECORD,,