letta-nightly 0.6.1.dev20241206104246__tar.gz → 0.6.1.dev20241208104134__tar.gz

{letta_nightly-0.6.1.dev20241206104246 → letta_nightly-0.6.1.dev20241208104134}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.1.dev20241206104246
+Version: 0.6.1.dev20241208104134
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -26,7 +26,7 @@ Requires-Dist: alembic (>=1.13.3,<2.0.0)
 Requires-Dist: autoflake (>=2.3.0,<3.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: black[jupyter] (>=24.2.0,<25.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: chromadb (>=0.4.24,<0.5.0)
-Requires-Dist: composio-core (>=0.5.34,<0.6.0)
+Requires-Dist: composio-core (>=0.5.51,<0.6.0)
 Requires-Dist: composio-langchain (>=0.5.28,<0.6.0)
 Requires-Dist: datasets (>=2.14.6,<3.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: demjson3 (>=3.0.6,<4.0.0)

{letta_nightly-0.6.1.dev20241206104246 → letta_nightly-0.6.1.dev20241208104134}/letta/agent.py

@@ -19,6 +19,7 @@ from letta.constants import (
     MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST,
     MESSAGE_SUMMARY_TRUNC_TOKEN_FRAC,
     MESSAGE_SUMMARY_WARNING_FRAC,
+    O1_BASE_TOOLS,
     REQ_HEARTBEAT_MESSAGE,
 )
 from letta.errors import LLMError
@@ -27,16 +28,15 @@ from letta.interface import AgentInterface
 from letta.llm_api.helpers import is_context_overflow_error
 from letta.llm_api.llm_api_tools import create
 from letta.local_llm.utils import num_tokens_from_functions, num_tokens_from_messages
-from letta.memory import ArchivalMemory, RecallMemory, summarize_messages
+from letta.memory import ArchivalMemory, EmbeddingArchivalMemory, summarize_messages
 from letta.metadata import MetadataStore
 from letta.orm import User
-from letta.persistence_manager import LocalStateManager
 from letta.schemas.agent import AgentState, AgentStepResponse
 from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import MessageRole
 from letta.schemas.memory import ContextWindowOverview, Memory
-from letta.schemas.message import Message, UpdateMessage
+from letta.schemas.message import Message, MessageUpdate
 from letta.schemas.openai.chat_completion_request import (
     Tool as ChatCompletionRequestTool,
 )
@@ -49,7 +49,9 @@ from letta.schemas.passage import Passage
 from letta.schemas.tool import Tool
 from letta.schemas.tool_rule import TerminalToolRule
 from letta.schemas.usage import LettaUsageStatistics
+from letta.schemas.user import User as PydanticUser
 from letta.services.block_manager import BlockManager
+from letta.services.message_manager import MessageManager
 from letta.services.source_manager import SourceManager
 from letta.services.tool_execution_sandbox import ToolExecutionSandbox
 from letta.services.user_manager import UserManager
@@ -80,9 +82,11 @@ from letta.utils import (
 
 
 def compile_memory_metadata_block(
+    actor: PydanticUser,
+    agent_id: str,
     memory_edit_timestamp: datetime.datetime,
     archival_memory: Optional[ArchivalMemory] = None,
-    recall_memory: Optional[RecallMemory] = None,
+    message_manager: Optional[MessageManager] = None,
 ) -> str:
     # Put the timestamp in the local timezone (mimicking get_local_time())
     timestamp_str = memory_edit_timestamp.astimezone().strftime("%Y-%m-%d %I:%M:%S %p %Z%z").strip()
@@ -91,7 +95,7 @@ def compile_memory_metadata_block(
     memory_metadata_block = "\n".join(
         [
             f"### Memory [last modified: {timestamp_str}]",
-            f"{recall_memory.count() if recall_memory else 0} previous messages between you and the user are stored in recall memory (use functions to access them)",
+            f"{message_manager.size(actor=actor, agent_id=agent_id) if message_manager else 0} previous messages between you and the user are stored in recall memory (use functions to access them)",
             f"{archival_memory.count() if archival_memory else 0} total memories you created are stored in archival memory (use functions to access them)",
             "\nCore memory shown below (limited in size, additional information stored in archival / recall memory):",
         ]
@@ -101,10 +105,12 @@ def compile_memory_metadata_block(
 
 def compile_system_message(
     system_prompt: str,
+    agent_id: str,
     in_context_memory: Memory,
     in_context_memory_last_edit: datetime.datetime,  # TODO move this inside of BaseMemory?
+    actor: PydanticUser,
     archival_memory: Optional[ArchivalMemory] = None,
-    recall_memory: Optional[RecallMemory] = None,
+    message_manager: Optional[MessageManager] = None,
     user_defined_variables: Optional[dict] = None,
     append_icm_if_missing: bool = True,
     template_format: Literal["f-string", "mustache", "jinja2"] = "f-string",
@@ -129,9 +135,11 @@ def compile_system_message(
     else:
         # TODO should this all put into the memory.__repr__ function?
         memory_metadata_string = compile_memory_metadata_block(
+            actor=actor,
+            agent_id=agent_id,
             memory_edit_timestamp=in_context_memory_last_edit,
             archival_memory=archival_memory,
-            recall_memory=recall_memory,
+            message_manager=message_manager,
         )
         full_memory_string = memory_metadata_string + "\n" + in_context_memory.compile()
 
@@ -164,9 +172,11 @@ def compile_system_message(
 def initialize_message_sequence(
     model: str,
     system: str,
+    agent_id: str,
     memory: Memory,
+    actor: PydanticUser,
     archival_memory: Optional[ArchivalMemory] = None,
-    recall_memory: Optional[RecallMemory] = None,
+    message_manager: Optional[MessageManager] = None,
     memory_edit_timestamp: Optional[datetime.datetime] = None,
     include_initial_boot_message: bool = True,
 ) -> List[dict]:
@@ -177,11 +187,13 @@ def initialize_message_sequence(
     # system, memory, memory_edit_timestamp, archival_memory=archival_memory, recall_memory=recall_memory
     # )
     full_system_message = compile_system_message(
+        agent_id=agent_id,
         system_prompt=system,
         in_context_memory=memory,
         in_context_memory_last_edit=memory_edit_timestamp,
+        actor=actor,
         archival_memory=archival_memory,
-        recall_memory=recall_memory,
+        message_manager=message_manager,
         user_defined_variables=None,
         append_icm_if_missing=True,
     )
@@ -282,7 +294,8 @@ class Agent(BaseAgent):
         self.interface = interface
 
         # Create the persistence manager object based on the AgentState info
-        self.persistence_manager = LocalStateManager(agent_state=self.agent_state)
+        self.archival_memory = EmbeddingArchivalMemory(agent_state)
+        self.message_manager = MessageManager()
 
         # State needed for heartbeat pausing
         self.pause_heartbeats_start = None
@@ -309,9 +322,11 @@ class Agent(BaseAgent):
             init_messages = initialize_message_sequence(
                 model=self.model,
                 system=self.agent_state.system,
+                agent_id=self.agent_state.id,
                 memory=self.agent_state.memory,
+                actor=self.user,
                 archival_memory=None,
-                recall_memory=None,
+                message_manager=None,
                 memory_edit_timestamp=get_utc_time(),
                 include_initial_boot_message=True,
             )
@@ -333,8 +348,10 @@ class Agent(BaseAgent):
                     model=self.model,
                     system=self.agent_state.system,
                     memory=self.agent_state.memory,
+                    agent_id=self.agent_state.id,
+                    actor=self.user,
                     archival_memory=None,
-                    recall_memory=None,
+                    message_manager=None,
                     memory_edit_timestamp=get_utc_time(),
                     include_initial_boot_message=True,
                 )
@@ -356,7 +373,6 @@ class Agent(BaseAgent):
 
             # Put the messages inside the message buffer
             self.messages_total = 0
-            # self._append_to_messages(added_messages=[cast(Message, msg) for msg in init_messages_objs if msg is not None])
             self._append_to_messages(added_messages=init_messages_objs)
             self._validate_message_buffer_is_utc()
 
@@ -413,7 +429,10 @@ class Agent(BaseAgent):
         # TODO: need to have an AgentState object that actually has full access to the block data
         # this is because the sandbox tools need to be able to access block.value to edit this data
         try:
-            if function_name in BASE_TOOLS:
+            # TODO: This is NO BUENO
+            # TODO: Matching purely by names is extremely problematic, users can create tools with these names and run them in the agent loop
+            # TODO: We will have probably have to match the function strings exactly for safety
+            if function_name in BASE_TOOLS or function_name in O1_BASE_TOOLS:
                 # base tools are allowed to access the `Agent` object and run on the database
                 function_args["self"] = self  # need to attach self to arg since it's dynamically linked
                 function_response = function_to_call(**function_args)
@@ -458,10 +477,10 @@ class Agent(BaseAgent):
         for tool in tools:
             try:
                 # WARNING: name may not be consistent?
-                if tool.module:  # execute the whole module
-                    exec(tool.module, env)
-                else:
-                    exec(tool.source_code, env)
+                # if tool.module:  # execute the whole module
+                #    exec(tool.module, env)
+                # else:
+                exec(tool.source_code, env)
                 self.functions_python[tool.json_schema["name"]] = env[tool.json_schema["name"]]
                 self.functions.append(tool.json_schema)
             except Exception:
@@ -474,7 +493,7 @@ class Agent(BaseAgent):
         # Pull the message objects from the database
         message_objs = []
         for msg_id in message_ids:
-            msg_obj = self.persistence_manager.recall_memory.storage.get(msg_id)
+            msg_obj = self.message_manager.get_message_by_id(msg_id, actor=self.user)
             if msg_obj:
                 if isinstance(msg_obj, Message):
                     message_objs.append(msg_obj)
@@ -493,9 +512,10 @@ class Agent(BaseAgent):
         for m in self._messages:
             # assert is_utc_datetime(m.created_at), f"created_at on message for agent {self.agent_state.name} isn't UTC:\n{vars(m)}"
             # TODO eventually do casting via an edit_message function
-            if not is_utc_datetime(m.created_at):
-                printd(f"Warning - created_at on message for agent {self.agent_state.name} isn't UTC (text='{m.text}')")
-                m.created_at = m.created_at.replace(tzinfo=datetime.timezone.utc)
+            if m.created_at:
+                if not is_utc_datetime(m.created_at):
+                    printd(f"Warning - created_at on message for agent {self.agent_state.name} isn't UTC (text='{m.text}')")
+                    m.created_at = m.created_at.replace(tzinfo=datetime.timezone.utc)
 
     def set_message_buffer(self, message_ids: List[str], force_utc: bool = True):
         """Set the messages in the buffer to the message IDs list"""
@@ -522,16 +542,13 @@ class Agent(BaseAgent):
 
     def _trim_messages(self, num):
         """Trim messages from the front, not including the system message"""
-        self.persistence_manager.trim_messages(num)
-
         new_messages = [self._messages[0]] + self._messages[num:]
         self._messages = new_messages
 
     def _prepend_to_messages(self, added_messages: List[Message]):
         """Wrapper around self.messages.prepend to allow additional calls to a state/persistence manager"""
         assert all([isinstance(msg, Message) for msg in added_messages])
-
-        self.persistence_manager.prepend_to_messages(added_messages)
+        self.message_manager.create_many_messages(added_messages, actor=self.user)
 
         new_messages = [self._messages[0]] + added_messages + self._messages[1:]  # prepend (no system)
         self._messages = new_messages
@@ -540,8 +557,7 @@ class Agent(BaseAgent):
     def _append_to_messages(self, added_messages: List[Message]):
         """Wrapper around self.messages.append to allow additional calls to a state/persistence manager"""
         assert all([isinstance(msg, Message) for msg in added_messages])
-
-        self.persistence_manager.append_to_messages(added_messages)
+        self.message_manager.create_many_messages(added_messages, actor=self.user)
 
         # strip extra metadata if it exists
         # for msg in added_messages:
@@ -885,7 +901,6 @@ class Agent(BaseAgent):
                 messages=next_input_message,
                 **kwargs,
             )
-            step_response.messages
             heartbeat_request = step_response.heartbeat_request
             function_failed = step_response.function_failed
             token_warning = step_response.in_context_memory_warning
@@ -1247,7 +1262,7 @@ class Agent(BaseAgent):
         assert new_system_message_obj.role == "system", new_system_message_obj
         assert self._messages[0].role == "system", self._messages
 
-        self.persistence_manager.swap_system_message(new_system_message_obj)
+        self.message_manager.create_message(new_system_message_obj, actor=self.user)
 
         new_messages = [new_system_message_obj] + self._messages[1:]  # swap index 0 (system)
         self._messages = new_messages
@@ -1280,11 +1295,13 @@ class Agent(BaseAgent):
 
         # update memory (TODO: potentially update recall/archival stats seperately)
         new_system_message_str = compile_system_message(
+            agent_id=self.agent_state.id,
             system_prompt=self.agent_state.system,
             in_context_memory=self.agent_state.memory,
             in_context_memory_last_edit=memory_edit_timestamp,
-            archival_memory=self.persistence_manager.archival_memory,
-            recall_memory=self.persistence_manager.recall_memory,
+            actor=self.user,
+            archival_memory=self.archival_memory,
+            message_manager=self.message_manager,
             user_defined_variables=None,
             append_icm_if_missing=True,
         )
@@ -1370,55 +1387,29 @@ class Agent(BaseAgent):
                 # passage.id = create_uuid_from_string(f"{source_id}_{str(passage.agent_id)}_{passage.text}")
 
             # insert into agent archival memory
-            self.persistence_manager.archival_memory.storage.insert_many(passages)
+            self.archival_memory.storage.insert_many(passages)
             all_passages += passages
 
         assert size == len(all_passages), f"Expected {size} passages, but only got {len(all_passages)}"
 
         # save destination storage
-        self.persistence_manager.archival_memory.storage.save()
+        self.archival_memory.storage.save()
 
         # attach to agent
         source = SourceManager().get_source_by_id(source_id=source_id, actor=user)
         assert source is not None, f"Source {source_id} not found in metadata store"
         ms.attach_source(agent_id=self.agent_state.id, source_id=source_id, user_id=self.agent_state.user_id)
 
-        total_agent_passages = self.persistence_manager.archival_memory.storage.size()
+        total_agent_passages = self.archival_memory.storage.size()
 
         printd(
             f"Attached data source {source.name} to agent {self.agent_state.name}, consisting of {len(all_passages)}. Agent now has {total_agent_passages} embeddings in archival memory.",
         )
 
-    def update_message(self, request: UpdateMessage) -> Message:
+    def update_message(self, message_id: str, request: MessageUpdate) -> Message:
         """Update the details of a message associated with an agent"""
-
-        message = self.persistence_manager.recall_memory.storage.get(id=request.id)
-        if message is None:
-            raise ValueError(f"Message with id {request.id} not found")
-        assert isinstance(message, Message), f"Message is not a Message object: {type(message)}"
-
-        # Override fields
-        # NOTE: we try to do some sanity checking here (see asserts), but it's not foolproof
-        if request.role:
-            message.role = request.role
-        if request.text:
-            message.text = request.text
-        if request.name:
-            message.name = request.name
-        if request.tool_calls:
-            assert message.role == MessageRole.assistant, "Tool calls can only be added to assistant messages"
-            message.tool_calls = request.tool_calls
-        if request.tool_call_id:
-            assert message.role == MessageRole.tool, "tool_call_id can only be added to tool messages"
-            message.tool_call_id = request.tool_call_id
-
         # Save the updated message
-        self.persistence_manager.recall_memory.storage.update(record=message)
-
-        # Return the updated message
-        updated_message = self.persistence_manager.recall_memory.storage.get(id=message.id)
-        if updated_message is None:
-            raise ValueError(f"Error persisting message - message with id {request.id} not found")
+        updated_message = self.message_manager.update_message_by_id(message_id=message_id, message_update=request, actor=self.user)
         return updated_message
 
     # TODO(sarah): should we be creating a new message here, or just editing a message?
@@ -1428,10 +1419,10 @@ class Agent(BaseAgent):
             msg_obj = self._messages[x]
             if msg_obj.role == MessageRole.assistant:
                 updated_message = self.update_message(
-                    request=UpdateMessage(
-                        id=msg_obj.id,
+                    message_id=msg_obj.id,
+                    request=MessageUpdate(
                         text=new_thought,
-                    )
+                    ),
                 )
                 self.refresh_message_buffer()
                 return updated_message
@@ -1470,10 +1461,10 @@ class Agent(BaseAgent):
 
                     # Write the update to the DB
                     updated_message = self.update_message(
-                        request=UpdateMessage(
-                            id=message_obj.id,
+                        message_id=message_obj.id,
+                        request=MessageUpdate(
                             tool_calls=message_obj.tool_calls,
-                        )
+                        ),
                     )
                     self.refresh_message_buffer()
                     return updated_message
@@ -1496,7 +1487,7 @@ class Agent(BaseAgent):
                 deleted_message = self._messages.pop()
                 # then also remove it from recall storage
                 try:
-                    self.persistence_manager.recall_memory.storage.delete(filters={"id": deleted_message.id})
+                    self.message_manager.delete_message_by_id(deleted_message.id, actor=self.user)
                     popped_messages.append(deleted_message)
                 except Exception as e:
                     warnings.warn(f"Error deleting message {deleted_message.id} from recall memory: {e}")
@@ -1522,7 +1513,6 @@ class Agent(BaseAgent):
 
     def retry_message(self) -> List[Message]:
         """Retry / regenerate the last message"""
-
         self.pop_until_user()
         user_message = self.pop_message(count=1)[0]
         assert user_message.text is not None, "User message text is None"
@@ -1569,12 +1559,14 @@ class Agent(BaseAgent):
                 num_tokens_from_messages(messages=messages_openai_format[1:], model=self.model) if len(messages_openai_format) > 1 else 0
             )
 
-        num_archival_memory = self.persistence_manager.archival_memory.storage.size()
-        num_recall_memory = self.persistence_manager.recall_memory.storage.size()
+        num_archival_memory = self.archival_memory.storage.size()
+        message_manager_size = self.message_manager.size(actor=self.user, agent_id=self.agent_state.id)
         external_memory_summary = compile_memory_metadata_block(
+            actor=self.user,
+            agent_id=self.agent_state.id,
             memory_edit_timestamp=get_utc_time(),  # dummy timestamp
-            archival_memory=self.persistence_manager.archival_memory,
-            recall_memory=self.persistence_manager.recall_memory,
+            archival_memory=self.archival_memory,
+            message_manager=self.message_manager,
         )
         num_tokens_external_memory_summary = count_tokens(external_memory_summary)
 
@@ -1600,7 +1592,7 @@ class Agent(BaseAgent):
             # context window breakdown (in messages)
             num_messages=len(self._messages),
             num_archival_memory=num_archival_memory,
-            num_recall_memory=num_recall_memory,
+            num_recall_memory=message_manager_size,
             num_tokens_external_memory_summary=num_tokens_external_memory_summary,
             # top-level information
             context_window_size_max=self.agent_state.llm_config.context_window,

{letta_nightly-0.6.1.dev20241206104246 → letta_nightly-0.6.1.dev20241208104134}/letta/agent_store/db.py

@@ -27,13 +27,11 @@ from tqdm import tqdm
 from letta.agent_store.storage import StorageConnector, TableType
 from letta.config import LettaConfig
 from letta.constants import MAX_EMBEDDING_DIM
-from letta.metadata import EmbeddingConfigColumn, ToolCallColumn
+from letta.metadata import EmbeddingConfigColumn
 from letta.orm.base import Base
 from letta.orm.file import FileMetadata as FileMetadataModel
 
 # from letta.schemas.message import Message, Passage, Record, RecordType, ToolCall
-from letta.schemas.message import Message
-from letta.schemas.openai.chat_completions import ToolCall
 from letta.schemas.passage import Passage
 from letta.settings import settings
 
@@ -69,69 +67,6 @@ class CommonVector(TypeDecorator):
         return np.frombuffer(value, dtype=np.float32)
 
 
-class MessageModel(Base):
-    """Defines data model for storing Message objects"""
-
-    __tablename__ = "messages"
-    __table_args__ = {"extend_existing": True}
-
-    # Assuming message_id is the primary key
-    id = Column(String, primary_key=True)
-    user_id = Column(String, nullable=False)
-    agent_id = Column(String, nullable=False)
-
-    # openai info
-    role = Column(String, nullable=False)
-    text = Column(String)  # optional: can be null if function call
-    model = Column(String)  # optional: can be null if LLM backend doesn't require specifying
-    name = Column(String)  # optional: multi-agent only
-
-    # tool call request info
-    # if role == "assistant", this MAY be specified
-    # if role != "assistant", this must be null
-    # TODO align with OpenAI spec of multiple tool calls
-    # tool_calls = Column(ToolCallColumn)
-    tool_calls = Column(ToolCallColumn)
-
-    # tool call response info
-    # if role == "tool", then this must be specified
-    # if role != "tool", this must be null
-    tool_call_id = Column(String)
-
-    # Add a datetime column, with default value as the current time
-    created_at = Column(DateTime(timezone=True))
-    Index("message_idx_user", user_id, agent_id),
-
-    def __repr__(self):
-        return f"<Message(message_id='{self.id}', text='{self.text}')>"
-
-    def to_record(self):
-        # calls = (
-        #    [ToolCall(id=tool_call["id"], function=ToolCallFunction(**tool_call["function"])) for tool_call in self.tool_calls]
-        #    if self.tool_calls
-        #    else None
-        # )
-        # if calls:
-        #    assert isinstance(calls[0], ToolCall)
-        if self.tool_calls and len(self.tool_calls) > 0:
-            assert isinstance(self.tool_calls[0], ToolCall), type(self.tool_calls[0])
-            for tool in self.tool_calls:
-                assert isinstance(tool, ToolCall), type(tool)
-        return Message(
-            user_id=self.user_id,
-            agent_id=self.agent_id,
-            role=self.role,
-            name=self.name,
-            text=self.text,
-            model=self.model,
-            # tool_calls=[ToolCall(id=tool_call["id"], function=ToolCallFunction(**tool_call["function"])) for tool_call in self.tool_calls] if self.tool_calls else None,
-            tool_calls=self.tool_calls,
-            tool_call_id=self.tool_call_id,
-            created_at=self.created_at,
-            id=self.id,
-        )
-
-
 class PassageModel(Base):
     """Defines data model for storing Passages (consisting of text, embedding)"""
 
@@ -367,11 +302,6 @@ class PostgresStorageConnector(SQLStorageConnector):
             self.db_model = PassageModel
             if self.config.archival_storage_uri is None:
                 raise ValueError(f"Must specify archival_storage_uri in config {self.config.config_path}")
-        elif table_type == TableType.RECALL_MEMORY:
-            self.uri = self.config.recall_storage_uri
-            self.db_model = MessageModel
-            if self.config.recall_storage_uri is None:
-                raise ValueError(f"Must specify recall_storage_uri in config {self.config.config_path}")
         elif table_type == TableType.FILES:
             self.uri = self.config.metadata_storage_uri
             self.db_model = FileMetadataModel
@@ -490,12 +420,6 @@ class SQLLiteStorageConnector(SQLStorageConnector):
         # get storage URI
         if table_type == TableType.ARCHIVAL_MEMORY or table_type == TableType.PASSAGES:
             raise ValueError(f"Table type {table_type} not implemented")
-        elif table_type == TableType.RECALL_MEMORY:
-            # TODO: eventually implement URI option
-            self.path = self.config.recall_storage_path
-            if self.path is None:
-                raise ValueError(f"Must specify recall_storage_path in config.")
-            self.db_model = MessageModel
         elif table_type == TableType.FILES:
             self.path = self.config.metadata_storage_path
             if self.path is None:

{letta_nightly-0.6.1.dev20241206104246 → letta_nightly-0.6.1.dev20241208104134}/letta/agent_store/storage.py

@@ -110,11 +110,6 @@ class StorageConnector:
             from letta.agent_store.qdrant import QdrantStorageConnector
 
             return QdrantStorageConnector(table_type, config, user_id, agent_id)
-        # TODO: add back
-        # elif storage_type == "lancedb":
-        #    from letta.agent_store.db import LanceDBConnector
-
-        #    return LanceDBConnector(agent_config=agent_config, table_type=table_type)
 
         elif storage_type == "sqlite":
             from letta.agent_store.db import SQLLiteStorageConnector

{letta_nightly-0.6.1.dev20241206104246 → letta_nightly-0.6.1.dev20241208104134}/letta/cli/cli.py

@@ -51,7 +51,6 @@ def server(
     port: Annotated[Optional[int], typer.Option(help="Port to run the server on")] = None,
     host: Annotated[Optional[str], typer.Option(help="Host to run the server on (default to localhost)")] = None,
     debug: Annotated[bool, typer.Option(help="Turn debugging output on")] = False,
-    ade: Annotated[bool, typer.Option(help="Allows remote access")] = False,
     secure: Annotated[bool, typer.Option(help="Adds simple security access")] = False,
 ):
     """Launch a Letta server process"""
@@ -171,7 +170,6 @@ def run(
         # printd("State path:", agent_config.save_state_dir())
         # printd("Persistent manager path:", agent_config.save_persistence_manager_dir())
         # printd("Index path:", agent_config.save_agent_index_dir())
-        # persistence_manager = LocalStateManager(agent_config).load() # TODO: implement load
         # TODO: load prior agent state
 
         # Allow overriding model specifics (model, model wrapper, model endpoint IP + type, context_window)
@@ -372,8 +370,7 @@ def delete_agent(
         sys.exit(1)
 
 
-def version():
+def version() -> str:
     import letta
 
-    print(letta.__version__)
     return letta.__version__

{letta_nightly-0.6.1.dev20241206104246 → letta_nightly-0.6.1.dev20241208104134}/letta/client/client.py

@@ -22,7 +22,7 @@ from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import JobStatus, MessageRole
 from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
-from letta.schemas.letta_request import LettaRequest
+from letta.schemas.letta_request import LettaRequest, LettaStreamingRequest
 from letta.schemas.letta_response import LettaResponse, LettaStreamingResponse
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import (
@@ -32,7 +32,7 @@ from letta.schemas.memory import (
     Memory,
     RecallMemorySummary,
 )
-from letta.schemas.message import Message, MessageCreate, UpdateMessage
+from letta.schemas.message import Message, MessageCreate, MessageUpdate
 from letta.schemas.openai.chat_completions import ToolCall
 from letta.schemas.organization import Organization
 from letta.schemas.passage import Passage
@@ -586,8 +586,7 @@ class RESTClient(AbstractClient):
         tool_calls: Optional[List[ToolCall]] = None,
         tool_call_id: Optional[str] = None,
     ) -> Message:
-        request = UpdateMessage(
-            id=message_id,
+        request = MessageUpdate(
             role=role,
             text=text,
             name=name,
@@ -965,8 +964,10 @@ class RESTClient(AbstractClient):
         if stream_tokens or stream_steps:
             from letta.client.streaming import _sse_post
 
+            request = LettaStreamingRequest(messages=messages, stream_tokens=stream_tokens)
             return _sse_post(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/messages/stream", request.model_dump(), self.headers)
         else:
+            request = LettaRequest(messages=messages)
             response = requests.post(
                 f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/messages", json=request.model_dump(), headers=self.headers
             )
@@ -2146,8 +2147,8 @@ class LocalClient(AbstractClient):
     ) -> Message:
         message = self.server.update_agent_message(
             agent_id=agent_id,
-            request=UpdateMessage(
-                id=message_id,
+            message_id=message_id,
+            request=MessageUpdate(
                 role=role,
                 text=text,
                 name=name,
@@ -2683,7 +2684,7 @@ class LocalClient(AbstractClient):
         return self.server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=self.user)
 
     def load_composio_tool(self, action: "ActionType") -> Tool:
-        tool_create = ToolCreate.from_composio(action=action)
+        tool_create = ToolCreate.from_composio(action_name=action.name)
         return self.server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=self.user)
 
     def create_tool(
@@ -3054,16 +3055,13 @@ class LocalClient(AbstractClient):
 
     # recall memory
 
-    def get_messages(
-        self, agent_id: str, before: Optional[str] = None, after: Optional[str] = None, limit: Optional[int] = 1000
-    ) -> List[Message]:
+    def get_messages(self, agent_id: str, cursor: Optional[str] = None, limit: Optional[int] = 1000) -> List[Message]:
         """
         Get messages from an agent with pagination.
 
         Args:
             agent_id (str): ID of the agent
-            before (str): Get messages before a certain time
-            after (str): Get messages after a certain time
+            cursor (str): Get messages after a certain time
             limit (int): Limit number of messages
 
         Returns:
@@ -3074,8 +3072,7 @@ class LocalClient(AbstractClient):
         return self.server.get_agent_recall_cursor(
             user_id=self.user_id,
             agent_id=agent_id,
-            before=before,
-            after=after,
+            cursor=cursor,
             limit=limit,
             reverse=True,
         )

{letta_nightly-0.6.1.dev20241206104246 → letta_nightly-0.6.1.dev20241208104134}/letta/constants.py

@@ -38,6 +38,7 @@ 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"]
+O1_BASE_TOOLS = ["send_thinking_message", "send_final_message"]
 # Base memory tools CAN be edited, and are added by default by the server
 BASE_MEMORY_TOOLS = ["core_memory_append", "core_memory_replace"]