letta-nightly 0.6.0.dev20241204054116__tar.gz → 0.6.0.dev20241204213946__tar.gz

{letta_nightly-0.6.0.dev20241204054116 → letta_nightly-0.6.0.dev20241204213946}/PKG-INFO

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

{letta_nightly-0.6.0.dev20241204054116 → letta_nightly-0.6.0.dev20241204213946}/letta/agent.py

@@ -350,6 +350,8 @@ class Agent(BaseAgent):
             init_messages_objs = []
             for msg in init_messages:
                 init_messages_objs.append(msg)
+            for msg in init_messages_objs:
+                assert isinstance(msg, Message), f"Message object is not of type Message: {type(msg)}"
             assert all([isinstance(msg, Message) for msg in init_messages_objs]), (init_messages_objs, init_messages)
 
             # Put the messages inside the message buffer

{letta_nightly-0.6.0.dev20241204054116 → letta_nightly-0.6.0.dev20241204213946}/letta/schemas/agent.py

@@ -9,7 +9,7 @@ from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
-from letta.schemas.message import Message
+from letta.schemas.message import Message, MessageCreate
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.source import Source
 from letta.schemas.tool import Tool
@@ -124,7 +124,7 @@ class CreateAgent(BaseAgent):  #
     embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the agent.")
     # Note: if this is None, then we'll populate with the standard "more human than human" initial message sequence
     # If the client wants to make this empty, then the client can set the arg to an empty list
-    initial_message_sequence: Optional[List[Message]] = Field(
+    initial_message_sequence: Optional[List[MessageCreate]] = Field(
         None, description="The initial set of messages to put in the agent's in-context memory."
     )
 

{letta_nightly-0.6.0.dev20241204054116 → letta_nightly-0.6.0.dev20241204213946}/letta/schemas/sandbox_config.py

@@ -24,6 +24,11 @@ class SandboxRunResult(BaseModel):
 
 class LocalSandboxConfig(BaseModel):
     sandbox_dir: str = Field(..., description="Directory for the sandbox environment.")
+    use_venv: bool = Field(False, description="Whether or not to use the venv, or run directly in the same run loop.")
+    venv_name: str = Field(
+        "venv",
+        description="The name for the venv in the sandbox directory. We first search for an existing venv with this name, otherwise, we make it from the requirements.txt.",
+    )
 
     @property
     def type(self) -> "SandboxType":

{letta_nightly-0.6.0.dev20241204054116 → letta_nightly-0.6.0.dev20241204213946}/letta/server/server.py

@@ -372,6 +372,22 @@ class SyncServer(Server):
             }
         )
 
+    def initialize_agent(self, agent_id, interface: Union[AgentInterface, None] = None, initial_message_sequence=None) -> Agent:
+        """Initialize an agent from the database"""
+        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, initial_message_sequence=initial_message_sequence)
+        else:
+            assert initial_message_sequence is None, f"Initial message sequence is not supported for O1Agents"
+            agent = O1Agent(agent_state=agent_state, interface=interface, user=actor)
+
+        # Persist to agent
+        save_agent(agent, self.ms)
+        return agent
+
     def load_agent(self, agent_id: str, interface: Union[AgentInterface, None] = None) -> Agent:
         """Updated method to load agents from persisted storage"""
         agent_lock = self.per_agent_lock_manager.get_lock(agent_id)
@@ -385,6 +401,9 @@ class SyncServer(Server):
             else:
                 agent = O1Agent(agent_state=agent_state, interface=interface, user=actor)
 
+            # Rebuild the system prompt - may be linked to new blocks now
+            agent.rebuild_system_prompt()
+
             # Persist to agent
             save_agent(agent, self.ms)
             return agent
@@ -802,8 +821,6 @@ class SyncServer(Server):
         if not user:
             raise ValueError(f"cannot find user with associated client id: {user_id}")
 
-        # TODO: create the message objects (NOTE: do this after we migrate to `CreateMessage`)
-
         # created and persist the agent state in the DB
         agent_state = PersistedAgentState(
             name=request.name,
@@ -822,6 +839,31 @@ class SyncServer(Server):
         # this saves the agent ID and state into the DB
         self.ms.create_agent(agent_state)
 
+        # create the agent object
+        if request.initial_message_sequence:
+            # init_messages = [Message(user_id=user_id, agent_id=agent_state.id, role=message.role, text=message.text) for message in request.initial_message_sequence]
+            init_messages = []
+            for message in request.initial_message_sequence:
+
+                if message.role == MessageRole.user:
+                    packed_message = system.package_user_message(
+                        user_message=message.text,
+                    )
+                elif message.role == MessageRole.system:
+                    packed_message = system.package_system_message(
+                        system_message=message.text,
+                    )
+                else:
+                    raise ValueError(f"Invalid message role: {message.role}")
+
+                init_messages.append(Message(role=message.role, text=packed_message, user_id=user_id, agent_id=agent_state.id))
+            # init_messages = [Message.dict_to_message(user_id=user_id, agent_id=agent_state.id, openai_message_dict=message.model_dump()) for message in request.initial_message_sequence]
+        else:
+            init_messages = None
+
+        # initialize the agent (generates initial message list with system prompt)
+        self.initialize_agent(agent_id=agent_state.id, interface=interface, initial_message_sequence=init_messages)
+
         # Note: mappings (e.g. tags, blocks) are created after the agent is persisted
         # TODO: add source mappings here as well
 
@@ -1876,7 +1918,8 @@ class SyncServer(Server):
         apps = self.composio_client.apps.get()
         apps_with_actions = []
         for app in apps:
-            if app.meta["actionsCount"] > 0:
+            # A bit of hacky logic until composio patches this
+            if app.meta["actionsCount"] > 0 and not app.name.lower().endswith("_beta"):
                 apps_with_actions.append(app)
 
         return apps_with_actions

{letta_nightly-0.6.0.dev20241204054116 → letta_nightly-0.6.0.dev20241204213946}/letta/services/tool_execution_sandbox.py

@@ -4,9 +4,12 @@ import io
 import os
 import pickle
 import runpy
+import subprocess
 import sys
 import tempfile
-from typing import Any, Optional
+import uuid
+import venv
+from typing import Any, Dict, Optional, TextIO
 
 from letta.log import get_logger
 from letta.schemas.agent import AgentState
@@ -24,6 +27,11 @@ class ToolExecutionSandbox:
     METADATA_CONFIG_STATE_KEY = "config_state"
     REQUIREMENT_TXT_NAME = "requirements.txt"
 
+    # For generating long, random marker hashes
+    NAMESPACE = uuid.NAMESPACE_DNS
+    LOCAL_SANDBOX_RESULT_START_MARKER = str(uuid.uuid5(NAMESPACE, "local-sandbox-result-start-marker"))
+    LOCAL_SANDBOX_RESULT_END_MARKER = str(uuid.uuid5(NAMESPACE, "local-sandbox-result-end-marker"))
+
     # This is the variable name in the auto-generated code that contains the function results
     # 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"
@@ -65,12 +73,10 @@ class ToolExecutionSandbox:
         """
         if tool_settings.e2b_api_key:
             logger.debug(f"Using e2b sandbox to execute {self.tool_name}")
-            code = self.generate_execution_script(agent_state=agent_state)
-            result = self.run_e2b_sandbox(code=code)
+            result = self.run_e2b_sandbox(agent_state=agent_state)
         else:
             logger.debug(f"Using local sandbox to execute {self.tool_name}")
-            code = self.generate_execution_script(agent_state=agent_state)
-            result = self.run_local_dir_sandbox(code=code)
+            result = self.run_local_dir_sandbox(agent_state=agent_state)
 
         # Log out any stdout from the tool run
         logger.debug(f"Executed tool '{self.tool_name}', logging stdout from tool run: \n")
@@ -94,12 +100,14 @@ class ToolExecutionSandbox:
             os.environ.clear()
             os.environ.update(original_env)  # Restore original environment variables
 
-    def run_local_dir_sandbox(self, code: str) -> Optional[SandboxRunResult]:
+    def run_local_dir_sandbox(self, agent_state: AgentState) -> Optional[SandboxRunResult]:
         sbx_config = self.sandbox_config_manager.get_or_create_default_sandbox_config(sandbox_type=SandboxType.LOCAL, actor=self.user)
         local_configs = sbx_config.get_local_config()
 
         # Get environment variables for the sandbox
         env_vars = self.sandbox_config_manager.get_sandbox_env_vars_as_dict(sandbox_config_id=sbx_config.id, actor=self.user, limit=100)
+        env = os.environ.copy()
+        env.update(env_vars)
 
         # Safety checks
         if not os.path.isdir(local_configs.sandbox_dir):
@@ -107,6 +115,12 @@ class ToolExecutionSandbox:
 
         # Write the code to a temp file in the sandbox_dir
         with tempfile.NamedTemporaryFile(mode="w", dir=local_configs.sandbox_dir, suffix=".py", delete=False) as temp_file:
+            if local_configs.use_venv:
+                # If using venv, we need to wrap with special string markers to separate out the output and the stdout (since it is all in stdout)
+                code = self.generate_execution_script(agent_state=agent_state, wrap_print_with_markers=True)
+            else:
+                code = self.generate_execution_script(agent_state=agent_state)
+
             temp_file.write(code)
             temp_file.flush()
             temp_file_path = temp_file.name
@@ -114,39 +128,122 @@ class ToolExecutionSandbox:
         # Save the old stdout
         old_stdout = sys.stdout
         try:
-            # Redirect stdout to capture script output
-            captured_stdout = io.StringIO()
-            sys.stdout = captured_stdout
-
-            # Execute the temp file
-            with self.temporary_env_vars(env_vars):
-                result = runpy.run_path(temp_file_path, init_globals=env_vars)
-
-            # Fetch the result
-            func_result = result.get(self.LOCAL_SANDBOX_RESULT_VAR_NAME)
-            func_return, agent_state = self.parse_best_effort(func_result)
-
-            # Restore stdout and collect captured output
-            sys.stdout = old_stdout
-            stdout_output = captured_stdout.getvalue()
-
-            return SandboxRunResult(
-                func_return=func_return,
-                agent_state=agent_state,
-                stdout=[stdout_output],
-                sandbox_config_fingerprint=sbx_config.fingerprint(),
-            )
+            if local_configs.use_venv:
+                return self.run_local_dir_sandbox_venv(sbx_config, env, temp_file_path)
+            else:
+                return self.run_local_dir_sandbox_runpy(sbx_config, env_vars, temp_file_path, old_stdout)
         except Exception as e:
             logger.error(f"Executing tool {self.tool_name} has an unexpected error: {e}")
+            logger.error(f"Logging out tool {self.tool_name} auto-generated code for debugging: \n\n{code}")
             raise e
         finally:
             # Clean up the temp file and restore stdout
             sys.stdout = old_stdout
             os.remove(temp_file_path)
 
+    def run_local_dir_sandbox_venv(self, sbx_config: SandboxConfig, env: Dict[str, str], temp_file_path: str) -> SandboxRunResult:
+        local_configs = sbx_config.get_local_config()
+        venv_path = os.path.join(local_configs.sandbox_dir, local_configs.venv_name)
+
+        # Safety checks for the venv
+        # Verify that the venv path exists and is a directory
+        if not os.path.isdir(venv_path):
+            logger.warning(f"Virtual environment directory does not exist at: {venv_path}, creating one now...")
+            self.create_venv_for_local_sandbox(sandbox_dir_path=local_configs.sandbox_dir, venv_path=venv_path, env=env)
+
+        # Ensure the python interpreter exists in the virtual environment
+        python_executable = os.path.join(venv_path, "bin", "python3")
+        if not os.path.isfile(python_executable):
+            raise FileNotFoundError(f"Python executable not found in virtual environment: {python_executable}")
+
+        # Set up env for venv
+        env["VIRTUAL_ENV"] = venv_path
+        env["PATH"] = os.path.join(venv_path, "bin") + ":" + env["PATH"]
+
+        # Execute the code in a restricted subprocess
+        try:
+            result = subprocess.run(
+                [os.path.join(venv_path, "bin", "python3"), temp_file_path],
+                env=env,
+                cwd=local_configs.sandbox_dir,  # Restrict execution to sandbox_dir
+                timeout=60,
+                capture_output=True,
+                text=True,
+            )
+            if result.stderr:
+                logger.error(f"Sandbox execution error: {result.stderr}")
+                raise RuntimeError(f"Sandbox execution error: {result.stderr}")
+
+            func_result, stdout = self.parse_out_function_results_markers(result.stdout)
+            func_return, agent_state = self.parse_best_effort(func_result)
+            return SandboxRunResult(
+                func_return=func_return, agent_state=agent_state, stdout=[stdout], sandbox_config_fingerprint=sbx_config.fingerprint()
+            )
+        except subprocess.TimeoutExpired:
+            raise TimeoutError(f"Executing tool {self.tool_name} has timed out.")
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Executing tool {self.tool_name} has process error: {e}")
+        except Exception as e:
+            raise RuntimeError(f"Executing tool {self.tool_name} has an unexpected error: {e}")
+
+    def run_local_dir_sandbox_runpy(
+        self, sbx_config: SandboxConfig, env_vars: Dict[str, str], temp_file_path: str, old_stdout: TextIO
+    ) -> SandboxRunResult:
+        # Redirect stdout to capture script output
+        captured_stdout = io.StringIO()
+        sys.stdout = captured_stdout
+
+        # Execute the temp file
+        with self.temporary_env_vars(env_vars):
+            result = runpy.run_path(temp_file_path, init_globals=env_vars)
+
+        # Fetch the result
+        func_result = result.get(self.LOCAL_SANDBOX_RESULT_VAR_NAME)
+        func_return, agent_state = self.parse_best_effort(func_result)
+
+        # Restore stdout and collect captured output
+        sys.stdout = old_stdout
+        stdout_output = captured_stdout.getvalue()
+
+        return SandboxRunResult(
+            func_return=func_return,
+            agent_state=agent_state,
+            stdout=[stdout_output],
+            sandbox_config_fingerprint=sbx_config.fingerprint(),
+        )
+
+    def parse_out_function_results_markers(self, text: str):
+        marker_len = len(self.LOCAL_SANDBOX_RESULT_START_MARKER)
+        start_index = text.index(self.LOCAL_SANDBOX_RESULT_START_MARKER) + marker_len
+        end_index = text.index(self.LOCAL_SANDBOX_RESULT_END_MARKER)
+        return text[start_index:end_index], text[: start_index - marker_len] + text[end_index + +marker_len :]
+
+    def create_venv_for_local_sandbox(self, sandbox_dir_path: str, venv_path: str, env: Dict[str, str]):
+        # Step 1: Create the virtual environment
+        venv.create(venv_path, with_pip=True)
+
+        pip_path = os.path.join(venv_path, "bin", "pip")
+        try:
+            # Step 2: Upgrade pip
+            logger.info("Upgrading pip in the virtual environment...")
+            subprocess.run([pip_path, "install", "--upgrade", "pip"], env=env, check=True)
+
+            # Step 3: Install packages from requirements.txt if provided
+            requirements_txt_path = os.path.join(sandbox_dir_path, self.REQUIREMENT_TXT_NAME)
+            if os.path.isfile(requirements_txt_path):
+                logger.info(f"Installing packages from requirements file: {requirements_txt_path}")
+                subprocess.run([pip_path, "install", "-r", requirements_txt_path], env=env, check=True)
+                logger.info("Successfully installed packages from requirements.txt")
+            else:
+                logger.warning("No requirements.txt file provided or the file does not exist. Skipping package installation.")
+
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Error while setting up the virtual environment: {e}")
+            raise RuntimeError(f"Failed to set up the virtual environment: {e}")
+
     # e2b sandbox specific functions
 
-    def run_e2b_sandbox(self, code: str) -> Optional[SandboxRunResult]:
+    def run_e2b_sandbox(self, agent_state: AgentState) -> Optional[SandboxRunResult]:
         sbx_config = self.sandbox_config_manager.get_or_create_default_sandbox_config(sandbox_type=SandboxType.E2B, actor=self.user)
         sbx = self.get_running_e2b_sandbox_with_same_state(sbx_config)
         if not sbx or self.force_recreate:
@@ -158,6 +255,7 @@ class ToolExecutionSandbox:
         # Get environment variables for the sandbox
         # TODO: We set limit to 100 here, but maybe we want it uncapped? Realistically this should be fine.
         env_vars = self.sandbox_config_manager.get_sandbox_env_vars_as_dict(sandbox_config_id=sbx_config.id, actor=self.user, limit=100)
+        code = self.generate_execution_script(agent_state=agent_state)
         execution = sbx.run_code(code, envs=env_vars)
         if execution.error is not None:
             logger.error(f"Executing tool {self.tool_name} failed with {execution.error}")
@@ -236,13 +334,14 @@ class ToolExecutionSandbox:
                     args.append(arg.arg)
         return args
 
-    def generate_execution_script(self, agent_state: AgentState) -> str:
+    def generate_execution_script(self, agent_state: AgentState, wrap_print_with_markers: bool = False) -> str:
         """
         Generate code to run inside of execution sandbox.
         Passes into a serialized agent state into the code, to be accessed by the tool.
 
         Args:
             agent_state (AgentState): The agent state
+            wrap_print_with_markers (bool): If true, we wrap the final statement with a `print` and wrap with special markers
 
         Returns:
             code (str): The generated code strong
@@ -286,7 +385,14 @@ class ToolExecutionSandbox:
         code += (
             f"{self.LOCAL_SANDBOX_RESULT_VAR_NAME} = base64.b64encode(pickle.dumps({self.LOCAL_SANDBOX_RESULT_VAR_NAME})).decode('utf-8')\n"
         )
-        code += f"{self.LOCAL_SANDBOX_RESULT_VAR_NAME}\n"
+
+        if wrap_print_with_markers:
+            code += f"sys.stdout.write('{self.LOCAL_SANDBOX_RESULT_START_MARKER}')\n"
+            code += f"sys.stdout.write(str({self.LOCAL_SANDBOX_RESULT_VAR_NAME}))\n"
+            code += f"sys.stdout.write('{self.LOCAL_SANDBOX_RESULT_END_MARKER}')\n"
+        else:
+            code += f"{self.LOCAL_SANDBOX_RESULT_VAR_NAME}\n"
+
         return code
 
     def _convert_param_to_value(self, param_type: str, raw_value: str) -> str:

{letta_nightly-0.6.0.dev20241204054116 → letta_nightly-0.6.0.dev20241204213946}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.6.0.dev20241204054116"
+version = "0.6.0.dev20241204213946"
 packages = [
     {include = "letta"}
 ]