flock-core 0.5.9__py3-none-any.whl → 0.5.10__py3-none-any.whl

flock/mcp/client.py

@@ -76,7 +76,9 @@ class FlockMCPClient(BaseModel, ABC):
     """
 
     # --- Properties ---
-    config: FlockMCPConfiguration = Field(..., description="The config for this client instance.")
+    config: FlockMCPConfiguration = Field(
+        ..., description="The config for this client instance."
+    )
 
     tool_cache: TTLCache | None = Field(
         default=None,
@@ -174,14 +176,18 @@ class FlockMCPClient(BaseModel, ABC):
                         await client._ensure_connected()
                         try:
                             # delegate the real session
-                            return await getattr(client.client_session, name)(*args, **kwargs)
+                            return await getattr(client.client_session, name)(
+                                *args, **kwargs
+                            )
                         except McpError as e:
                             # only retry on a transport timeout
                             if e.error.code == httpx.codes.REQUEST_TIMEOUT:
                                 kind = "timeout"
                             else:
                                 # application-level MCP error -> give up immediately
-                                logger.exception(f"MCP error in session.{name}: {e.error}")
+                                logger.exception(
+                                    f"MCP error in session.{name}: {e.error}"
+                                )
                                 return None
                         except (BrokenPipeError, ClosedResourceError) as e:
                             kind = type(e).__name__
@@ -301,21 +307,27 @@ class FlockMCPClient(BaseModel, ABC):
 
         if not self.message_handler:
             if not self.config.callback_config.message_handler:
-                self.message_handler = default_flock_mcp_message_handler_callback_factory(
-                    associated_client=self,
-                    logger=logger,
+                self.message_handler = (
+                    default_flock_mcp_message_handler_callback_factory(
+                        associated_client=self,
+                        logger=logger,
+                    )
                 )
             else:
                 self.message_handler = self.config.callback_config.message_handler
 
         if not self.list_roots_callback:
             if not self.config.callback_config.list_roots_callback:
-                self.list_roots_callback = default_flock_mcp_list_roots_callback_factory(
-                    associated_client=self,
-                    logger=logger,
+                self.list_roots_callback = (
+                    default_flock_mcp_list_roots_callback_factory(
+                        associated_client=self,
+                        logger=logger,
+                    )
                 )
             else:
-                self.list_roots_callback = self.config.callback_config.list_roots_callback
+                self.list_roots_callback = (
+                    self.config.callback_config.list_roots_callback
+                )
 
         if not self.sampling_callback:
             if not self.config.callback_config.sampling_callback:
@@ -407,7 +419,9 @@ class FlockMCPClient(BaseModel, ABC):
         if cache_key in self.tool_result_cache:
             return self.tool_result_cache[cache_key]
 
-        async def _call_tool_internal(name: str, arguments: dict[str, Any]) -> CallToolResult:
+        async def _call_tool_internal(
+            name: str, arguments: dict[str, Any]
+        ) -> CallToolResult:
             logger.debug(f"Calling tool '{name}' with arguments {arguments}")
             return await self.session.call_tool(
                 name=name,
@@ -465,19 +479,27 @@ class FlockMCPClient(BaseModel, ABC):
 
     async def invalidate_resource_list_cache(self) -> None:
         """Invalidate the entries in the resource list cache."""
-        logger.debug(f"Invalidating resource_list_cache for server '{self.config.name}'")
+        logger.debug(
+            f"Invalidating resource_list_cache for server '{self.config.name}'"
+        )
         async with self.lock:
             if self.resource_list_cache:
                 self.resource_list_cache.clear()
-                logger.debug(f"Invalidated resource_list_cache for server '{self.config.name}'")
+                logger.debug(
+                    f"Invalidated resource_list_cache for server '{self.config.name}'"
+                )
 
     async def invalidate_resource_contents_cache(self) -> None:
         """Invalidate the entries in the resource contents cache."""
-        logger.debug(f"Invalidating resource_contents_cache for server '{self.config.name}'.")
+        logger.debug(
+            f"Invalidating resource_contents_cache for server '{self.config.name}'."
+        )
         async with self.lock:
             if self.resource_contents_cache:
                 self.resource_contents_cache.clear()
-                logger.debug(f"Invalidated resource_contents_cache for server '{self.config.name}'")
+                logger.debug(
+                    f"Invalidated resource_contents_cache for server '{self.config.name}'"
+                )
 
     async def invalidate_resource_contents_cache_entry(self, key: str) -> None:
         """Invalidate a single entry in the resource contents cache."""
@@ -533,7 +555,9 @@ class FlockMCPClient(BaseModel, ABC):
         server_params = self.config.connection_config.connection_parameters
 
         # Single Hook
-        transport_ctx = await self.create_transport(server_params, self.additional_params)
+        transport_ctx = await self.create_transport(
+            server_params, self.additional_params
+        )
         safe_transport = self._safe_transport_ctx(transport_ctx)
         result = await stack.enter_async_context(safe_transport)
 
@@ -547,15 +571,21 @@ class FlockMCPClient(BaseModel, ABC):
             # new type
             read, write, _get_session_id_callback = result
         else:
-            raise RuntimeError(f"create_transport returned unexpected tuple of {result}")
+            raise RuntimeError(
+                f"create_transport returned unexpected tuple of {result}"
+            )
 
         if read is None or write is None:
-            raise RuntimeError("create_transport did not create any read or write streams.")
+            raise RuntimeError(
+                "create_transport did not create any read or write streams."
+            )
 
         read_timeout = self.config.connection_config.read_timeout_seconds
 
         if self.additional_params and "read_timeout_seconds" in self.additional_params:
-            read_timeout = self.additional_params.get("read_timeout_seconds", read_timeout)
+            read_timeout = self.additional_params.get(
+                "read_timeout_seconds", read_timeout
+            )
 
         timeout_seconds = (
             read_timeout

flock/mcp/config.py

@@ -159,15 +159,17 @@ class FlockMCPConnectionConfiguration(BaseModel):
         ..., description="Connection parameters for the server."
     )
 
-    transport_type: Literal["stdio", "websockets", "sse", "streamable_http", "custom"] = Field(
-        ..., description="Type of transport to use."
-    )
+    transport_type: Literal[
+        "stdio", "websockets", "sse", "streamable_http", "custom"
+    ] = Field(..., description="Type of transport to use.")
 
     mount_points: list[MCPRoot] | None = Field(
         default=None, description="Initial Mountpoints to operate under."
     )
 
-    read_timeout_seconds: float | int = Field(default=60 * 5, description="Read Timeout.")
+    read_timeout_seconds: float | int = Field(
+        default=60 * 5, description="Read Timeout."
+    )
 
     server_logging_level: LoggingLevel = Field(
         default="error",
@@ -187,7 +189,9 @@ class FlockMCPConnectionConfiguration(BaseModel):
             mode="json",
         )
 
-        data["connection_parameters"] = self.connection_parameters.to_dict(path_type=path_type)
+        data["connection_parameters"] = self.connection_parameters.to_dict(
+            path_type=path_type
+        )
 
         return data
 
@@ -235,7 +239,9 @@ class FlockMCPConnectionConfiguration(BaseModel):
                         )
                     case _:
                         # handle custom server params
-                        connection_params_obj = ServerParameters(**dict(connection_params.items()))
+                        connection_params_obj = ServerParameters(
+                            **dict(connection_params.items())
+                        )
 
         if connection_params_obj:
             data["connection_parameters"] = connection_params_obj

flock/mcp/manager.py

@@ -39,7 +39,7 @@ class FlockMCPClientManager:
             "filesystem": FlockMCPConfiguration(
                 name="filesystem",
                 connection_config=connection_config,
-                feature_config=feature_config
+                feature_config=feature_config,
             )
         }
         manager = FlockMCPClientManager(configs)
@@ -69,7 +69,11 @@ class FlockMCPClientManager:
         self._lock = asyncio.Lock()
 
     async def get_client(
-        self, server_name: str, agent_id: str, run_id: str, mount_points: list[str] | None = None
+        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.
 

flock/mcp/servers/sse/flock_sse_server.py

@@ -32,7 +32,9 @@ class FlockSSEConnectionConfig(FlockMCPConnectionConfiguration):
 
     # Only thing we need to override here is the concrete transport_type
     # and connection_parameters fields.
-    transport_type: Literal["sse"] = Field(default="sse", description="Use the sse transport type.")
+    transport_type: Literal["sse"] = Field(
+        default="sse", description="Use the sse transport type."
+    )
 
     connection_parameters: SseServerParameters = Field(
         ..., description="SSE Server Connection Parameters."
@@ -73,11 +75,15 @@ class FlockSSEClient(FlockMCPClient):
             override_headers = bool(additional_params.get("override_headers", False))
             if "headers" in additional_params:
                 if override_headers:
-                    param_copy.headers = additional_params.get("headers", params.headers)
+                    param_copy.headers = additional_params.get(
+                        "headers", params.headers
+                    )
                 else:
                     param_copy.headers.update(additional_params.get("headers", {}))
             if "read_timeout_seconds" in additional_params:
-                param_copy.timeout = additional_params.get("read_timeout_seconds", params.timeout)
+                param_copy.timeout = additional_params.get(
+                    "read_timeout_seconds", params.timeout
+                )
 
             if "sse_read_timeout" in additional_params:
                 param_copy.sse_read_timeout = additional_params.get(

flock/mcp/servers/streamable_http/flock_streamable_http_server.py

@@ -84,7 +84,9 @@ class FlockStreamableHttpClient(FlockMCPClient):
 
             if "headers" in additional_params:
                 if override_headers:
-                    param_copy.headers = additional_params.get("headers", params.headers)
+                    param_copy.headers = additional_params.get(
+                        "headers", params.headers
+                    )
                 else:
                     param_copy.headers.update(additional_params.get("headers", {}))
             if "auth" in additional_params and isinstance(
@@ -93,7 +95,9 @@ class FlockStreamableHttpClient(FlockMCPClient):
                 param_copy.auth = additional_params.get("auth", param_copy.auth)
 
             if "read_timeout_seconds" in additional_params:
-                param_copy.timeout = additional_params.get("read_timeout_seconds", params.timeout)
+                param_copy.timeout = additional_params.get(
+                    "read_timeout_seconds", params.timeout
+                )
 
             if "sse_read_timeout" in additional_params:
                 param_copy.sse_read_timeout = additional_params.get(

flock/mcp/tool.py

@@ -32,11 +32,17 @@ class FlockMCPTool(BaseModel):
 
     name: str = Field(..., description="Name of the tool")
 
-    agent_id: str = Field(..., description="Associated agent_id. Used for internal tracking.")
+    agent_id: str = Field(
+        ..., description="Associated agent_id. Used for internal tracking."
+    )
 
-    run_id: str = Field(..., description="Associated run_id. Used for internal tracking.")
+    run_id: str = Field(
+        ..., description="Associated run_id. Used for internal tracking."
+    )
 
-    description: str | None = Field(..., description="A human-readable description of the tool")
+    description: str | None = Field(
+        ..., description="A human-readable description of the tool"
+    )
 
     input_schema: dict[str, Any] = Field(
         ...,
@@ -76,11 +82,15 @@ class FlockMCPTool(BaseModel):
         try:
             return convert_input_schema_to_tool_args(input_schema)
         except Exception as e:  # pragma: no cover - defensive
-            logger.exception("Failed to convert MCP tool schema to DSPy tool args: %s", e)
+            logger.exception(
+                "Failed to convert MCP tool schema to DSPy tool args: %s", e
+            )
             # Fallback to empty definitions to avoid breaking execution
             return {}, {}, {}
 
-    def _convert_mcp_tool_result(self, call_tool_result: CallToolResult) -> str | list[Any]:
+    def _convert_mcp_tool_result(
+        self, call_tool_result: CallToolResult
+    ) -> str | list[Any]:
         text_contents: list[TextContent] = []
         non_text_contents = []
 
@@ -107,7 +117,9 @@ class FlockMCPTool(BaseModel):
 
     def as_dspy_tool(self, server: Any) -> DSPyTool:
         """Wrap this tool as a DSPyTool for downstream."""
-        args, arg_type, args_desc = self._convert_input_schema_to_tool_args(self.input_schema)
+        args, arg_type, args_desc = self._convert_input_schema_to_tool_args(
+            self.input_schema
+        )
 
         async def func(*args, **kwargs):
             with tracer.start_as_current_span(f"tool.{self.name}.call") as span:

flock/mcp/types/handlers.py

@@ -161,7 +161,9 @@ async def handle_logging_message(
     metadata: dict[str, Any] = params.meta or {}  # type: ignore[assignment]
 
     str_level = "DEBUG"
-    prefix = f"Message from Remote MCP Logger '{logger_name}' for server '{server_name}': "
+    prefix = (
+        f"Message from Remote MCP Logger '{logger_name}' for server '{server_name}': "
+    )
 
     match level:
         case "info":

flock/mcp/types/types.py

@@ -128,7 +128,9 @@ class ServerParameters(BaseModel):
 class StdioServerParameters(_MCPStdioServerParameters, ServerParameters):
     """Base Type for Stdio Server parameters."""
 
-    transport_type: Literal["stdio"] = Field(default="stdio", description="Use stdio params.")
+    transport_type: Literal["stdio"] = Field(
+        default="stdio", description="Use stdio params."
+    )
 
     env: dict[str, str] | None = Field(
         default_factory=get_default_env,
@@ -169,7 +171,9 @@ class StreamableHttpServerParameters(ServerParameters):
         description="How long the client will wait before disconnecting from the server.",
     )
 
-    terminate_on_close: bool = Field(default=True, description="Terminate connection on close")
+    terminate_on_close: bool = Field(
+        default=True, description="Terminate connection on close"
+    )
 
     auth: httpx.Auth | None = Field(default=None, description="Httpx Auth Scheme")
 
@@ -241,7 +245,9 @@ class StreamableHttpServerParameters(ServerParameters):
 class SseServerParameters(ServerParameters):
     """Base Type for SSE Server params."""
 
-    transport_type: Literal["sse"] = Field(default="sse", description="Use sse server params.")
+    transport_type: Literal["sse"] = Field(
+        default="sse", description="Use sse server params."
+    )
 
     url: str | AnyUrl = Field(..., description="The url the server listens at.")