letta-nightly 0.6.1.dev20241206104246__py3-none-any.whl → 0.6.1.dev20241208104134__py3-none-any.whl

letta/functions/function_sets/base.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import Optional
 
 from letta.agent import Agent
@@ -38,7 +39,7 @@ Returns:
 """
 
 
-def pause_heartbeats(self: Agent, minutes: int) -> Optional[str]:
+def pause_heartbeats(self: "Agent", minutes: int) -> Optional[str]:
     import datetime
 
     from letta.constants import MAX_PAUSE_HEARTBEATS
@@ -80,7 +81,15 @@ def conversation_search(self: "Agent", query: str, page: Optional[int] = 0) -> O
     except:
         raise ValueError(f"'page' argument must be an integer")
     count = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
-    results, total = self.persistence_manager.recall_memory.text_search(query, count=count, start=page * count)
+    # TODO: add paging by page number. currently cursor only works with strings.
+    # original: start=page * count
+    results = self.message_manager.list_user_messages_for_agent(
+        agent_id=self.agent_state.id,
+        actor=self.user,
+        query_text=query,
+        limit=count,
+    )
+    total = len(results)
     num_pages = math.ceil(total / count) - 1  # 0 index
     if len(results) == 0:
         results_str = f"No results found."
@@ -112,10 +121,29 @@ def conversation_search_date(self: "Agent", start_date: str, end_date: str, page
         page = 0
     try:
         page = int(page)
+        if page < 0:
+            raise ValueError
     except:
         raise ValueError(f"'page' argument must be an integer")
+
+    # Convert date strings to datetime objects
+    try:
+        start_datetime = datetime.strptime(start_date, "%Y-%m-%d").replace(hour=0, minute=0, second=0, microsecond=0)
+        end_datetime = datetime.strptime(end_date, "%Y-%m-%d").replace(hour=23, minute=59, second=59, microsecond=999999)
+    except ValueError:
+        raise ValueError("Dates must be in the format 'YYYY-MM-DD'")
+
     count = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
-    results, total = self.persistence_manager.recall_memory.date_search(start_date, end_date, count=count, start=page * count)
+    results = self.message_manager.list_user_messages_for_agent(
+        # TODO: add paging by page number. currently cursor only works with strings.
+        agent_id=self.agent_state.id,
+        actor=self.user,
+        start_date=start_datetime,
+        end_date=end_datetime,
+        limit=count,
+        # start_date=start_date, end_date=end_date, limit=count, start=page * count
+    )
+    total = len(results)
     num_pages = math.ceil(total / count) - 1  # 0 index
     if len(results) == 0:
         results_str = f"No results found."
@@ -136,7 +164,7 @@ def archival_memory_insert(self: "Agent", content: str) -> Optional[str]:
     Returns:
         Optional[str]: None is always returned as this function does not produce a response.
     """
-    self.persistence_manager.archival_memory.insert(content)
+    self.archival_memory.insert(content)
     return None
 
 
@@ -163,7 +191,7 @@ def archival_memory_search(self: "Agent", query: str, page: Optional[int] = 0) -
     except:
         raise ValueError(f"'page' argument must be an integer")
     count = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
-    results, total = self.persistence_manager.archival_memory.search(query, count=count, start=page * count)
+    results, total = self.archival_memory.search(query, count=count, start=page * count)
     num_pages = math.ceil(total / count) - 1  # 0 index
     if len(results) == 0:
         results_str = f"No results found."

letta/functions/helpers.py

@@ -4,12 +4,12 @@ import humps
 from pydantic import BaseModel
 
 
-def generate_composio_tool_wrapper(action: "ActionType") -> tuple[str, str]:
+def generate_composio_tool_wrapper(action_name: str) -> tuple[str, str]:
     # Instantiate the object
-    tool_instantiation_str = f"composio_toolset.get_tools(actions=[Action.{str(action)}])[0]"
+    tool_instantiation_str = f"composio_toolset.get_tools(actions=['{action_name}'])[0]"
 
     # Generate func name
-    func_name = action.name.lower()
+    func_name = action_name.lower()
 
     wrapper_function_str = f"""
 def {func_name}(**kwargs):

letta/llm_api/openai.py

@@ -217,7 +217,6 @@ def openai_chat_completions_process_stream(
     dummy_message = _Message(
         role=_MessageRole.assistant,
         text="",
-        user_id="",
         agent_id="",
         model="",
         name=None,

letta/local_llm/llm_chat_completion_wrappers/chatml.py

@@ -3,6 +3,7 @@ from letta.local_llm.json_parser import clean_json
 from letta.local_llm.llm_chat_completion_wrappers.wrapper_base import (
     LLMChatCompletionWrapper,
 )
+from letta.schemas.enums import MessageRole
 from letta.utils import json_dumps, json_loads
 
 PREFIX_HINT = """# Reminders:
@@ -208,7 +209,9 @@ class ChatMLInnerMonologueWrapper(LLMChatCompletionWrapper):
 
         # Last are the user/assistant messages
         for message in messages[1:]:
-            assert message["role"] in ["user", "assistant", "function", "tool"], message
+            # check that message["role"] is a valid option for MessageRole
+            # TODO: this shouldn't be necessary if we use pydantic in the future
+            assert message["role"] in [role.value for role in MessageRole]
 
             if message["role"] == "user":
                 # Support for AutoGen naming of agents
@@ -231,6 +234,15 @@ class ChatMLInnerMonologueWrapper(LLMChatCompletionWrapper):
 
                 prompt += f"\n<|im_start|>{role_str}\n{msg_str.strip()}<|im_end|>"
 
+            elif message["role"] == "system":
+
+                role_str = "system"
+                msg_str = self._compile_system_message(
+                    system_message=message["content"], functions=functions, function_documentation=function_documentation
+                )
+
+                prompt += f"\n<|im_start|>{role_str}\n{msg_str.strip()}<|im_end|>"
+
             elif message["role"] in ["tool", "function"]:
                 if self.allow_function_role:
                     role_str = message["role"]

letta/main.py

@@ -190,8 +190,8 @@ def run_agent_loop(
                 elif user_input.lower() == "/memory":
                     print(f"\nDumping memory contents:\n")
                     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()}")
+                    print(f"{letta_agent.archival_memory.compile()}")
+                    print(f"{letta_agent.recall_memory.compile()}")
                     continue
 
                 elif user_input.lower() == "/model":

letta/memory.py

@@ -67,14 +67,12 @@ def summarize_messages(
             + message_sequence_to_summarize[cutoff:]
         )
 
-    dummy_user_id = agent_state.user_id
+    agent_state.user_id
     dummy_agent_id = agent_state.id
     message_sequence = []
-    message_sequence.append(Message(user_id=dummy_user_id, agent_id=dummy_agent_id, role=MessageRole.system, text=summary_prompt))
-    message_sequence.append(
-        Message(user_id=dummy_user_id, agent_id=dummy_agent_id, role=MessageRole.assistant, text=MESSAGE_SUMMARY_REQUEST_ACK)
-    )
-    message_sequence.append(Message(user_id=dummy_user_id, agent_id=dummy_agent_id, role=MessageRole.user, text=summary_input))
+    message_sequence.append(Message(agent_id=dummy_agent_id, role=MessageRole.system, text=summary_prompt))
+    message_sequence.append(Message(agent_id=dummy_agent_id, role=MessageRole.assistant, text=MESSAGE_SUMMARY_REQUEST_ACK))
+    message_sequence.append(Message(agent_id=dummy_agent_id, role=MessageRole.user, text=summary_input))
 
     # TODO: We need to eventually have a separate LLM config for the summarizer LLM
     llm_config_no_inner_thoughts = agent_state.llm_config.model_copy(deep=True)
@@ -252,82 +250,6 @@ class DummyRecallMemory(RecallMemory):
             return matches, len(matches)
 
 
-class BaseRecallMemory(RecallMemory):
-    """Recall memory based on base functions implemented by storage connectors"""
-
-    def __init__(self, agent_state, restrict_search_to_summaries=False):
-        # If true, the pool of messages that can be queried are the automated summaries only
-        # (generated when the conversation window needs to be shortened)
-        self.restrict_search_to_summaries = restrict_search_to_summaries
-        from letta.agent_store.storage import StorageConnector
-
-        self.agent_state = agent_state
-
-        # create embedding model
-        self.embed_model = embedding_model(agent_state.embedding_config)
-        self.embedding_chunk_size = agent_state.embedding_config.embedding_chunk_size
-
-        # create storage backend
-        self.storage = StorageConnector.get_recall_storage_connector(user_id=agent_state.user_id, agent_id=agent_state.id)
-        # TODO: have some mechanism for cleanup otherwise will lead to OOM
-        self.cache = {}
-
-    def get_all(self, start=0, count=None):
-        start = 0 if start is None else int(start)
-        count = 0 if count is None else int(count)
-        results = self.storage.get_all(start, count)
-        results_json = [message.to_openai_dict() for message in results]
-        return results_json, len(results)
-
-    def text_search(self, query_string, count=None, start=None):
-        start = 0 if start is None else int(start)
-        count = 0 if count is None else int(count)
-        results = self.storage.query_text(query_string, count, start)
-        results_json = [message.to_openai_dict_search_results() for message in results]
-        return results_json, len(results)
-
-    def date_search(self, start_date, end_date, count=None, start=None):
-        start = 0 if start is None else int(start)
-        count = 0 if count is None else int(count)
-        results = self.storage.query_date(start_date, end_date, count, start)
-        results_json = [message.to_openai_dict_search_results() for message in results]
-        return results_json, len(results)
-
-    def compile(self) -> str:
-        total = self.storage.size()
-        system_count = self.storage.size(filters={"role": "system"})
-        user_count = self.storage.size(filters={"role": "user"})
-        assistant_count = self.storage.size(filters={"role": "assistant"})
-        function_count = self.storage.size(filters={"role": "function"})
-        other_count = total - (system_count + user_count + assistant_count + function_count)
-
-        memory_str = (
-            f"Statistics:"
-            + f"\n{total} total messages"
-            + f"\n{system_count} system"
-            + f"\n{user_count} user"
-            + f"\n{assistant_count} assistant"
-            + f"\n{function_count} function"
-            + f"\n{other_count} other"
-        )
-        return f"\n### RECALL MEMORY ###" + f"\n{memory_str}"
-
-    def insert(self, message: Message):
-        self.storage.insert(message)
-
-    def insert_many(self, messages: List[Message]):
-        self.storage.insert_many(messages)
-
-    def save(self):
-        self.storage.save()
-
-    def __len__(self):
-        return self.storage.size()
-
-    def count(self) -> int:
-        return len(self)
-
-
 class EmbeddingArchivalMemory(ArchivalMemory):
     """Archival memory with embedding based search"""
 

letta/metadata.py

@@ -14,7 +14,6 @@ from letta.schemas.api_key import APIKey
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import ToolRuleType
 from letta.schemas.llm_config import LLMConfig
-from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
 from letta.schemas.tool_rule import ChildToolRule, InitToolRule, TerminalToolRule
 from letta.schemas.user import User
 from letta.services.per_agent_lock_manager import PerAgentLockManager
@@ -66,40 +65,6 @@ class EmbeddingConfigColumn(TypeDecorator):
         return value
 
 
-class ToolCallColumn(TypeDecorator):
-
-    impl = JSON
-    cache_ok = True
-
-    def load_dialect_impl(self, dialect):
-        return dialect.type_descriptor(JSON())
-
-    def process_bind_param(self, value, dialect):
-        if value:
-            values = []
-            for v in value:
-                if isinstance(v, ToolCall):
-                    values.append(v.model_dump())
-                else:
-                    values.append(v)
-            return values
-
-        return value
-
-    def process_result_value(self, value, dialect):
-        if value:
-            tools = []
-            for tool_value in value:
-                if "function" in tool_value:
-                    tool_call_function = ToolCallFunction(**tool_value["function"])
-                    del tool_value["function"]
-                else:
-                    tool_call_function = None
-                tools.append(ToolCall(function=tool_call_function, **tool_value))
-            return tools
-        return value
-
-
 # TODO: eventually store providers?
 # class Provider(Base):
 #    __tablename__ = "providers"

letta/o1_agent.py

@@ -20,7 +20,7 @@ def send_thinking_message(self: "Agent", message: str) -> Optional[str]:
     Returns:
         Optional[str]: None is always returned as this function does not produce a response.
     """
-    self.interface.internal_monologue(message, msg_obj=self._messages[-1])
+    self.interface.internal_monologue(message)
     return None
 
 
@@ -34,7 +34,7 @@ def send_final_message(self: "Agent", message: str) -> Optional[str]:
     Returns:
         Optional[str]: None is always returned as this function does not produce a response.
     """
-    self.interface.internal_monologue(message, msg_obj=self._messages[-1])
+    self.interface.internal_monologue(message)
     return None
 
 
@@ -62,10 +62,15 @@ class O1Agent(Agent):
         """Run Agent.inner_step in a loop, terminate when final thinking message is sent or max_thinking_steps is reached"""
         # assert ms is not None, "MetadataStore is required"
         next_input_message = messages if isinstance(messages, list) else [messages]
+
         counter = 0
         total_usage = UsageStatistics()
         step_count = 0
         while step_count < self.max_thinking_steps:
+            # This is hacky but we need to do this for now
+            for m in next_input_message:
+                m.id = m._generate_id()
+
             kwargs["ms"] = ms
             kwargs["first_message"] = False
             step_response = self.inner_step(

letta/offline_memory_agent.py

@@ -18,6 +18,7 @@ def trigger_rethink_memory(agent_state: "AgentState", message: Optional[str]) ->
 
     """
     from letta import create_client
+
     client = create_client()
     agents = client.list_agents()
     for agent in agents:
@@ -149,6 +150,11 @@ class OfflineMemoryAgent(Agent):
         step_count = 0
 
         while counter < self.max_memory_rethinks:
+            # This is hacky but we need to do this for now
+            # TODO: REMOVE THIS
+            for m in next_input_message:
+                m.id = m._generate_id()
+
             kwargs["ms"] = ms
             kwargs["first_message"] = False
             step_response = self.inner_step(

letta/orm/__init__.py

@@ -1,8 +1,10 @@
+from letta.orm.agents_tags import AgentsTags
 from letta.orm.base import Base
 from letta.orm.block import Block
 from letta.orm.blocks_agents import BlocksAgents
 from letta.orm.file import FileMetadata
 from letta.orm.job import Job
+from letta.orm.message import Message
 from letta.orm.organization import Organization
 from letta.orm.sandbox_config import SandboxConfig, SandboxEnvironmentVariable
 from letta.orm.source import Source

letta/orm/file.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, List
 
 from sqlalchemy import Integer, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship

letta/orm/message.py

@@ -0,0 +1,64 @@
+from typing import Optional
+
+from sqlalchemy import JSON, TypeDecorator
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.mixins import AgentMixin, OrganizationMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.message import Message as PydanticMessage
+from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
+
+
+class ToolCallColumn(TypeDecorator):
+
+    impl = JSON
+    cache_ok = True
+
+    def load_dialect_impl(self, dialect):
+        return dialect.type_descriptor(JSON())
+
+    def process_bind_param(self, value, dialect):
+        if value:
+            values = []
+            for v in value:
+                if isinstance(v, ToolCall):
+                    values.append(v.model_dump())
+                else:
+                    values.append(v)
+            return values
+
+        return value
+
+    def process_result_value(self, value, dialect):
+        if value:
+            tools = []
+            for tool_value in value:
+                if "function" in tool_value:
+                    tool_call_function = ToolCallFunction(**tool_value["function"])
+                    del tool_value["function"]
+                else:
+                    tool_call_function = None
+                tools.append(ToolCall(function=tool_call_function, **tool_value))
+            return tools
+        return value
+
+
+class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
+    """Defines data model for storing Message objects"""
+
+    __tablename__ = "messages"
+    __table_args__ = {"extend_existing": True}
+    __pydantic_model__ = PydanticMessage
+
+    id: Mapped[str] = mapped_column(primary_key=True, doc="Unique message identifier")
+    role: Mapped[str] = mapped_column(doc="Message role (user/assistant/system/tool)")
+    text: Mapped[Optional[str]] = mapped_column(nullable=True, doc="Message content")
+    model: Mapped[Optional[str]] = mapped_column(nullable=True, doc="LLM model used")
+    name: Mapped[Optional[str]] = mapped_column(nullable=True, doc="Name for multi-agent scenarios")
+    tool_calls: Mapped[ToolCall] = mapped_column(ToolCallColumn, doc="Tool call information")
+    tool_call_id: Mapped[Optional[str]] = mapped_column(nullable=True, doc="ID of the tool call")
+
+    # Relationships
+    # TODO: Add in after Agent ORM is created
+    # agent: Mapped["Agent"] = relationship("Agent", back_populates="messages", lazy="selectin")
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="messages", lazy="selectin")

letta/orm/mixins.py

@@ -31,6 +31,22 @@ class UserMixin(Base):
     user_id: Mapped[str] = mapped_column(String, ForeignKey("users.id"))
 
 
+class AgentMixin(Base):
+    """Mixin for models that belong to an agent."""
+
+    __abstract__ = True
+
+    agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id"))
+
+
+class FileMixin(Base):
+    """Mixin for models that belong to a file."""
+
+    __abstract__ = True
+
+    file_id: Mapped[str] = mapped_column(String, ForeignKey("files.id"))
+
+
 class SourceMixin(Base):
     """Mixin for models (e.g. file) that belong to a source."""
 

letta/orm/organization.py

@@ -33,6 +33,7 @@ class Organization(SqlalchemyBase):
     sandbox_environment_variables: Mapped[List["SandboxEnvironmentVariable"]] = relationship(
         "SandboxEnvironmentVariable", back_populates="organization", cascade="all, delete-orphan"
     )
+    messages: Mapped[List["Message"]] = relationship("Message", back_populates="organization", cascade="all, delete-orphan")
 
     # TODO: Map these relationships later when we actually make these models
     # below is just a suggestion