flock-core 0.5.0b63__py3-none-any.whl → 0.5.0b65__py3-none-any.whl

flock/agent.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 import os
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, TypedDict
 
 from pydantic import BaseModel
 
@@ -27,6 +27,38 @@ if TYPE_CHECKING:  # pragma: no cover - type hints only
     from flock.orchestrator import Flock
 
 
+class MCPServerConfig(TypedDict, total=False):
+    """Configuration for MCP server assignment to an agent.
+
+    All fields are optional. If omitted, no restrictions apply.
+
+    Attributes:
+        roots: Filesystem paths this server can access.
+               Empty list or omitted = no mount restrictions.
+        tool_whitelist: Tool names the agent can use from this server.
+                       Empty list or omitted = all tools available.
+
+    Examples:
+        >>> # No restrictions
+        >>> config: MCPServerConfig = {}
+
+        >>> # Mount restrictions only
+        >>> config: MCPServerConfig = {"roots": ["/workspace/data"]}
+
+        >>> # Tool whitelist only
+        >>> config: MCPServerConfig = {"tool_whitelist": ["read_file", "write_file"]}
+
+        >>> # Both restrictions
+        >>> config: MCPServerConfig = {
+        ...     "roots": ["/workspace/data"],
+        ...     "tool_whitelist": ["read_file"]
+        ... }
+    """
+
+    roots: list[str]
+    tool_whitelist: list[str]
+
+
 @dataclass
 class AgentOutput:
     spec: ArtifactSpec
@@ -67,7 +99,7 @@ class Agent(metaclass=AutoTracedMeta):
         self.engines: list[EngineComponent] = []
         self.best_of_n: int = 1
         self.best_of_score: Callable[[EvalResult], float] | None = None
-        self.max_concurrency: int = 1
+        self.max_concurrency: int = 2
         self._semaphore = asyncio.Semaphore(self.max_concurrency)
         self.calls_func: Callable[..., Any] | None = None
         self.tools: set[Callable[..., Any]] = set()
@@ -77,6 +109,9 @@ class Agent(metaclass=AutoTracedMeta):
         self.prevent_self_trigger: bool = True  # T065: Prevent infinite feedback loops
         # MCP integration
         self.mcp_server_names: set[str] = set()
+        self.mcp_mount_points: list[str] = []  # Deprecated: Use mcp_server_mounts instead
+        self.mcp_server_mounts: dict[str, list[str]] = {}  # Server-specific mount points
+        self.tool_whitelist: list[str] | None = None
 
     @property
     def identity(self) -> AgentIdentity:
@@ -137,15 +172,30 @@ class Agent(metaclass=AutoTracedMeta):
             # Get the MCP manager from orchestrator
             manager = self._orchestrator.get_mcp_manager()
 
-            # Import tool wrapper
-
             # Fetch tools from all assigned servers
             tools_dict = await manager.get_tools_for_agent(
                 agent_id=self.name,
                 run_id=ctx.task_id,
                 server_names=self.mcp_server_names,
+                server_mounts=self.mcp_server_mounts,  # Pass server-specific mounts
             )
 
+            # Whitelisting logic
+            tool_whitelist = self.tool_whitelist
+            if (
+                tool_whitelist is not None
+                and isinstance(tool_whitelist, list)
+                and len(tool_whitelist) > 0
+            ):
+                filtered_tools: dict[str, Any] = {}
+                for tool_key, tool_entry in tools_dict.items():
+                    if isinstance(tool_entry, dict):
+                        original_name = tool_entry.get("original_name", None)
+                        if original_name is not None and original_name in tool_whitelist:
+                            filtered_tools[tool_key] = tool_entry
+
+                tools_dict = filtered_tools
+
             # Convert to DSPy tool callables
             dspy_tools = []
             for namespaced_name, tool_info in tools_dict.items():
@@ -630,30 +680,103 @@ class AgentBuilder:
         self._agent.tools.update(funcs)
         return self
 
-    def with_mcps(self, server_names: Iterable[str]) -> AgentBuilder:
-        """Assign MCP servers to this agent.
-
-        Architecture Decision: AD001 - Two-Level Architecture
-        Agents reference servers registered at orchestrator level.
-
-        Args:
-            server_names: Names of MCP servers this agent should use
-
-        Returns:
-            self for method chaining
-
-        Raises:
-            ValueError: If any server name is not registered with orchestrator
-
-        Example:
-            >>> agent = (
-            ...     orchestrator.agent("file_agent")
-            ...     .with_mcps(["filesystem", "github"])
-            ...     .build()
-            ... )
+    def with_mcps(
+        self,
+        servers: (
+            Iterable[str]
+            | dict[str, MCPServerConfig | list[str]]  # Support both new and old format
+            | list[str | dict[str, MCPServerConfig | list[str]]]
+        ),
+    ) -> AgentBuilder:
+        """Assign MCP servers to this agent with optional server-specific mount points.
+
+                Architecture Decision: AD001 - Two-Level Architecture
+                Agents reference servers registered at orchestrator level.
+
+                Args:
+                    servers: One of:
+                        - List of server names (strings) - no specific mounts
+                        - Dict mapping server names to MCPServerConfig or list[str] (backward compatible)
+                        - Mixed list of strings and dicts for flexibility
+
+                Returns:
+                    self for method chaining
+
+                Raises:
+                    ValueError: If any server name is not registered with orchestrator
+
+                Examples:
+                    >>> # Simple: no mount restrictions
+                    >>> agent.with_mcps(["filesystem", "github"])
+
+                    >>> # New format: Server-specific config with roots and tool whitelist
+                    >>> agent.with_mcps({
+                    ...     "filesystem": {"roots": ["/workspace/dir/data"], "tool_whitelist": ["read_file"]},
+                    ...     "github": {}  # No restrictions for github
+                    ... })
+
+                    >>> # Old format: Direct list (backward compatible)
+                    >>> agent.with_mcps({
+                    ...     "filesystem": ["/workspace/dir/data"],  # Old format still works
+                    ... })
+
+                    >>> # Mixed: backward compatible
+                    >>> agent.with_mcps([
+                    ...     "github",  # No mounts
+                    ...     {"filesystem": {"roots": ["mount1", "mount2"] } }
+        ```
+                    ... ])
         """
-        # Convert to set for efficient lookup
-        server_set = set(server_names)
+        # Parse input into server_names and mounts
+        server_set: set[str] = set()
+        server_mounts: dict[str, list[str]] = {}
+        whitelist = None
+
+        if isinstance(servers, dict):
+            # Dict format: supports both old and new formats
+            # Old: {"server": ["/path1", "/path2"]}
+            # New: {"server": {"roots": ["/path1"], "tool_whitelist": ["tool1"]}}
+            for server_name, server_config in servers.items():
+                server_set.add(server_name)
+
+                # Check if it's the old format (direct list) or new format (MCPServerConfig dict)
+                if isinstance(server_config, list):
+                    # Old format: direct list of paths (backward compatibility)
+                    if len(server_config) > 0:
+                        server_mounts[server_name] = list(server_config)
+                elif isinstance(server_config, dict):
+                    # New format: MCPServerConfig with optional roots and tool_whitelist
+                    mounts = server_config.get("roots", None)
+                    if mounts is not None and isinstance(mounts, list) and len(mounts) > 0:
+                        server_mounts[server_name] = list(mounts)
+
+                    config_whitelist = server_config.get("tool_whitelist", None)
+                    if (
+                        config_whitelist is not None
+                        and isinstance(config_whitelist, list)
+                        and len(config_whitelist) > 0
+                    ):
+                        whitelist = config_whitelist
+        elif isinstance(servers, list):
+            # List format: can be mixed
+            for item in servers:
+                if isinstance(item, str):
+                    # Simple server name
+                    server_set.add(item)
+                elif isinstance(item, dict):
+                    # Dict with mounts
+                    for server_name, mounts in item.items():
+                        server_set.add(server_name)
+                        if mounts:
+                            server_mounts[server_name] = list(mounts)
+                else:
+                    raise TypeError(
+                        f"Invalid server specification: {item}. "
+                        f"Expected string or dict, got {type(item).__name__}"
+                    )
+        else:
+            # Assume it's an iterable of strings (backward compatibility)
+            server_set = set(servers)
 
         # Validate all servers exist in orchestrator
         registered_servers = set(self._orchestrator._mcp_configs.keys())
@@ -669,6 +792,61 @@ class AgentBuilder:
 
         # Store in agent
         self._agent.mcp_server_names = server_set
+        self._agent.mcp_server_mounts = server_mounts
+        self._agent.tool_whitelist = whitelist
+
+        return self
+
+    def mount(self, paths: str | list[str], *, validate: bool = False) -> AgentBuilder:
+        """Mount agent in specific directories for MCP root access.
+
+        .. deprecated:: 0.2.0
+            Use `.with_mcps({"server_name": ["/path"]})` instead for server-specific mounts.
+            This method applies mounts globally to all MCP servers.
+
+        This sets the filesystem roots that MCP servers will operate under for this agent.
+        Paths are cumulative across multiple calls.
+
+        Args:
+            paths: Single path or list of paths to mount
+            validate: If True, validate that paths exist (default: False)
+
+        Returns:
+            AgentBuilder for method chaining
+
+        Example:
+            >>> # Old way (deprecated)
+            >>> agent.with_mcps(["filesystem"]).mount("/workspace/src")
+            >>>
+            >>> # New way (recommended)
+            >>> agent.with_mcps({"filesystem": ["/workspace/src"]})
+        """
+        import warnings
+
+        warnings.warn(
+            "Agent.mount() is deprecated. Use .with_mcps({'server': ['/path']}) "
+            "for server-specific mounts instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        if isinstance(paths, str):
+            paths = [paths]
+        if validate:
+            from pathlib import Path
+
+            for path in paths:
+                if not Path(path).exists():
+                    raise ValueError(f"Mount path does not exist: {path}")
+
+        # Add to agent's mount points (cumulative) - for backward compatibility
+        self._agent.mcp_mount_points.extend(paths)
+
+        # Also add to all configured servers for backward compatibility
+        for server_name in self._agent.mcp_server_names:
+            if server_name not in self._agent.mcp_server_mounts:
+                self._agent.mcp_server_mounts[server_name] = []
+            self._agent.mcp_server_mounts[server_name].extend(paths)
 
         return self
 

flock/dashboard/websocket.py

@@ -124,15 +124,26 @@ class WebSocketManager:
         # Broadcast to all clients concurrently
         # Use return_exceptions=True to handle client failures gracefully
         # Use send_text() for FastAPI WebSocket (send JSON string as text)
+        # CRITICAL: Add timeout to prevent deadlock when client send buffer is full
         clients_list = list(self.clients)  # Copy to avoid modification during iteration
-        send_tasks = [client.send_text(message) for client in clients_list]
+
+        send_tasks = [
+            asyncio.wait_for(client.send_text(message), timeout=0.5)  # 500ms timeout
+            for client in clients_list
+        ]
         results = await asyncio.gather(*send_tasks, return_exceptions=True)
 
         # Remove clients that failed to receive the message
         failed_clients = []
         for client, result in zip(clients_list, results, strict=False):
             if isinstance(result, Exception):
-                logger.warning(f"Failed to send to client: {result}")
+                # Check if it's a timeout (backpressure) or other error
+                if isinstance(result, asyncio.TimeoutError):
+                    logger.warning(
+                        "Client send timeout (backpressure) - client is slow or disconnected, removing client"
+                    )
+                else:
+                    logger.warning(f"Failed to send to client: {result}")
                 failed_clients.append(client)
 
         # Clean up failed clients

flock/engines/dspy_engine.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import json
 import os
 from collections import OrderedDict, defaultdict
@@ -562,6 +563,9 @@ class DSPyEngine(EngineComponent):
         stream_buffers[status_field] = []
         stream_sequence = 0  # Monotonic sequence for ordering
 
+        # Track background WebSocket broadcast tasks to prevent garbage collection
+        ws_broadcast_tasks: set[asyncio.Task] = set()
+
         formatter = theme_dict = styles = agent_label = None
         live_cm = nullcontext()
         overflow_mode = self.stream_vertical_overflow
@@ -607,7 +611,7 @@ class DSPyEngine(EngineComponent):
                         stream_buffers[status_field].append(str(token) + "\n")
                         display_data["status"] = "".join(stream_buffers[status_field])
 
-                        # Emit to WebSocket
+                        # Emit to WebSocket (non-blocking to prevent deadlock)
                         if ws_manager and token:
                             try:
                                 event = StreamingOutputEvent(
@@ -621,10 +625,15 @@ class DSPyEngine(EngineComponent):
                                     sequence=stream_sequence,
                                     is_final=False,
                                 )
-                                await ws_manager.broadcast(event)
+                                # Use create_task to avoid blocking the streaming loop
+                                task = asyncio.create_task(ws_manager.broadcast(event))
+                                ws_broadcast_tasks.add(task)
+                                task.add_done_callback(ws_broadcast_tasks.discard)
                                 stream_sequence += 1
                             except Exception as e:
                                 logger.warning(f"Failed to emit streaming event: {e}")
+                        else:
+                            logger.exception("NO WS_MANAGER PRESENT!!!!")
 
                         if formatter is not None:
                             _refresh_panel()
@@ -643,7 +652,7 @@ class DSPyEngine(EngineComponent):
                                 stream_buffers[buffer_key]
                             )
 
-                            # Emit to WebSocket
+                            # Emit to WebSocket (non-blocking to prevent deadlock)
                             if ws_manager:
                                 logger.info(
                                     f"[STREAMING] Emitting StreamResponse token='{token}', sequence={stream_sequence}"
@@ -660,7 +669,10 @@ class DSPyEngine(EngineComponent):
                                         sequence=stream_sequence,
                                         is_final=False,
                                     )
-                                    await ws_manager.broadcast(event)
+                                    # Use create_task to avoid blocking the streaming loop
+                                    task = asyncio.create_task(ws_manager.broadcast(event))
+                                    ws_broadcast_tasks.add(task)
+                                    task.add_done_callback(ws_broadcast_tasks.discard)
                                     stream_sequence += 1
                                 except Exception as e:
                                     logger.warning(f"Failed to emit streaming event: {e}")
@@ -690,7 +702,7 @@ class DSPyEngine(EngineComponent):
                         stream_buffers[status_field].append(str(token))
                         display_data["status"] = "".join(stream_buffers[status_field])
 
-                    # Emit to WebSocket
+                    # Emit to WebSocket (non-blocking to prevent deadlock)
                     if ws_manager and token:
                         try:
                             event = StreamingOutputEvent(
@@ -704,7 +716,10 @@ class DSPyEngine(EngineComponent):
                                 sequence=stream_sequence,
                                 is_final=False,
                             )
-                            await ws_manager.broadcast(event)
+                            # Use create_task to avoid blocking the streaming loop
+                            task = asyncio.create_task(ws_manager.broadcast(event))
+                            ws_broadcast_tasks.add(task)
+                            task.add_done_callback(ws_broadcast_tasks.discard)
                             stream_sequence += 1
                         except Exception as e:
                             logger.warning(f"Failed to emit streaming event: {e}")
@@ -716,7 +731,7 @@ class DSPyEngine(EngineComponent):
                 if isinstance(value, dspy_mod.Prediction):
                     final_result = value
 
-                    # Emit final streaming event
+                    # Emit final streaming event (non-blocking to prevent deadlock)
                     if ws_manager:
                         try:
                             event = StreamingOutputEvent(
@@ -730,7 +745,10 @@ class DSPyEngine(EngineComponent):
                                 sequence=stream_sequence,
                                 is_final=True,  # Mark as final
                             )
-                            await ws_manager.broadcast(event)
+                            # Use create_task to avoid blocking the streaming loop
+                            task = asyncio.create_task(ws_manager.broadcast(event))
+                            ws_broadcast_tasks.add(task)
+                            task.add_done_callback(ws_broadcast_tasks.discard)
                             event = StreamingOutputEvent(
                                 correlation_id=str(ctx.correlation_id)
                                 if ctx and ctx.correlation_id
@@ -742,7 +760,10 @@ class DSPyEngine(EngineComponent):
                                 sequence=stream_sequence,
                                 is_final=True,  # Mark as final
                             )
-                            await ws_manager.broadcast(event)
+                            # Use create_task to avoid blocking the streaming loop
+                            task = asyncio.create_task(ws_manager.broadcast(event))
+                            ws_broadcast_tasks.add(task)
+                            task.add_done_callback(ws_broadcast_tasks.discard)
                         except Exception as e:
                             logger.warning(f"Failed to emit final streaming event: {e}")
 

flock/frontend/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "flock-ui",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "flock-ui",
-      "version": "0.1.3",
+      "version": "0.1.4",
       "license": "ISC",
       "dependencies": {
         "@types/dagre": "^0.7.53",
@@ -147,7 +147,6 @@
       "integrity": "sha512-2BCOP7TN8M+gVDj7/ht3hsaO/B/n5oDbiAyyvnRlNOs+u1o+JWNYTQrmpuNp1/Wq2gcFrI01JAW+paEKDMx/CA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.27.1",
         "@babel/generator": "^7.28.3",
@@ -356,7 +355,6 @@
       "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.4.tgz",
       "integrity": "sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==",
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=6.9.0"
       }
@@ -507,7 +505,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=18"
       },
@@ -554,7 +551,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=18"
       }
@@ -1507,7 +1503,8 @@
       "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
       "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/@types/babel__core": {
       "version": "7.20.5",
@@ -1638,7 +1635,6 @@
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.0.tgz",
       "integrity": "sha512-1LOH8xovvsKsCBq1wnT4ntDUdCJKmnEakhsuoUSy6ExlHCkGP2hqnatagYTgFk6oeL0VU31u7SNjunPN+GchtA==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "csstype": "^3.0.2"
       }
@@ -1649,7 +1645,6 @@
       "integrity": "sha512-brtBs0MnE9SMx7px208g39lRmC5uHZs96caOJfTjFcYSLHNamvaSMfJNagChVNkup2SdtOxKX1FDBkRSJe1ZAg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "peerDependencies": {
         "@types/react": "^19.2.0"
       }
@@ -1845,7 +1840,6 @@
       "integrity": "sha512-hGISOaP18plkzbWEcP/QvtRW1xDXF2+96HbEX6byqQhAUbiS5oH6/9JwW+QsQCIYON2bI6QZBF+2PvOmrRZ9wA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@vitest/utils": "3.2.4",
         "fflate": "^0.8.2",
@@ -1963,6 +1957,7 @@
       "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=10"
       },
@@ -2066,7 +2061,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.8.9",
         "caniuse-lite": "^1.0.30001746",
@@ -2295,7 +2289,6 @@
       "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz",
       "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==",
       "license": "ISC",
-      "peer": true,
       "engines": {
         "node": ">=12"
       }
@@ -2418,7 +2411,8 @@
       "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
       "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/eastasianwidth": {
       "version": "0.2.0",
@@ -2840,7 +2834,6 @@
       "integrity": "sha512-lIHeR1qlIRrIN5VMccd8tI2Sgw6ieYXSVktcSHaNe3Z5nE/tcPQYQWOq00wxMvYOsz+73eAkNenVvmPC6bba9A==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@asamuzakjp/dom-selector": "^6.5.4",
         "cssstyle": "^5.3.0",
@@ -2942,6 +2935,7 @@
       "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "lz-string": "bin/bin.js"
       }
@@ -3186,7 +3180,6 @@
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -3214,7 +3207,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "nanoid": "^3.3.11",
         "picocolors": "^1.1.1",
@@ -3230,6 +3222,7 @@
       "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "ansi-regex": "^5.0.1",
         "ansi-styles": "^5.0.0",
@@ -3281,7 +3274,6 @@
       "resolved": "https://registry.npmjs.org/react/-/react-19.2.0.tgz",
       "integrity": "sha512-tmbWg6W31tQLeB5cdIBOicJDJRR2KzXsV7uSK9iNfLWQ5bIZfxuPEHp7M8wiHyHnn0DD1i7w3Zmin0FtkrwoCQ==",
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -3291,7 +3283,6 @@
       "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.0.tgz",
       "integrity": "sha512-UlbRu4cAiGaIewkPyiRGJk0imDN2T3JjieT6spoL2UeSf5od4n5LB/mQ4ejmxhCFT1tYe8IvaFulzynWovsEFQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "scheduler": "^0.27.0"
       },
@@ -3318,7 +3309,8 @@
       "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz",
       "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/react-refresh": {
       "version": "0.17.0",
@@ -3907,7 +3899,6 @@
       "integrity": "sha512-4nVGliEpxmhCL8DslSAUdxlB6+SMrhB0a1v5ijlh1xB1nEPuy1mxaHxysVucLHuWryAxLWg6a5ei+U4TLn/rFg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "esbuild": "^0.25.0",
         "fdir": "^6.5.0",
@@ -4006,7 +3997,6 @@
       "integrity": "sha512-LUCP5ev3GURDysTWiP47wRRUpLKMOfPh+yKTx3kVIEiu5KOMeqzpnYNsKyOoVrULivR8tLcks4+lga33Whn90A==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@types/chai": "^5.2.2",
         "@vitest/expect": "3.2.4",

flock/mcp/client.py

@@ -153,6 +153,9 @@ class FlockMCPClient(BaseModel, ABC):
     class _SessionProxy:
         def __init__(self, client: Any):
             self._client = client
+            # Check if roots are specified in the config
+            if not self.current_roots and self.config.connection_config.mount_points:
+                self.current_roots = self.config.connection_config.mount_points
 
         def __getattr__(self, name: str):
             # return an async function that auto-reconnects, then calls through.
@@ -366,11 +369,20 @@ class FlockMCPClient(BaseModel, ABC):
             return result
 
         async def _get_tools_internal() -> list[FlockMCPTool]:
-            # TODO: Crash
             response: ListToolsResult = await self.session.list_tools()
             flock_tools = []
+            tool_whitelist = self.config.feature_config.tool_whitelist
 
             for tool in response.tools:
+                # Skip tools that are not whitelisted
+                # IF a whitelist is present
+                if (
+                    tool_whitelist is not None
+                    and isinstance(tool_whitelist, list)
+                    and len(tool_whitelist) > 0
+                    and tool.name not in tool_whitelist
+                ):
+                    continue
                 converted_tool = FlockMCPTool.from_mcp_tool(
                     tool,
                     agent_id=agent_id,
@@ -422,6 +434,14 @@ class FlockMCPClient(BaseModel, ABC):
         async with self.lock:
             return self.current_roots
 
+    def _get_roots_no_lock(self) -> list[MCPRoot] | None:
+        """Get the currently set roots without acquiring a lock.
+
+        WARNING: Only use this internally when you're sure there's no race condition.
+        This is primarily for use during initialization when the lock is already held.
+        """
+        return self.current_roots
+
     async def set_roots(self, new_roots: list[MCPRoot]) -> None:
         """Set the current roots of the client.
 
@@ -599,6 +619,10 @@ class FlockMCPClient(BaseModel, ABC):
         # 2) if we already know our current roots, notify the server
         #    so that it will follow up with a ListRootsRequest
         if self.current_roots and self.config.feature_config.roots_enabled:
+            logger.debug(
+                f"Notifying server '{self.config.name}' of {len(self.current_roots)} root(s): "
+                f"{[r.uri for r in self.current_roots]}"
+            )
             await self.client_session.send_roots_list_changed()
 
         # 3) Tell the server, what logging level we would like to use

flock/mcp/config.py

@@ -271,7 +271,7 @@ class FlockMCPFeatureConfiguration(BaseModel):
         default=None,
         description="Whitelist of tool names that are enabled for this MCP server. "
         "If provided, only tools with names in this list will be available "
-        "from this server. Used in conjunction with allow_all_tools setting. "
+        "from this server."
         "Note: Agent-level tool filtering is generally preferred over "
         "server-level filtering for better granular control.",
     )
@@ -313,15 +313,6 @@ class FlockMCPConfiguration(BaseModel):
 
     name: str = Field(..., description="Name of the server the client connects to.")
 
-    allow_all_tools: bool = Field(
-        default=True,
-        description="Whether to allow usage of all tools from this MCP server. "
-        "When True (default), all tools are available unless restricted "
-        "by tool_whitelist. When False, tool access is controlled entirely "
-        "by tool_whitelist (if provided). Setting to False with no whitelist "
-        "will block all tools from this server.",
-    )
-
     connection_config: FlockMCPConnectionConfiguration = Field(
         ..., description="MCP Connection Configuration for a client."
     )

flock/mcp/manager.py

@@ -68,7 +68,9 @@ class FlockMCPClientManager:
         self._pool: dict[tuple[str, str], dict[str, FlockMCPClient]] = {}
         self._lock = asyncio.Lock()
 
-    async def get_client(self, server_name: str, agent_id: str, run_id: str) -> FlockMCPClient:
+    async def get_client(
+        self, server_name: str, agent_id: str, run_id: str, mount_points: list[str] | None = None
+    ) -> FlockMCPClient:
         """Get or create an MCP client for the given context.
 
         Architecture Decision: AD005 - Lazy Connection Establishment
@@ -105,6 +107,24 @@ class FlockMCPClientManager:
                     f"(agent={agent_id}, run={run_id})"
                 )
                 config = self._configs[server_name]
+                # MCP-ROOTS: Override mount points if provided
+                if mount_points:
+                    from flock.mcp.types import MCPRoot
+
+                    # Create MCPRoot objects from paths
+                    roots = [
+                        MCPRoot(uri=f"file://{path}", name=path.split("/")[-1])
+                        for path in mount_points
+                    ]
+                    logger.info(
+                        f"Setting {len(roots)} mount point(s) for server '{server_name}' "
+                        f"(agent={agent_id}, run={run_id}): {[r.uri for r in roots]}"
+                    )
+                    # Clone config with new mount points
+                    from copy import deepcopy
+
+                    config = deepcopy(config)
+                    config.connection_config.mount_points = roots
 
                 # Instantiate the correct concrete client class based on transport type
                 # Lazy import to avoid requiring all dependencies
@@ -145,7 +165,11 @@ class FlockMCPClientManager:
             return self._pool[key][server_name]
 
     async def get_tools_for_agent(
-        self, agent_id: str, run_id: str, server_names: set[str]
+        self,
+        agent_id: str,
+        run_id: str,
+        server_names: set[str],
+        server_mounts: dict[str, list[str]] | None = None,
     ) -> dict[str, Any]:
         """Get all tools from specified servers for an agent.
 
@@ -156,6 +180,7 @@ class FlockMCPClientManager:
             agent_id: Agent requesting tools
             run_id: Current run identifier
             server_names: Set of MCP server names to fetch tools from
+            server_mounts: Optional dict mapping server names to mount points
 
         Returns:
             Dictionary mapping namespaced tool names to tool definitions
@@ -166,10 +191,16 @@ class FlockMCPClientManager:
             other servers rather than failing the entire operation.
         """
         tools = {}
+        server_mounts = server_mounts or {}
 
         for server_name in server_names:
             try:
-                client = await self.get_client(server_name, agent_id, run_id)
+                # Get mount points specific to this server
+                mount_points = server_mounts.get(server_name)
+
+                client = await self.get_client(
+                    server_name, agent_id, run_id, mount_points=mount_points
+                )
                 server_tools = await client.get_tools(agent_id, run_id)
 
                 # Apply namespacing: AD003

flock/mcp/types/callbacks.py

@@ -64,7 +64,10 @@ async def default_list_roots_callback(
 ) -> ListRootsResult | ErrorData:
     """Default List Roots Callback."""
     if associated_client.config.feature_config.roots_enabled:
-        current_roots = await associated_client.get_roots()
+        # Use lock-free version to avoid deadlock during initialization
+        # when the lock is already held by _connect()
+        current_roots = associated_client._get_roots_no_lock()
+        logger.debug(f"Server requested list/roots. Sending: {current_roots}")
         return ListRootsResult(roots=current_roots)
     return ErrorData(code=INVALID_REQUEST, message="List roots not supported.")
 

flock/orchestrator.py

@@ -7,7 +7,7 @@ import os
 from asyncio import Task
 from collections.abc import Iterable, Mapping, Sequence
 from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, AsyncGenerator
 from uuid import uuid4
 
 from opentelemetry import trace
@@ -193,8 +193,8 @@ class Flock(metaclass=AutoTracedMeta):
         enable_prompts_feature: bool = True,
         enable_sampling_feature: bool = True,
         enable_roots_feature: bool = True,
+        mount_points: list[str] | None = None,
         tool_whitelist: list[str] | None = None,
-        allow_all_tools: bool = True,
         read_timeout_seconds: float = 300,
         max_retries: int = 3,
         **kwargs,
@@ -212,7 +212,6 @@ class Flock(metaclass=AutoTracedMeta):
             enable_sampling_feature: Enable LLM sampling requests
             enable_roots_feature: Enable filesystem roots
             tool_whitelist: Optional list of tool names to allow
-            allow_all_tools: If True, allow all tools (subject to whitelist)
             read_timeout_seconds: Timeout for server communications
             max_retries: Connection retry attempts
 
@@ -244,12 +243,43 @@ class Flock(metaclass=AutoTracedMeta):
         else:
             transport_type = "custom"
 
+        mcp_roots = None
+        if mount_points:
+            from pathlib import Path as PathLib
+
+            from flock.mcp.types import MCPRoot
+
+            mcp_roots = []
+            for path in mount_points:
+                # Normalize the path
+                if path.startswith("file://"):
+                    # Already a file URI
+                    uri = path
+                    # Extract path from URI for name
+                    path_str = path.replace("file://", "")
+                # the test:// path-prefix is used by testing servers such as the mcp-everything server.
+                elif path.startswith("test://"):
+                    # Already a test URI
+                    uri = path
+                    # Extract path from URI for name
+                    path_str = path.replace("test://", "")
+                else:
+                    # Convert to absolute path and create URI
+                    abs_path = PathLib(path).resolve()
+                    uri = f"file://{abs_path}"
+                    path_str = str(abs_path)
+
+                # Extract a meaningful name (last component of path)
+                name = PathLib(path_str).name or path_str.rstrip("/").split("/")[-1] or "root"
+                mcp_roots.append(MCPRoot(uri=uri, name=name))
+
         # Build configuration
         connection_config = FlockMCPConnectionConfiguration(
             max_retries=max_retries,
             connection_parameters=connection_params,
             transport_type=transport_type,
             read_timeout_seconds=read_timeout_seconds,
+            mount_points=mcp_roots,
         )
 
         feature_config = FlockMCPFeatureConfiguration(
@@ -262,7 +292,6 @@ class Flock(metaclass=AutoTracedMeta):
 
         mcp_config = FlockMCPConfiguration(
             name=name,
-            allow_all_tools=allow_all_tools,
             connection_config=connection_config,
             feature_config=feature_config,
         )

{flock_core-0.5.0b63.dist-info → flock_core-0.5.0b65.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.5.0b63
+Version: 0.5.0b65
 Summary: Add your description here
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -9,6 +9,7 @@ Requires-Dist: devtools>=0.12.2
 Requires-Dist: dspy==3.0.0
 Requires-Dist: duckdb>=1.1.0
 Requires-Dist: fastapi>=0.117.1
+Requires-Dist: hanging-threads>=2.0.7
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: litellm==1.75.3
 Requires-Dist: loguru>=0.7.3

{flock_core-0.5.0b63.dist-info → flock_core-0.5.0b65.dist-info}/RECORD

@@ -1,10 +1,10 @@
 flock/__init__.py,sha256=fvp4ltfaAGmYliShuTY_XVIpOUN6bMXbWiBnwb1NBoM,310
-flock/agent.py,sha256=gEELgq0Ab8TnaNLkkjvmR28kYZnLNO1yGhsu0CzfToE,31973
+flock/agent.py,sha256=LHc2COiV_w0eKmGaq9IsTDaNg_gc6iTSKmGPk1FKbt0,39731
 flock/artifacts.py,sha256=Xnizu0V4Jbwd1yV_FhXjUZG8Em-5GYsLt7sMX0V2OKI,2222
 flock/cli.py,sha256=Ay_Z4KDd5wnnF1fLr0NqjMF7kRm_9X_1RXyv5GETDAY,2126
 flock/components.py,sha256=17vhNMHKc3VUruEbSdb9YNKcDziIe0coS9jpfWBmX4o,6259
 flock/examples.py,sha256=61xkD48yCW-aDrUXIrqrvxLtV8Vn4DrraQrHrrEUnWA,3530
-flock/orchestrator.py,sha256=fF7wteH6T_yAPpJDG7kSIkUe5ggJAZ9BIpP6Flz-ozA,33747
+flock/orchestrator.py,sha256=QUFOrgOdMr_TofJnudXmlM6eYYafinrCcFUpKiV2gK4,34963
 flock/registry.py,sha256=s0-H-TMtOsDZiZQCc7T1tYiWQg3OZHn5T--jaI_INIc,4786
 flock/runtime.py,sha256=UG-38u578h628mSddBmyZn2VIzFQ0wlHCpCALFiScqA,8518
 flock/service.py,sha256=cfvcsqZw9xOsEggncZ08zmiDxFiZpxsBYDSji5OIQQ8,5256
@@ -18,12 +18,12 @@ flock/dashboard/collector.py,sha256=dF8uddDMpOSdxGkhDSAvRNNaABo-TfOceipf1SQmLSU,
 flock/dashboard/events.py,sha256=ujdmRJK-GQubrv43qfQ73dnrTj7g39VzBkWfmskJ0j8,5234
 flock/dashboard/launcher.py,sha256=zXWVpyLNxCIu6fJ2L2j2sJ4oDWTvkxhT4FWz7K6eooM,8122
 flock/dashboard/service.py,sha256=30_uUxDhvX1jfy02G4muNuzbcMH5TujY_G5aXWNQa8Q,32104
-flock/dashboard/websocket.py,sha256=RdJ7fhjNYJR8WHJ19wWdf9GEQtuKE14NmUpqm-QsLnA,9013
+flock/dashboard/websocket.py,sha256=6piBJ92nSAeTgGFDUgAaQ8CthqThwRUC6aMUBB_2O6E,9508
 flock/engines/__init__.py,sha256=waNyObJ8PKCLFZL3WUFynxSK-V47m559P3Px-vl_OSc,124
-flock/engines/dspy_engine.py,sha256=Q2gPYLW_f8f-JuBYOMtjtoCZH8Fc447zWF8cHpJl4ew,34538
+flock/engines/dspy_engine.py,sha256=mEhOKPsTnKN2BpnBv_cntqxH7hhg0Fv_QQuQneyDHPk,36176
 flock/frontend/README.md,sha256=OFdOItV8FGifmUDb694rV2xLC0vl1HlR5KBEtYv5AB0,25054
 flock/frontend/index.html,sha256=BFg1VR_YVAJ_MGN16xa7sT6wTGwtFYUhfJhGuKv89VM,312
-flock/frontend/package-lock.json,sha256=F-KmPhq6IbHXzxtmHL0S7dt6DGs4fWrOkrfKeXaSx6U,150998
+flock/frontend/package-lock.json,sha256=PKQaw0nU0PRUWiJ3OIQyS9v-vphokMbUkxoPdgdkiZo,150798
 flock/frontend/package.json,sha256=8cpupeJo0xlJgHiEHpBYCU-nHFiiNGJ73NfZLr5-FSg,1258
 flock/frontend/tsconfig.json,sha256=B9p9jXohg_jrCZAq5_yIHvznpeXHiHQkwUZrVE2oMRA,705
 flock/frontend/tsconfig.node.json,sha256=u5_YWSqeNkZBRBIZ8Q2E2q6bospcyF23mO-taRO7glc,233
@@ -152,9 +152,9 @@ flock/logging/telemetry_exporter/duckdb_exporter.py,sha256=MoFFsAb-twZF9ZAB0s8TO
 flock/logging/telemetry_exporter/file_exporter.py,sha256=uTgQZSKfbLjzypirBbiVnccaKBDkiRzhFvUdV26pKEY,3126
 flock/logging/telemetry_exporter/sqlite_exporter.py,sha256=754G8s4X-JHHpCdoNydJnPX4NZijZk9URutfPWFIT7s,3479
 flock/mcp/__init__.py,sha256=QuANhTz09E2fFhtp2yJ716WxXKwEpCMTGqHj54VRs2Q,2512
-flock/mcp/client.py,sha256=QcxSdj3iUsWSsOR0l2IpZdr_dyvaqslmyuSk_LZEamQ,24610
-flock/mcp/config.py,sha256=QJcP_r8uE_1mdxMIUop7ca-CtJuEZwUXgUqCjR_a2UU,15326
-flock/mcp/manager.py,sha256=wD48yi9oD7Y4ZBCi2HmdJ8TFNO__ODsj8KuRa4UTMxM,9658
+flock/mcp/client.py,sha256=FRkuWNohFhzAzv-8aLz8Nd3CxkCf_SgHpfbPGTjRbMg,25790
+flock/mcp/config.py,sha256=EgCFYTkV97fy8PlmnFVkB8FLCCSIni5vF3mQB0Yy-3c,14850
+flock/mcp/manager.py,sha256=X54Ph5CtcIIZNuWndSH2sZijVjVBpPCNHS4M-B1bViU,10942
 flock/mcp/tool.py,sha256=cn59dFM1wD0_hl0GjcHxtVYEmPClqskYVMc9AVMB9RY,5397
 flock/mcp/servers/sse/__init__.py,sha256=qyfDdkZkgscHOkFREvsvoNtzA-CCnXPNma5w9uaIUCo,51
 flock/mcp/servers/sse/flock_sse_server.py,sha256=dbkRAcn11V9bBEoPlCMuuzuErTjHigqsnvGYJL4v2ts,3685
@@ -165,7 +165,7 @@ flock/mcp/servers/streamable_http/flock_streamable_http_server.py,sha256=qPAypNi
 flock/mcp/servers/websockets/__init__.py,sha256=KeNgNQRdeCQ9xgpaHB1I0-HyYeBhkifAuZPTIA8eDqM,47
 flock/mcp/servers/websockets/flock_websocket_server.py,sha256=UywSLftw3stbg_b-3Ygn_tNMo5Btm6I3bmSebcprfjk,3118
 flock/mcp/types/__init__.py,sha256=iwO7MXRjA-WhIyHSCI9fR6KF_UhzjqXJWT13f_8w4HM,1274
-flock/mcp/types/callbacks.py,sha256=9Ex-giTw1D6CNWIUq988SmWYoEqcDPGcJlZmS3fwjNQ,2399
+flock/mcp/types/callbacks.py,sha256=8S-ZhWTnR7dzUtxTc9nFcKCDbNyhnE3Bsm1QpA_ArEg,2607
 flock/mcp/types/factories.py,sha256=B7h8apMDT2nR6POOj7aWWn39UbELt6nxHluPhRmemGw,3424
 flock/mcp/types/handlers.py,sha256=6ukkSMv1VZSfk2QDUiJnm8xifHnQvWZsxWXqN21BYSg,7804
 flock/mcp/types/types.py,sha256=ZbzbVihABFnfmZz2X-CCN7hQDzaSY0T-en43PFbFwQQ,11469
@@ -508,8 +508,8 @@ flock/themes/zenburned.toml,sha256=UEmquBbcAO3Zj652XKUwCsNoC2iQSlIh-q5c6DH-7Kc,1
 flock/themes/zenwritten-dark.toml,sha256=-dgaUfg1iCr5Dv4UEeHv_cN4GrPUCWAiHSxWK20X1kI,1663
 flock/themes/zenwritten-light.toml,sha256=G1iEheCPfBNsMTGaVpEVpDzYBHA_T-MV27rolUYolmE,1666
 flock/utility/output_utility_component.py,sha256=yVHhlIIIoYKziI5UyT_zvQb4G-NsxCTgLwA1wXXTTj4,9047
-flock_core-0.5.0b63.dist-info/METADATA,sha256=dFHOh--Y96joJgB4NdboiySS8gX3kAN2imVW3bEBAgc,34949
-flock_core-0.5.0b63.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.5.0b63.dist-info/entry_points.txt,sha256=UQdPmtHd97gSA_IdLt9MOd-1rrf_WO-qsQeIiHWVrp4,42
-flock_core-0.5.0b63.dist-info/licenses/LICENSE,sha256=U3IZuTbC0yLj7huwJdldLBipSOHF4cPf6cUOodFiaBE,1072
-flock_core-0.5.0b63.dist-info/RECORD,,
+flock_core-0.5.0b65.dist-info/METADATA,sha256=foWf00WbMuVzmlasEjY3lQxyrju5nmdGQO2iFa5FHf0,34987
+flock_core-0.5.0b65.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.5.0b65.dist-info/entry_points.txt,sha256=UQdPmtHd97gSA_IdLt9MOd-1rrf_WO-qsQeIiHWVrp4,42
+flock_core-0.5.0b65.dist-info/licenses/LICENSE,sha256=U3IZuTbC0yLj7huwJdldLBipSOHF4cPf6cUOodFiaBE,1072
+flock_core-0.5.0b65.dist-info/RECORD,,