letta-nightly 0.5.4.dev20241202104311__py3-none-any.whl → 0.5.4.dev20241203104336__py3-none-any.whl

letta/functions/functions.py

@@ -1,11 +1,8 @@
-import importlib
 import inspect
-import os
 from textwrap import dedent  # remove indentation
 from types import ModuleType
 from typing import Dict, List, Optional
 
-from letta.constants import CLI_WARNING_PREFIX
 from letta.errors import LettaToolCreateError
 from letta.functions.schema_generator import generate_schema
 
@@ -90,46 +87,3 @@ def load_function_set(module: ModuleType) -> dict:
     if len(function_dict) == 0:
         raise ValueError(f"No functions found in module {module}")
     return function_dict
-
-
-def validate_function(module_name, module_full_path):
-    try:
-        file = os.path.basename(module_full_path)
-        spec = importlib.util.spec_from_file_location(module_name, module_full_path)
-        module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(module)
-    except ModuleNotFoundError as e:
-        # Handle missing module imports
-        missing_package = str(e).split("'")[1]  # Extract the name of the missing package
-        print(f"{CLI_WARNING_PREFIX}skipped loading python file '{module_full_path}'!")
-        return (
-            False,
-            f"'{file}' imports '{missing_package}', but '{missing_package}' is not installed locally - install python package '{missing_package}' to link functions from '{file}' to Letta.",
-        )
-    except SyntaxError as e:
-        # Handle syntax errors in the module
-        return False, f"{CLI_WARNING_PREFIX}skipped loading python file '{file}' due to a syntax error: {e}"
-    except Exception as e:
-        # Handle other general exceptions
-        return False, f"{CLI_WARNING_PREFIX}skipped loading python file '{file}': {e}"
-
-    return True, None
-
-
-def load_function_file(filepath: str) -> dict:
-    file = os.path.basename(filepath)
-    module_name = file[:-3]  # Remove '.py' from filename
-    try:
-        spec = importlib.util.spec_from_file_location(module_name, filepath)
-        module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(module)
-    except ModuleNotFoundError as e:
-        # Handle missing module imports
-        missing_package = str(e).split("'")[1]  # Extract the name of the missing package
-        print(f"{CLI_WARNING_PREFIX}skipped loading python file '{filepath}'!")
-        print(
-            f"'{file}' imports '{missing_package}', but '{missing_package}' is not installed locally - install python package '{missing_package}' to link functions from '{file}' to Letta."
-        )
-    # load all functions in the module
-    function_dict = load_function_set(module)
-    return function_dict

letta/schemas/tool.py

@@ -201,3 +201,15 @@ class ToolUpdate(LettaBase):
     class Config:
         extra = "ignore"  # Allows extra fields without validation errors
         # TODO: Remove this, and clean usage of ToolUpdate everywhere else
+
+
+class ToolRun(LettaBase):
+    id: str = Field(..., description="The ID of the tool to run.")
+    args: str = Field(..., description="The arguments to pass to the tool (as stringified JSON).")
+
+
+class ToolRunFromSource(LettaBase):
+    args: str = Field(..., description="The arguments to pass to the tool (as stringified JSON).")
+    name: Optional[str] = Field(..., description="The name of the tool to run.")
+    source_code: str = Field(None, description="The source code of the function.")
+    source_type: Optional[str] = Field(None, description="The type of the source code.")

letta/server/rest_api/routers/v1/agents.py

@@ -448,21 +448,18 @@ async def send_message(
     This endpoint accepts a message from a user and processes it through the agent.
     """
     actor = server.get_user_or_default(user_id=user_id)
-
-    agent_lock = server.per_agent_lock_manager.get_lock(agent_id)
-    async with agent_lock:
-        result = await send_message_to_agent(
-            server=server,
-            agent_id=agent_id,
-            user_id=actor.id,
-            messages=request.messages,
-            stream_steps=False,
-            stream_tokens=False,
-            # Support for AssistantMessage
-            assistant_message_tool_name=request.assistant_message_tool_name,
-            assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
-        )
-        return result
+    result = await send_message_to_agent(
+        server=server,
+        agent_id=agent_id,
+        user_id=actor.id,
+        messages=request.messages,
+        stream_steps=False,
+        stream_tokens=False,
+        # Support for AssistantMessage
+        assistant_message_tool_name=request.assistant_message_tool_name,
+        assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
+    )
+    return result
 
 
 @router.post(
@@ -490,21 +487,18 @@ async def send_message_streaming(
     It will stream the steps of the response always, and stream the tokens if 'stream_tokens' is set to True.
     """
     actor = server.get_user_or_default(user_id=user_id)
-
-    agent_lock = server.per_agent_lock_manager.get_lock(agent_id)
-    async with agent_lock:
-        result = await send_message_to_agent(
-            server=server,
-            agent_id=agent_id,
-            user_id=actor.id,
-            messages=request.messages,
-            stream_steps=True,
-            stream_tokens=request.stream_tokens,
-            # Support for AssistantMessage
-            assistant_message_tool_name=request.assistant_message_tool_name,
-            assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
-        )
-        return result
+    result = await send_message_to_agent(
+        server=server,
+        agent_id=agent_id,
+        user_id=actor.id,
+        messages=request.messages,
+        stream_steps=True,
+        stream_tokens=request.stream_tokens,
+        # Support for AssistantMessage
+        assistant_message_tool_name=request.assistant_message_tool_name,
+        assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
+    )
+    return result
 
 
 # TODO: move this into server.py?

letta/server/rest_api/routers/v1/sandbox_configs.py

@@ -8,6 +8,7 @@ from letta.schemas.sandbox_config import SandboxEnvironmentVariable as PydanticE
 from letta.schemas.sandbox_config import (
     SandboxEnvironmentVariableCreate,
     SandboxEnvironmentVariableUpdate,
+    SandboxType,
 )
 from letta.server.rest_api.utils import get_letta_server, get_user_id
 from letta.server.server import SyncServer
@@ -29,6 +30,24 @@ def create_sandbox_config(
     return server.sandbox_config_manager.create_or_update_sandbox_config(config_create, actor)
 
 
+@router.post("/e2b/default", response_model=PydanticSandboxConfig)
+def create_default_e2b_sandbox_config(
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.get_or_create_default_sandbox_config(sandbox_type=SandboxType.E2B, actor=actor)
+
+
+@router.post("/local/default", response_model=PydanticSandboxConfig)
+def create_default_local_sandbox_config(
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.get_or_create_default_sandbox_config(sandbox_type=SandboxType.LOCAL, actor=actor)
+
+
 @router.patch("/{sandbox_config_id}", response_model=PydanticSandboxConfig)
 def update_sandbox_config(
     sandbox_config_id: str,

letta/server/rest_api/routers/v1/tools.py

@@ -1,10 +1,12 @@
 from typing import List, Optional
 
+from composio.client.collections import ActionModel, AppModel
 from fastapi import APIRouter, Body, Depends, Header, HTTPException
 
 from letta.errors import LettaToolCreateError
 from letta.orm.errors import UniqueConstraintViolationError
-from letta.schemas.tool import Tool, ToolCreate, ToolUpdate
+from letta.schemas.letta_message import FunctionReturn
+from letta.schemas.tool import Tool, ToolCreate, ToolRunFromSource, ToolUpdate
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
 
@@ -156,3 +158,74 @@ def add_base_tools(
     """
     actor = server.get_user_or_default(user_id=user_id)
     return server.tool_manager.add_base_tools(actor=actor)
+
+
+# NOTE: can re-enable if needed
+# @router.post("/{tool_id}/run", response_model=FunctionReturn, operation_id="run_tool")
+# def run_tool(
+#     server: SyncServer = Depends(get_letta_server),
+#     request: ToolRun = Body(...),
+#     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+# ):
+#     """
+#     Run an existing tool on provided arguments
+#     """
+#     actor = server.get_user_or_default(user_id=user_id)
+
+#     return server.run_tool(tool_id=request.tool_id, tool_args=request.tool_args, user_id=actor.id)
+
+
+@router.post("/run", response_model=FunctionReturn, operation_id="run_tool_from_source")
+def run_tool_from_source(
+    server: SyncServer = Depends(get_letta_server),
+    request: ToolRunFromSource = Body(...),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+):
+    """
+    Attempt to build a tool from source, then run it on the provided arguments
+    """
+    actor = server.get_user_or_default(user_id=user_id)
+
+    return server.run_tool_from_source(
+        tool_source=request.source_code,
+        tool_source_type=request.source_type,
+        tool_args=request.args,
+        tool_name=request.name,
+        user_id=actor.id,
+    )
+
+
+# Specific routes for Composio
+
+
+@router.get("/composio/apps", response_model=List[AppModel], operation_id="list_composio_apps")
+def list_composio_apps(server: SyncServer = Depends(get_letta_server)):
+    """
+    Get a list of all Composio apps
+    """
+    return server.get_composio_apps()
+
+
+@router.get("/composio/apps/{composio_app_name}/actions", response_model=List[ActionModel], operation_id="list_composio_actions_by_app")
+def list_composio_actions_by_app(
+    composio_app_name: str,
+    server: SyncServer = Depends(get_letta_server),
+):
+    """
+    Get a list of all Composio actions for a specific app
+    """
+    return server.get_composio_actions_from_app_name(composio_app_name=composio_app_name)
+
+
+@router.post("/composio/{composio_action_name}", response_model=Tool, operation_id="add_composio_tool")
+def add_composio_tool(
+    composio_action_name: str,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Add a new Composio tool by action name (Composio refers to each tool as an `Action`)
+    """
+    actor = server.get_user_or_default(user_id=user_id)
+    tool_create = ToolCreate.from_composio(action=composio_action_name)
+    return server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=actor)

letta/server/server.py

@@ -1,4 +1,5 @@
 # inspecting tools
+import json
 import os
 import traceback
 import warnings
@@ -7,6 +8,8 @@ from asyncio import Lock
 from datetime import datetime
 from typing import Callable, Dict, List, Optional, Tuple, Union
 
+from composio.client import Composio
+from composio.client.collections import ActionModel, AppModel
 from fastapi import HTTPException
 
 import letta.constants as constants
@@ -54,7 +57,7 @@ from letta.schemas.embedding_config import EmbeddingConfig
 # openai schemas
 from letta.schemas.enums import JobStatus
 from letta.schemas.job import Job
-from letta.schemas.letta_message import LettaMessage
+from letta.schemas.letta_message import FunctionReturn, LettaMessage
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import (
     ArchivalMemorySummary,
@@ -76,9 +79,10 @@ from letta.services.organization_manager import OrganizationManager
 from letta.services.per_agent_lock_manager import PerAgentLockManager
 from letta.services.sandbox_config_manager import SandboxConfigManager
 from letta.services.source_manager import SourceManager
+from letta.services.tool_execution_sandbox import ToolExecutionSandbox
 from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
-from letta.utils import create_random_username, json_dumps, json_loads
+from letta.utils import create_random_username, get_utc_time, json_dumps, json_loads
 
 logger = get_logger(__name__)
 
@@ -227,6 +231,11 @@ class SyncServer(Server):
         # Locks
         self.send_message_lock = Lock()
 
+        # Composio
+        self.composio_client = None
+        if tool_settings.composio_api_key:
+            self.composio_client = Composio(api_key=tool_settings.composio_api_key)
+
         # Initialize the metadata store
         config = LettaConfig.load()
         if settings.letta_pg_uri_no_default:
@@ -365,14 +374,20 @@ class SyncServer(Server):
 
     def load_agent(self, agent_id: str, interface: Union[AgentInterface, None] = None) -> Agent:
         """Updated method to load agents from persisted storage"""
-        agent_state = self.get_agent(agent_id=agent_id)
-        actor = self.user_manager.get_user_by_id(user_id=agent_state.user_id)
+        agent_lock = self.per_agent_lock_manager.get_lock(agent_id)
+        with agent_lock:
+            agent_state = self.get_agent(agent_id=agent_id)
+            actor = self.user_manager.get_user_by_id(user_id=agent_state.user_id)
+
+            interface = interface or self.default_interface_factory()
+            if agent_state.agent_type == AgentType.memgpt_agent:
+                agent = Agent(agent_state=agent_state, interface=interface, user=actor)
+            else:
+                agent = O1Agent(agent_state=agent_state, interface=interface, user=actor)
 
-        interface = interface or self.default_interface_factory()
-        if agent_state.agent_type == AgentType.memgpt_agent:
-            return Agent(agent_state=agent_state, interface=interface, user=actor)
-        else:
-            return O1Agent(agent_state=agent_state, interface=interface, user=actor)
+            # Persist to agent
+            save_agent(agent, self.ms)
+            return agent
 
     def _step(
         self,
@@ -1715,7 +1730,7 @@ class SyncServer(Server):
         self.blocks_agents_manager.add_block_to_agent(agent_id, block_id, block_label=block.label)
 
         # get agent memory
-        memory = self.load_agent(agent_id=agent_id).agent_state.memory
+        memory = self.get_agent(agent_id=agent_id).memory
         return memory
 
     def unlink_block_from_agent_memory(self, user_id: str, agent_id: str, block_label: str, delete_if_no_ref: bool = True) -> Memory:
@@ -1723,7 +1738,7 @@ class SyncServer(Server):
         self.blocks_agents_manager.remove_block_with_label_from_agent(agent_id=agent_id, block_label=block_label)
 
         # get agent memory
-        memory = self.load_agent(agent_id=agent_id).agent_state.memory
+        memory = self.get_agent(agent_id=agent_id).memory
         return memory
 
     def update_agent_memory_limit(self, user_id: str, agent_id: str, block_label: str, limit: int) -> Memory:
@@ -1733,7 +1748,7 @@ class SyncServer(Server):
             block_id=block.id, block_update=BlockUpdate(limit=limit), actor=self.user_manager.get_user_by_id(user_id=user_id)
         )
         # get agent memory
-        memory = self.load_agent(agent_id=agent_id).agent_state.memory
+        memory = self.get_agent(agent_id=agent_id).memory
         return memory
 
     def upate_block(self, user_id: str, block_id: str, block_update: BlockUpdate) -> Block:
@@ -1750,3 +1765,122 @@ class SyncServer(Server):
             if block.label == label:
                 return block
         return None
+
+    # def run_tool(self, tool_id: str, tool_args: str, user_id: str) -> FunctionReturn:
+    #     """Run a tool using the sandbox and return the result"""
+
+    #     try:
+    #         tool_args_dict = json.loads(tool_args)
+    #     except json.JSONDecodeError:
+    #         raise ValueError("Invalid JSON string for tool_args")
+
+    #     # Get the tool by ID
+    #     user = self.user_manager.get_user_by_id(user_id=user_id)
+    #     tool = self.tool_manager.get_tool_by_id(tool_id=tool_id, actor=user)
+    #     if tool.name is None:
+    #         raise ValueError(f"Tool with id {tool_id} does not have a name")
+
+    #     # TODO eventually allow using agent state in tools
+    #     agent_state = None
+
+    #     try:
+    #         sandbox_run_result = ToolExecutionSandbox(tool.name, tool_args_dict, user_id).run(agent_state=agent_state)
+    #         if sandbox_run_result is None:
+    #             raise ValueError(f"Tool with id {tool_id} returned execution with None")
+    #         function_response = str(sandbox_run_result.func_return)
+
+    #         return FunctionReturn(
+    #             id="null",
+    #             function_call_id="null",
+    #             date=get_utc_time(),
+    #             status="success",
+    #             function_return=function_response,
+    #         )
+    #     except Exception as e:
+    #         # same as agent.py
+    #         from letta.constants import MAX_ERROR_MESSAGE_CHAR_LIMIT
+
+    #         error_msg = f"Error executing tool {tool.name}: {e}"
+    #         if len(error_msg) > MAX_ERROR_MESSAGE_CHAR_LIMIT:
+    #             error_msg = error_msg[:MAX_ERROR_MESSAGE_CHAR_LIMIT]
+
+    #         return FunctionReturn(
+    #             id="null",
+    #             function_call_id="null",
+    #             date=get_utc_time(),
+    #             status="error",
+    #             function_return=error_msg,
+    #         )
+
+    def run_tool_from_source(
+        self,
+        user_id: str,
+        tool_args: str,
+        tool_source: str,
+        tool_source_type: Optional[str] = None,
+        tool_name: Optional[str] = None,
+    ) -> FunctionReturn:
+        """Run a tool from source code"""
+
+        try:
+            tool_args_dict = json.loads(tool_args)
+        except json.JSONDecodeError:
+            raise ValueError("Invalid JSON string for tool_args")
+
+        if tool_source_type is not None and tool_source_type != "python":
+            raise ValueError("Only Python source code is supported at this time")
+
+        # NOTE: we're creating a floating Tool object and NOT persiting to DB
+        tool = Tool(
+            name=tool_name,
+            source_code=tool_source,
+        )
+        assert tool.name is not None, "Failed to create tool object"
+
+        # TODO eventually allow using agent state in tools
+        agent_state = None
+
+        # Next, attempt to run the tool with the sandbox
+        try:
+            sandbox_run_result = ToolExecutionSandbox(tool.name, tool_args_dict, user_id, tool_object=tool).run(agent_state=agent_state)
+            if sandbox_run_result is None:
+                raise ValueError(f"Tool with id {tool.id} returned execution with None")
+            function_response = str(sandbox_run_result.func_return)
+
+            return FunctionReturn(
+                id="null",
+                function_call_id="null",
+                date=get_utc_time(),
+                status="success",
+                function_return=function_response,
+            )
+        except Exception as e:
+            # same as agent.py
+            from letta.constants import MAX_ERROR_MESSAGE_CHAR_LIMIT
+
+            error_msg = f"Error executing tool {tool.name}: {e}"
+            if len(error_msg) > MAX_ERROR_MESSAGE_CHAR_LIMIT:
+                error_msg = error_msg[:MAX_ERROR_MESSAGE_CHAR_LIMIT]
+
+            return FunctionReturn(
+                id="null",
+                function_call_id="null",
+                date=get_utc_time(),
+                status="error",
+                function_return=error_msg,
+            )
+
+    # Composio wrappers
+    def get_composio_apps(self) -> List["AppModel"]:
+        """Get a list of all Composio apps with actions"""
+        apps = self.composio_client.apps.get()
+        apps_with_actions = []
+        for app in apps:
+            if app.meta["actionsCount"] > 0:
+                apps_with_actions.append(app)
+
+        return apps_with_actions
+
+    def get_composio_actions_from_app_name(self, composio_app_name: str) -> List["ActionModel"]:
+        actions = self.composio_client.actions.get(apps=[composio_app_name])
+        return actions

letta/services/per_agent_lock_manager.py

@@ -1,4 +1,4 @@
-import asyncio
+import threading
 from collections import defaultdict
 
 
@@ -6,9 +6,9 @@ class PerAgentLockManager:
     """Manages per-agent locks."""
 
     def __init__(self):
-        self.locks = defaultdict(asyncio.Lock)
+        self.locks = defaultdict(threading.Lock)
 
-    def get_lock(self, agent_id: str) -> asyncio.Lock:
+    def get_lock(self, agent_id: str) -> threading.Lock:
         """Retrieve the lock for a specific agent_id."""
         return self.locks[agent_id]
 

letta/services/tool_execution_sandbox.py

@@ -11,6 +11,7 @@ from typing import Any, Optional
 from letta.log import get_logger
 from letta.schemas.agent import AgentState
 from letta.schemas.sandbox_config import SandboxConfig, SandboxRunResult, SandboxType
+from letta.schemas.tool import Tool
 from letta.services.sandbox_config_manager import SandboxConfigManager
 from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
@@ -27,7 +28,7 @@ class ToolExecutionSandbox:
     # We make this a long random string to avoid collisions with any variables in the user's code
     LOCAL_SANDBOX_RESULT_VAR_NAME = "result_ZQqiequkcFwRwwGQMqkt"
 
-    def __init__(self, tool_name: str, args: dict, user_id: str, force_recreate=False):
+    def __init__(self, tool_name: str, args: dict, user_id: str, force_recreate=False, tool_object: Optional[Tool] = None):
         self.tool_name = tool_name
         self.args = args
 
@@ -36,14 +37,18 @@ class ToolExecutionSandbox:
         # agent_state is the state of the agent that invoked this run
         self.user = UserManager().get_user_by_id(user_id=user_id)
 
-        # Get the tool
-        # TODO: So in theory, it's possible this retrieves a tool not provisioned to the agent
-        # TODO: That would probably imply that agent_state is incorrectly configured
-        self.tool = ToolManager().get_tool_by_name(tool_name=tool_name, actor=self.user)
-        if not self.tool:
-            raise ValueError(
-                f"Agent attempted to invoke tool {self.tool_name} that does not exist for organization {self.user.organization_id}"
-            )
+        # If a tool object is provided, we use it directly, otherwise pull via name
+        if tool_object is not None:
+            self.tool = tool_object
+        else:
+            # Get the tool via name
+            # TODO: So in theory, it's possible this retrieves a tool not provisioned to the agent
+            # TODO: That would probably imply that agent_state is incorrectly configured
+            self.tool = ToolManager().get_tool_by_name(tool_name=tool_name, actor=self.user)
+            if not self.tool:
+                raise ValueError(
+                    f"Agent attempted to invoke tool {self.tool_name} that does not exist for organization {self.user.organization_id}"
+                )
 
         self.sandbox_config_manager = SandboxConfigManager(tool_settings)
         self.force_recreate = force_recreate
@@ -132,7 +137,8 @@ class ToolExecutionSandbox:
                 sandbox_config_fingerprint=sbx_config.fingerprint(),
             )
         except Exception as e:
-            raise RuntimeError(f"Executing tool {self.tool_name} has an unexpected error: {e}")
+            logger.error(f"Executing tool {self.tool_name} has an unexpected error: {e}")
+            raise e
         finally:
             # Clean up the temp file and restore stdout
             sys.stdout = old_stdout
@@ -154,7 +160,9 @@ class ToolExecutionSandbox:
         env_vars = self.sandbox_config_manager.get_sandbox_env_vars_as_dict(sandbox_config_id=sbx_config.id, actor=self.user, limit=100)
         execution = sbx.run_code(code, envs=env_vars)
         if execution.error is not None:
-            raise Exception(f"Executing tool {self.tool_name} failed with {execution.error}")
+            logger.error(f"Executing tool {self.tool_name} failed with {execution.error}")
+            # Raise a concise exception as this gets returned to the LLM
+            raise self.parse_exception_from_e2b_execution(execution)
         elif len(execution.results) == 0:
             return None
         else:
@@ -166,6 +174,12 @@ class ToolExecutionSandbox:
                 sandbox_config_fingerprint=sbx_config.fingerprint(),
             )
 
+    def parse_exception_from_e2b_execution(self, e2b_execution: "Execution") -> Exception:
+        builtins_dict = __builtins__ if isinstance(__builtins__, dict) else vars(__builtins__)
+        # Dynamically fetch the exception class from builtins, defaulting to Exception if not found
+        exception_class = builtins_dict.get(e2b_execution.error.name, Exception)
+        return exception_class(e2b_execution.error.value)
+
     def get_running_e2b_sandbox_with_same_state(self, sandbox_config: SandboxConfig) -> Optional["Sandbox"]:
         from e2b_code_interpreter import Sandbox
 

letta/utils.py

@@ -1015,13 +1015,6 @@ def get_persona_text(name: str, enforce_limit=True):
     raise ValueError(f"Persona {name}.txt not found")
 
 
-def get_human_text(name: str):
-    for file_path in list_human_files():
-        file = os.path.basename(file_path)
-        if f"{name}.txt" == file or name == file:
-            return open(file_path, "r", encoding="utf-8").read().strip()
-
-
 def get_schema_diff(schema_a, schema_b):
     # Assuming f_schema and linked_function['json_schema'] are your JSON schemas
     f_schema_json = json_dumps(schema_a)

{letta_nightly-0.5.4.dev20241202104311.dist-info → letta_nightly-0.5.4.dev20241203104336.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.5.4.dev20241202104311
+Version: 0.5.4.dev20241203104336
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -129,24 +129,24 @@ The two main ways to install Letta are through **pypi** (`pip`) or via **Docker*
 
 ### Step 1 - Install Letta using `pip`
 ```sh
-$ pip install -U letta
+pip install -U letta
 ```
 
 ### Step 2 - Set your environment variables for your chosen LLM / embedding providers
 ```sh
-$ export OPENAI_API_KEY=sk-...
+export OPENAI_API_KEY=sk-...
 ```
 
 For Ollama (see our full [documentation](https://docs.letta.com/install) for examples of how to set up various providers):
 ```sh
-$ export OLLAMA_BASE_URL=http://localhost:11434
+export OLLAMA_BASE_URL=http://localhost:11434
 ```
 
 ### Step 3 - Run the Letta CLI
 
 You can create agents and chat with them via the Letta CLI tool (`letta run`):
 ```sh
-$ letta run
+letta run
 ```
 ```
 🧬 Creating new agent...
@@ -179,7 +179,7 @@ Hit enter to begin (will request first Letta message)
 
 You can start the Letta API server with `letta server` (see the full API reference [here](https://docs.letta.com/api-reference)):
 ```sh
-$ letta server
+letta server
 ```
 ```
 Initializing database...

{letta_nightly-0.5.4.dev20241202104311.dist-info → letta_nightly-0.5.4.dev20241203104336.dist-info}/RECORD

@@ -26,7 +26,7 @@ letta/errors.py,sha256=mFeTpZP37otDMr68s9hyGOnafJPrWeblQOI79cgP4nQ,3209
 letta/functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/functions/function_sets/base.py,sha256=9Rs8SNrtUgqYtlmztE1gVO6FEn864u8t-X1qik24nps,8096
 letta/functions/function_sets/extras.py,sha256=Jik3UiDqYTm4Lam1XPTvuVjvgUHwIAhopsnbmVhGMBg,4732
-letta/functions/functions.py,sha256=qCoU9w51uXC8NODHr6dj_tz69NB4924I9PToN2yh2NA,5418
+letta/functions/functions.py,sha256=evH6GKnIJwVVre1Xre2gaSIqREv4eNM4DiWOhn8PMqg,3299
 letta/functions/helpers.py,sha256=K84kqAN1RXZIhjb7-btS0C2p-SInYNv6FvSfo-16Y6g,8578
 letta/functions/schema_generator.py,sha256=Y0rQjJBI8Z5fSKmT71EGXtHpIvNb3dMM5X00TP89tlY,19330
 letta/helpers/__init__.py,sha256=p0luQ1Oe3Skc6sH4O58aHHA3Qbkyjifpuq0DZ1GAY0U,59
@@ -156,7 +156,7 @@ letta/schemas/organization.py,sha256=d2oN3IK2HeruEHKXwIzCbJ3Fxdi_BEe9JZ8J9aDbHwQ
 letta/schemas/passage.py,sha256=eYQMxD_XjHAi72jmqcGBU4wM4VZtSU0XK8uhQxxN3Ug,3563
 letta/schemas/sandbox_config.py,sha256=LC0hnB3TbFJmY7lXqVsseJkqTbxry0xmBB0bwI8Y7Rc,4769
 letta/schemas/source.py,sha256=B1VbaDJV-EGPv1nQXwCx_RAzeAJd50UqP_1m1cIRT8c,2854
-letta/schemas/tool.py,sha256=DolG1PZDacREGQco7gYFVJNZFLjfBa1jDRmuCPKNiuM,9131
+letta/schemas/tool.py,sha256=V8eTe2I1P9khanOJQYICmT0Fo_rMY599neGVW4Wn2Cw,9715
 letta/schemas/tool_rule.py,sha256=pLt-BzgFSrlVO6ipY4kygyvfoM0BWA-XdqhGxso9aKs,1192
 letta/schemas/usage.py,sha256=lvn1ooHwLEdv6gwQpw5PBUbcwn_gwdT6HA-fCiix6sY,817
 letta/schemas/user.py,sha256=V32Tgl6oqB3KznkxUz12y7agkQicjzW7VocSpj78i6Q,1526
@@ -178,19 +178,19 @@ letta/server/rest_api/routers/openai/assistants/threads.py,sha256=g8iu98__tQEMY9
 letta/server/rest_api/routers/openai/chat_completions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/chat_completions/chat_completions.py,sha256=qFMpxfYIlJ-PW08IQt09RW44u6hwkssdsUT-h_GuOvE,4836
 letta/server/rest_api/routers/v1/__init__.py,sha256=RZc0fIHNN4BGretjU6_TGK7q49RyV4jfYNudoiK_sUo,762
-letta/server/rest_api/routers/v1/agents.py,sha256=SHWsfcSB86WS23wiGqmZFeY0ns5s1VpzJ2mQZYpo60M,25168
+letta/server/rest_api/routers/v1/agents.py,sha256=Tj7QyHjem_tOgzDzTyEJREDH2rzDgpE6S5azBDrhY_o,24884
 letta/server/rest_api/routers/v1/blocks.py,sha256=UCVfMbb8hzOXI6a8OYWKuXyOropIxw6PYKZkwwAh1v0,4880
 letta/server/rest_api/routers/v1/health.py,sha256=pKCuVESlVOhGIb4VC4K-H82eZqfghmT6kvj2iOkkKuc,401
 letta/server/rest_api/routers/v1/jobs.py,sha256=a-j0v-5A0un0pVCOHpfeWnzpOWkVDQO6ti42k_qAlZY,2272
 letta/server/rest_api/routers/v1/llms.py,sha256=TcyvSx6MEM3je5F4DysL7ligmssL_pFlJaaO4uL95VY,877
 letta/server/rest_api/routers/v1/organizations.py,sha256=tyqVzXTpMtk3sKxI3Iz4aS6RhbGEbXDzFBB_CpW18v4,2080
-letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=j-q9coHFhrsRwyswGyrVPUjawI0Iy6eYaG4iKd6ZKMA,4219
+letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=4tkTH8z9vpuBiGzxrS_wxkFdznnWZx-U-9F08czHMP8,5004
 letta/server/rest_api/routers/v1/sources.py,sha256=5Cs2YTSooh_WNT2C18PsdKzkyr4ZvaHt5Xjubyz0yJw,9196
-letta/server/rest_api/routers/v1/tools.py,sha256=eDzRv7ETP8Tu0kPxFutLC1Lz4J411sHOqbHF9nD5MLs,6204
+letta/server/rest_api/routers/v1/tools.py,sha256=jxw4DEM2OycGDOH4rVWMNQqtBqBJhXQruOpIYsVVyEk,8977
 letta/server/rest_api/routers/v1/users.py,sha256=M1wEr2IyHzuRwINYxLXTkrbAH3osLe_cWjzrWrzR1aw,3729
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/utils.py,sha256=6c5a_-ZFTlwZ1IuzpRQtqxSG1eD56nNhKhWlrdgBYWk,3103
-letta/server/server.py,sha256=Ki5MrO5y0L9iCTO1SoNqRtCLKdWQ5uxoRDebAzPi8NM,73777
+letta/server/server.py,sha256=jgi0QipurP1xZKUEdUDk-ZD_6MbB8rDw82fd0RB60wc,78943
 letta/server/startup.sh,sha256=wTOQOJJZw_Iec57WIu0UW0AVflk0ZMWYZWg8D3T_gSQ,698
 letta/server/static_files/assets/index-3ab03d5b.css,sha256=OrA9W4iKJ5h2Wlr7GwdAT4wow0CM8hVit1yOxEL49Qw,54295
 letta/server/static_files/assets/index-9fa459a2.js,sha256=wtfkyHnEIMACHKL3UgN_jZNOKWEcOFjmWoeRHLngPwk,1815584
@@ -208,10 +208,10 @@ letta/services/agents_tags_manager.py,sha256=zNqeXDpaf4dQ77jrRHiQfITdk4FawBzcND-
 letta/services/block_manager.py,sha256=TrbStwHAREwnybA6jZSkNPe-EYUa5rdiuliPR2PTV-M,5426
 letta/services/blocks_agents_manager.py,sha256=mfO3EMW9os_E1_r4SRlC2wmBFFLpt8p-yhdOH_Iotaw,5627
 letta/services/organization_manager.py,sha256=OfE2_NMmhqXURX4sg7hCOiFQVQpV5ZiPu7J3sboCSYc,3555
-letta/services/per_agent_lock_manager.py,sha256=02iw5e-xoLiKGqqn2KdJdk-QlrDHPz5oMuEs1ibwXHA,540
+letta/services/per_agent_lock_manager.py,sha256=porM0cKKANQ1FvcGXOO_qM7ARk5Fgi1HVEAhXsAg9-4,546
 letta/services/sandbox_config_manager.py,sha256=9BCu59nHR4nIMFXgFyEMOY2UTmZvBMS3GlDBWWCHB4I,12648
 letta/services/source_manager.py,sha256=StX5Wfd7XSCKJet8qExIu3GMoI-eMIbEarAeTv2gq0s,6555
-letta/services/tool_execution_sandbox.py,sha256=LrFzANZ75hNtAtfJiSOu2geu18d-9ms0IgN7SEVhh9I,13462
+letta/services/tool_execution_sandbox.py,sha256=VaULtNz8n0lUbJDzahvyYZNujn8nnmeQeQ311kJe_uU,14324
 letta/services/tool_manager.py,sha256=FVCB9R3NFahh-KE5jROzf6J9WEgqhqGoDk5RpWjlgjg,7835
 letta/services/tool_sandbox_env/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/user_manager.py,sha256=UJa0hqCjz0yXtvrCR8OVBqlSR5lC_Ejn-uG__58zLds,4398
@@ -219,9 +219,9 @@ letta/settings.py,sha256=ZcUcwvl7hStawZ0JOA0133jNk3j5qBd7qlFAAaIPsU8,3608
 letta/streaming_interface.py,sha256=_FPUWy58j50evHcpXyd7zB1wWqeCc71NCFeWh_TBvnw,15736
 letta/streaming_utils.py,sha256=329fsvj1ZN0r0LpQtmMPZ2vSxkDBIUUwvGHZFkjm2I8,11745
 letta/system.py,sha256=buKYPqG5n2x41hVmWpu6JUpyd7vTWED9Km2_M7dLrvk,6960
-letta/utils.py,sha256=COwQLAt02eEM9tjp6p5kN8YeTqGXr714l5BvffLVCLU,32376
-letta_nightly-0.5.4.dev20241202104311.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.5.4.dev20241202104311.dist-info/METADATA,sha256=X5kCjVS10z2psCmtDwSwrD9gZCsa8W5Ljgbh-X6N4nY,11515
-letta_nightly-0.5.4.dev20241202104311.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.5.4.dev20241202104311.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.5.4.dev20241202104311.dist-info/RECORD,,
+letta/utils.py,sha256=iELiiJhSnijGDmwyk_T4NBJIqFUnEw_Flv9ZpSBUPFA,32136
+letta_nightly-0.5.4.dev20241203104336.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.5.4.dev20241203104336.dist-info/METADATA,sha256=TLAqq1J7qA4wMmkrsK-u1P1ryMPcgolT0ho-je8B7UQ,11505
+letta_nightly-0.5.4.dev20241203104336.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.5.4.dev20241203104336.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.5.4.dev20241203104336.dist-info/RECORD,,