letta-nightly 0.5.1.dev20241025104130__py3-none-any.whl → 0.5.1.dev20241026104101__py3-none-any.whl

letta/agent.py

@@ -240,7 +240,6 @@ class Agent(BaseAgent):
         assert isinstance(self.agent_state.memory, Memory), f"Memory object is not of type Memory: {type(self.agent_state.memory)}"
 
         # link tools
-        self.tools = tools
         self.link_tools(tools)
 
         # gpt-4, gpt-3.5-turbo, ...
@@ -1154,7 +1153,7 @@ class Agent(BaseAgent):
                     printd(f"skipping block update, unexpected value: {block_id=}")
                     continue
                 # TODO: we may want to update which columns we're updating from shared memory e.g. the limit
-                self.memory.update_block_value(name=block.get("label", ""), value=db_block.value)
+                self.memory.update_block_value(label=block.get("label", ""), value=db_block.value)
 
         # If the memory didn't update, we probably don't want to update the timestamp inside
         # For example, if we're doing a system prompt swap, this should probably be False
@@ -1521,10 +1520,6 @@ def save_agent(agent: Agent, ms: MetadataStore):
     else:
         ms.create_agent(agent_state)
 
-    for tool in agent.tools:
-        if ms.get_tool(tool_name=tool.name, user_id=tool.user_id) is None:
-            ms.create_tool(tool)
-
     agent.agent_state = ms.get_agent(agent_id=agent_id)
     assert isinstance(agent.agent_state.memory, Memory), f"Memory is not a Memory object: {type(agent_state.memory)}"
 

letta/cli/cli.py

@@ -133,6 +133,7 @@ def run(
     # read user id from config
     ms = MetadataStore(config)
     client = create_client()
+    server = client.server
 
     # determine agent to use, if not provided
     if not yes and not agent:
@@ -217,7 +218,9 @@ def run(
         )
 
         # create agent
-        tools = [ms.get_tool(tool_name, user_id=client.user_id) for tool_name in agent_state.tools]
+        tools = [
+            server.tool_manager.get_tool_by_name_and_user_id(tool_name=tool_name, user_id=client.user_id) for tool_name in agent_state.tools
+        ]
         letta_agent = Agent(agent_state=agent_state, interface=interface(), tools=tools)
 
     else:  # create new agent
@@ -297,7 +300,7 @@ def run(
         )
         assert isinstance(agent_state.memory, Memory), f"Expected Memory, got {type(agent_state.memory)}"
         typer.secho(f"->  🛠️  {len(agent_state.tools)} tools: {', '.join([t for t in agent_state.tools])}", fg=typer.colors.WHITE)
-        tools = [ms.get_tool(tool_name, user_id=client.user_id) for tool_name in agent_state.tools]
+        tools = [server.tool_manager.get_tool_by_name_and_user_id(tool_name, user_id=client.user_id) for tool_name in agent_state.tools]
 
         letta_agent = Agent(
             interface=interface(),
@@ -325,13 +328,12 @@ def run(
 
 def delete_agent(
     agent_name: Annotated[str, typer.Option(help="Specify agent to delete")],
-    user_id: Annotated[Optional[str], typer.Option(help="User ID to associate with the agent.")] = None,
 ):
     """Delete an agent from the database"""
     # use client ID is no user_id provided
     config = LettaConfig.load()
     MetadataStore(config)
-    client = create_client(user_id=user_id)
+    client = create_client()
     agent = client.get_agent_by_name(agent_name)
     if not agent:
         typer.secho(f"Couldn't find agent named '{agent_name}' to delete", fg=typer.colors.RED)

letta/client/client.py

@@ -182,6 +182,15 @@ class AbstractClient(object):
     def delete_human(self, id: str):
         raise NotImplementedError
 
+    def load_langchain_tool(self, langchain_tool: "LangChainBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> Tool:
+        raise NotImplementedError
+
+    def load_crewai_tool(self, crewai_tool: "CrewAIBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> Tool:
+        raise NotImplementedError
+
+    def load_composio_tool(self, action: "ActionType") -> Tool:
+        raise NotImplementedError
+
     def create_tool(
         self,
         func,
@@ -829,8 +838,8 @@ class RESTClient(AbstractClient):
         else:
             return [Block(**block) for block in response.json()]
 
-    def create_block(self, label: str, name: str, text: str) -> Block:  #
-        request = CreateBlock(label=label, name=name, value=text)
+    def create_block(self, label: str, text: str, name: Optional[str] = None, template: bool = False) -> Block:  #
+        request = CreateBlock(label=label, value=text, template=template, name=name)
         response = requests.post(f"{self.base_url}/{self.api_prefix}/blocks", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to create block: {response.text}")
@@ -890,13 +899,13 @@ class RESTClient(AbstractClient):
         Create a human block template (saved human string to pre-fill `ChatMemory`)
 
         Args:
-            name (str): Name of the human block
-            text (str): Text of the human block
+            name (str): Name of the human block template
+            text (str): Text of the human block template
 
         Returns:
             human (Human): Human block
         """
-        return self.create_block(label="human", name=name, text=text)
+        return self.create_block(label="human", name=name, text=text, template=True)
 
     def update_human(self, human_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Human:
         """
@@ -936,7 +945,7 @@ class RESTClient(AbstractClient):
         Returns:
             persona (Persona): Persona block
         """
-        return self.create_block(label="persona", name=name, text=text)
+        return self.create_block(label="persona", name=name, text=text, template=True)
 
     def update_persona(self, persona_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Persona:
         """
@@ -1298,12 +1307,6 @@ class RESTClient(AbstractClient):
         source_code = parse_source_code(func)
         source_type = "python"
 
-        # TODO: Check if tool already exists
-        # if name:
-        #     tool_id = self.get_tool_id(tool_name=name)
-        #     if tool_id:
-        #         raise ValueError(f"Tool with name {name} (id={tool_id}) already exists")
-
         # call server function
         request = ToolCreate(source_type=source_type, source_code=source_code, name=name, tags=tags)
         response = requests.post(f"{self.base_url}/{self.api_prefix}/tools", json=request.model_dump(), headers=self.headers)
@@ -1337,7 +1340,7 @@ class RESTClient(AbstractClient):
 
         source_type = "python"
 
-        request = ToolUpdate(id=id, source_type=source_type, source_code=source_code, tags=tags, name=name)
+        request = ToolUpdate(source_type=source_type, source_code=source_code, tags=tags, name=name)
         response = requests.patch(f"{self.base_url}/{self.api_prefix}/tools/{id}", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to update tool: {response.text}")
@@ -1394,6 +1397,7 @@ class RESTClient(AbstractClient):
             params["cursor"] = str(cursor)
         if limit:
             params["limit"] = limit
+
         response = requests.get(f"{self.base_url}/{self.api_prefix}/tools", params=params, headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to list tools: {response.text}")
@@ -1503,6 +1507,7 @@ class LocalClient(AbstractClient):
         self,
         auto_save: bool = False,
         user_id: Optional[str] = None,
+        org_id: Optional[str] = None,
         debug: bool = False,
         default_llm_config: Optional[LLMConfig] = None,
         default_embedding_config: Optional[EmbeddingConfig] = None,
@@ -1529,15 +1534,19 @@ class LocalClient(AbstractClient):
         self.interface = QueuingInterface(debug=debug)
         self.server = SyncServer(default_interface_factory=lambda: self.interface)
 
+        # save org_id that `LocalClient` is associated with
+        if org_id:
+            self.org_id = org_id
+        else:
+            self.org_id = self.server.organization_manager.DEFAULT_ORG_ID
         # save user_id that `LocalClient` is associated with
         if user_id:
             self.user_id = user_id
         else:
             # get default user
-            self.user_id = self.server.get_default_user().id
+            self.user_id = self.server.user_manager.DEFAULT_USER_ID
 
     # agents
-
     def list_agents(self) -> List[AgentState]:
         self.interface.clear()
 
@@ -1777,7 +1786,7 @@ class LocalClient(AbstractClient):
         """
         self.server.delete_agent(user_id=self.user_id, agent_id=agent_id)
 
-    def get_agent_by_name(self, agent_name: str, user_id: str) -> AgentState:
+    def get_agent_by_name(self, agent_name: str) -> AgentState:
         """
         Get an agent by its name
 
@@ -1788,7 +1797,7 @@ class LocalClient(AbstractClient):
             agent_state (AgentState): State of the agent
         """
         self.interface.clear()
-        return self.server.get_agent(agent_name=agent_name, user_id=user_id, agent_id=None)
+        return self.server.get_agent(agent_name=agent_name, user_id=self.user_id, agent_id=None)
 
     def get_agent(self, agent_id: str) -> AgentState:
         """
@@ -2186,50 +2195,27 @@ class LocalClient(AbstractClient):
         self.server.delete_block(id)
 
     # tools
+    def load_langchain_tool(self, langchain_tool: "LangChainBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> Tool:
+        tool_create = ToolCreate.from_langchain(
+            langchain_tool=langchain_tool,
+            user_id=self.user_id,
+            organization_id=self.org_id,
+            additional_imports_module_attr_map=additional_imports_module_attr_map,
+        )
+        return self.server.tool_manager.create_or_update_tool(tool_create)
 
-    # TODO: merge this into create_tool
-    def add_tool(self, tool: Tool, update: Optional[bool] = True) -> Tool:
-        """
-        Adds a tool directly.
+    def load_crewai_tool(self, crewai_tool: "CrewAIBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> Tool:
+        tool_create = ToolCreate.from_crewai(
+            crewai_tool=crewai_tool,
+            additional_imports_module_attr_map=additional_imports_module_attr_map,
+            user_id=self.user_id,
+            organization_id=self.org_id,
+        )
+        return self.server.tool_manager.create_or_update_tool(tool_create)
 
-        Args:
-            tool (Tool): The tool to add.
-            update (bool, optional): Update the tool if it already exists. Defaults to True.
-
-        Returns:
-            None
-        """
-        if self.tool_with_name_and_user_id_exists(tool):
-            if update:
-                return self.server.update_tool(
-                    ToolUpdate(
-                        id=tool.id,
-                        description=tool.description,
-                        source_type=tool.source_type,
-                        source_code=tool.source_code,
-                        tags=tool.tags,
-                        json_schema=tool.json_schema,
-                        name=tool.name,
-                    ),
-                    self.user_id,
-                )
-            else:
-                raise ValueError(f"Tool with id={tool.id} and name={tool.name}already exists")
-        else:
-            # call server function
-            return self.server.create_tool(
-                ToolCreate(
-                    id=tool.id,
-                    description=tool.description,
-                    source_type=tool.source_type,
-                    source_code=tool.source_code,
-                    name=tool.name,
-                    json_schema=tool.json_schema,
-                    tags=tool.tags,
-                ),
-                user_id=self.user_id,
-                update=update,
-            )
+    def load_composio_tool(self, action: "ActionType") -> Tool:
+        tool_create = ToolCreate.from_composio(action=action, user_id=self.user_id, organization_id=self.org_id)
+        return self.server.tool_manager.create_or_update_tool(tool_create)
 
     # TODO: Use the above function `add_tool` here as there is duplicate logic
     def create_tool(
@@ -2262,11 +2248,16 @@ class LocalClient(AbstractClient):
             tags = []
 
         # call server function
-        return self.server.create_tool(
-            # ToolCreate(source_type=source_type, source_code=source_code, name=tool_name, json_schema=json_schema, tags=tags),
-            ToolCreate(source_type=source_type, source_code=source_code, name=name, tags=tags, terminal=terminal),
-            user_id=self.user_id,
-            update=update,
+        return self.server.tool_manager.create_or_update_tool(
+            ToolCreate(
+                user_id=self.user_id,
+                organization_id=self.org_id,
+                source_type=source_type,
+                source_code=source_code,
+                name=name,
+                tags=tags,
+                terminal=terminal,
+            ),
         )
 
     def update_tool(
@@ -2288,16 +2279,17 @@ class LocalClient(AbstractClient):
         Returns:
             tool (Tool): Updated tool
         """
-        if func:
-            source_code = parse_source_code(func)
-        else:
-            source_code = None
+        update_data = {
+            "source_type": "python",  # Always include source_type
+            "source_code": parse_source_code(func) if func else None,
+            "tags": tags,
+            "name": name,
+        }
 
-        source_type = "python"
+        # Filter out any None values from the dictionary
+        update_data = {key: value for key, value in update_data.items() if value is not None}
 
-        return self.server.update_tool(
-            ToolUpdate(id=id, source_type=source_type, source_code=source_code, tags=tags, name=name), self.user_id
-        )
+        return self.server.tool_manager.update_tool_by_id(id, ToolUpdate(**update_data))
 
     def list_tools(self, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[Tool]:
         """
@@ -2306,11 +2298,11 @@ class LocalClient(AbstractClient):
         Returns:
             tools (List[Tool]): List of tools
         """
-        return self.server.list_tools(cursor=cursor, limit=limit, user_id=self.user_id)
+        return self.server.tool_manager.list_tools_for_org(cursor=cursor, limit=limit, organization_id=self.org_id)
 
     def get_tool(self, id: str) -> Optional[Tool]:
         """
-        Get a tool give its ID.
+        Get a tool given its ID.
 
         Args:
             id (str): ID of the tool
@@ -2318,7 +2310,7 @@ class LocalClient(AbstractClient):
         Returns:
             tool (Tool): Tool
         """
-        return self.server.get_tool(id)
+        return self.server.tool_manager.get_tool_by_id(id)
 
     def delete_tool(self, id: str):
         """
@@ -2327,11 +2319,11 @@ class LocalClient(AbstractClient):
         Args:
             id (str): ID of the tool
         """
-        return self.server.delete_tool(id)
+        return self.server.tool_manager.delete_tool_by_id(id)
 
     def get_tool_id(self, name: str) -> Optional[str]:
         """
-        Get the ID of a tool
+        Get the ID of a tool from its name. The client will use the org_id it is configured with.
 
         Args:
             name (str): Name of the tool
@@ -2339,19 +2331,8 @@ class LocalClient(AbstractClient):
         Returns:
             id (str): ID of the tool (`None` if not found)
         """
-        return self.server.get_tool_id(name, self.user_id)
-
-    def tool_with_name_and_user_id_exists(self, tool: Tool) -> bool:
-        """
-        Check if the tool with name and user_id exists
-
-        Args:
-            tool (Tool): the tool
-
-        Returns:
-            (bool): True if the id exists, False otherwise.
-        """
-        return self.server.tool_with_name_and_user_id_exists(tool, self.user_id)
+        tool = self.server.tool_manager.get_tool_by_name_and_org_id(tool_name=name, organization_id=self.org_id)
+        return tool.id
 
     def load_data(self, connector: DataConnector, source_name: str):
         """
@@ -2622,7 +2603,7 @@ class LocalClient(AbstractClient):
         """
         return self.server.get_blocks(label=label, template=templates_only)
 
-    def create_block(self, name: str, text: str, label: Optional[str] = None) -> Block:  #
+    def create_block(self, label: str, text: str, name: Optional[str] = None, template: bool = False) -> Block:  #
         """
         Create a block
 
@@ -2634,7 +2615,9 @@ class LocalClient(AbstractClient):
         Returns:
             block (Block): Created block
         """
-        return self.server.create_block(CreateBlock(label=label, name=name, value=text, user_id=self.user_id), user_id=self.user_id)
+        return self.server.create_block(
+            CreateBlock(label=label, name=name, value=text, user_id=self.user_id, template=template), user_id=self.user_id
+        )
 
     def update_block(self, block_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Block:
         """

letta/config.py

@@ -13,7 +13,6 @@ from letta.constants import (
     DEFAULT_HUMAN,
     DEFAULT_PERSONA,
     DEFAULT_PRESET,
-    DEFAULT_USER_ID,
     LETTA_DIR,
 )
 from letta.log import get_logger
@@ -45,7 +44,6 @@ def set_field(config, section, field, value):
 @dataclass
 class LettaConfig:
     config_path: str = os.getenv("MEMGPT_CONFIG_PATH") or os.path.join(LETTA_DIR, "config")
-    anon_clientid: str = DEFAULT_USER_ID
 
     # preset
     preset: str = DEFAULT_PRESET  # TODO: rename to system prompt
@@ -182,7 +180,6 @@ class LettaConfig:
                 "metadata_storage_path": get_field(config, "metadata_storage", "path"),
                 "metadata_storage_uri": get_field(config, "metadata_storage", "uri"),
                 # Misc
-                "anon_clientid": get_field(config, "client", "anon_clientid"),
                 "config_path": config_path,
                 "letta_version": get_field(config, "version", "letta_version"),
             }
@@ -278,9 +275,6 @@ class LettaConfig:
         # set version
         set_field(config, "version", "letta_version", letta.__version__)
 
-        # client
-        set_field(config, "client", "anon_clientid", self.anon_clientid)
-
         # always make sure all directories are present
         self.create_config_dir()
 

letta/constants.py

@@ -3,15 +3,6 @@ from logging import CRITICAL, DEBUG, ERROR, INFO, NOTSET, WARN, WARNING
 
 LETTA_DIR = os.path.join(os.path.expanduser("~"), ".letta")
 
-# Defaults
-DEFAULT_USER_ID = "user-00000000-0000-4000-8000-000000000000"
-# This UUID follows the UUID4 rules:
-# The 13th character (4) indicates it's version 4.
-# The first character of the third segment (8) ensures the variant is correctly set.
-DEFAULT_ORG_ID = "organization-00000000-0000-4000-8000-000000000000"
-DEFAULT_USER_NAME = "default_user"
-DEFAULT_ORG_NAME = "default_org"
-
 
 # String in the error message for when the context window is too large
 # Example full message:

letta/functions/functions.py

@@ -3,9 +3,33 @@ import inspect
 import os
 from textwrap import dedent  # remove indentation
 from types import ModuleType
+from typing import Optional
 
 from letta.constants import CLI_WARNING_PREFIX
 from letta.functions.schema_generator import generate_schema
+from letta.schemas.tool import ToolCreate
+
+
+def derive_openai_json_schema(tool_create: ToolCreate) -> dict:
+    # auto-generate openai schema
+    try:
+        # Define a custom environment with necessary imports
+        env = {
+            "Optional": Optional,  # Add any other required imports here
+        }
+
+        env.update(globals())
+        exec(tool_create.source_code, env)
+
+        # get available functions
+        functions = [f for f in env if callable(env[f])]
+
+        # TODO: not sure if this always works
+        func = env[functions[-1]]
+        json_schema = generate_schema(func, terminal=tool_create.terminal, name=tool_create.name)
+        return json_schema
+    except Exception as e:
+        raise RuntimeError(f"Failed to execute source code: {e}")
 
 
 def parse_source_code(func) -> str:

letta/functions/helpers.py

@@ -1,5 +1,6 @@
 from typing import Any, Optional, Union
 
+import humps
 from pydantic import BaseModel
 
 
@@ -8,7 +9,7 @@ def generate_composio_tool_wrapper(action: "ActionType") -> tuple[str, str]:
     tool_instantiation_str = f"composio_toolset.get_tools(actions=[Action.{str(action)}])[0]"
 
     # Generate func name
-    func_name = f"run_{action.name.lower()}"
+    func_name = action.name.lower()
 
     wrapper_function_str = f"""
 def {func_name}(**kwargs):
@@ -40,7 +41,7 @@ def generate_langchain_tool_wrapper(
 
     tool_instantiation = f"tool = {generate_imported_tool_instantiation_call_str(tool)}"
     run_call = f"return tool._run(**kwargs)"
-    func_name = f"run_{tool_name.lower()}"
+    func_name = humps.decamelize(tool_name)
 
     # Combine all parts into the wrapper function
     wrapper_function_str = f"""
@@ -70,7 +71,7 @@ def generate_crewai_tool_wrapper(tool: "CrewAIBaseTool", additional_imports_modu
 
     tool_instantiation = f"tool = {generate_imported_tool_instantiation_call_str(tool)}"
     run_call = f"return tool._run(**kwargs)"
-    func_name = f"run_{tool_name.lower()}"
+    func_name = humps.decamelize(tool_name)
 
     # Combine all parts into the wrapper function
     wrapper_function_str = f"""

letta/functions/schema_generator.py

@@ -74,7 +74,7 @@ def pydantic_model_to_open_ai(model):
     }
 
 
-def generate_schema(function, terminal: Optional[bool], name: Optional[str] = None, description: Optional[str] = None):
+def generate_schema(function, terminal: Optional[bool], name: Optional[str] = None, description: Optional[str] = None) -> dict:
     # Get the signature of the function
     sig = inspect.signature(function)
 
@@ -139,7 +139,7 @@ def generate_schema(function, terminal: Optional[bool], name: Optional[str] = No
 
 
 def generate_schema_from_args_schema(
-    args_schema: Type[BaseModel], name: Optional[str] = None, description: Optional[str] = None
+    args_schema: Type[BaseModel], name: Optional[str] = None, description: Optional[str] = None, append_heartbeat: bool = True
 ) -> Dict[str, Any]:
     properties = {}
     required = []
@@ -163,4 +163,12 @@ def generate_schema_from_args_schema(
         "parameters": {"type": "object", "properties": properties, "required": required},
     }
 
+    # append heartbeat (necessary for triggering another reasoning step after this tool call)
+    if append_heartbeat:
+        function_call_json["parameters"]["properties"]["request_heartbeat"] = {
+            "type": "boolean",
+            "description": "Request an immediate heartbeat after function execution. Set to `True` if you want to send a follow-up message or run a follow-up function.",
+        }
+        function_call_json["parameters"]["required"].append("request_heartbeat")
+
     return function_call_json