letta-nightly 0.7.29.dev20250602104315__py3-none-any.whl → 0.8.0.dev20250604104349__py3-none-any.whl

letta/functions/ast_parsers.py

@@ -5,23 +5,13 @@ import typing
 from typing import Dict, Optional, Tuple
 
 from letta.errors import LettaToolCreateError
-
-# Registry of known types for annotation resolution
-BUILTIN_TYPES = {
-    "int": int,
-    "float": float,
-    "str": str,
-    "dict": dict,
-    "list": list,
-    "set": set,
-    "tuple": tuple,
-    "bool": bool,
-}
+from letta.types import JsonDict
 
 
 def resolve_type(annotation: str):
     """
     Resolve a type annotation string into a Python type.
+    Previously, primitive support for int, float, str, dict, list, set, tuple, bool.
 
     Args:
         annotation (str): The annotation string (e.g., 'int', 'list[int]', 'dict[str, int]').
@@ -32,24 +22,19 @@ def resolve_type(annotation: str):
     Raises:
         ValueError: If the annotation is unsupported or invalid.
     """
-    if annotation in BUILTIN_TYPES:
-        return BUILTIN_TYPES[annotation]
+    python_types = {**vars(typing), **vars(builtins)}
+
+    if annotation in python_types:
+        return python_types[annotation]
 
     try:
         # Allow use of typing and builtins in a safe eval context
-        namespace = {
-            **vars(typing),
-            **vars(builtins),
-            "list": list,
-            "dict": dict,
-            "tuple": tuple,
-            "set": set,
-        }
-        return eval(annotation, namespace)
+        return eval(annotation, python_types)
     except Exception:
         raise ValueError(f"Unsupported annotation: {annotation}")
 
 
+# TODO :: THIS MUST BE EDITED TO HANDLE THINGS
 def get_function_annotations_from_source(source_code: str, function_name: str) -> Dict[str, str]:
     """
     Parse the source code to extract annotations for a given function name.
@@ -76,7 +61,8 @@ def get_function_annotations_from_source(source_code: str, function_name: str) -
     raise ValueError(f"Function '{function_name}' not found in the provided source code.")
 
 
-def coerce_dict_args_by_annotations(function_args: dict, annotations: Dict[str, str]) -> dict:
+# NOW json_loads -> ast.literal_eval -> typing.get_origin
+def coerce_dict_args_by_annotations(function_args: JsonDict, annotations: Dict[str, str]) -> dict:
     coerced_args = dict(function_args)  # Shallow copy
 
     for arg_name, value in coerced_args.items():
@@ -110,8 +96,8 @@ def coerce_dict_args_by_annotations(function_args: dict, annotations: Dict[str,
     return coerced_args
 
 
-def get_function_name_and_description(source_code: str, name: Optional[str] = None) -> Tuple[str, str]:
-    """Gets the name and description for a given function source code by parsing the AST.
+def get_function_name_and_docstring(source_code: str, name: Optional[str] = None) -> Tuple[str, str]:
+    """Gets the name and docstring for a given function source code by parsing the AST.
 
     Args:
         source_code: The source code to parse
@@ -147,11 +133,8 @@ def get_function_name_and_description(source_code: str, name: Optional[str] = No
 
         return function_name, docstring
 
-    except Exception as e:
-        raise LettaToolCreateError(f"Failed to parse function name and docstring: {str(e)}")
-
     except Exception as e:
         import traceback
 
         traceback.print_exc()
-        raise LettaToolCreateError(f"Name and docstring generation failed: {str(e)}")
+        raise LettaToolCreateError(f"Failed to parse function name and docstring: {str(e)}")

letta/functions/function_sets/base.py

@@ -288,7 +288,9 @@ def memory_insert(agent_state: "AgentState", label: str, new_str: str, insert_li
     n_lines = len(current_value_lines)
 
     # Check if we're in range, from 0 (pre-line), to 1 (first line), to n_lines (last line)
-    if insert_line < 0 or insert_line > n_lines:
+    if insert_line == -1:
+        insert_line = n_lines
+    elif insert_line < 0 or insert_line > n_lines:
         raise ValueError(
             f"Invalid `insert_line` parameter: {insert_line}. It should be within the range of lines of the memory block: {[0, n_lines]}, or -1 to append to the end of the memory block."
         )

letta/functions/functions.py

@@ -12,6 +12,8 @@ from letta.functions.schema_generator import generate_schema
 def derive_openai_json_schema(source_code: str, name: Optional[str] = None) -> dict:
     """Derives the OpenAI JSON schema for a given function source code.
 
+    # TODO (cliandy): I don't think we need to or should execute here
+    # TODO (cliandy): CONFIRM THIS BEFORE MERGING.
     First, attempts to execute the source code in a custom environment with only the necessary imports.
     Then, it generates the schema from the function's docstring and signature.
     """

letta/functions/mcp_client/base_client.py

@@ -1,102 +1,156 @@
-import asyncio
-from typing import List, Optional, Tuple
-
-from mcp import ClientSession
-from mcp.types import TextContent
-
-from letta.functions.mcp_client.exceptions import MCPTimeoutError
-from letta.functions.mcp_client.types import BaseServerConfig, MCPTool
 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 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 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,33 +1,51 @@
-import asyncio
+# 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__)
 
-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
+# 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
+#