chuk-tool-processor 0.1.7__py3-none-any.whl → 0.3__py3-none-any.whl

chuk_tool_processor/execution/strategies/inprocess_strategy.py

@@ -1,11 +1,13 @@
 #!/usr/bin/env python
 # chuk_tool_processor/execution/strategies/inprocess_strategy.py
 """
-In-process execution strategy for tools with true streaming support.
+In-process execution strategy for tools with proper timeout handling.
 
 This strategy executes tools concurrently in the same process using asyncio.
 It has special support for streaming tools, accessing their stream_execute method
 directly to enable true item-by-item streaming.
+
+FIXED: Ensures consistent timeout handling across all execution paths.
 """
 from __future__ import annotations
 
@@ -36,7 +38,7 @@ async def _noop_cm():
 
 # --------------------------------------------------------------------------- #
 class InProcessStrategy(ExecutionStrategy):
-    """Execute tools in the local event-loop with optional concurrency cap."""
+    """Execute tools in the local event-loop with optional concurrency cap and consistent timeout handling."""
 
     def __init__(
         self,
@@ -53,7 +55,7 @@ class InProcessStrategy(ExecutionStrategy):
             max_concurrency: Maximum number of concurrent executions
         """
         self.registry = registry
-        self.default_timeout = default_timeout
+        self.default_timeout = default_timeout or 30.0  # Always have a default
         self._sem = asyncio.Semaphore(max_concurrency) if max_concurrency else None
         
         # Task tracking for cleanup
@@ -64,6 +66,9 @@ class InProcessStrategy(ExecutionStrategy):
         # Tracking for which calls are being handled directly by the executor
         # to prevent duplicate streaming results
         self._direct_streaming_calls = set()
+        
+        logger.debug("InProcessStrategy initialized with timeout: %ss, max_concurrency: %s", 
+                    self.default_timeout, max_concurrency)
 
     # ------------------------------------------------------------------ #
     def mark_direct_streaming(self, call_ids: Set[str]) -> None:
@@ -116,11 +121,15 @@ class InProcessStrategy(ExecutionStrategy):
         """
         if not calls:
             return []
+        
+        # Use default_timeout if no timeout specified
+        effective_timeout = timeout if timeout is not None else self.default_timeout
+        logger.debug("Executing %d calls with %ss timeout each", len(calls), effective_timeout)
             
         tasks = []
         for call in calls:
             task = asyncio.create_task(
-                self._execute_single_call(call, timeout or self.default_timeout)
+                self._execute_single_call(call, effective_timeout)  # Always pass timeout
             )
             self._active_tasks.add(task)
             task.add_done_callback(self._active_tasks.discard)
@@ -142,10 +151,13 @@ class InProcessStrategy(ExecutionStrategy):
         if not calls:
             return
 
+        # Use default_timeout if no timeout specified
+        effective_timeout = timeout if timeout is not None else self.default_timeout
+
         queue: asyncio.Queue[ToolResult] = asyncio.Queue()
         tasks = {
             asyncio.create_task(
-                self._stream_tool_call(call, queue, timeout or self.default_timeout)
+                self._stream_tool_call(call, queue, effective_timeout)  # Always pass timeout
             )
             for call in calls
             if call.id not in self._direct_streaming_calls
@@ -170,7 +182,7 @@ class InProcessStrategy(ExecutionStrategy):
         self,
         call: ToolCall,
         queue: asyncio.Queue,
-        timeout: Optional[float],
+        timeout: float,  # Make timeout required
     ) -> None:
         """
         Execute a tool call with streaming support.
@@ -181,7 +193,7 @@ class InProcessStrategy(ExecutionStrategy):
         Args:
             call: The tool call to execute
             queue: Queue to put results into
-            timeout: Optional timeout in seconds
+            timeout: Timeout in seconds (required)
         """
         # Skip if call is being handled directly by the executor
         if call.id in self._direct_streaming_calls:
@@ -269,7 +281,7 @@ class InProcessStrategy(ExecutionStrategy):
         tool: Any, 
         call: ToolCall, 
         queue: asyncio.Queue, 
-        timeout: Optional[float]
+        timeout: float,  # Make timeout required
     ) -> None:
         """
         Stream results from a streaming tool with timeout support.
@@ -281,12 +293,14 @@ class InProcessStrategy(ExecutionStrategy):
             tool: The tool instance
             call: Tool call data
             queue: Queue to put results into
-            timeout: Optional timeout in seconds
+            timeout: Timeout in seconds (required)
         """
         start_time = datetime.now(timezone.utc)
         machine = os.uname().nodename
         pid = os.getpid()
         
+        logger.debug("Streaming %s with %ss timeout", call.tool, timeout)
+        
         # Define the streaming task
         async def streamer():
             try:
@@ -318,15 +332,17 @@ class InProcessStrategy(ExecutionStrategy):
                 await queue.put(error_result)
         
         try:
-            # Execute with timeout if specified
-            if timeout:
-                await asyncio.wait_for(streamer(), timeout)
-            else:
-                await streamer()
+            # Always execute with timeout
+            await asyncio.wait_for(streamer(), timeout)
+            logger.debug("%s streaming completed within %ss", call.tool, timeout)
                 
         except asyncio.TimeoutError:
             # Handle timeout
             now = datetime.now(timezone.utc)
+            actual_duration = (now - start_time).total_seconds()
+            logger.debug("%s streaming timed out after %.3fs (limit: %ss)", 
+                        call.tool, actual_duration, timeout)
+            
             timeout_result = ToolResult(
                 tool=call.tool,
                 result=None,
@@ -341,6 +357,8 @@ class InProcessStrategy(ExecutionStrategy):
         except Exception as e:
             # Handle other errors
             now = datetime.now(timezone.utc)
+            logger.debug("%s streaming failed: %s", call.tool, e)
+            
             error_result = ToolResult(
                 tool=call.tool,
                 result=None,
@@ -356,7 +374,7 @@ class InProcessStrategy(ExecutionStrategy):
         self,
         call: ToolCall,
         queue: asyncio.Queue,
-        timeout: Optional[float],
+        timeout: float,  # Make timeout required
     ) -> None:
         """Execute a single call and put the result in the queue."""
         # Skip if call is being handled directly by the executor
@@ -370,17 +388,17 @@ class InProcessStrategy(ExecutionStrategy):
     async def _execute_single_call(
         self,
         call: ToolCall,
-        timeout: Optional[float],
+        timeout: float,  # Make timeout required, not optional
     ) -> ToolResult:
         """
-        Execute a single tool call.
+        Execute a single tool call with guaranteed timeout.
 
         The entire invocation – including argument validation – is wrapped
         by the semaphore to honour *max_concurrency*.
         
         Args:
             call: Tool call to execute
-            timeout: Optional timeout in seconds
+            timeout: Timeout in seconds (required)
             
         Returns:
             Tool execution result
@@ -389,6 +407,8 @@ class InProcessStrategy(ExecutionStrategy):
         machine = os.uname().nodename
         start = datetime.now(timezone.utc)
         
+        logger.debug("Executing %s with %ss timeout", call.tool, timeout)
+        
         # Early exit if shutting down
         if self._shutting_down:
             return ToolResult(
@@ -464,19 +484,18 @@ class InProcessStrategy(ExecutionStrategy):
         self,
         tool: Any,
         call: ToolCall,
-        timeout: float | None,
+        timeout: float,  # Make timeout required, not optional
         start: datetime,
         machine: str,
         pid: int,
     ) -> ToolResult:
         """
-        Resolve the correct async entry-point and invoke it with an optional
-        timeout.
+        Resolve the correct async entry-point and invoke it with a guaranteed timeout.
         
         Args:
             tool: Tool instance
             call: Tool call data
-            timeout: Optional timeout in seconds
+            timeout: Timeout in seconds (required)
             start: Start time for the execution
             machine: Machine name
             pid: Process ID
@@ -507,62 +526,46 @@ class InProcessStrategy(ExecutionStrategy):
             )
 
         try:
-            if timeout:
-                # Use a task with explicit cancellation
-                task = asyncio.create_task(fn(**call.arguments))
+            # Always apply timeout
+            logger.debug("Applying %ss timeout to %s", timeout, call.tool)
+            
+            try:
+                result_val = await asyncio.wait_for(fn(**call.arguments), timeout=timeout)
+                
+                end_time = datetime.now(timezone.utc)
+                actual_duration = (end_time - start).total_seconds()
+                logger.debug("%s completed in %.3fs (limit: %ss)", 
+                           call.tool, actual_duration, timeout)
                 
-                try:
-                    # Wait for the task with timeout
-                    result_val = await asyncio.wait_for(task, timeout)
-                    
-                    return ToolResult(
-                        tool=call.tool,
-                        result=result_val,
-                        error=None,
-                        start_time=start,
-                        end_time=datetime.now(timezone.utc),
-                        machine=machine,
-                        pid=pid,
-                    )
-                except asyncio.TimeoutError:
-                    # Cancel the task if it times out
-                    if not task.done():
-                        task.cancel()
-                        
-                        # Wait for cancellation to complete
-                        try:
-                            await task
-                        except asyncio.CancelledError:
-                            # Expected - we just cancelled it
-                            pass
-                        except Exception:
-                            # Ignore any other exceptions during cancellation
-                            pass
-                    
-                    # Return a timeout error
-                    return ToolResult(
-                        tool=call.tool,
-                        result=None,
-                        error=f"Timeout after {timeout}s",
-                        start_time=start,
-                        end_time=datetime.now(timezone.utc),
-                        machine=machine,
-                        pid=pid,
-                    )
-            else:
-                # No timeout
-                result_val = await fn(**call.arguments)
                 return ToolResult(
                     tool=call.tool,
                     result=result_val,
                     error=None,
                     start_time=start,
-                    end_time=datetime.now(timezone.utc),
+                    end_time=end_time,
                     machine=machine,
                     pid=pid,
                 )
+            except asyncio.TimeoutError:
+                # Handle timeout
+                end_time = datetime.now(timezone.utc)
+                actual_duration = (end_time - start).total_seconds()
+                logger.debug("%s timed out after %.3fs (limit: %ss)", 
+                           call.tool, actual_duration, timeout)
+                
+                return ToolResult(
+                    tool=call.tool,
+                    result=None,
+                    error=f"Timeout after {timeout}s",
+                    start_time=start,
+                    end_time=end_time,
+                    machine=machine,
+                    pid=pid,
+                )
+                
         except asyncio.CancelledError:
             # Handle cancellation explicitly
+            logger.debug("%s was cancelled", call.tool)
             return ToolResult(
                 tool=call.tool,
                 result=None,
@@ -574,12 +577,16 @@ class InProcessStrategy(ExecutionStrategy):
             )
         except Exception as exc:
             logger.exception("Error executing %s: %s", call.tool, exc)
+            end_time = datetime.now(timezone.utc)
+            actual_duration = (end_time - start).total_seconds()
+            logger.debug("%s failed after %.3fs: %s", call.tool, actual_duration, exc)
+            
             return ToolResult(
                 tool=call.tool,
                 result=None,
                 error=str(exc),
                 start_time=start,
-                end_time=datetime.now(timezone.utc),
+                end_time=end_time,
                 machine=machine,
                 pid=pid,
             )

chuk_tool_processor/execution/strategies/subprocess_strategy.py

@@ -4,6 +4,8 @@ Subprocess execution strategy - truly runs tools in separate OS processes.
 
 This strategy executes tools in separate Python processes using a process pool,
 providing isolation and potentially better parallelism on multi-core systems.
+
+FIXED: Ensures consistent timeout handling across all execution paths.
 """
 from __future__ import annotations
 
@@ -133,7 +135,7 @@ def _process_worker(
         
         try:
             # Execute the tool with timeout
-            if timeout:
+            if timeout is not None and timeout > 0:
                 result_value = loop.run_until_complete(
                     asyncio.wait_for(execute_fn(**arguments), timeout)
                 )
@@ -192,7 +194,7 @@ class SubprocessStrategy(ExecutionStrategy):
         """
         self.registry = registry
         self.max_workers = max_workers
-        self.default_timeout = default_timeout
+        self.default_timeout = default_timeout or 30.0  # Always have a default
         self.worker_init_timeout = worker_init_timeout
         
         # Process pool (initialized lazily)
@@ -204,6 +206,9 @@ class SubprocessStrategy(ExecutionStrategy):
         self._shutdown_event = asyncio.Event()
         self._shutting_down = False
         
+        logger.debug("SubprocessStrategy initialized with timeout: %ss, max_workers: %d", 
+                    self.default_timeout, max_workers)
+        
         # Register shutdown handler if in main thread
         try:
             loop = asyncio.get_running_loop()
@@ -238,12 +243,12 @@ class SubprocessStrategy(ExecutionStrategy):
                     loop.run_in_executor(self._process_pool, _pool_test_func),
                     timeout=self.worker_init_timeout
                 )
-                logger.info(f"Process pool initialized with {self.max_workers} workers")
+                logger.info("Process pool initialized with %d workers", self.max_workers)
             except Exception as e:
                 # Clean up on initialization error
                 self._process_pool.shutdown(wait=False)
                 self._process_pool = None
-                logger.error(f"Failed to initialize process pool: {e}")
+                logger.error("Failed to initialize process pool: %s", e)
                 raise RuntimeError(f"Failed to initialize process pool: {e}") from e
     
     # ------------------------------------------------------------------ #
@@ -296,12 +301,16 @@ class SubprocessStrategy(ExecutionStrategy):
                 )
                 for call in calls
             ]
+        
+        # Use default_timeout if no timeout specified
+        effective_timeout = timeout if timeout is not None else self.default_timeout
+        logger.debug("Executing %d calls in subprocesses with %ss timeout each", len(calls), effective_timeout)
             
         # Create tasks for each call
         tasks = []
         for call in calls:
             task = asyncio.create_task(self._execute_single_call(
-                call, timeout or self.default_timeout
+                call, effective_timeout  # Always pass concrete timeout
             ))
             self._active_tasks.add(task)
             task.add_done_callback(self._active_tasks.discard)
@@ -342,6 +351,9 @@ class SubprocessStrategy(ExecutionStrategy):
                     pid=os.getpid(),
                 )
             return
+        
+        # Use default_timeout if no timeout specified
+        effective_timeout = timeout if timeout is not None else self.default_timeout
             
         # Create a queue for results
         queue = asyncio.Queue()
@@ -350,7 +362,7 @@ class SubprocessStrategy(ExecutionStrategy):
         pending = set()
         for call in calls:
             task = asyncio.create_task(self._execute_to_queue(
-                call, queue, timeout or self.default_timeout
+                call, queue, effective_timeout  # Always pass concrete timeout
             ))
             self._active_tasks.add(task)
             task.add_done_callback(self._active_tasks.discard)
@@ -372,13 +384,13 @@ class SubprocessStrategy(ExecutionStrategy):
                 try:
                     await task
                 except Exception as e:
-                    logger.exception(f"Error in task: {e}")
+                    logger.exception("Error in task: %s", e)
 
     async def _execute_to_queue(
         self,
         call: ToolCall,
         queue: asyncio.Queue,
-        timeout: Optional[float],
+        timeout: float,  # Make timeout required
     ) -> None:
         """Execute a single call and put the result in the queue."""
         result = await self._execute_single_call(call, timeout)
@@ -387,20 +399,22 @@ class SubprocessStrategy(ExecutionStrategy):
     async def _execute_single_call(
         self,
         call: ToolCall,
-        timeout: Optional[float],
+        timeout: float,  # Make timeout required
     ) -> ToolResult:
         """
         Execute a single tool call in a separate process.
         
         Args:
             call: Tool call to execute
-            timeout: Optional timeout in seconds
+            timeout: Timeout in seconds (required)
             
         Returns:
             Tool execution result
         """
         start_time = datetime.now(timezone.utc)
         
+        logger.debug("Executing %s in subprocess with %ss timeout", call.tool, timeout)
+        
         try:
             # Ensure pool is initialized
             await self._ensure_pool()
@@ -429,8 +443,8 @@ class SubprocessStrategy(ExecutionStrategy):
             # Execute in subprocess
             loop = asyncio.get_running_loop()
             
-            # We need to add safety timeout here to handle process crashes
-            safety_timeout = (timeout or self.default_timeout or 60.0) + 5.0
+            # Add safety timeout to handle process crashes (tool timeout + buffer)
+            safety_timeout = timeout + 5.0
             
             try:
                 result_data = await asyncio.wait_for(
@@ -443,7 +457,7 @@ class SubprocessStrategy(ExecutionStrategy):
                             module_name, 
                             class_name, 
                             call.arguments, 
-                            timeout
+                            timeout  # Pass the actual timeout to worker
                         )
                     ),
                     timeout=safety_timeout
@@ -458,25 +472,40 @@ class SubprocessStrategy(ExecutionStrategy):
                     end_time_str = result_data["end_time"]
                     result_data["end_time"] = datetime.fromisoformat(end_time_str)
                 
+                end_time = datetime.now(timezone.utc)
+                actual_duration = (end_time - start_time).total_seconds()
+                
+                if result_data.get("error"):
+                    logger.debug("%s subprocess failed after %.3fs: %s", 
+                               call.tool, actual_duration, result_data["error"])
+                else:
+                    logger.debug("%s subprocess completed in %.3fs (limit: %ss)", 
+                               call.tool, actual_duration, timeout)
+                
                 # Create ToolResult from worker data
                 return ToolResult(
                     tool=result_data.get("tool", call.tool),
                     result=result_data.get("result"),
                     error=result_data.get("error"),
                     start_time=result_data.get("start_time", start_time),
-                    end_time=result_data.get("end_time", datetime.now(timezone.utc)),
+                    end_time=result_data.get("end_time", end_time),
                     machine=result_data.get("machine", os.uname().nodename),
                     pid=result_data.get("pid", os.getpid()),
                 )
                 
             except asyncio.TimeoutError:
                 # This happens if the worker process itself hangs
+                end_time = datetime.now(timezone.utc)
+                actual_duration = (end_time - start_time).total_seconds()
+                logger.debug("%s subprocess timed out after %.3fs (safety limit: %ss)", 
+                           call.tool, actual_duration, safety_timeout)
+                
                 return ToolResult(
                     tool=call.tool,
                     result=None,
                     error=f"Worker process timed out after {safety_timeout}s",
                     start_time=start_time,
-                    end_time=datetime.now(timezone.utc),
+                    end_time=end_time,
                     machine=os.uname().nodename,
                     pid=os.getpid(),
                 )
@@ -500,6 +529,7 @@ class SubprocessStrategy(ExecutionStrategy):
                 
         except asyncio.CancelledError:
             # Handle cancellation
+            logger.debug("%s subprocess was cancelled", call.tool)
             return ToolResult(
                 tool=call.tool,
                 result=None,
@@ -512,13 +542,18 @@ class SubprocessStrategy(ExecutionStrategy):
             
         except Exception as e:
             # Handle any other errors
-            logger.exception(f"Error executing {call.tool} in subprocess: {e}")
+            logger.exception("Error executing %s in subprocess: %s", call.tool, e)
+            end_time = datetime.now(timezone.utc)
+            actual_duration = (end_time - start_time).total_seconds()
+            logger.debug("%s subprocess setup failed after %.3fs: %s", 
+                       call.tool, actual_duration, e)
+            
             return ToolResult(
                 tool=call.tool,
                 result=None,
                 error=f"Error: {str(e)}",
                 start_time=start_time,
-                end_time=datetime.now(timezone.utc),
+                end_time=end_time,
                 machine=os.uname().nodename,
                 pid=os.getpid(),
             )
@@ -531,7 +566,7 @@ class SubprocessStrategy(ExecutionStrategy):
     async def _signal_handler(self, sig: int) -> None:
         """Handle termination signals."""
         signame = signal.Signals(sig).name
-        logger.info(f"Received {signame}, shutting down process pool")
+        logger.info("Received %s, shutting down process pool", signame)
         await self.shutdown()
         
     async def shutdown(self) -> None:
@@ -549,7 +584,7 @@ class SubprocessStrategy(ExecutionStrategy):
         # Cancel all active tasks
         active_tasks = list(self._active_tasks)
         if active_tasks:
-            logger.info(f"Cancelling {len(active_tasks)} active tool executions")
+            logger.info("Cancelling %d active tool executions", len(active_tasks))
             for task in active_tasks:
                 task.cancel()
                 

chuk_tool_processor/mcp/mcp_tool.py

@@ -36,9 +36,11 @@ class MCPTool:
         servers: Optional[List[str]] = None,
         server_names: Optional[Dict[int, str]] = None,
         namespace: str = "stdio",
+        default_timeout: Optional[float] = None,  # Add default timeout support
     ) -> None:
         self.tool_name = tool_name
         self._sm: Optional[StreamManager] = stream_manager
+        self.default_timeout = default_timeout or 30.0  # Default to 30s if not specified
 
         # Boot-strap parameters (only needed if _sm is None)
         self._cfg_file = cfg_file
@@ -78,21 +80,56 @@ class MCPTool:
         return self._sm  # type: ignore[return-value]
 
     # ------------------------------------------------------------------ #
-    async def execute(self, **kwargs: Any) -> Any:
+    async def execute(self, timeout: Optional[float] = None, **kwargs: Any) -> Any:
         """
-        Forward the call to the remote MCP tool.
+        Forward the call to the remote MCP tool with timeout support.
+
+        Args:
+            timeout: Optional timeout for this specific call. If not provided,
+                    uses the instance's default_timeout.
+            **kwargs: Arguments to pass to the MCP tool.
+
+        Returns:
+            The result from the MCP tool call.
 
         Raises
         ------
         RuntimeError
             If the server returns an error payload.
+        asyncio.TimeoutError
+            If the call times out.
         """
         sm = await self._ensure_stream_manager()
-        result = await sm.call_tool(tool_name=self.tool_name, arguments=kwargs)
+        
+        # Use provided timeout, fall back to instance default, then global default
+        effective_timeout = timeout if timeout is not None else self.default_timeout
+        
+        logger.debug("Calling MCP tool '%s' with timeout: %ss", self.tool_name, effective_timeout)
+        
+        try:
+            # Pass timeout directly to StreamManager instead of wrapping with wait_for
+            result = await sm.call_tool(
+                tool_name=self.tool_name, 
+                arguments=kwargs,
+                timeout=effective_timeout
+            )
+            
+            if result.get("isError"):
+                err = result.get("error", "Unknown error")
+                logger.error("Remote MCP error from '%s': %s", self.tool_name, err)
+                raise RuntimeError(err)
+
+            return result.get("content")
+            
+        except asyncio.TimeoutError:
+            logger.warning("MCP tool '%s' timed out after %ss", self.tool_name, effective_timeout)
+            raise
+        except Exception as e:
+            logger.error("Error calling MCP tool '%s': %s", self.tool_name, e)
+            raise
 
-        if result.get("isError"):
-            err = result.get("error", "Unknown error")
-            logger.error("Remote MCP error from '%s': %s", self.tool_name, err)
-            raise RuntimeError(err)
-
-        return result.get("content")
+    # ------------------------------------------------------------------ #
+    # Legacy method name support
+    async def _aexecute(self, timeout: Optional[float] = None, **kwargs: Any) -> Any:
+        """Legacy alias for execute() method."""
+        return await self.execute(timeout=timeout, **kwargs)

chuk_tool_processor/mcp/setup_mcp_sse.py

@@ -14,6 +14,7 @@ Utility that wires up:
 
 from __future__ import annotations
 
+import os
 from typing import Dict, List, Optional, Tuple
 
 from chuk_tool_processor.core.processor import ToolProcessor
@@ -47,7 +48,26 @@ async def setup_mcp_sse(  # noqa: C901 – long, but just a config wrapper
     and return a ready-to-go :class:`ToolProcessor`.
 
     Everything is **async-native** – call with ``await``.
+    
+    NEW: Automatically detects and adds bearer token from MCP_BEARER_TOKEN
+    environment variable if not explicitly provided in server config.
     """
+    
+    # NEW: Auto-detect and add bearer token to servers if available
+    bearer_token = os.getenv("MCP_BEARER_TOKEN")
+    if bearer_token:
+        logger.info("Found MCP_BEARER_TOKEN environment variable, adding to server configs")
+        
+        # Add api_key to servers that don't already have it
+        enhanced_servers = []
+        for server in servers:
+            enhanced_server = dict(server)  # Make a copy
+            if "api_key" not in enhanced_server and bearer_token:
+                enhanced_server["api_key"] = bearer_token
+                logger.info("Added bearer token to server: %s", enhanced_server.get("name", "unnamed"))
+            enhanced_servers.append(enhanced_server)
+        servers = enhanced_servers
+    
     # 1️⃣  connect to the remote MCP servers
     stream_manager = await StreamManager.create_with_sse(
         servers=servers,
@@ -76,4 +96,4 @@ async def setup_mcp_sse(  # noqa: C901 – long, but just a config wrapper
         "" if len(registered) == 1 else "s",
         namespace,
     )
-    return processor, stream_manager
+    return processor, stream_manager