flock-core 0.4.512__py3-none-any.whl → 0.4.513__py3-none-any.whl

flock/core/mcp/types/types.py

@@ -1,9 +1,13 @@
 """Types for Flock's MCP functionality."""
 
+import importlib
+import inspect
+import os
 from collections.abc import Awaitable, Callable
 from contextlib import AbstractAsyncContextManager
-from typing import Any
+from typing import Any, Literal
 
+import httpx
 from anyio.streams.memory import (
     MemoryObjectReceiveStream,
     MemoryObjectSendStream,
@@ -36,6 +40,7 @@ from mcp.types import (
 from pydantic import AnyUrl, BaseModel, ConfigDict, Field
 
 from flock.core.mcp.util.helpers import get_default_env
+from flock.core.serialization.serializable import Serializable
 
 
 class ServerNotification(_MCPServerNotification):
@@ -80,17 +85,40 @@ class MCPRoot(_MCPRoot):
     """Wrapper for mcp.types.Root."""
 
 
-class ServerParameters(BaseModel):
+class ServerParameters(BaseModel, Serializable):
     """Base Type for server parameters."""
 
     model_config = ConfigDict(
         arbitrary_types_allowed=True,
     )
 
+    transport_type: Literal["stdio", "websockets", "sse", "streamable_http"] = Field(
+        ...,
+        description="which type of transport these connection params are used for."
+    )
+
+    def to_dict(self, path_type: str = "relative"):
+        """Serialize."""
+        return self.model_dump(
+            exclude_defaults=False,
+            exclude_none=True,
+            mode="json"
+        )
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]):
+        """Deserialize."""
+        return cls(**data)
+
 
 class StdioServerParameters(_MCPStdioServerParameters, ServerParameters):
     """Base Type for Stdio Server parameters."""
 
+    transport_type: Literal["stdio"] = Field(
+        default="stdio",
+        description="Use stdio params."
+    )
+
     env: dict[str, str] | None = Field(
         default_factory=get_default_env,
         description="Environment for the MCP Server.",
@@ -100,12 +128,121 @@ class StdioServerParameters(_MCPStdioServerParameters, ServerParameters):
 class WebsocketServerParameters(ServerParameters):
     """Base Type for Websocket Server params."""
 
+    transport_type: Literal["websockets"] = Field(
+        default="websockets",
+        description="Use websocket params."
+    )
+
     url: str | AnyUrl = Field(..., description="Url the server listens at.")
 
+class StreamableHttpServerParameters(ServerParameters):
+    """Base Type for StreamableHttp params."""
+
+    transport_type: Literal["streamable_http"] = Field(
+        default="streamable_http",
+        description="Use streamable http params."
+    )
+
+    url: str | AnyUrl = Field(
+        ...,
+        description="The url the server listens at."
+    )
+
+    headers: dict[str, Any] | None = Field(
+        default=None,
+        description="Additional headers to pass to the client."
+    )
+
+    timeout: float | int = Field(
+        default=5,
+        description="Http Timeout",
+    )
+
+    sse_read_timeout: float | int = Field(
+        default=60*5,
+        description="How long the client will wait before disconnecting from the server."
+    )
+
+    terminate_on_close: bool = Field(
+        default=True,
+        description="Terminate connection on close"
+    )
+
+    auth: httpx.Auth | None = Field(
+        default=None,
+        description="Httpx Auth Scheme"
+    )
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]):
+        """Deserialize the object from a dict."""
+        # find and import the concrete implementation for
+        # the auth object
+        auth_obj: httpx.Auth | None = None
+        auth_impl = data.pop("auth", None)
+        if auth_impl:
+            # find the concrete implementation
+            impl = auth_impl.pop("implementation", None)
+            params = auth_impl.pop("params", None)
+            if impl:
+                mod = importlib.import_module(impl["module_path"])
+                real_cls = getattr(mod, impl["classname"])
+                if params:
+                    auth_obj = real_cls(**{k: v for k, v in params.items()})
+                else:
+                    # assume that the implementation handles it.
+                    auth_obj = real_cls()
+            else:
+                raise ValueError("No concrete implementation for auth provided.")
+
+        data["auth"] = auth_obj
+        return cls(**{k: v for k, v in data.items()})
+
+    def to_dict(self, path_type = "relative"):
+        """Serialize the object."""
+        exclude = ["auth"]
+
+        data = self.model_dump(
+            exclude=exclude,
+            exclude_defaults=False,
+            exclude_none=True,
+        )
+
+        # inject implentation info for auth
+        if self.auth is not None:
+            file_path = inspect.getsourcefile(type(self.auth))
+            if path_type == "relative":
+                file_path = os.path.relpath(file_path)
+            try:
+                # params should be primitive types, keeping with the
+                # declarative approach of flock.
+                params = {
+                    k: getattr(self.auth, k)
+                    for k in getattr(self.auth, "__dict__", {})
+                    if not k.startswith("_")
+                }
+            except Exception:
+                params = None
+
+        data["auth"] = {
+            "implementation": {
+                "class_name": type(self.auth).__name__,
+                "module_path": type(self.auth).__module__,
+                "file_path": file_path,
+            },
+            "params": params,
+        }
+
+        return data
 
 class SseServerParameters(ServerParameters):
     """Base Type for 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.")
 
     headers: dict[str, Any] | None = Field(
@@ -119,6 +256,72 @@ class SseServerParameters(ServerParameters):
         description="How long the client will wait before disconnecting from the server.",
     )
 
+    auth: httpx.Auth | None = Field(
+        default=None,
+        description="Httpx Auth Scheme."
+    )
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]):
+        """Deserialize the object from a dict."""
+        # find and import the concrete implementation for
+        # the auth object.
+        auth_obj: httpx.Auth | None = None
+        auth_impl = data.pop("auth", None) # get the specs for the auth class
+        if auth_impl:
+            # find the concrete implementation
+            impl = auth_impl.pop("implementation", None)
+            params = auth_impl.pop("params", None)
+            if impl:
+                mod = importlib.import_module(impl["module_path"])
+                real_cls = getattr(mod, impl["class_name"])
+                if params:
+                    auth_obj = real_cls(**{k: v for k, v in params.items()})
+                else:
+                    # assume that implementation handles it
+                    auth_obj = real_cls()
+            else:
+                raise ValueError("No concrete implementation for auth provided.")
+
+        data["auth"] = auth_obj
+        return cls(**{k: v for k, v in data.items()})
+
+    def to_dict(self, path_type = "relative"):
+        """Serialize the object."""
+        exclude = ["auth"]
+
+        data = self.model_dump(
+            exclude=exclude,
+            exclude_defaults=False,
+            exclude_none=True,
+        )
+
+        # inject implentation info for auth
+        if self.auth is not None:
+            file_path = inspect.getsourcefile(type(self.auth))
+            if path_type == "relative":
+                file_path = os.path.relpath(file_path)
+            try:
+                # params should be primitive types, keeping with the
+                # declarative approach of flock.
+                params = {
+                    k: getattr(self.auth, k)
+                    for k in getattr(self.auth, "__dict__", {})
+                    if not k.startswith("_")
+                }
+            except Exception:
+                params = None
+
+        data["auth"] = {
+            "implementation": {
+                "class_name": type(self.auth).__name__,
+                "module_path": type(self.auth).__module__,
+                "file_path": file_path,
+            },
+            "params": params,
+        }
+
+        return data
 
 MCPCLientInitFunction = Callable[
     ...,

flock/mcp/servers/sse/flock_sse_server.py

@@ -4,12 +4,13 @@ import copy
 from contextlib import AbstractAsyncContextManager
 from typing import Any, Literal
 
+import httpx
 from anyio.streams.memory import (
     MemoryObjectReceiveStream,
     MemoryObjectSendStream,
 )
 from mcp.client.sse import sse_client
-from mcp.types import JSONRPCMessage
+from mcp.shared.message import SessionMessage
 from opentelemetry import trace
 from pydantic import Field
 
@@ -63,45 +64,51 @@ class FlockSSEClient(FlockMCPClientBase):
         additional_params: dict[str, Any] | None = None,
     ) -> AbstractAsyncContextManager[
         tuple[
-            MemoryObjectReceiveStream[JSONRPCMessage | Exception],
-            MemoryObjectSendStream[JSONRPCMessage],
+            MemoryObjectReceiveStream[SessionMessage | Exception],
+            MemoryObjectSendStream[SessionMessage],
         ]
     ]:
         """Return an async context manager whose __aenter__ method yields (read_stream, send_stream)."""
         # avoid modifying the config of the client as a side-effect.
         param_copy = copy.deepcopy(params)
 
-        if self.additional_params:
+        if additional_params:
             override_headers = bool(
-                self.additional_params.get("override_headers", False)
+                additional_params.get("override_headers", False)
             )
-            if "headers" in self.additional_params:
+            if "headers" in additional_params:
                 if override_headers:
-                    param_copy.headers = self.additional_params.get(
+                    param_copy.headers = additional_params.get(
                         "headers", params.headers
                     )
                 else:
                     param_copy.headers.update(
-                        self.additional_params.get("headers", {})
+                        additional_params.get("headers", {})
                     )
-            if "read_timeout_seconds" in self.additional_params:
-                param_copy.timeout = self.additional_params.get(
+            if "read_timeout_seconds" in additional_params:
+                param_copy.timeout =  additional_params.get(
                     "read_timeout_seconds", params.timeout
                 )
 
-            if "sse_read_timeout" in self.additional_params:
-                param_copy.sse_read_timeout = self.additional_params.get(
+            if "sse_read_timeout" in additional_params:
+                param_copy.sse_read_timeout = additional_params.get(
                     "sse_read_timeout",
                     params.sse_read_timeout,
                 )
-            if "url" in self.additional_params:
-                param_copy.url = self.additional_params.get(
+            if "url" in additional_params:
+                param_copy.url = additional_params.get(
                     "url",
                     params.url,
                 )
 
+            if "auth" in additional_params and isinstance(
+                additional_params.get("auth"), httpx.Auth
+            ):
+                param_copy.auth = additional_params.get("auth", param_copy.auth)
+
         return sse_client(
             url=param_copy.url,
+            auth=param_copy.auth,
             headers=param_copy.headers,
             timeout=float(param_copy.timeout),
             sse_read_timeout=float(param_copy.sse_read_timeout),

flock/mcp/servers/streamable_http/flock_streamable_http_server.py

@@ -0,0 +1,169 @@
+"""This module provides the Flock Streamable-Http functionality."""
+
+import copy
+from collections.abc import Callable
+from contextlib import AbstractAsyncContextManager
+from datetime import timedelta
+from typing import Any, Literal
+
+import httpx
+from anyio.streams.memory import (
+    MemoryObjectReceiveStream,
+    MemoryObjectSendStream,
+)
+from mcp.client.streamable_http import streamablehttp_client
+from mcp.shared.message import SessionMessage
+from opentelemetry import trace
+from pydantic import Field
+
+from flock.core.logging.logging import get_logger
+from flock.core.mcp.flock_mcp_server import FlockMCPServerBase
+from flock.core.mcp.mcp_client import FlockMCPClientBase
+from flock.core.mcp.mcp_client_manager import FlockMCPClientManagerBase
+from flock.core.mcp.mcp_config import (
+    FlockMCPConfigurationBase,
+    FlockMCPConnectionConfigurationBase,
+)
+from flock.core.mcp.types.types import (
+    StreamableHttpServerParameters,
+)
+
+logger = get_logger("mcp.streamable_http.server")
+tracer = trace.get_tracer(__name__)
+
+GetSessionIdCallback = Callable[[], str | None]
+
+
+class FlockStreamableHttpConnectionConfig(FlockMCPConnectionConfigurationBase):
+    """Concrete ConnectionConfig for a StreamableHttpClient."""
+
+    # Only thing we need to override here is the concrete transport_type
+    # and connection parameter fields.
+    transport_type: Literal["streamable_http"] = Field(
+        default="streamable_http",
+        description="Use the streamable_http Transport type.",
+    )
+
+    connection_parameters: StreamableHttpServerParameters = Field(
+        ..., description="Streamable HTTP Server Connection Parameters."
+    )
+
+
+class FlockStreamableHttpConfig(FlockMCPConfigurationBase):
+    """Configuration for Streamable HTTP Clients."""
+
+    # The only thing we need to override here is the
+    # concrete connection config.
+    # The rest is generic enough to handle everything else.
+    connection_config: FlockStreamableHttpConnectionConfig = Field(
+        ..., description="Concrete StreamableHttp Connection Configuration."
+    )
+
+
+class FlockStreamableHttpClient(FlockMCPClientBase):
+    """Client for StreamableHttpServers."""
+
+    config: FlockStreamableHttpConfig = Field(
+        ..., description="Client configuration."
+    )
+
+    async def create_transport(
+        self,
+        params: StreamableHttpServerParameters,
+        additional_params: dict[str, Any] | None = None,
+    ) -> AbstractAsyncContextManager[
+    tuple[
+        MemoryObjectReceiveStream[SessionMessage | Exception],
+        MemoryObjectSendStream[SessionMessage],
+        GetSessionIdCallback,
+    ],
+    None,
+]:
+        """Return an async context manager whose __aenter__ method yields (read_stream, send_stream)."""
+        param_copy = copy.deepcopy(params)
+
+        if additional_params:
+            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
+                    )
+                else:
+                    param_copy.headers.update(
+                        additional_params.get("headers", {})
+                    )
+            if "auth" in additional_params and isinstance(
+                additional_params.get("auth"), httpx.Auth
+            ):
+                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
+                )
+
+            if "sse_read_timeout" in additional_params:
+                param_copy.sse_read_timeout = additional_params.get(
+                    "sse_read_timeout",
+                    params.sse_read_timeout,
+                )
+            if "url" in additional_params:
+                param_copy.url = additional_params.get(
+                    "url",
+                    params.url,
+                )
+
+            if "terminate_on_close" in additional_params:
+                param_copy.terminate_on_close = bool(
+                    additional_params.get("terminate_on_close", True)
+                )
+
+        timeout_http = timedelta(seconds=param_copy.timeout)
+        sse_timeout = timedelta(seconds=param_copy.sse_read_timeout)
+
+        return streamablehttp_client(
+            url=param_copy.url,
+            headers=param_copy.headers,
+            timeout=timeout_http,
+            sse_read_timeout=sse_timeout,
+            terminate_on_close=param_copy.terminate_on_close,
+            auth=param_copy.auth,
+        )
+
+
+class FlockStreamableHttpClientManager(FlockMCPClientManagerBase):
+    """Manager for handling StreamableHttpClients."""
+
+    client_config: FlockStreamableHttpConfig = Field(
+        ..., description="Configuration for clients."
+    )
+
+    async def make_client(
+        self, additional_params: dict[str, Any] | None = None
+    ) -> FlockStreamableHttpClient:
+        """Create a new client instance."""
+        new_client = FlockStreamableHttpClient(
+            config=self.client_config,
+            additional_params=additional_params,
+        )
+        return new_client
+
+
+class FlockStreamableHttpServer(FlockMCPServerBase):
+    """Class which represents a MCP Server using the streamable Http Transport type."""
+
+    config: FlockStreamableHttpConfig = Field(
+        ..., description="Config for the server."
+    )
+
+    async def initialize(self) -> FlockStreamableHttpClientManager:
+        """Called when initializing the server."""
+        client_manager = FlockStreamableHttpClientManager(
+            client_config=self.config
+        )
+
+        return client_manager

flock/mcp/servers/websockets/flock_websocket_server.py

@@ -9,7 +9,7 @@ from anyio.streams.memory import (
     MemoryObjectSendStream,
 )
 from mcp.client.websocket import websocket_client
-from mcp.types import JSONRPCMessage
+from mcp.shared.message import SessionMessage
 from opentelemetry import trace
 from pydantic import Field
 
@@ -69,8 +69,8 @@ class FlockWSClient(FlockMCPClientBase):
         additional_params: dict[str, Any] | None = None,
     ) -> AbstractAsyncContextManager[
         tuple[
-            MemoryObjectReceiveStream[JSONRPCMessage | Exception],
-            MemoryObjectSendStream[JSONRPCMessage],
+            MemoryObjectReceiveStream[SessionMessage | Exception],
+            MemoryObjectSendStream[SessionMessage],
         ]
     ]:
         """Return an async context manager whose __aenter__ method yields a read_stream and a send_stream."""

{flock_core-0.4.512.dist-info → flock_core-0.4.513.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.4.512
+Version: 0.4.513
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE

{flock_core-0.4.512.dist-info → flock_core-0.4.513.dist-info}/RECORD

@@ -27,9 +27,9 @@ flock/cli/yaml_editor.py,sha256=K3N0bh61G1TSDAZDnurqW9e_-hO6CtSQKXQqlDhCjVo,1252
 flock/cli/assets/release_notes.md,sha256=bqnk50jxM3w5uY44Dc7MkdT8XmRREFxrVBAG9XCOSSU,4896
 flock/core/__init__.py,sha256=juwyNr3QqKXUS5-E3hlMYRhgqHgQBqgtP12OF3tUCAI,1249
 flock/core/flock.py,sha256=iR4i0_z0w2ns_iHbP7FqN--7wlsPIWch1H-BVecPs_I,38205
-flock/core/flock_agent.py,sha256=9CNF1cWY6yASM1mAoJ73y9P1g0O5B5LBHJydXTe-fac,48830
+flock/core/flock_agent.py,sha256=Hl6TONSiJi2I-N_49-1hkW2q_hyPXMebMr-5oZLI-PY,48842
 flock/core/flock_evaluator.py,sha256=TPy6u6XX3cqkY1r9NW1w2lTwCMNW7pxhFYKLefnEbXg,1820
-flock/core/flock_factory.py,sha256=P07VsJgSf9YQEwokW_3WqXJmsno8ubvTSBv8S1s6nVI,15902
+flock/core/flock_factory.py,sha256=L3EFEUKqQmyxM_q0mh23ikLHPexSkV4Q8ifxIBSGA6s,18805
 flock/core/flock_module.py,sha256=ObILimpVaPnaaqYvcBYJJ20lQzfrjgTdADplaNRjHU0,7448
 flock/core/flock_registry.py,sha256=KzdFfc3QC-Dk42G24hdf6Prp3HvGj9ymXR3TTBe-T-A,27161
 flock/core/flock_router.py,sha256=1OAXDsdaIIFApEfo6SRfFEDoTuGt3Si7n2MXiySEfis,2644
@@ -55,7 +55,7 @@ flock/core/execution/local_executor.py,sha256=rnIQvaJOs6zZORUcR3vvyS6LPREDJTjayg
 flock/core/execution/temporal_executor.py,sha256=dHcb0xuzPFWU_wbwTgI7glLNyyppei93Txs2sapjhaw,6283
 flock/core/interpreter/python_interpreter.py,sha256=RaUMZuufsKBNQ4FAeSaOgUuxzs8VYu5TgUUs-xwaxxM,26376
 flock/core/logging/__init__.py,sha256=xn5fC-8IgsdIv0ywe_cICK1KVhTrVD8t-jYORg0ETUA,155
-flock/core/logging/logging.py,sha256=-fYk4rv41LUbSLCzaSApg3cFTAk04bDR64-4ve-2mHk,19541
+flock/core/logging/logging.py,sha256=VyBsin-3q8UQ0DY-K72t8FtrGJQbUwIfzxaC7rIWMvQ,19820
 flock/core/logging/telemetry.py,sha256=Trssqx02SBovTL843YwY3L-ZGj3KvcfMHLMU7Syk8L0,6561
 flock/core/logging/trace_and_logged.py,sha256=5vNrK1kxuPMoPJ0-QjQg-EDJL1oiEzvU6UNi6X8FiMs,2117
 flock/core/logging/formatters/enum_builder.py,sha256=LgEYXUv84wK5vwHflZ5h8HBGgvLH3sByvUQe8tZiyY0,981
@@ -67,16 +67,16 @@ flock/core/logging/telemetry_exporter/base_exporter.py,sha256=rQJJzS6q9n2aojoSqw
 flock/core/logging/telemetry_exporter/file_exporter.py,sha256=nKAjJSZtA7FqHSTuTiFtYYepaxOq7l1rDvs8U8rSBlA,3023
 flock/core/logging/telemetry_exporter/sqlite_exporter.py,sha256=CDsiMb9QcqeXelZ6ZqPSS56ovMPGqOu6whzBZRK__Vg,3498
 flock/core/mcp/__init__.py,sha256=g3hzM_9ntsr-Af9dE9cCZEjQ9YX2jk7-Jm-0JcHSk1A,25
-flock/core/mcp/flock_mcp_server.py,sha256=-rdIRwRoEqdxxd-pd_m4G5ySanFCr4EwedEUrNT_rnk,24732
-flock/core/mcp/flock_mcp_tool_base.py,sha256=pMxyHPRc2qx6bt38jq2VYBarZLVxhK2TpvK32EmdS8s,6814
-flock/core/mcp/mcp_client.py,sha256=LiX3TRnwBaV01_fNS9pZpBpjOARs0RD7fk_x1cY1_p0,24666
-flock/core/mcp/mcp_client_manager.py,sha256=YCNWgGMG8Va5AYfOmbG3s83EBzIrPGRrdPywUevqnT4,8075
-flock/core/mcp/mcp_config.py,sha256=knKywvyNPvYkQqaKFBLb3WayupSd5mt7KNrxx_ZjBco,7325
+flock/core/mcp/flock_mcp_server.py,sha256=WgvQDMq5qFj-PzuTXght0uFsztodYEkcIUXQ5TC4Q4M,25852
+flock/core/mcp/flock_mcp_tool_base.py,sha256=ZY6bUJEW3FY0Q5W5vNW0F8RqIovzKZU-X0JrVmK0TuA,6804
+flock/core/mcp/mcp_client.py,sha256=Nf-fC5EtX2egeoqgDx02EIWlwEd6aaNuT1n2DEbnvg0,25934
+flock/core/mcp/mcp_client_manager.py,sha256=hn97F9xEpYNbs02ruEbrtQo4PYD7TNKQAC0AwuAh6xw,8061
+flock/core/mcp/mcp_config.py,sha256=izO07hTD-2CrAhilqF9WDTpHNaK5l1T4UwFn6VsDwYc,16575
 flock/core/mcp/types/__init__.py,sha256=YgEJvTXe5VfSMfJNlpefdBYJOmMbMWQsXzc_qmOAybg,25
-flock/core/mcp/types/callbacks.py,sha256=kD5PnuL-oMYhHjKU-l1pAk8NkJ7RmeDDLu0pjMgK7oU,2547
-flock/core/mcp/types/factories.py,sha256=fgdbZUlZPwn-HH3Q3ljh-DsB7lcR6u5qFnzhC-jAM3I,3528
-flock/core/mcp/types/handlers.py,sha256=mhAoSS6vA3K7YP_mF9Sb2Zn2RvFM8fXxtbwC4zgU2JQ,7888
-flock/core/mcp/types/types.py,sha256=NFVFv0BXy4P79SGe8rKBO4VH41xkpF6Y-yvU3Fmzx6w,4872
+flock/core/mcp/types/callbacks.py,sha256=M4dvL9-PUVmojPTK18fg8ngHqYd7AogMoO6HixM9q10,2494
+flock/core/mcp/types/factories.py,sha256=T4fIyyJYibP8AGg_gjR1Pu5LO5xP5LsAfmBxyD6bBmY,3440
+flock/core/mcp/types/handlers.py,sha256=VEpOx5ShvlvOEvgo2Fs5rql-x0obVQYgEpcb8FBrm24,7788
+flock/core/mcp/types/types.py,sha256=2amE-oastGe1GGVI4gbH2ltCX7QvYnJebSArATvttUU,11410
 flock/core/mcp/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 flock/core/mcp/util/helpers.py,sha256=Xlf4iKW_lZxsVMTRoOnV29JsJfAppfmEJrb6sIcoCH4,636
 flock/core/mixin/dspy_integration.py,sha256=LQN4cfcG6Myi6kX0-2bKCuK1K_k_lu3SNaTdHHk3lEU,17745
@@ -101,11 +101,13 @@ flock/evaluators/memory/memory_evaluator.py,sha256=ySwz7kcc8suXMJ7gKNSWThW8iOMlE
 flock/evaluators/test/test_case_evaluator.py,sha256=3Emcoty0LOLLBIuPGxSpKphuZC9Fu1DTr1vbGg-hd0Q,1233
 flock/evaluators/zep/zep_evaluator.py,sha256=6_5vTdU0yJAH8I8w3-MPXiAZx6iUPhAVCsHjrHzkPLM,2058
 flock/mcp/servers/sse/__init__.py,sha256=r6YtleRSOMJqKhTtKQeFKd3QDaUJVz9R1BGJgOm_PF8,51
-flock/mcp/servers/sse/flock_sse_server.py,sha256=mtFW4JlOZFRA9uGXUTSRv4iTMXvFnyRV-ztxfujsuEE,4764
+flock/mcp/servers/sse/flock_sse_server.py,sha256=YesBrgdbxOsZO6Lgm8EQ8SsDDqhQGkTUPcEuLcqy89A,4980
 flock/mcp/servers/stdio/__init__.py,sha256=36QMguWwHCklLbISNNe1m2cq-y9klAWRf_QnuYpD2aY,53
 flock/mcp/servers/stdio/flock_stdio_server.py,sha256=E78F7iJ6hDyiHREZqNvou5-31NOBRGAYnpeEcRUF5VA,4921
+flock/mcp/servers/streamable_http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flock/mcp/servers/streamable_http/flock_streamable_http_server.py,sha256=3bKxx5zBkVXZIvD9qz31oL1ucsMeEO4kdOpv4S558zo,5818
 flock/mcp/servers/websockets/__init__.py,sha256=KeNgNQRdeCQ9xgpaHB1I0-HyYeBhkifAuZPTIA8eDqM,47
-flock/mcp/servers/websockets/flock_websocket_server.py,sha256=uxgCNOHQdlK_ZrWlWKyNt440BxJSwtwey2fm4bQ5J4I,4315
+flock/mcp/servers/websockets/flock_websocket_server.py,sha256=ntDLKMM20xTGd7k2TbNEK3ToJAF14oyW6vwofNzvqtM,4324
 flock/modules/__init__.py,sha256=Y0cEkx0dujRmy--TDpKoTqFSLzbyFz8BwEOv8kdSUhg,22
 flock/modules/assertion/__init__.py,sha256=Y0cEkx0dujRmy--TDpKoTqFSLzbyFz8BwEOv8kdSUhg,22
 flock/modules/assertion/assertion_module.py,sha256=2p9mIj8yBXRGgfe5pUWYXcLT86Ny13KyWHpRhe0Ehtg,12877
@@ -558,8 +560,8 @@ flock/workflow/agent_execution_activity.py,sha256=Gy6FtuVAjf0NiUXmC3syS2eJpNQF4R
 flock/workflow/flock_workflow.py,sha256=iSUF_soFvWar0ffpkzE4irkDZRx0p4HnwmEBi_Ne2sY,9666
 flock/workflow/temporal_config.py,sha256=3_8O7SDEjMsSMXsWJBfnb6XTp0TFaz39uyzSlMTSF_I,3988
 flock/workflow/temporal_setup.py,sha256=YIHnSBntzOchHfMSh8hoLeNXrz3B1UbR14YrR6soM7A,1606
-flock_core-0.4.512.dist-info/METADATA,sha256=ssgilAbpLRbIA5c6wUsPfiWciI5M-kw8FzMu_ufG888,22656
-flock_core-0.4.512.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.4.512.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.4.512.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.4.512.dist-info/RECORD,,
+flock_core-0.4.513.dist-info/METADATA,sha256=B1qPt_zjSDR-AT1CZrY4VxbYOa6s6DXdsW2LV_07OsY,22656
+flock_core-0.4.513.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.4.513.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.4.513.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.4.513.dist-info/RECORD,,