letta-nightly 0.5.4.dev20241126104249__py3-none-any.whl → 0.5.4.dev20241128000451__py3-none-any.whl

letta/config.py

@@ -16,7 +16,7 @@ from letta.constants import (
     LETTA_DIR,
 )
 from letta.log import get_logger
-from letta.schemas.agent import AgentState
+from letta.schemas.agent import PersistedAgentState
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.llm_config import LLMConfig
 
@@ -434,7 +434,7 @@ class AgentConfig:
             json.dump(vars(self), f, indent=4)
 
     def to_agent_state(self):
-        return AgentState(
+        return PersistedAgentState(
             name=self.name,
             preset=self.preset,
             persona=self.persona,

letta/constants.py

@@ -38,6 +38,8 @@ DEFAULT_PRESET = "memgpt_chat"
 
 # Base tools that cannot be edited, as they access agent state directly
 BASE_TOOLS = ["send_message", "conversation_search", "conversation_search_date", "archival_memory_insert", "archival_memory_search"]
+# Base memory tools CAN be edited, and are added by default by the server
+BASE_MEMORY_TOOLS = ["core_memory_append", "core_memory_replace"]
 
 # The name of the tool used to send message to the user
 # May not be relevant in cases where the agent has multiple ways to message to user (send_imessage, send_discord_mesasge, ...)
@@ -127,6 +129,9 @@ MESSAGE_SUMMARY_REQUEST_ACK = "Understood, I will respond with a summary of the
 # These serve as in-context examples of how to use functions / what user messages look like
 MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST = 3
 
+# Maximum length of an error message
+MAX_ERROR_MESSAGE_CHAR_LIMIT = 500
+
 # Default memory limits
 CORE_MEMORY_PERSONA_CHAR_LIMIT: int = 5000
 CORE_MEMORY_HUMAN_CHAR_LIMIT: int = 5000

letta/errors.py

@@ -10,6 +10,18 @@ class LettaError(Exception):
     """Base class for all Letta related errors."""
 
 
+class LettaToolCreateError(LettaError):
+    """Error raised when a tool cannot be created."""
+
+    default_error_message = "Error creating tool."
+
+    def __init__(self, message=None):
+        if message is None:
+            message = self.default_error_message
+        self.message = message
+        super().__init__(self.message)
+
+
 class LLMError(LettaError):
     pass
 

letta/functions/function_sets/base.py

@@ -11,7 +11,7 @@ from letta.constants import MAX_PAUSE_HEARTBEATS
 # If the function fails, throw an exception
 
 
-def send_message(self: Agent, message: str) -> Optional[str]:
+def send_message(self: "Agent", message: str) -> Optional[str]:
     """
     Sends a message to the human user.
 
@@ -172,3 +172,40 @@ def archival_memory_search(self: Agent, query: str, page: Optional[int] = 0) ->
         results_formatted = [f"timestamp: {d['timestamp']}, memory: {d['content']}" for d in results]
         results_str = f"{results_pref} {json_dumps(results_formatted)}"
     return results_str
+
+
+def core_memory_append(agent_state: "AgentState", label: str, content: str) -> Optional[str]:  # type: ignore
+    """
+    Append to the contents of core memory.
+
+    Args:
+        label (str): Section of the memory to be edited (persona or human).
+        content (str): Content to write to the memory. All unicode (including emojis) are supported.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    current_value = str(agent_state.memory.get_block(label).value)
+    new_value = current_value + "\n" + str(content)
+    agent_state.memory.update_block_value(label=label, value=new_value)
+    return None
+
+
+def core_memory_replace(agent_state: "AgentState", label: str, old_content: str, new_content: str) -> Optional[str]:  # type: ignore
+    """
+    Replace the contents of core memory. To delete memories, use an empty string for new_content.
+
+    Args:
+        label (str): Section of the memory to be edited (persona or human).
+        old_content (str): String to replace. Must be an exact match.
+        new_content (str): Content to write to the memory. All unicode (including emojis) are supported.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    current_value = str(agent_state.memory.get_block(label).value)
+    if old_content not in current_value:
+        raise ValueError(f"Old content '{old_content}' not found in memory block '{label}'")
+    new_value = current_value.replace(str(old_content), str(new_content))
+    agent_state.memory.update_block_value(label=label, value=new_value)
+    return None

letta/functions/functions.py

@@ -3,9 +3,10 @@ import inspect
 import os
 from textwrap import dedent  # remove indentation
 from types import ModuleType
-from typing import Optional, List
+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
 
 
@@ -13,10 +14,7 @@ def derive_openai_json_schema(source_code: str, name: Optional[str] = None) -> d
     # auto-generate openai schema
     try:
         # Define a custom environment with necessary imports
-        env = {
-            "Optional": Optional,  # Add any other required imports here
-            "List": List
-        }
+        env = {"Optional": Optional, "List": List, "Dict": Dict}  # Add any other required imports here
 
         env.update(globals())
         exec(source_code, env)
@@ -29,7 +27,7 @@ def derive_openai_json_schema(source_code: str, name: Optional[str] = None) -> d
         json_schema = generate_schema(func, name=name)
         return json_schema
     except Exception as e:
-        raise RuntimeError(f"Failed to execute source code: {e}")
+        raise LettaToolCreateError(f"Failed to derive JSON schema from source code: {e}")
 
 
 def parse_source_code(func) -> str:

letta/functions/schema_generator.py

@@ -131,11 +131,12 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[
         else:
             # Add parameter details to the schema
             param_doc = next((d for d in docstring.params if d.arg_name == param.name), None)
-            schema["parameters"]["properties"][param.name] = {
-                # "type": "string" if param.annotation == str else str(param.annotation),
-                "type": type_to_json_schema_type(param.annotation) if param.annotation != inspect.Parameter.empty else "string",
-                "description": param_doc.description,
-            }
+            if param_doc:
+                schema["parameters"]["properties"][param.name] = {
+                    # "type": "string" if param.annotation == str else str(param.annotation),
+                    "type": type_to_json_schema_type(param.annotation) if param.annotation != inspect.Parameter.empty else "string",
+                    "description": param_doc.description,
+                }
         if param.default == inspect.Parameter.empty:
             schema["parameters"]["required"].append(param.name)
 

letta/helpers/tool_rule_solver.py

@@ -2,11 +2,12 @@ from typing import Dict, List, Optional, Set
 
 from pydantic import BaseModel, Field
 
+from letta.schemas.enums import ToolRuleType
 from letta.schemas.tool_rule import (
     BaseToolRule,
+    ChildToolRule,
     InitToolRule,
     TerminalToolRule,
-    ToolRule,
 )
 
 
@@ -21,7 +22,7 @@ class ToolRulesSolver(BaseModel):
     init_tool_rules: List[InitToolRule] = Field(
         default_factory=list, description="Initial tool rules to be used at the start of tool execution."
     )
-    tool_rules: List[ToolRule] = Field(
+    tool_rules: List[ChildToolRule] = Field(
         default_factory=list, description="Standard tool rules for controlling execution sequence and allowed transitions."
     )
     terminal_tool_rules: List[TerminalToolRule] = Field(
@@ -33,11 +34,11 @@ class ToolRulesSolver(BaseModel):
         super().__init__(**kwargs)
         # Separate the provided tool rules into init, standard, and terminal categories
         for rule in tool_rules:
-            if isinstance(rule, InitToolRule):
+            if rule.type == ToolRuleType.run_first:
                 self.init_tool_rules.append(rule)
-            elif isinstance(rule, ToolRule):
+            elif rule.type == ToolRuleType.constrain_child_tools:
                 self.tool_rules.append(rule)
-            elif isinstance(rule, TerminalToolRule):
+            elif rule.type == ToolRuleType.exit_loop:
                 self.terminal_tool_rules.append(rule)
 
         # Validate the tool rules to ensure they form a DAG

letta/main.py

@@ -189,7 +189,7 @@ def run_agent_loop(
 
                 elif user_input.lower() == "/memory":
                     print(f"\nDumping memory contents:\n")
-                    print(f"{letta_agent.memory.compile()}")
+                    print(f"{letta_agent.agent_state.memory.compile()}")
                     print(f"{letta_agent.persistence_manager.archival_memory.compile()}")
                     print(f"{letta_agent.persistence_manager.recall_memory.compile()}")
                     continue

letta/metadata.py

@@ -3,28 +3,23 @@
 import os
 import secrets
 import warnings
-from typing import List, Optional
+from typing import List, Optional, Union
 
 from sqlalchemy import JSON, Column, DateTime, Index, String, TypeDecorator
 from sqlalchemy.sql import func
 
 from letta.config import LettaConfig
 from letta.orm.base import Base
-from letta.schemas.agent import AgentState
+from letta.schemas.agent import PersistedAgentState
 from letta.schemas.api_key import APIKey
 from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.enums import JobStatus
+from letta.schemas.enums import JobStatus, ToolRuleType
 from letta.schemas.job import Job
 from letta.schemas.llm_config import LLMConfig
-from letta.schemas.memory import Memory
 from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
-from letta.schemas.tool_rule import (
-    BaseToolRule,
-    InitToolRule,
-    TerminalToolRule,
-    ToolRule,
-)
+from letta.schemas.tool_rule import ChildToolRule, InitToolRule, TerminalToolRule
 from letta.schemas.user import User
+from letta.services.per_agent_lock_manager import PerAgentLockManager
 from letta.settings import settings
 from letta.utils import enforce_types, get_utc_time, printd
 
@@ -164,28 +159,35 @@ class ToolRulesColumn(TypeDecorator):
     def load_dialect_impl(self, dialect):
         return dialect.type_descriptor(JSON())
 
-    def process_bind_param(self, value: List[BaseToolRule], dialect):
+    def process_bind_param(self, value, dialect):
         """Convert a list of ToolRules to JSON-serializable format."""
         if value:
-            return [rule.model_dump() for rule in value]
+            data = [rule.model_dump() for rule in value]
+            for d in data:
+                d["type"] = d["type"].value
+
+            for d in data:
+                assert not (d["type"] == "ToolRule" and "children" not in d), "ToolRule does not have children field"
+            return data
         return value
 
-    def process_result_value(self, value, dialect) -> List[BaseToolRule]:
+    def process_result_value(self, value, dialect) -> List[Union[ChildToolRule, InitToolRule, TerminalToolRule]]:
         """Convert JSON back to a list of ToolRules."""
         if value:
             return [self.deserialize_tool_rule(rule_data) for rule_data in value]
         return value
 
     @staticmethod
-    def deserialize_tool_rule(data: dict) -> BaseToolRule:
+    def deserialize_tool_rule(data: dict) -> Union[ChildToolRule, InitToolRule, TerminalToolRule]:
         """Deserialize a dictionary to the appropriate ToolRule subclass based on the 'type'."""
-        rule_type = data.get("type")  # Remove 'type' field if it exists since it is a class var
-        if rule_type == "InitToolRule":
+        rule_type = ToolRuleType(data.get("type"))  # Remove 'type' field if it exists since it is a class var
+        if rule_type == ToolRuleType.run_first:
             return InitToolRule(**data)
-        elif rule_type == "TerminalToolRule":
+        elif rule_type == ToolRuleType.exit_loop:
             return TerminalToolRule(**data)
-        elif rule_type == "ToolRule":
-            return ToolRule(**data)
+        elif rule_type == ToolRuleType.constrain_child_tools:
+            rule = ChildToolRule(**data)
+            return rule
         else:
             raise ValueError(f"Unknown tool rule type: {rule_type}")
 
@@ -204,7 +206,6 @@ class AgentModel(Base):
 
     # state (context compilation)
     message_ids = Column(JSON)
-    memory = Column(JSON)
     system = Column(String)
 
     # configs
@@ -216,7 +217,7 @@ class AgentModel(Base):
     metadata_ = Column(JSON)
 
     # tools
-    tools = Column(JSON)
+    tool_names = Column(JSON)
     tool_rules = Column(ToolRulesColumn)
 
     Index(__tablename__ + "_idx_user", user_id),
@@ -224,24 +225,22 @@ class AgentModel(Base):
     def __repr__(self) -> str:
         return f"<Agent(id='{self.id}', name='{self.name}')>"
 
-    def to_record(self) -> AgentState:
-        agent_state = AgentState(
+    def to_record(self) -> PersistedAgentState:
+        agent_state = PersistedAgentState(
             id=self.id,
             user_id=self.user_id,
             name=self.name,
             created_at=self.created_at,
             description=self.description,
             message_ids=self.message_ids,
-            memory=Memory.load(self.memory),  # load dictionary
             system=self.system,
-            tools=self.tools,
+            tool_names=self.tool_names,
             tool_rules=self.tool_rules,
             agent_type=self.agent_type,
             llm_config=self.llm_config,
             embedding_config=self.embedding_config,
             metadata_=self.metadata_,
         )
-        assert isinstance(agent_state.memory, Memory), f"Memory object is not of type Memory: {type(agent_state.memory)}"
         return agent_state
 
 
@@ -346,18 +345,18 @@ class MetadataStore:
             return tokens
 
     @enforce_types
-    def create_agent(self, agent: AgentState):
+    def create_agent(self, agent: PersistedAgentState):
         # insert into agent table
         # make sure agent.name does not already exist for user user_id
         with self.session_maker() as session:
             if session.query(AgentModel).filter(AgentModel.name == agent.name).filter(AgentModel.user_id == agent.user_id).count() > 0:
                 raise ValueError(f"Agent with name {agent.name} already exists")
             fields = vars(agent)
-            fields["memory"] = agent.memory.to_dict()
-            if "_internal_memory" in fields:
-                del fields["_internal_memory"]
-            else:
-                warnings.warn(f"Agent {agent.id} has no _internal_memory field")
+            # fields["memory"] = agent.memory.to_dict()
+            # if "_internal_memory" in fields:
+            #    del fields["_internal_memory"]
+            # else:
+            #    warnings.warn(f"Agent {agent.id} has no _internal_memory field")
             if "tags" in fields:
                 del fields["tags"]
             else:
@@ -366,15 +365,15 @@ class MetadataStore:
             session.commit()
 
     @enforce_types
-    def update_agent(self, agent: AgentState):
+    def update_agent(self, agent: PersistedAgentState):
         with self.session_maker() as session:
             fields = vars(agent)
-            if isinstance(agent.memory, Memory):  # TODO: this is nasty but this whole class will soon be removed so whatever
-                fields["memory"] = agent.memory.to_dict()
-            if "_internal_memory" in fields:
-                del fields["_internal_memory"]
-            else:
-                warnings.warn(f"Agent {agent.id} has no _internal_memory field")
+            # if isinstance(agent.memory, Memory):  # TODO: this is nasty but this whole class will soon be removed so whatever
+            #    fields["memory"] = agent.memory.to_dict()
+            # if "_internal_memory" in fields:
+            #    del fields["_internal_memory"]
+            # else:
+            #    warnings.warn(f"Agent {agent.id} has no _internal_memory field")
             if "tags" in fields:
                 del fields["tags"]
             else:
@@ -383,7 +382,11 @@ class MetadataStore:
             session.commit()
 
     @enforce_types
-    def delete_agent(self, agent_id: str):
+    def delete_agent(self, agent_id: str, per_agent_lock_manager: PerAgentLockManager):
+        # TODO: Remove this once Agent is on the ORM
+        # TODO: To prevent unbounded growth
+        per_agent_lock_manager.clear_lock(agent_id)
+
         with self.session_maker() as session:
 
             # delete agents
@@ -395,7 +398,7 @@ class MetadataStore:
             session.commit()
 
     @enforce_types
-    def list_agents(self, user_id: str) -> List[AgentState]:
+    def list_agents(self, user_id: str) -> List[PersistedAgentState]:
         with self.session_maker() as session:
             results = session.query(AgentModel).filter(AgentModel.user_id == user_id).all()
             return [r.to_record() for r in results]
@@ -403,7 +406,7 @@ class MetadataStore:
     @enforce_types
     def get_agent(
         self, agent_id: Optional[str] = None, agent_name: Optional[str] = None, user_id: Optional[str] = None
-    ) -> Optional[AgentState]:
+    ) -> Optional[PersistedAgentState]:
         with self.session_maker() as session:
             if agent_id:
                 results = session.query(AgentModel).filter(AgentModel.id == agent_id).all()

letta/o1_agent.py

@@ -6,7 +6,6 @@ from letta.metadata import MetadataStore
 from letta.schemas.agent import AgentState
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import UsageStatistics
-from letta.schemas.tool import Tool
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 
@@ -45,13 +44,11 @@ class O1Agent(Agent):
         interface: AgentInterface,
         agent_state: AgentState,
         user: User,
-        tools: List[Tool] = [],
         max_thinking_steps: int = 10,
         first_message_verify_mono: bool = False,
     ):
-        super().__init__(interface, agent_state, tools, user)
+        super().__init__(interface, agent_state, user)
         self.max_thinking_steps = max_thinking_steps
-        self.tools = tools
         self.first_message_verify_mono = first_message_verify_mono
 
     def step(

letta/orm/block.py

@@ -10,7 +10,7 @@ from letta.schemas.block import Block as PydanticBlock
 from letta.schemas.block import Human, Persona
 
 if TYPE_CHECKING:
-    from letta.orm.organization import Organization
+    from letta.orm import BlocksAgents, Organization
 
 
 class Block(OrganizationMixin, SqlalchemyBase):
@@ -35,6 +35,7 @@ class Block(OrganizationMixin, SqlalchemyBase):
 
     # relationships
     organization: Mapped[Optional["Organization"]] = relationship("Organization")
+    blocks_agents: Mapped[list["BlocksAgents"]] = relationship("BlocksAgents", back_populates="block", cascade="all, delete")
 
     def to_pydantic(self) -> Type:
         match self.label:

letta/orm/blocks_agents.py

@@ -1,5 +1,5 @@
 from sqlalchemy import ForeignKey, ForeignKeyConstraint, String, UniqueConstraint
-from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.blocks_agents import BlocksAgents as PydanticBlocksAgents
@@ -27,3 +27,6 @@ class BlocksAgents(SqlalchemyBase):
     agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id"), primary_key=True)
     block_id: Mapped[str] = mapped_column(String, primary_key=True)
     block_label: Mapped[str] = mapped_column(String, primary_key=True)
+
+    # relationships
+    block: Mapped["Block"] = relationship("Block", back_populates="blocks_agents")

letta/orm/sqlalchemy_base.py

@@ -180,6 +180,19 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         """Handle database errors and raise appropriate custom exceptions."""
         orig = e.orig  # Extract the original error from the DBAPIError
         error_code = None
+        error_message = str(orig) if orig else str(e)
+        logger.info(f"Handling DBAPIError: {error_message}")
+
+        # Handle SQLite-specific errors
+        if "UNIQUE constraint failed" in error_message:
+            raise UniqueConstraintViolationError(
+                f"A unique constraint was violated for {cls.__name__}. Check your input for duplicates: {e}"
+            ) from e
+
+        if "FOREIGN KEY constraint failed" in error_message:
+            raise ForeignKeyConstraintViolationError(
+                f"A foreign key constraint was violated for {cls.__name__}. Check your input for missing or invalid references: {e}"
+            ) from e
 
         # For psycopg2
         if hasattr(orig, "pgcode"):

letta/persistence_manager.py

@@ -121,6 +121,7 @@ class LocalStateManager(PersistenceManager):
         # self.messages = [self.messages[0]] + added_messages + self.messages[1:]
 
         # add to recall memory
+        self.recall_memory.insert_many([m for m in added_messages])
 
     def append_to_messages(self, added_messages: List[Message]):
         # first tag with timestamps