chuk-tool-processor 0.4__py3-none-any.whl → 0.5__py3-none-any.whl

chuk_tool_processor/plugins/parsers/xml_tool.py

@@ -68,7 +68,7 @@ class XmlToolPlugin(ParserPlugin):
         return calls
 
     # ------------------------------------------------------------------ #
-    # Helper – robust JSON decode for the args attribute
+    # Helper - robust JSON decode for the args attribute
     # ------------------------------------------------------------------ #
     @staticmethod
     def _decode_args(raw_args: str) -> dict:
@@ -89,7 +89,7 @@ class XmlToolPlugin(ParserPlugin):
             except json.JSONDecodeError:
                 parsed = None
 
-        # 3️⃣ Last resort – naive unescaping of \" → "
+        # 3️⃣ Last resort - naive unescaping of \" → "
         if parsed is None:
             try:
                 parsed = json.loads(raw_args.replace(r"\"", "\""))

chuk_tool_processor/registry/auto_register.py

@@ -22,7 +22,7 @@ from pydantic import BaseModel, create_model
 try:  # optional dependency
     from langchain.tools.base import BaseTool  # type: ignore
 except ModuleNotFoundError:  # pragma: no cover
-    BaseTool = None  # noqa: N816  – keep the name for isinstance() checks
+    BaseTool = None  # noqa: N816  - keep the name for isinstance() checks
 
 # registry
 from .decorators import register_tool
@@ -30,7 +30,7 @@ from .provider import ToolRegistryProvider
 
 
 # ────────────────────────────────────────────────────────────────────────────
-# internals – build a Pydantic schema from an arbitrary callable
+# internals - build a Pydantic schema from an arbitrary callable
 # ────────────────────────────────────────────────────────────────────────────
 
 
@@ -39,7 +39,7 @@ def _auto_schema(func: Callable) -> Type[BaseModel]:
     Turn a function signature into a `pydantic.BaseModel` subclass.
 
     *Unknown* or *un-imported* annotations (common with third-party libs that
-    use forward-refs without importing the target – e.g. ``uuid.UUID`` in
+    use forward-refs without importing the target - e.g. ``uuid.UUID`` in
     LangChain's `CallbackManagerForToolRun`) default to ``str`` instead of
     crashing `get_type_hints()`.
     """
@@ -90,7 +90,7 @@ async def register_fn_tool(
     tool_description = (description or func.__doc__ or "").strip()
     
     # Create the tool wrapper class
-    class _Tool:  # noqa: D401, N801 – internal auto-wrapper
+    class _Tool:  # noqa: D401, N801 - internal auto-wrapper
         """Auto-generated tool wrapper for function."""
         
         async def execute(self, **kwargs: Any) -> Any:
@@ -154,7 +154,7 @@ async def register_langchain_tool(
 
     if not isinstance(tool, BaseTool):  # pragma: no cover
         raise TypeError(
-            "Expected a langchain.tools.base.BaseTool instance – got "
+            "Expected a langchain.tools.base.BaseTool instance - got "
             f"{type(tool).__name__}"
         )
 

chuk_tool_processor/registry/decorators.py

@@ -1,6 +1,10 @@
-# chuk_tool_processor/registry/decorators.py
+#!/usr/bin/env python
 """
-Decorators for registering tools with the registry asynchronously.
+Decorator that handles Pydantic models (StreamingTool) properly.
+
+The issue was that Pydantic models have strict field validation and reject
+arbitrary attribute assignment. This fix detects Pydantic models and handles
+them appropriately.
 """
 
 import asyncio
@@ -17,35 +21,221 @@ from chuk_tool_processor.registry.provider import ToolRegistryProvider
 T = TypeVar('T')
 
 # Global tracking of classes to be registered
-# Store coroutines rather than awaitables to avoid warnings
 _PENDING_REGISTRATIONS: List[Callable[[], Awaitable]] = []
 _REGISTERED_CLASSES = weakref.WeakSet()
-
-# Keep track of whether we're shutting down
 _SHUTTING_DOWN = False
 
 
-def register_tool(name: Optional[str] = None, namespace: str = "default", **metadata):
+def _is_pydantic_model(cls: Type) -> bool:
+    """Check if a class is a Pydantic model."""
+    try:
+        # Check for Pydantic v2
+        return hasattr(cls, 'model_fields') or hasattr(cls, '__pydantic_core_schema__')
+    except:
+        try:
+            # Check for Pydantic v1
+            return hasattr(cls, '__fields__')
+        except:
+            return False
+
+
+def _add_subprocess_serialization_support(cls: Type, tool_name: str) -> Type:
     """
-    Decorator for registering tools with the global registry.
+    Add subprocess serialization support to a tool class.
+    
+    FIXED: Now properly handles Pydantic models by using class attributes
+    instead of instance attributes where necessary.
+    """
+    # Store the tool name for serialization at class level
+    cls._tool_name = tool_name
     
-    This decorator will queue the registration to happen asynchronously.
-    You must call `await ensure_registrations()` in your application startup
-    to complete all registrations.
+    # Check if this is a Pydantic model
+    is_pydantic = _is_pydantic_model(cls)
+    
+    # Check if the class already has custom serialization methods
+    has_custom_getstate = '__getstate__' in cls.__dict__ and callable(cls.__dict__['__getstate__'])
+    has_custom_setstate = '__setstate__' in cls.__dict__ and callable(cls.__dict__['__setstate__'])
+    
+    if has_custom_getstate and has_custom_setstate:
+        # Class already has both custom serialization methods
+        original_getstate = cls.__getstate__
+        original_setstate = cls.__setstate__
+        
+        def enhanced_getstate(self):
+            """Enhanced __getstate__ that ensures tool_name is included."""
+            state = original_getstate(self)
+            if isinstance(state, dict):
+                state['tool_name'] = getattr(self, 'tool_name', tool_name)
+                return state
+            else:
+                return {
+                    '_custom_state': state,
+                    'tool_name': getattr(self, 'tool_name', tool_name)
+                }
+        
+        def enhanced_setstate(self, state):
+            """Enhanced __setstate__ that handles tool_name."""
+            if isinstance(state, dict) and '_custom_state' in state:
+                # FIXED: For Pydantic models, set as class attribute
+                if is_pydantic:
+                    self.__class__._tool_name = state.get('tool_name', tool_name)
+                else:
+                    self.tool_name = state.get('tool_name', tool_name)
+                original_setstate(self, state['_custom_state'])
+            else:
+                if isinstance(state, dict):
+                    if is_pydantic:
+                        self.__class__._tool_name = state.get('tool_name', tool_name)
+                    else:
+                        self.tool_name = state.get('tool_name', tool_name)
+                original_setstate(self, state)
+        
+        cls.__getstate__ = enhanced_getstate
+        cls.__setstate__ = enhanced_setstate
+        
+    elif not has_custom_getstate and not has_custom_setstate:
+        # No custom serialization methods - add default implementation
+        
+        if is_pydantic:
+            # FIXED: Special handling for Pydantic models
+            def __getstate__(self):
+                """Pydantic-compatible serialization method."""
+                try:
+                    # Try Pydantic v2 first
+                    if hasattr(self, 'model_dump'):
+                        state = self.model_dump()
+                    elif hasattr(self, 'dict'):
+                        # Pydantic v1
+                        state = self.dict()
+                    else:
+                        # Fallback to __dict__
+                        state = self.__dict__.copy()
+                except Exception:
+                    # Fallback to __dict__
+                    state = self.__dict__.copy()
+                
+                # Always include tool_name
+                state['tool_name'] = getattr(self, 'tool_name', getattr(self.__class__, '_tool_name', tool_name))
+                return state
+            
+            def __setstate__(self, state):
+                """Pydantic-compatible deserialization method."""
+                if isinstance(state, dict):
+                    # Extract tool_name and store at class level for Pydantic
+                    tool_name_value = state.get('tool_name', tool_name)
+                    self.__class__._tool_name = tool_name_value
+                    
+                    # For Pydantic models, we need to be careful about restoration
+                    try:
+                        # Remove tool_name from state since it's not a Pydantic field
+                        state_copy = state.copy()
+                        state_copy.pop('tool_name', None)
+                        
+                        # Update the object's fields
+                        if hasattr(self, '__dict__'):
+                            self.__dict__.update(state_copy)
+                    except Exception:
+                        # Fallback - just update __dict__
+                        if hasattr(self, '__dict__'):
+                            self.__dict__.update(state)
+                else:
+                    # Non-dict state
+                    self.__class__._tool_name = tool_name
+        
+        else:
+            # Regular class handling (same as before)
+            def __getstate__(self):
+                """Default serialization method for subprocess execution."""
+                state = self.__dict__.copy()
+                state['tool_name'] = getattr(self, 'tool_name', tool_name)
+                
+                # Remove non-serializable attributes
+                non_serializable_attrs = []
+                for key, value in list(state.items()):
+                    if key == 'tool_name':
+                        continue
+                    try:
+                        import pickle
+                        pickle.dumps(value)
+                    except (TypeError, AttributeError, pickle.PicklingError):
+                        non_serializable_attrs.append(key)
+                
+                for key in non_serializable_attrs:
+                    if key in state:
+                        del state[key]
+                
+                return state
+            
+            def __setstate__(self, state):
+                """Default deserialization method for subprocess execution."""
+                if isinstance(state, dict):
+                    self.__dict__.update(state)
+                    if not hasattr(self, 'tool_name') or not self.tool_name:
+                        self.tool_name = state.get('tool_name', tool_name)
+                else:
+                    self.tool_name = tool_name
+        
+        cls.__getstate__ = __getstate__
+        cls.__setstate__ = __setstate__
+    
+    # FIXED: Enhanced __init__ wrapper that handles Pydantic models
+    if hasattr(cls, '__init__'):
+        original_init = cls.__init__
+        
+        @functools.wraps(original_init)
+        def enhanced_init(self, *args, **kwargs):
+            # Call original __init__
+            original_init(self, *args, **kwargs)
+            
+            # FIXED: Handle tool_name setting based on model type
+            if is_pydantic:
+                # For Pydantic models, store at class level and add property
+                self.__class__._tool_name = tool_name
+                
+                # Add a property to access tool_name if it doesn't exist
+                if not hasattr(self.__class__, 'tool_name'):
+                    def tool_name_property(self):
+                        return getattr(self.__class__, '_tool_name', tool_name)
+                    
+                    # Add as a property
+                    setattr(self.__class__, 'tool_name', property(tool_name_property))
+            else:
+                # For regular classes, set as instance attribute
+                if not hasattr(self, 'tool_name'):
+                    self.tool_name = tool_name
+        
+        cls.__init__ = enhanced_init
+    else:
+        # FIXED: Add appropriate __init__ based on model type
+        if is_pydantic:
+            def __init__(self, *args, **kwargs):
+                super(cls, self).__init__(*args, **kwargs)
+                self.__class__._tool_name = tool_name
+        else:
+            def __init__(self):
+                self.tool_name = tool_name
+        
+        cls.__init__ = __init__
+    
+    # FIXED: Add tool_name property for Pydantic models
+    if is_pydantic and not hasattr(cls, 'tool_name'):
+        def tool_name_property(self):
+            return getattr(self.__class__, '_tool_name', tool_name)
+        
+        # Add as a property so it can be accessed but not set directly
+        setattr(cls, 'tool_name', property(tool_name_property))
     
-    Example:
-        @register_tool(name="my_tool", namespace="math", description="Performs math operations")
-        class MyTool:
-            async def execute(self, x: int, y: int) -> int:
-                return x + y
+    return cls
+
+
+def register_tool(name: Optional[str] = None, namespace: str = "default", **metadata):
+    """
+    Decorator for registering tools with the global registry.
     
-    Args:
-        name: Optional explicit name; if omitted, uses class.__name__.
-        namespace: Namespace for the tool (default: "default").
-        **metadata: Additional metadata for the tool.
+    FIXED: Now properly handles Pydantic models (like StreamingTool).
     
-    Returns:
-        A decorator function that registers the class with the registry.
+    This decorator automatically adds subprocess serialization support,
+    making tools compatible with both InProcessStrategy and SubprocessStrategy.
     """
     def decorator(cls: Type[T]) -> Type[T]:
         # Skip if already registered
@@ -59,76 +249,109 @@ def register_tool(name: Optional[str] = None, namespace: str = "default", **meta
         # Ensure execute method is async
         if hasattr(cls, 'execute') and not inspect.iscoroutinefunction(cls.execute):
             raise TypeError(f"Tool {cls.__name__} must have an async execute method")
+        
+        # Determine the tool name
+        tool_name = name or cls.__name__
+        
+        # FIXED: Add subprocess serialization support with Pydantic handling
+        enhanced_cls = _add_subprocess_serialization_support(cls, tool_name)
             
-        # Create registration function (not coroutine)
+        # Create registration function
         async def do_register():
             registry = await ToolRegistryProvider.get_registry()
             await registry.register_tool(
-                cls, 
-                name=name, 
+                enhanced_cls, 
+                name=tool_name, 
                 namespace=namespace, 
                 metadata=metadata
             )
         
-        # Store the function, not the coroutine
         _PENDING_REGISTRATIONS.append(do_register)
-        _REGISTERED_CLASSES.add(cls)
+        _REGISTERED_CLASSES.add(enhanced_cls)
         
-        # Add class attribute so we can identify decorated classes
-        cls._tool_registration_info = {
-            'name': name or cls.__name__,
+        # Add class attribute for identification
+        enhanced_cls._tool_registration_info = {
+            'name': tool_name,
             'namespace': namespace,
             'metadata': metadata
         }
         
-        # Don't modify the original class
-        return cls
+        return enhanced_cls
     
     return decorator
 
 
-async def ensure_registrations() -> None:
+# Alternative approach: A helper function for Pydantic compatibility
+def make_pydantic_tool_compatible(cls: Type, tool_name: str) -> Type:
     """
-    Process all pending tool registrations.
+    Alternative helper function to make Pydantic tools subprocess-compatible.
     
-    This must be called during application startup to register
-    all tools decorated with @register_tool.
-    
-    Returns:
-        None
+    This can be used as a manual alternative if the decorator approach
+    doesn't work for your specific use case.
     """
+    # Store tool name at class level
+    cls._tool_name = tool_name
+    
+    # Add property access
+    if not hasattr(cls, 'tool_name'):
+        def tool_name_getter(self):
+            return getattr(self.__class__, '_tool_name', tool_name)
+        
+        setattr(cls, 'tool_name', property(tool_name_getter))
+    
+    # Add serialization methods
+    if not hasattr(cls, '__getstate__'):
+        def __getstate__(self):
+            try:
+                if hasattr(self, 'model_dump'):
+                    state = self.model_dump()
+                elif hasattr(self, 'dict'):
+                    state = self.dict()
+                else:
+                    state = self.__dict__.copy()
+            except:
+                state = self.__dict__.copy()
+            
+            state['tool_name'] = getattr(self.__class__, '_tool_name', tool_name)
+            return state
+        
+        cls.__getstate__ = __getstate__
+    
+    if not hasattr(cls, '__setstate__'):
+        def __setstate__(self, state):
+            if isinstance(state, dict):
+                self.__class__._tool_name = state.get('tool_name', tool_name)
+                state_copy = state.copy()
+                state_copy.pop('tool_name', None)
+                if hasattr(self, '__dict__'):
+                    self.__dict__.update(state_copy)
+        
+        cls.__setstate__ = __setstate__
+    
+    return cls
+
+
+async def ensure_registrations() -> None:
+    """Process all pending tool registrations."""
     global _PENDING_REGISTRATIONS
     
     if not _PENDING_REGISTRATIONS:
         return
         
-    # Create tasks from the stored functions
     tasks = []
     for registration_fn in _PENDING_REGISTRATIONS:
-        # Now we await the function to get the coroutine, then create a task
         tasks.append(asyncio.create_task(registration_fn()))
     
-    # Clear the pending list
     _PENDING_REGISTRATIONS.clear()
     
-    # Wait for all registrations to complete
     if tasks:
         await asyncio.gather(*tasks)
 
 
 def discover_decorated_tools() -> List[Type]:
-    """
-    Discover all tool classes decorated with @register_tool.
-    
-    This can be used to inspect what tools have been registered
-    without awaiting ensure_registrations().
-    
-    Returns:
-        List of tool classes that have been decorated
-    """
+    """Discover all tool classes decorated with @register_tool."""
     tools = []
     
-    # Search all loaded modules
     for module_name, module in list(sys.modules.items()):
         if not module_name.startswith('chuk_tool_processor'):
             continue
@@ -144,22 +367,13 @@ def discover_decorated_tools() -> List[Type]:
     return tools
 
 
-# Register atexit handler to prevent warnings at shutdown
+# Shutdown handling
 def _handle_shutdown():
-    """
-    Handle shutdown by marking shutdown flag and clearing pending registrations.
-    This prevents warnings about unawaited coroutines.
-    """
+    """Handle shutdown by clearing pending registrations."""
     global _SHUTTING_DOWN, _PENDING_REGISTRATIONS
-    
-    # Set the shutdown flag
     _SHUTTING_DOWN = True
-    
-    # Clear without creating any coroutines
     _PENDING_REGISTRATIONS = []
 
-# Register the shutdown handler
-atexit.register(_handle_shutdown)
 
-# Filter the coroutine never awaited warning
+atexit.register(_handle_shutdown)
 warnings.filterwarnings("ignore", message="coroutine.*was never awaited")

chuk_tool_processor/registry/interface.py

@@ -104,8 +104,8 @@ class ToolRegistryInterface(Protocol):
 
         Args:
             namespace: Optional filter by namespace.
-                • None (default) – metadata from all namespaces
-                • "some_ns" – only that namespace
+                • None (default) - metadata from all namespaces
+                • "some_ns" - only that namespace
 
         Returns:
             List of ToolMetadata objects.

chuk_tool_processor/registry/providers/memory.py

@@ -125,8 +125,8 @@ class InMemoryToolRegistry(ToolRegistryInterface):
 
         Args:
             namespace: Optional filter by namespace.
-                • None (default) – metadata from all namespaces
-                • "some_ns" – only that namespace
+                • None (default) - metadata from all namespaces
+                • "some_ns" - only that namespace
 
         Returns:
             List of ToolMetadata objects.

chuk_tool_processor/utils/validation.py

@@ -25,7 +25,7 @@ __all__ = [
 ]
 
 # --------------------------------------------------------------------------- #
-# helpers – create & cache ad-hoc pydantic models
+# helpers - create & cache ad-hoc pydantic models
 # --------------------------------------------------------------------------- #
 
 

{chuk_tool_processor-0.4.dist-info → chuk_tool_processor-0.5.dist-info}/METADATA

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: chuk-tool-processor
-Version: 0.4
+Version: 0.5
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: chuk-mcp>=0.1.12
+Requires-Dist: chuk-mcp>=0.2
 Requires-Dist: dotenv>=0.9.9
-Requires-Dist: openai>=1.76.0
 Requires-Dist: pydantic>=2.11.3
 Requires-Dist: uuid>=1.30
 

{chuk_tool_processor-0.4.dist-info → chuk_tool_processor-0.5.dist-info}/RECORD

@@ -1,58 +1,58 @@
 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=ttEYZTQHctXXiUP8gxAMCCSjbRvyOHojQe_UJezJYRs,18369
+chuk_tool_processor/core/processor.py,sha256=diquzXCQax6wxK-MLfezIJIjdCm9rkRYSFsWMHXU2A4,18367
 chuk_tool_processor/execution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chuk_tool_processor/execution/tool_executor.py,sha256=SGnOrsQJ8b9dPD_2rYlRyp1WLcwn7pLfbrm5APOsQvo,14387
+chuk_tool_processor/execution/tool_executor.py,sha256=0kxOc6r_LOixANitCOKWX-VJbdquHskSl7fvdzPbOX4,14401
 chuk_tool_processor/execution/strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chuk_tool_processor/execution/strategies/inprocess_strategy.py,sha256=UJIv1g3Z9LpMsTYa9cqJB376StsI0up3cftH4OkqC2I,22582
-chuk_tool_processor/execution/strategies/subprocess_strategy.py,sha256=Rb5GTffl-4dkAQG_zz8wjggqyWznVOr9gReLGHmE2io,22469
+chuk_tool_processor/execution/strategies/inprocess_strategy.py,sha256=95dP4jrCBfFCCEIC5Nld3L_yNEH2E6RZhc5LhNiaFj0,23480
+chuk_tool_processor/execution/strategies/subprocess_strategy.py,sha256=i_xtKx79OwjXAerGFvrpnfG0L2W1JL98DHt9hwE3MyA,24795
 chuk_tool_processor/execution/wrappers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chuk_tool_processor/execution/wrappers/caching.py,sha256=1pSyouYT4H7AGkNcK_7wWAIT1d4AKnHJlKBODPO8tZw,20416
+chuk_tool_processor/execution/wrappers/caching.py,sha256=3KDb84ARhDKjUQXrpJT1FaO2pM8ciXFuEdr5zmeLiBM,20410
 chuk_tool_processor/execution/wrappers/rate_limiting.py,sha256=CBBsI1VLosjo8dZXLeJ3IaclGvy9VdjGyqgunY089KQ,9231
-chuk_tool_processor/execution/wrappers/retry.py,sha256=oK6g0Ey8zbAubOgOvDbTFyvP1bVCI53knjXgfd_b3dw,10350
-chuk_tool_processor/logging/__init__.py,sha256=Uux0QnL6Xcd4vNjtt54rNei3yvxUZ-sOuAahlcPAez0,3382
-chuk_tool_processor/logging/context.py,sha256=8wLE6yoDxush7rGu_wTzVCautqq-Jq_0R9SBxLOjpwI,8520
+chuk_tool_processor/execution/wrappers/retry.py,sha256=UgJ1UzOGx-HOXfMYmqVfRcMQKT6Q4l2eb4nJJ6nSSps,10144
+chuk_tool_processor/logging/__init__.py,sha256=UDFPYU_bzeUUSN8qw3nMpo-FMKXetIi7OYtN3W3iPbg,3794
+chuk_tool_processor/logging/context.py,sha256=69EsAhCiya_4zyivz1uUJAhwo0rXpOoTvePWvaFYIi8,12225
 chuk_tool_processor/logging/formatter.py,sha256=RhlV6NqBYRBOtytDY49c9Y1J4l02ZjNXIgVRn03tfSQ,3061
 chuk_tool_processor/logging/helpers.py,sha256=c1mS1sb_rh4bKG0hisyvT7l7cirQfXPSyWeBqmqALRw,5941
 chuk_tool_processor/logging/metrics.py,sha256=s59Au8q0eqGGtJMDqmJBZhbJHh4BWGE1CzT0iI8lRS8,3624
 chuk_tool_processor/mcp/__init__.py,sha256=vR9HHxLpXlKTIIwJJRr3QTmZegcdedR1YKyb46j6FIM,689
-chuk_tool_processor/mcp/mcp_tool.py,sha256=a7WnBiu8DaSuZ8RI0Ums4M5A7v46RvijlqZa0020wWg,4922
-chuk_tool_processor/mcp/register_mcp_tools.py,sha256=0q73gafC1d0ei_gqNidcUeY7NUg13UZdjhVOKEFcD5o,3642
-chuk_tool_processor/mcp/setup_mcp_sse.py,sha256=T0V27azQy06yc-RSc5uzEKyhbyAXFT-7O3pIn4k10HQ,3769
-chuk_tool_processor/mcp/setup_mcp_stdio.py,sha256=P9qSgmxoNQbsOlGp83DlLLpN9BsG__MhlRsxFplNP3M,2753
-chuk_tool_processor/mcp/stream_manager.py,sha256=Wro1csV8S-V-PBan-4-c3cCyhJPmxG1wQJa4MLh02Dc,16914
+chuk_tool_processor/mcp/mcp_tool.py,sha256=XZ83UG76TaBqiP5OUfnG78YsYUQ2B1RfncligGHu_zw,8899
+chuk_tool_processor/mcp/register_mcp_tools.py,sha256=ZqR9kikHCbD7InL5cYl9ttUkhA5e4q2S76lbPLWe98I,3636
+chuk_tool_processor/mcp/setup_mcp_sse.py,sha256=Sja3y1uBkqKfpGS69Y90KBb9XNDxKDu3GgQsFqgFiTU,3761
+chuk_tool_processor/mcp/setup_mcp_stdio.py,sha256=emSL1IabdHoFdNUpEJNdzlc9-0qA51ZMuNJHpsYtw5o,2749
+chuk_tool_processor/mcp/stream_manager.py,sha256=FRTvvSBzBxU6-kPU1mZOjGCaqi8hHk5_F-h0jXynATg,19118
 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=2nyuc04Clc4FmJWxxZ2TmwiRd9NI7fpLqSN-g1wvRAI,19689
-chuk_tool_processor/mcp/transport/stdio_transport.py,sha256=lFXL7p8ca4z_J0RBL8UCHrQ1UH7C2-LbC0tZhpya4V4,7763
+chuk_tool_processor/mcp/transport/base_transport.py,sha256=bqId34OMQMxzMXtrKq_86sot0_x0NS_ecaIllsCyy6I,3423
+chuk_tool_processor/mcp/transport/sse_transport.py,sha256=nzzMgCgfUV_-Owga2rqJFEc5WLdgXZ922V9maLMwRBI,19408
+chuk_tool_processor/mcp/transport/stdio_transport.py,sha256=5ocANj4wWnYxOZVuz2ttxfyMq3CHkznvIXBtCdBTJvo,7727
 chuk_tool_processor/models/__init__.py,sha256=TC__rdVa0lQsmJHM_hbLDPRgToa_pQT_UxRcPZk6iVw,40
 chuk_tool_processor/models/execution_strategy.py,sha256=UVW35YIeMY2B3mpIKZD2rAkyOPayI6ckOOUALyf0YiQ,2115
 chuk_tool_processor/models/streaming_tool.py,sha256=0v2PSPTgZ5TS_PpVdohvVhh99fPwPQM_R_z4RU0mlLM,3541
 chuk_tool_processor/models/tool_call.py,sha256=t3QOQVzUaNRBea_n5fsrCgK4_ILiZlT8LvF7UwaZU84,1748
 chuk_tool_processor/models/tool_export_mixin.py,sha256=U9NJvn9fqH3pW50ozdDAHlA0fQSnjUt-lYhEoW_leZU,998
 chuk_tool_processor/models/tool_result.py,sha256=-8LdlaE9Ajfb1t-UyN9lW0XB2abQWALD7j8PZc-txhQ,5029
-chuk_tool_processor/models/validated_tool.py,sha256=LYc9-IBCiQmoMUotyByinRQQ-jfrC6g6tflMtSf9MUg,5908
+chuk_tool_processor/models/validated_tool.py,sha256=m12jmaOsKek5pib1uXEOuDMILf9qoDzb-aqlp9wedMc,5896
 chuk_tool_processor/plugins/__init__.py,sha256=QO_ipvlsWG-rbaqGzj6-YtD7zi7Lx26hw-Cqha4MuWc,48
-chuk_tool_processor/plugins/discovery.py,sha256=kHRpOrcRnHiviKHCCdQN04cpSUqbifAZdSbU81Wc0fA,7112
+chuk_tool_processor/plugins/discovery.py,sha256=ZKWTJgrKzKnIuCPHg1CPu0j7e1L4R8y10Tq9IKXkj5M,7106
 chuk_tool_processor/plugins/parsers/__init__.py,sha256=07waNfAGuytn-Dntx2IxjhgSkM9F40TBYNUXC8G4VVo,49
-chuk_tool_processor/plugins/parsers/base.py,sha256=r-15AZUmlGwWC3EQHRxiqPgivNv-mro6aTKqOwhuAtg,752
+chuk_tool_processor/plugins/parsers/base.py,sha256=sqBngdyCoUwUsTTJlT6722jN0QxxYz-ijtD4hmEK6mU,750
 chuk_tool_processor/plugins/parsers/function_call_tool.py,sha256=kaUTMhIpDP4jZa_CJZiGchIoszK3AboZM2BJOXzPJmg,3198
 chuk_tool_processor/plugins/parsers/json_tool.py,sha256=jljG7jR9070oHSTFqcrXbtFjYorw1cb4ZpwfrsLgFSE,1556
 chuk_tool_processor/plugins/parsers/openai_tool.py,sha256=O33DyXN0Llqv7AHygE9sVQkbSDVNIOcNqqa1CaZF6vo,2849
-chuk_tool_processor/plugins/parsers/xml_tool.py,sha256=V-JSWWy1ncXwX6-Of45zaLEGXryjKMTDEgTmEl6-XlY,3186
+chuk_tool_processor/plugins/parsers/xml_tool.py,sha256=oIDSWOk38IUKBAMoGuN2hnrAhrhDuO_9L0-p77rEHJw,3182
 chuk_tool_processor/registry/__init__.py,sha256=PBv5QyzHmUJEjgFQW1zgcUmppa5xUTjXTLVsYoVnDQI,2036
-chuk_tool_processor/registry/auto_register.py,sha256=wanaibx9CNsI1et0v2I25xzi5I_w8YaSlvW05ENEpIU,7252
-chuk_tool_processor/registry/decorators.py,sha256=qFK-z7wd53BY7rEbqqWMrWQXbP4UaTLVTCQRI2iUhHI,5035
-chuk_tool_processor/registry/interface.py,sha256=dqThCnHd2KCgX8j96j_hZxF2rigGClrI-hRc5n_nv2M,3467
+chuk_tool_processor/registry/auto_register.py,sha256=cPod3t1Gng9Dz2-ujqpZBsrpOOcLd7UBJ7L6NqXzXqU,7242
+chuk_tool_processor/registry/decorators.py,sha256=VBPCPgOQTDT0BT_GiXC4NaIv2Cdxu7ZCNPLoys1nLoA,14207
+chuk_tool_processor/registry/interface.py,sha256=sFacGnhcZXmeK7iF5fSm21ktecYTVzRiyGjxGWSkt-k,3463
 chuk_tool_processor/registry/metadata.py,sha256=lR9FO__lhPr-ax7PhFk8Se1bJdN_48rabiN7qegx4Ns,4582
 chuk_tool_processor/registry/provider.py,sha256=YUCGCFARNxnzV2Dm72Ur4DOrDs_ZYDtCzd6OBBzlis8,5162
 chuk_tool_processor/registry/tool_export.py,sha256=FEdMsfZ3uhiOjoDHqcnSwNehAN7Z5mgi4nI1UKu2hgs,7569
 chuk_tool_processor/registry/providers/__init__.py,sha256=eigwG_So11j7WbDGSWaKd3KwVen3Rap-aNQCSWA6T4k,2705
-chuk_tool_processor/registry/providers/memory.py,sha256=LlpPUU9E7S8Se6Q3VyKxLwpNm82SvmP8GLUmI8MkHxQ,5188
+chuk_tool_processor/registry/providers/memory.py,sha256=6cMtUwLO6zrk3pguQRgxJ2CReHAzewgZsizWZhsoStk,5184
 chuk_tool_processor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chuk_tool_processor/utils/validation.py,sha256=fiTSsHq7zx-kyd755GaFCvPCa-EVasSpg0A1liNHkxU,4138
-chuk_tool_processor-0.4.dist-info/METADATA,sha256=yk5rGA3xmEMCEZtikLNE508Q7oY1GwbTZR2jzOR2P5I,24312
-chuk_tool_processor-0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-chuk_tool_processor-0.4.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
-chuk_tool_processor-0.4.dist-info/RECORD,,
+chuk_tool_processor/utils/validation.py,sha256=V5N1dH9sJlHepFIbiI2k2MU82o7nvnh0hKyIt2jdgww,4136
+chuk_tool_processor-0.5.dist-info/METADATA,sha256=fo__t2M-CSnUDOPMgmibn8oGbI_zmSEfmtBSRG40OYw,24279
+chuk_tool_processor-0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chuk_tool_processor-0.5.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
+chuk_tool_processor-0.5.dist-info/RECORD,,