letta-nightly 0.11.4.dev20250825104222__py3-none-any.whl → 0.11.5__py3-none-any.whl

letta/functions/mcp_client/base_client.py

@@ -1,156 +0,0 @@
-from letta.log import get_logger
-
-logger = get_logger(__name__)
-
-
-# class BaseMCPClient:
-#    def __init__(self, server_config: BaseServerConfig):
-#        self.server_config = server_config
-#        self.session: Optional[ClientSession] = None
-#        self.stdio = None
-#        self.write = None
-#        self.initialized = False
-#        self.loop = asyncio.new_event_loop()
-#        self.cleanup_funcs = []
-#
-#    def connect_to_server(self):
-#        asyncio.set_event_loop(self.loop)
-#        success = self._initialize_connection(self.server_config, timeout=tool_settings.mcp_connect_to_server_timeout)
-#
-#        if success:
-#            try:
-#                self.loop.run_until_complete(
-#                    asyncio.wait_for(self.session.initialize(), timeout=tool_settings.mcp_connect_to_server_timeout)
-#                )
-#                self.initialized = True
-#            except asyncio.TimeoutError:
-#                raise MCPTimeoutError("initializing session", self.server_config.server_name, tool_settings.mcp_connect_to_server_timeout)
-#        else:
-#            raise RuntimeError(
-#                f"Connecting to MCP server failed. Please review your server config: {self.server_config.model_dump_json(indent=4)}"
-#            )
-#
-#    def _initialize_connection(self, server_config: BaseServerConfig, timeout: float) -> bool:
-#        raise NotImplementedError("Subclasses must implement _initialize_connection")
-#
-#    def list_tools(self) -> List[MCPTool]:
-#        self._check_initialized()
-#        try:
-#            response = self.loop.run_until_complete(
-#                asyncio.wait_for(self.session.list_tools(), timeout=tool_settings.mcp_list_tools_timeout)
-#            )
-#            return response.tools
-#        except asyncio.TimeoutError:
-#            logger.error(
-#                f"Timed out while listing tools for MCP server {self.server_config.server_name} (timeout={tool_settings.mcp_list_tools_timeout}s)."
-#            )
-#            raise MCPTimeoutError("listing tools", self.server_config.server_name, tool_settings.mcp_list_tools_timeout)
-#
-#    def execute_tool(self, tool_name: str, tool_args: dict) -> Tuple[str, bool]:
-#        self._check_initialized()
-#        try:
-#            result = self.loop.run_until_complete(
-#                asyncio.wait_for(self.session.call_tool(tool_name, tool_args), timeout=tool_settings.mcp_execute_tool_timeout)
-#            )
-#
-#            parsed_content = []
-#            for content_piece in result.content:
-#                if isinstance(content_piece, TextContent):
-#                    parsed_content.append(content_piece.text)
-#                    print("parsed_content (text)", parsed_content)
-#                else:
-#                    parsed_content.append(str(content_piece))
-#                    print("parsed_content (other)", parsed_content)
-#
-#            if len(parsed_content) > 0:
-#                final_content = " ".join(parsed_content)
-#            else:
-#                # TODO move hardcoding to constants
-#                final_content = "Empty response from tool"
-#
-#            return final_content, result.isError
-#        except asyncio.TimeoutError:
-#            logger.error(
-#                f"Timed out while executing tool '{tool_name}' for MCP server {self.server_config.server_name} (timeout={tool_settings.mcp_execute_tool_timeout}s)."
-#            )
-#            raise MCPTimeoutError(f"executing tool '{tool_name}'", self.server_config.server_name, tool_settings.mcp_execute_tool_timeout)
-#
-#    def _check_initialized(self):
-#        if not self.initialized:
-#            logger.error("MCPClient has not been initialized")
-#            raise RuntimeError("MCPClient has not been initialized")
-#
-#    def cleanup(self):
-#        try:
-#            for cleanup_func in self.cleanup_funcs:
-#                cleanup_func()
-#            self.initialized = False
-#            if not self.loop.is_closed():
-#                self.loop.close()
-#        except Exception as e:
-#            logger.warning(e)
-#        finally:
-#            logger.info("Cleaned up MCP clients on shutdown.")
-#
-#
-# class BaseAsyncMCPClient:
-#    def __init__(self, server_config: BaseServerConfig):
-#        self.server_config = server_config
-#        self.session: Optional[ClientSession] = None
-#        self.stdio = None
-#        self.write = None
-#        self.initialized = False
-#        self.cleanup_funcs = []
-#
-#    async def connect_to_server(self):
-#
-#        success = await self._initialize_connection(self.server_config, timeout=tool_settings.mcp_connect_to_server_timeout)
-#
-#        if success:
-#            self.initialized = True
-#        else:
-#            raise RuntimeError(
-#                f"Connecting to MCP server failed. Please review your server config: {self.server_config.model_dump_json(indent=4)}"
-#            )
-#
-#    async def list_tools(self) -> List[MCPTool]:
-#        self._check_initialized()
-#        response = await self.session.list_tools()
-#        return response.tools
-#
-#    async def execute_tool(self, tool_name: str, tool_args: dict) -> Tuple[str, bool]:
-#        self._check_initialized()
-#        result = await self.session.call_tool(tool_name, tool_args)
-#
-#        parsed_content = []
-#        for content_piece in result.content:
-#            if isinstance(content_piece, TextContent):
-#                parsed_content.append(content_piece.text)
-#            else:
-#                parsed_content.append(str(content_piece))
-#
-#            if len(parsed_content) > 0:
-#                final_content = " ".join(parsed_content)
-#            else:
-#                # TODO move hardcoding to constants
-#                final_content = "Empty response from tool"
-#
-#            return final_content, result.isError
-#
-#    def _check_initialized(self):
-#        if not self.initialized:
-#            logger.error("MCPClient has not been initialized")
-#            raise RuntimeError("MCPClient has not been initialized")
-#
-#    async def cleanup(self):
-#        try:
-#            for cleanup_func in self.cleanup_funcs:
-#                cleanup_func()
-#            self.initialized = False
-#            if not self.loop.is_closed():
-#                self.loop.close()
-#        except Exception as e:
-#            logger.warning(e)
-#        finally:
-#            logger.info("Cleaned up MCP clients on shutdown.")
-#

letta/functions/mcp_client/sse_client.py

@@ -1,51 +0,0 @@
-# import asyncio
-#
-# from mcp import ClientSession
-# from mcp.client.sse import sse_client
-#
-# from letta.functions.mcp_client.base_client import BaseAsyncMCPClient, BaseMCPClient
-# from letta.functions.mcp_client.types import SSEServerConfig
-# from letta.log import get_logger
-#
-## see: https://modelcontextprotocol.io/quickstart/user
-#
-# logger = get_logger(__name__)
-
-
-# class SSEMCPClient(BaseMCPClient):
-#    def _initialize_connection(self, server_config: SSEServerConfig, timeout: float) -> bool:
-#        try:
-#            sse_cm = sse_client(url=server_config.server_url)
-#            sse_transport = self.loop.run_until_complete(asyncio.wait_for(sse_cm.__aenter__(), timeout=timeout))
-#            self.stdio, self.write = sse_transport
-#            self.cleanup_funcs.append(lambda: self.loop.run_until_complete(sse_cm.__aexit__(None, None, None)))
-#
-#            session_cm = ClientSession(self.stdio, self.write)
-#            self.session = self.loop.run_until_complete(asyncio.wait_for(session_cm.__aenter__(), timeout=timeout))
-#            self.cleanup_funcs.append(lambda: self.loop.run_until_complete(session_cm.__aexit__(None, None, None)))
-#            return True
-#        except asyncio.TimeoutError:
-#            logger.error(f"Timed out while establishing SSE connection (timeout={timeout}s).")
-#            return False
-#        except Exception:
-#            logger.exception("Exception occurred while initializing SSE client session.")
-#            return False
-#
-#
-# class AsyncSSEMCPClient(BaseAsyncMCPClient):
-#
-#    async def _initialize_connection(self, server_config: SSEServerConfig, timeout: float) -> bool:
-#        try:
-#            sse_cm = sse_client(url=server_config.server_url)
-#            sse_transport = await sse_cm.__aenter__()
-#            self.stdio, self.write = sse_transport
-#            self.cleanup_funcs.append(lambda: sse_cm.__aexit__(None, None, None))
-#
-#            session_cm = ClientSession(self.stdio, self.write)
-#            self.session = await session_cm.__aenter__()
-#            self.cleanup_funcs.append(lambda: session_cm.__aexit__(None, None, None))
-#            return True
-#        except Exception:
-#            logger.exception("Exception occurred while initializing SSE client session.")
-#            return False
-#

letta/functions/mcp_client/stdio_client.py

@@ -1,109 +0,0 @@
-# import asyncio
-# import sys
-# from contextlib import asynccontextmanager
-#
-# import anyio
-# import anyio.lowlevel
-# import mcp.types as types
-# from anyio.streams.text import TextReceiveStream
-# from mcp import ClientSession, StdioServerParameters
-# from mcp.client.stdio import get_default_environment
-#
-# from letta.functions.mcp_client.base_client import BaseMCPClient
-# from letta.functions.mcp_client.types import StdioServerConfig
-# from letta.log import get_logger
-#
-# logger = get_logger(__name__)
-
-
-# class StdioMCPClient(BaseMCPClient):
-#    def _initialize_connection(self, server_config: StdioServerConfig, timeout: float) -> bool:
-#        try:
-#            server_params = StdioServerParameters(command=server_config.command, args=server_config.args, env=server_config.env)
-#            stdio_cm = forked_stdio_client(server_params)
-#            stdio_transport = self.loop.run_until_complete(asyncio.wait_for(stdio_cm.__aenter__(), timeout=timeout))
-#            self.stdio, self.write = stdio_transport
-#            self.cleanup_funcs.append(lambda: self.loop.run_until_complete(stdio_cm.__aexit__(None, None, None)))
-#
-#            session_cm = ClientSession(self.stdio, self.write)
-#            self.session = self.loop.run_until_complete(asyncio.wait_for(session_cm.__aenter__(), timeout=timeout))
-#            self.cleanup_funcs.append(lambda: self.loop.run_until_complete(session_cm.__aexit__(None, None, None)))
-#            return True
-#        except asyncio.TimeoutError:
-#            logger.error(f"Timed out while establishing stdio connection (timeout={timeout}s).")
-#            return False
-#        except Exception:
-#            logger.exception("Exception occurred while initializing stdio client session.")
-#            return False
-#
-#
-# @asynccontextmanager
-# async def forked_stdio_client(server: StdioServerParameters):
-#    """
-#    Client transport for stdio: this will connect to a server by spawning a
-#    process and communicating with it over stdin/stdout.
-#    """
-#    read_stream_writer, read_stream = anyio.create_memory_object_stream(0)
-#    write_stream, write_stream_reader = anyio.create_memory_object_stream(0)
-#
-#    try:
-#        process = await anyio.open_process(
-#            [server.command, *server.args],
-#            env=server.env or get_default_environment(),
-#            stderr=sys.stderr,  # Consider logging stderr somewhere instead of silencing it
-#        )
-#    except OSError as exc:
-#        raise RuntimeError(f"Failed to spawn process: {server.command} {server.args}") from exc
-#
-#    async def stdout_reader():
-#        assert process.stdout, "Opened process is missing stdout"
-#        buffer = ""
-#        try:
-#            async with read_stream_writer:
-#                async for chunk in TextReceiveStream(
-#                    process.stdout,
-#                    encoding=server.encoding,
-#                    errors=server.encoding_error_handler,
-#                ):
-#                    lines = (buffer + chunk).split("\n")
-#                    buffer = lines.pop()
-#                    for line in lines:
-#                        try:
-#                            message = types.JSONRPCMessage.model_validate_json(line)
-#                        except Exception as exc:
-#                            await read_stream_writer.send(exc)
-#                            continue
-#                        await read_stream_writer.send(message)
-#        except anyio.ClosedResourceError:
-#            await anyio.lowlevel.checkpoint()
-#
-#    async def stdin_writer():
-#        assert process.stdin, "Opened process is missing stdin"
-#        try:
-#            async with write_stream_reader:
-#                async for message in write_stream_reader:
-#                    json = message.model_dump_json(by_alias=True, exclude_none=True)
-#                    await process.stdin.send(
-#                        (json + "\n").encode(
-#                            encoding=server.encoding,
-#                            errors=server.encoding_error_handler,
-#                        )
-#                    )
-#        except anyio.ClosedResourceError:
-#            await anyio.lowlevel.checkpoint()
-#
-#    async def watch_process_exit():
-#        returncode = await process.wait()
-#        if returncode != 0:
-#            raise RuntimeError(f"Subprocess exited with code {returncode}. Command: {server.command} {server.args}")
-#
-#    async with anyio.create_task_group() as tg, process:
-#        tg.start_soon(stdout_reader)
-#        tg.start_soon(stdin_writer)
-#        tg.start_soon(watch_process_exit)
-#
-#        with anyio.move_on_after(0.2):
-#            await anyio.sleep_forever()
-#
-#        yield read_stream, write_stream
-#