chuk-tool-processor 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

chuk_tool_processor/core/processor.py

@@ -1,9 +1,11 @@
 # chuk_tool_processor/core/processor.py
 import asyncio
 import time
+import json
+import hashlib
 from typing import Any, Dict, List, Optional, Type, Union
 
-# imports
+# imports
 from chuk_tool_processor.models.tool_call import ToolCall
 from chuk_tool_processor.models.tool_result import ToolResult
 from chuk_tool_processor.registry import ToolRegistryInterface, ToolRegistryProvider
@@ -21,6 +23,7 @@ class ToolProcessor:
     Main class for processing tool calls from LLM responses.
     Combines parsing, execution, and result handling.
     """
+
     def __init__(
         self,
         registry: Optional[ToolRegistryInterface] = None,
@@ -33,11 +36,11 @@ class ToolProcessor:
         tool_rate_limits: Optional[Dict[str, tuple]] = None,
         enable_retries: bool = True,
         max_retries: int = 3,
-        parser_plugins: Optional[List[str]] = None
+        parser_plugins: Optional[List[str]] = None,
     ):
         """
         Initialize the tool processor.
-        
+
         Args:
             registry: Tool registry to use. If None, uses the global registry.
             default_timeout: Default timeout for tool execution in seconds.
@@ -53,55 +56,55 @@ class ToolProcessor:
                 If None, uses all available parsers.
         """
         self.logger = get_logger("chuk_tool_processor.processor")
-        
+
         # Use provided registry or global registry
         self.registry = registry or ToolRegistryProvider.get_registry()
-        
+
         # Create base executor with in-process strategy
         self.strategy = InProcessStrategy(
             registry=self.registry,
             default_timeout=default_timeout,
-            max_concurrency=max_concurrency
+            max_concurrency=max_concurrency,
         )
-        
+
         self.executor = ToolExecutor(
             registry=self.registry,
             default_timeout=default_timeout,
-            strategy=self.strategy
+            strategy=self.strategy,
         )
-        
+
         # Apply optional wrappers
         if enable_retries:
             self.logger.debug("Enabling retry logic")
             self.executor = RetryableToolExecutor(
                 executor=self.executor,
-                default_config=RetryConfig(max_retries=max_retries)
+                default_config=RetryConfig(max_retries=max_retries),
             )
-        
+
         if enable_rate_limiting:
             self.logger.debug("Enabling rate limiting")
             rate_limiter = RateLimiter(
                 global_limit=global_rate_limit,
-                tool_limits=tool_rate_limits
+                tool_limits=tool_rate_limits,
             )
             self.executor = RateLimitedToolExecutor(
                 executor=self.executor,
-                rate_limiter=rate_limiter
+                rate_limiter=rate_limiter,
             )
-        
+
         if enable_caching:
             self.logger.debug("Enabling result caching")
             cache = InMemoryCache(default_ttl=cache_ttl)
             self.executor = CachingToolExecutor(
                 executor=self.executor,
                 cache=cache,
-                default_ttl=cache_ttl
+                default_ttl=cache_ttl,
             )
-        
+
         # Discover plugins if not already done
         if not plugin_registry.list_plugins().get("parser", []):
             discover_default_plugins()
-        
+
         # Get parser plugins
         if parser_plugins:
             self.parsers = [
@@ -112,63 +115,59 @@ class ToolProcessor:
         else:
             parser_names = plugin_registry.list_plugins().get("parser", [])
             self.parsers = [
-                plugin_registry.get_plugin("parser", name)
-                for name in parser_names
+                plugin_registry.get_plugin("parser", name) for name in parser_names
             ]
-        
+
         self.logger.debug(f"Initialized with {len(self.parsers)} parser plugins")
-    
+
     async def process_text(
         self,
         text: str,
         timeout: Optional[float] = None,
         use_cache: bool = True,
-        request_id: Optional[str] = None
+        request_id: Optional[str] = None,
     ) -> List[ToolResult]:
         """
         Process text to extract and execute tool calls.
-        
+
         Args:
             text: Text to process.
             timeout: Optional timeout for execution.
             use_cache: Whether to use cached results.
             request_id: Optional request ID for logging.
-            
+
         Returns:
             List of tool results.
         """
         # Create request context
         with request_logging(request_id) as req_id:
             self.logger.debug(f"Processing text ({len(text)} chars)")
-            
+
             # Extract tool calls
             calls = await self._extract_tool_calls(text)
-            
+
             if not calls:
                 self.logger.debug("No tool calls found")
                 return []
-            
+
             self.logger.debug(f"Found {len(calls)} tool calls")
-            
+
             # Execute tool calls
             with log_context_span("tool_execution", {"num_calls": len(calls)}):
                 # Check if any tools are unknown
-                tool_names = set(call.tool for call in calls)
-                unknown_tools = [
-                    name for name in tool_names
-                    if not self.registry.get_tool(name)
-                ]
-                
+                tool_names = {call.tool for call in calls}
+                unknown_tools = [name for name in tool_names if not self.registry.get_tool(name)]
+
                 if unknown_tools:
                     self.logger.warning(f"Unknown tools: {unknown_tools}")
-                
+
                 # Execute tools
                 results = await self.executor.execute(calls, timeout=timeout)
-                
+
                 # Log metrics for each tool call
                 for call, result in zip(calls, results):
                     log_tool_call(call, result)
-                    
+
                     # Record metrics
                     duration = (result.end_time - result.start_time).total_seconds()
                     metrics.log_tool_execution(
@@ -177,47 +176,47 @@ class ToolProcessor:
                         duration=duration,
                         error=result.error,
                         cached=getattr(result, "cached", False),
-                        attempts=getattr(result, "attempts", 1)
+                        attempts=getattr(result, "attempts", 1),
                     )
-                
+
                 return results
-    
+
     async def _extract_tool_calls(self, text: str) -> List[ToolCall]:
         """
         Extract tool calls from text using all available parsers.
-        
+
         Args:
             text: Text to parse.
-            
+
         Returns:
             List of tool calls.
         """
-        all_calls = []
-        
+        all_calls: List[ToolCall] = []
+
         # Try each parser
         with log_context_span("parsing", {"text_length": len(text)}):
             for parser in self.parsers:
                 parser_name = parser.__class__.__name__
-                
+
                 with log_context_span(f"parser.{parser_name}", log_duration=True):
                     start_time = time.time()
-                    
+
                     try:
                         # Try to parse
                         calls = parser.try_parse(text)
-                        
+
                         # Log success
                         duration = time.time() - start_time
                         metrics.log_parser_metric(
                             parser=parser_name,
                             success=True,
                             duration=duration,
-                            num_calls=len(calls)
+                            num_calls=len(calls),
                         )
-                        
+
                         # Add calls to result
                         all_calls.extend(calls)
-                        
+
                     except Exception as e:
                         # Log failure
                         duration = time.time() - start_time
@@ -225,16 +224,24 @@ class ToolProcessor:
                             parser=parser_name,
                             success=False,
                             duration=duration,
-                            num_calls=0
+                            num_calls=0,
                         )
                         self.logger.error(f"Parser {parser_name} failed: {str(e)}")
-        
-        # Remove duplicates
-        unique_calls = {}
+
+        # ------------------------------------------------------------------ #
+        # Remove duplicates – use a stable digest instead of hashing a
+        # frozenset of argument items (which breaks on unhashable types).
+        # ------------------------------------------------------------------ #
+        def _args_digest(args: Dict[str, Any]) -> str:
+            """Return a stable hash for any JSON-serialisable payload."""
+            blob = json.dumps(args, sort_keys=True, default=str)
+            return hashlib.md5(blob.encode()).hexdigest()
+
+        unique_calls: Dict[str, ToolCall] = {}
         for call in all_calls:
-            key = f"{call.tool}:{hash(frozenset(call.arguments.items()))}"
+            key = f"{call.tool}:{_args_digest(call.arguments)}"
             unique_calls[key] = call
-        
+
         return list(unique_calls.values())
 
 
@@ -246,17 +253,17 @@ async def process_text(
     text: str,
     timeout: Optional[float] = None,
     use_cache: bool = True,
-    request_id: Optional[str] = None
+    request_id: Optional[str] = None,
 ) -> List[ToolResult]:
     """
     Process text with the default processor.
-    
+
     Args:
         text: Text to process.
         timeout: Optional timeout for execution.
         use_cache: Whether to use cached results.
         request_id: Optional request ID for logging.
-        
+
     Returns:
         List of tool results.
     """
@@ -264,5 +271,5 @@ async def process_text(
         text=text,
         timeout=timeout,
         use_cache=use_cache,
-        request_id=request_id
+        request_id=request_id,
     )

chuk_tool_processor/mcp/stream_manager.py

@@ -174,6 +174,34 @@ class StreamManager:
 
     def get_server_info(self) -> List[Dict[str, Any]]:
         return self.server_info
+    
+    async def list_tools(self, server_name: str) -> List[Dict[str, Any]]:
+        """
+        List all tools available from a specific server.
+        
+        This method is required by ProxyServerManager for proper tool discovery.
+        
+        Args:
+            server_name: Name of the server to query
+            
+        Returns:
+            List of tool definitions from the server
+        """
+        if server_name not in self.transports:
+            logger.error(f"Server '{server_name}' not found in transports")
+            return []
+        
+        # Get the transport for this server
+        transport = self.transports[server_name]
+        
+        try:
+            # Call the get_tools method on the transport
+            tools = await transport.get_tools()
+            logger.debug(f"Found {len(tools)} tools for server {server_name}")
+            return tools
+        except Exception as e:
+            logger.error(f"Error listing tools for server {server_name}: {e}")
+            return []
 
     # ------------------------------------------------------------------ #
     #  EXTRA HELPERS – ping / resources / prompts                        #

{chuk_tool_processor-0.1.4.dist-info → chuk_tool_processor-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chuk-tool-processor
-Version: 0.1.4
+Version: 0.1.6
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{chuk_tool_processor-0.1.4.dist-info → chuk_tool_processor-0.1.6.dist-info}/RECORD

@@ -1,7 +1,7 @@
 chuk_tool_processor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/core/__init__.py,sha256=slM7pZna88tyZrF3KtN22ApYyCqGNt5Yscv-knsLOOA,38
 chuk_tool_processor/core/exceptions.py,sha256=h4zL1jpCY1Ud1wT8xDeMxZ8GR8ttmkObcv36peUHJEA,1571
-chuk_tool_processor/core/processor.py,sha256=ud7ezONnUFh_aDSapiBGNx-LtZfhAFpYjFuw2m_tFXk,10165
+chuk_tool_processor/core/processor.py,sha256=fT3Qj8vmeUWoqOqHmWroi7lfJsMl52DpFQz8LT9UQME,10280
 chuk_tool_processor/execution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/execution/tool_executor.py,sha256=e1EHE-744uJuB1XeZZF_6VT25Yg1RCd8XI3v8uOrOSo,1794
 chuk_tool_processor/execution/strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -21,7 +21,7 @@ chuk_tool_processor/mcp/mcp_tool.py,sha256=TvZEudgQvaev2jaPw6OGsqAR5GNu6_cPaUCgq
 chuk_tool_processor/mcp/register_mcp_tools.py,sha256=ofE7pEn6sKDH8HWvNamVOaXsitLOaG48M5GhcpqCBbs,2801
 chuk_tool_processor/mcp/setup_mcp_sse.py,sha256=Ep2IKRdH1Y299bCxt9G0NtwnsvguYP6mpraZyUJ8OKU,2643
 chuk_tool_processor/mcp/setup_mcp_stdio.py,sha256=NjTvAFqQHxxN3XubsTgYY3lTrvPVWlnwCzkzbz7WE_M,2747
-chuk_tool_processor/mcp/stream_manager.py,sha256=qIWzsQCTlu1SQQBExAdvBHGB3T5isQDyMhj29WkfbKQ,11779
+chuk_tool_processor/mcp/stream_manager.py,sha256=mrmlG54P_xLbDYz_rBjdu-OPMnbi916dgyJg7BrIbjM,12798
 chuk_tool_processor/mcp/transport/__init__.py,sha256=7QQqeSKVKv0N9GcyJuYF0R4FDZeooii5RjggvFFg5GY,296
 chuk_tool_processor/mcp/transport/base_transport.py,sha256=1E29LjWw5vLQrPUDF_9TJt63P5dxAAN7n6E_KiZbGUY,3427
 chuk_tool_processor/mcp/transport/sse_transport.py,sha256=bryH9DOWOn5qr6LsimTriukDC4ix2kuRq6bUv9qOV20,7645
@@ -51,7 +51,7 @@ chuk_tool_processor/registry/providers/__init__.py,sha256=_0dg4YhyfAV0TXuR_i4ewX
 chuk_tool_processor/registry/providers/memory.py,sha256=29aI5uvykjDmn9ymIukEdUtmTC9SXOAsDu9hw36XF44,4474
 chuk_tool_processor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/utils/validation.py,sha256=7ezn_o-3IHDrzOD3j6ttsAn2s3zS-jIjeBTuqicrs6A,3775
-chuk_tool_processor-0.1.4.dist-info/METADATA,sha256=ekQNpVXyJrLw9kaLnhHW4iI1Q5do07T6Ol2QfeRsQn0,13703
-chuk_tool_processor-0.1.4.dist-info/WHEEL,sha256=GHB6lJx2juba1wDgXDNlMTyM13ckjBMKf-OnwgKOCtA,91
-chuk_tool_processor-0.1.4.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
-chuk_tool_processor-0.1.4.dist-info/RECORD,,
+chuk_tool_processor-0.1.6.dist-info/METADATA,sha256=XsvUbxDUKZHtefun8o-xsg6HvAm5hxqrEhkTFrhkjLI,13703
+chuk_tool_processor-0.1.6.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+chuk_tool_processor-0.1.6.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
+chuk_tool_processor-0.1.6.dist-info/RECORD,,

{chuk_tool_processor-0.1.4.dist-info → chuk_tool_processor-0.1.6.dist-info}/WHEEL

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