letta-nightly 0.6.41.dev20250316104011__tar.gz → 0.6.42.dev20250317175208__tar.gz

{letta_nightly-0.6.41.dev20250316104011 → letta_nightly-0.6.42.dev20250317175208}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.41.dev20250316104011
+Version: 0.6.42.dev20250317175208
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.6.41.dev20250316104011 → letta_nightly-0.6.42.dev20250317175208}/letta/embeddings.py

@@ -3,6 +3,7 @@ from typing import Any, List, Optional
 
 import numpy as np
 import tiktoken
+from openai import OpenAI
 
 from letta.constants import EMBEDDING_TO_TOKENIZER_DEFAULT, EMBEDDING_TO_TOKENIZER_MAP, MAX_EMBEDDING_DIM
 from letta.schemas.embedding_config import EmbeddingConfig
@@ -201,6 +202,21 @@ class GoogleVertexEmbeddings:
         return response.embeddings[0].embedding
 
 
+class OpenAIEmbeddings:
+
+    def __init__(self, api_key: str, model: str, base_url: str):
+        if base_url:
+            self.client = OpenAI(api_key=api_key, base_url=base_url)
+        else:
+            self.client = OpenAI(api_key=api_key)
+        self.model = model
+
+    def get_text_embedding(self, text: str):
+        response = self.client.embeddings.create(input=text, model=self.model)
+
+        return response.data[0].embedding
+
+
 def query_embedding(embedding_model, query_text: str):
     """Generate padded embedding for querying database"""
     query_vec = embedding_model.get_text_embedding(query_text)
@@ -218,15 +234,9 @@ def embedding_model(config: EmbeddingConfig, user_id: Optional[uuid.UUID] = None
     from letta.settings import model_settings
 
     if endpoint_type == "openai":
-        from llama_index.embeddings.openai import OpenAIEmbedding
-
-        additional_kwargs = {"user_id": user_id} if user_id else {}
-        model = OpenAIEmbedding(
-            api_base=config.embedding_endpoint,
-            api_key=model_settings.openai_api_key,
-            additional_kwargs=additional_kwargs,
+        return OpenAIEmbeddings(
+            api_key=model_settings.openai_api_key, model=config.embedding_model, base_url=model_settings.openai_api_base
         )
-        return model
 
     elif endpoint_type == "azure":
         assert all(

letta_nightly-0.6.42.dev20250317175208/letta/functions/mcp_client/base_client.py

@@ -0,0 +1,87 @@
+import asyncio
+from typing import List, Optional, Tuple
+
+from mcp import ClientSession, Tool
+
+from letta.functions.mcp_client.types import BaseServerConfig
+from letta.log import get_logger
+from letta.settings import tool_settings
+
+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 RuntimeError(
+                    f"Timed out while initializing session for MCP server {self.server_config.server_name} (timeout={tool_settings.mcp_connect_to_server_timeout}s)."
+                )
+        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[Tool]:
+        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:
+            # Could log, throw a custom exception, etc.
+            logger.error(
+                f"Timed out while listing tools for MCP server {self.server_config.server_name} (timeout={tool_settings.mcp_list_tools_timeout}s)."
+            )
+            return []
+
+    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)
+            )
+            return str(result.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)."
+            )
+            return "", True
+
+    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.")

letta_nightly-0.6.42.dev20250317175208/letta/functions/mcp_client/sse_client.py

@@ -0,0 +1,33 @@
+import asyncio
+
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+
+from letta.functions.mcp_client.base_client import BaseMCPClient
+from letta.functions.mcp_client.types import SSEServerConfig
+from letta.log import get_logger
+
+# see: https://modelcontextprotocol.io/quickstart/user
+MCP_CONFIG_TOPLEVEL_KEY = "mcpServers"
+
+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

{letta_nightly-0.6.41.dev20250316104011 → letta_nightly-0.6.42.dev20250317175208}/letta/functions/mcp_client/stdio_client.py

@@ -1,3 +1,4 @@
+import asyncio
 import sys
 from contextlib import asynccontextmanager
 
@@ -16,19 +17,23 @@ logger = get_logger(__name__)
 
 
 class StdioMCPClient(BaseMCPClient):
-    def _initialize_connection(self, server_config: StdioServerConfig) -> bool:
+    def _initialize_connection(self, server_config: StdioServerConfig, timeout: float) -> bool:
         try:
             server_params = StdioServerParameters(command=server_config.command, args=server_config.args)
             stdio_cm = forked_stdio_client(server_params)
-            stdio_transport = self.loop.run_until_complete(stdio_cm.__aenter__())
+            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(session_cm.__aenter__())
+            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
 
 

{letta_nightly-0.6.41.dev20250316104011 → letta_nightly-0.6.42.dev20250317175208}/letta/llm_api/anthropic.py

@@ -840,7 +840,7 @@ def anthropic_chat_completions_process_stream(
     # Create a dummy message for ID/datetime if needed
     dummy_message = _Message(
         role=_MessageRole.assistant,
-        text="",
+        content=[],
         agent_id="",
         model="",
         name=None,

{letta_nightly-0.6.41.dev20250316104011 → letta_nightly-0.6.42.dev20250317175208}/letta/memory.py

@@ -37,7 +37,12 @@ def get_memory_functions(cls: Memory) -> Dict[str, Callable]:
 
 def _format_summary_history(message_history: List[Message]):
     # TODO use existing prompt formatters for this (eg ChatML)
-    return "\n".join([f"{m.role}: {m.content[0].text}" for m in message_history])
+    def get_message_text(content):
+        if content and len(content) == 1 and isinstance(content[0], TextContent):
+            return content[0].text
+        return ""
+
+    return "\n".join([f"{m.role}: {get_message_text(m.content)}" for m in message_history])
 
 
 def summarize_messages(

{letta_nightly-0.6.41.dev20250316104011 → letta_nightly-0.6.42.dev20250317175208}/letta/schemas/source.py

@@ -50,7 +50,12 @@ class SourceCreate(BaseSource):
     # required
     name: str = Field(..., description="The name of the source.")
     # TODO: @matt, make this required after shub makes the FE changes
-    embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the source.")
+
+    embedding: Optional[str] = Field(None, description="The hande for the embedding config used by the source.")
+    embedding_chunk_size: Optional[int] = Field(None, description="The chunk size of the embedding.")
+
+    # TODO: remove (legacy config)
+    embedding_config: Optional[EmbeddingConfig] = Field(None, description="(Legacy) The embedding configuration used by the source.")
 
     # optional
     description: Optional[str] = Field(None, description="The description of the source.")

{letta_nightly-0.6.41.dev20250316104011 → letta_nightly-0.6.42.dev20250317175208}/letta/server/rest_api/app.py

@@ -256,15 +256,15 @@ def create_application() -> "FastAPI":
     )
 
     # Set up OpenTelemetry tracing
-    endpoint = os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
-    if endpoint:
-        print(f"▶ Using OTLP tracing with endpoint: {endpoint}")
+    otlp_endpoint = settings.otel_exporter_otlp_endpoint
+    if otlp_endpoint:
+        print(f"▶ Using OTLP tracing with endpoint: {otlp_endpoint}")
         env_name_suffix = os.getenv("ENV_NAME")
         service_name = f"letta-server-{env_name_suffix.lower()}" if env_name_suffix else "letta-server"
         from letta.tracing import setup_tracing
 
         setup_tracing(
-            endpoint=endpoint,
+            endpoint=otlp_endpoint,
             app=app,
             service_name=service_name,
         )
@@ -326,7 +326,7 @@ def start_server(
         print(f"▶ Server running at: https://{host or 'localhost'}:{port or REST_DEFAULT_PORT}")
         print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard\n")
         uvicorn.run(
-            app,
+            "letta.server.rest_api.app:app",
             host=host or "localhost",
             port=port or REST_DEFAULT_PORT,
             workers=settings.uvicorn_workers,
@@ -345,7 +345,7 @@ def start_server(
             print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard\n")
 
         uvicorn.run(
-            app,
+            "letta.server.rest_api.app:app",
             host=host or "localhost",
             port=port or REST_DEFAULT_PORT,
             workers=settings.uvicorn_workers,

{letta_nightly-0.6.41.dev20250316104011 → letta_nightly-0.6.42.dev20250317175208}/letta/server/rest_api/routers/v1/sources.py

@@ -76,8 +76,20 @@ def create_source(
     Create a new data source.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    source = Source(**source_create.model_dump())
-
+    if not source_create.embedding_config:
+        if not source_create.embedding:
+            # TODO: modify error type
+            raise ValueError("Must specify either embedding or embedding_config in request")
+        source_create.embedding_config = server.get_embedding_config_from_handle(
+            handle=source_create.embedding,
+            embedding_chunk_size=source_create.embedding_chunk_size or constants.DEFAULT_EMBEDDING_CHUNK_SIZE,
+        )
+    source = Source(
+        name=source_create.name,
+        embedding_config=source_create.embedding_config,
+        description=source_create.description,
+        metadata=source_create.metadata,
+    )
     return server.source_manager.create_source(source=source, actor=actor)
 
 
@@ -91,6 +103,7 @@ def modify_source(
     """
     Update the name or documentation of an existing data source.
     """
+    # TODO: allow updating the handle/embedding config
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
     if not server.source_manager.get_source_by_id(source_id=source_id, actor=actor):
         raise HTTPException(status_code=404, detail=f"Source with id={source_id} does not exist.")

{letta_nightly-0.6.41.dev20250316104011 → letta_nightly-0.6.42.dev20250317175208}/letta/server/server.py

@@ -332,14 +332,14 @@ class SyncServer(Server):
 
         for server_name, server_config in mcp_server_configs.items():
             if server_config.type == MCPServerType.SSE:
-                self.mcp_clients[server_name] = SSEMCPClient()
+                self.mcp_clients[server_name] = SSEMCPClient(server_config)
             elif server_config.type == MCPServerType.STDIO:
-                self.mcp_clients[server_name] = StdioMCPClient()
+                self.mcp_clients[server_name] = StdioMCPClient(server_config)
             else:
                 raise ValueError(f"Invalid MCP server config: {server_config}")
 
             try:
-                self.mcp_clients[server_name].connect_to_server(server_config)
+                self.mcp_clients[server_name].connect_to_server()
             except Exception as e:
                 logger.error(e)
                 self.mcp_clients.pop(server_name)
@@ -1266,6 +1266,11 @@ class SyncServer(Server):
     # TODO support both command + SSE servers (via config)
     def get_mcp_servers(self) -> dict[str, Union[SSEServerConfig, StdioServerConfig]]:
         """List the MCP servers in the config (doesn't test that they are actually working)"""
+
+        # TODO implement non-flatfile mechanism
+        if not tool_settings.mcp_read_from_config:
+            raise RuntimeError("MCP config file disabled. Enable it in settings.")
+
         mcp_server_list = {}
 
         # Attempt to read from ~/.letta/mcp_config.json
@@ -1326,13 +1331,18 @@ class SyncServer(Server):
 
     def add_mcp_server_to_config(
         self, server_config: Union[SSEServerConfig, StdioServerConfig], allow_upsert: bool = True
-    ) -> dict[str, Union[SSEServerConfig, StdioServerConfig]]:
+    ) -> List[Union[SSEServerConfig, StdioServerConfig]]:
         """Add a new server config to the MCP config file"""
 
+        # TODO implement non-flatfile mechanism
+        if not tool_settings.mcp_read_from_config:
+            raise RuntimeError("MCP config file disabled. Enable it in settings.")
+
         # If the config file doesn't exist, throw an error.
         mcp_config_path = os.path.join(constants.LETTA_DIR, constants.MCP_CONFIG_NAME)
         if not os.path.exists(mcp_config_path):
-            raise FileNotFoundError(f"MCP config file not found: {mcp_config_path}")
+            # Create the file if it doesn't exist
+            logger.debug(f"MCP config file not found, creating new file at: {mcp_config_path}")
 
         # If the file does exist, attempt to parse it get calling get_mcp_servers
         try:
@@ -1348,13 +1358,13 @@ class SyncServer(Server):
 
         # Attempt to initialize the connection to the server
         if server_config.type == MCPServerType.SSE:
-            new_mcp_client = SSEMCPClient()
+            new_mcp_client = SSEMCPClient(server_config)
         elif server_config.type == MCPServerType.STDIO:
-            new_mcp_client = StdioMCPClient()
+            new_mcp_client = StdioMCPClient(server_config)
         else:
             raise ValueError(f"Invalid MCP server config: {server_config}")
         try:
-            new_mcp_client.connect_to_server(server_config)
+            new_mcp_client.connect_to_server()
         except:
             logger.exception(f"Failed to connect to MCP server: {server_config.server_name}")
             raise RuntimeError(f"Failed to connect to MCP server: {server_config.server_name}")
@@ -1384,9 +1394,14 @@ class SyncServer(Server):
     def delete_mcp_server_from_config(self, server_name: str) -> dict[str, Union[SSEServerConfig, StdioServerConfig]]:
         """Delete a server config from the MCP config file"""
 
+        # TODO implement non-flatfile mechanism
+        if not tool_settings.mcp_read_from_config:
+            raise RuntimeError("MCP config file disabled. Enable it in settings.")
+
         # If the config file doesn't exist, throw an error.
         mcp_config_path = os.path.join(constants.LETTA_DIR, constants.MCP_CONFIG_NAME)
         if not os.path.exists(mcp_config_path):
+            # If the file doesn't exist, raise an error
             raise FileNotFoundError(f"MCP config file not found: {mcp_config_path}")
 
         # If the file does exist, attempt to parse it get calling get_mcp_servers

{letta_nightly-0.6.41.dev20250316104011 → letta_nightly-0.6.42.dev20250317175208}/letta/settings.py

@@ -18,6 +18,12 @@ class ToolSettings(BaseSettings):
     # Local Sandbox configurations
     local_sandbox_dir: Optional[str] = None
 
+    # MCP settings
+    mcp_connect_to_server_timeout: float = 15.0
+    mcp_list_tools_timeout: float = 10.0
+    mcp_execute_tool_timeout: float = 60.0
+    mcp_read_from_config: bool = True  # if False, will throw if attempting to read/write from file
+
 
 class SummarizerSettings(BaseSettings):
     model_config = SettingsConfigDict(env_prefix="letta_summarizer_", extra="ignore")

{letta_nightly-0.6.41.dev20250316104011 → letta_nightly-0.6.42.dev20250317175208}/letta/supervisor_multi_agent.py

@@ -3,16 +3,18 @@ from typing import List, Optional
 from letta.agent import Agent, AgentState
 from letta.constants import DEFAULT_MESSAGE_TOOL
 from letta.functions.function_sets.multi_agent import send_message_to_all_agents_in_group
+from letta.functions.functions import parse_source_code
+from letta.functions.schema_generator import generate_schema
 from letta.interface import AgentInterface
 from letta.orm import User
 from letta.orm.enums import ToolType
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.message import Message, MessageCreate
+from letta.schemas.tool import Tool
 from letta.schemas.tool_rule import ChildToolRule, InitToolRule, TerminalToolRule
 from letta.schemas.usage import LettaUsageStatistics
 from letta.services.agent_manager import AgentManager
 from letta.services.tool_manager import ToolManager
-from tests.helpers.utils import create_tool_from_func
 
 
 class SupervisorMultiAgent(Agent):
@@ -47,7 +49,14 @@ class SupervisorMultiAgent(Agent):
 
         # add multi agent tool
         if self.tool_manager.get_tool_by_name(tool_name="send_message_to_all_agents_in_group", actor=self.user) is None:
-            multi_agent_tool = create_tool_from_func(send_message_to_all_agents_in_group)
+            multi_agent_tool = Tool(
+                name=send_message_to_all_agents_in_group.__name__,
+                description="",
+                source_type="python",
+                tags=[],
+                source_code=parse_source_code(send_message_to_all_agents_in_group),
+                json_schema=generate_schema(send_message_to_all_agents_in_group, None),
+            )
             multi_agent_tool.tool_type = ToolType.LETTA_MULTI_AGENT_CORE
             multi_agent_tool = self.tool_manager.create_or_update_tool(
                 pydantic_tool=multi_agent_tool,

{letta_nightly-0.6.41.dev20250316104011 → letta_nightly-0.6.42.dev20250317175208}/letta/tracing.py

@@ -90,8 +90,8 @@ async def trace_error_handler(_request: Request, exc: Exception) -> JSONResponse
     # Add error details to current span
     span = trace.get_current_span()
     if span:
-        span.add_event(
-            name="exception",
+        span.record_exception(
+            exc,
             attributes={
                 "exception.message": error_msg,
                 "exception.type": type(exc).__name__,

{letta_nightly-0.6.41.dev20250316104011 → letta_nightly-0.6.42.dev20250317175208}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.6.41.dev20250316104011"
+version = "0.6.42.dev20250317175208"
 packages = [
     {include = "letta"},
 ]

letta_nightly-0.6.41.dev20250316104011/letta/functions/mcp_client/base_client.py

@@ -1,61 +0,0 @@
-import asyncio
-from typing import List, Optional, Tuple
-
-from mcp import ClientSession, Tool
-
-from letta.functions.mcp_client.types import BaseServerConfig
-from letta.log import get_logger
-
-logger = get_logger(__name__)
-
-
-class BaseMCPClient:
-    def __init__(self):
-        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, server_config: BaseServerConfig):
-        asyncio.set_event_loop(self.loop)
-        success = self._initialize_connection(server_config)
-
-        if success:
-            self.loop.run_until_complete(self.session.initialize())
-            self.initialized = True
-        else:
-            raise RuntimeError(
-                f"Connecting to MCP server failed. Please review your server config: {server_config.model_dump_json(indent=4)}"
-            )
-
-    def _initialize_connection(self, server_config: BaseServerConfig) -> bool:
-        raise NotImplementedError("Subclasses must implement _initialize_connection")
-
-    def list_tools(self) -> List[Tool]:
-        self._check_initialized()
-        response = self.loop.run_until_complete(self.session.list_tools())
-        return response.tools
-
-    def execute_tool(self, tool_name: str, tool_args: dict) -> Tuple[str, bool]:
-        self._check_initialized()
-        result = self.loop.run_until_complete(self.session.call_tool(tool_name, tool_args))
-        return str(result.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")
-
-    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_nightly-0.6.41.dev20250316104011/letta/functions/mcp_client/sse_client.py

@@ -1,21 +0,0 @@
-from mcp import ClientSession
-from mcp.client.sse import sse_client
-
-from letta.functions.mcp_client.base_client import BaseMCPClient
-from letta.functions.mcp_client.types import SSEServerConfig
-
-# see: https://modelcontextprotocol.io/quickstart/user
-MCP_CONFIG_TOPLEVEL_KEY = "mcpServers"
-
-
-class SSEMCPClient(BaseMCPClient):
-    def _initialize_connection(self, server_config: SSEServerConfig) -> bool:
-        sse_cm = sse_client(url=server_config.server_url)
-        sse_transport = self.loop.run_until_complete(sse_cm.__aenter__())
-        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(session_cm.__aenter__())
-        self.cleanup_funcs.append(lambda: self.loop.run_until_complete(session_cm.__aexit__(None, None, None)))
-        return True