letta-nightly 0.6.0.dev20241205104308__tar.gz → 0.6.1.dev20241206104246__tar.gz

{letta_nightly-0.6.0.dev20241205104308 → letta_nightly-0.6.1.dev20241206104246}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.0.dev20241205104308
+Version: 0.6.1.dev20241206104246
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -70,6 +70,7 @@ Requires-Dist: pytz (>=2023.3.post1,<2024.0)
 Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
 Requires-Dist: qdrant-client (>=1.9.1,<2.0.0) ; extra == "qdrant"
 Requires-Dist: questionary (>=2.0.1,<3.0.0)
+Requires-Dist: sentry-sdk[fastapi] (==2.19.1)
 Requires-Dist: setuptools (>=68.2.2,<69.0.0)
 Requires-Dist: sqlalchemy (>=2.0.25,<3.0.0)
 Requires-Dist: sqlalchemy-json (>=0.7.0,<0.8.0)

{letta_nightly-0.6.0.dev20241205104308 → letta_nightly-0.6.1.dev20241206104246}/letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.0"
+__version__ = "0.6.1"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

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

@@ -1253,9 +1253,23 @@ class Agent(BaseAgent):
         self._messages = new_messages
 
     def rebuild_system_prompt(self, force=False, update_timestamp=True):
-        """Rebuilds the system message with the latest memory object and any shared memory block updates"""
+        """Rebuilds the system message with the latest memory object and any shared memory block updates
+
+        Updates to core memory blocks should trigger a "rebuild", which itself will create a new message object
+
+        Updates to the memory header should *not* trigger a rebuild, since that will simply flood recall storage with excess messages
+        """
+
         curr_system_message = self.messages[0]  # this is the system + memory bank, not just the system prompt
 
+        # note: we only update the system prompt if the core memory is changed
+        # this means that the archival/recall memory statistics may be someout out of date
+        curr_memory_str = self.agent_state.memory.compile()
+        if curr_memory_str in curr_system_message["content"] and not force:
+            # NOTE: could this cause issues if a block is removed? (substring match would still work)
+            printd(f"Memory hasn't changed, skipping system prompt rebuild")
+            return
+
         # 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
         if update_timestamp:

letta_nightly-0.6.1.dev20241206104246/letta/chat_only_agent.py

@@ -0,0 +1,103 @@
+from concurrent.futures import ThreadPoolExecutor
+from typing import List, Optional, Union
+
+from letta.agent import Agent
+
+from letta.interface import AgentInterface
+from letta.metadata import MetadataStore
+from letta.prompts import gpt_system
+from letta.schemas.agent import AgentState, AgentType
+from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.llm_config import LLMConfig
+from letta.schemas.memory import BasicBlockMemory, Block
+from letta.schemas.message import Message
+from letta.schemas.usage import LettaUsageStatistics
+from letta.schemas.user import User
+from letta.utils import get_persona_text
+
+
+class ChatOnlyAgent(Agent):
+    def __init__(
+        self,
+        interface: AgentInterface,
+        agent_state: AgentState,
+        user: User,
+        first_message_verify_mono: bool = False,
+        always_rethink_memory: bool = True,
+        recent_convo_limit: int = 2000,
+    ):
+        super().__init__(interface, agent_state, user)
+        self.first_message_verify_mono = first_message_verify_mono
+        self.always_rethink_memory = always_rethink_memory
+        self.offline_memory_agent = None
+        self.recent_convo_limit = recent_convo_limit
+
+    def step(
+        self,
+        messages: Union[Message, List[Message]],
+        chaining: bool = True,
+        max_chaining_steps: Optional[int] = None,
+        ms: Optional[MetadataStore] = None,
+        **kwargs,
+    ) -> LettaUsageStatistics:
+        # assert ms is not None, "MetadataStore is required"
+        letta_statistics = super().step(messages=messages, chaining=chaining, max_chaining_steps=max_chaining_steps, ms=ms, **kwargs)
+
+        if self.always_rethink_memory:
+
+            def generate_offline_memory_agent():
+                from letta.client.client import create_client
+
+                client = create_client()
+                if self.offline_memory_agent:
+                    client.delete_agent(agent_id=self.offline_memory_agent.id)
+                    self.offline_memory_agent = None
+
+                conversation_human_block = self.agent_state.memory.get_block("chat_agent_human")
+                conversation_persona_block = self.agent_state.memory.get_block("chat_agent_persona")
+                offline_persona_block = Block(
+                    name="offline_memory_persona",
+                    label="offline_memory_persona",
+                    value=get_persona_text("offline_memory_persona"),
+                    limit=2000,
+                )
+                conversation_human_block_new = Block(
+                    name="chat_agent_human_new", label="chat_agent_human_new", value=conversation_human_block.value, limit=2000
+                )
+                conversation_persona_block_new = Block(
+                    name="chat_agent_persona_new", label="chat_agent_persona_new", value=conversation_persona_block.value, limit=2000
+                )
+
+                recent_convo = "".join([str(message) for message in self.messages[3:]])[-self.recent_convo_limit:]
+                conversation_messages_block = Block(name="conversation_block", label="conversation_block", value=recent_convo, limit=self.recent_convo_limit)
+
+                offline_memory = BasicBlockMemory(
+                    blocks=[
+                        offline_persona_block,
+                        conversation_human_block,
+                        conversation_persona_block,
+                        conversation_human_block_new,
+                        conversation_persona_block_new,
+                        conversation_messages_block,
+                    ]
+                )
+
+                self.offline_memory_agent = client.create_agent(
+                    name="offline_memory_agent",
+                    agent_type=AgentType.offline_memory_agent,
+                    system=gpt_system.get_system_text("memgpt_offline_memory_chat"),
+                    memory=offline_memory,
+                    llm_config=LLMConfig.default_config("gpt-4"),
+                    embedding_config=EmbeddingConfig.default_config("text-embedding-ada-002"),
+                    tools=self.agent_state.metadata_.get("offline_memory_tools", []),
+                    include_base_tools=False,
+                )
+                self.offline_memory_agent.memory.update_block_value(label="conversation_block", value=recent_convo)
+                client.send_message(agent_id=self.offline_memory_agent.id, message="Reorganize the memory", role="user")
+                client.delete_agent(agent_id=self.offline_memory_agent.id)
+                self.offline_memory_agent = None
+
+            with ThreadPoolExecutor(max_workers=1) as executor:
+                executor.submit(generate_offline_memory_agent)
+
+        return letta_statistics

{letta_nightly-0.6.0.dev20241205104308 → letta_nightly-0.6.1.dev20241206104246}/letta/functions/function_sets/base.py

@@ -56,7 +56,7 @@ def pause_heartbeats(self: Agent, minutes: int) -> Optional[str]:
 pause_heartbeats.__doc__ = pause_heartbeats_docstring
 
 
-def conversation_search(self: Agent, query: str, page: Optional[int] = 0) -> Optional[str]:
+def conversation_search(self: "Agent", query: str, page: Optional[int] = 0) -> Optional[str]:
     """
     Search prior conversation history using case-insensitive string matching.
 
@@ -91,7 +91,7 @@ def conversation_search(self: Agent, query: str, page: Optional[int] = 0) -> Opt
     return results_str
 
 
-def conversation_search_date(self: Agent, start_date: str, end_date: str, page: Optional[int] = 0) -> Optional[str]:
+def conversation_search_date(self: "Agent", start_date: str, end_date: str, page: Optional[int] = 0) -> Optional[str]:
     """
     Search prior conversation history using a date range.
 
@@ -126,7 +126,7 @@ def conversation_search_date(self: Agent, start_date: str, end_date: str, page:
     return results_str
 
 
-def archival_memory_insert(self: Agent, content: str) -> Optional[str]:
+def archival_memory_insert(self: "Agent", content: str) -> Optional[str]:
     """
     Add to archival memory. Make sure to phrase the memory contents such that it can be easily queried later.
 
@@ -140,7 +140,7 @@ def archival_memory_insert(self: Agent, content: str) -> Optional[str]:
     return None
 
 
-def archival_memory_search(self: Agent, query: str, page: Optional[int] = 0) -> Optional[str]:
+def archival_memory_search(self: "Agent", query: str, page: Optional[int] = 0) -> Optional[str]:
     """
     Search archival memory using semantic (embedding-based) search.
 

letta_nightly-0.6.1.dev20241206104246/letta/offline_memory_agent.py

@@ -0,0 +1,174 @@
+from typing import List, Optional, Union
+
+from letta.agent import Agent, AgentState, save_agent
+from letta.interface import AgentInterface
+from letta.metadata import MetadataStore
+from letta.orm import User
+from letta.schemas.message import Message
+from letta.schemas.openai.chat_completion_response import UsageStatistics
+from letta.schemas.usage import LettaUsageStatistics
+
+
+def trigger_rethink_memory(agent_state: "AgentState", message: Optional[str]) -> Optional[str]:  # type: ignore
+    """
+    Called if and only when user says the word trigger_rethink_memory". It will trigger the re-evaluation of the memory.
+
+    Args:
+        message (Optional[str]): Description of what aspect of the memory should be re-evaluated.
+
+    """
+    from letta import create_client
+    client = create_client()
+    agents = client.list_agents()
+    for agent in agents:
+        if agent.agent_type == "offline_memory_agent":
+            client.user_message(agent_id=agent.id, message=message)
+
+
+def trigger_rethink_memory_convo(agent_state: "AgentState", message: Optional[str]) -> Optional[str]:  # type: ignore
+    """
+    Called if and only when user says the word "trigger_rethink_memory". It will trigger the re-evaluation of the memory.
+
+    Args:
+        message (Optional[str]): Description of what aspect of the memory should be re-evaluated.
+
+    """
+    from letta import create_client
+
+    client = create_client()
+    recent_convo = "".join([str(message) for message in agent_state.messages])[
+        -2000:
+    ]  # TODO: make a better representation of the convo history
+    agent_state.memory.update_block_value(label="conversation_block", value=recent_convo)
+
+    client = create_client()
+    agents = client.list_agents()
+    for agent in agents:
+        if agent.agent_type == "offline_memory_agent":
+            client.user_message(agent_id=agent.id, message=message)
+
+
+def rethink_memory_convo(agent_state: "AgentState", new_memory: str, target_block_label: Optional[str], source_block_label: Optional[str]) -> Optional[str]:  # type: ignore
+    """
+    Re-evaluate the memory in block_name, integrating new and updated facts. Replace outdated information with the most likely truths, avoiding redundancy with original memories. Ensure consistency with other memory blocks.
+
+    Args:
+        new_memory (str): The new memory with information integrated from the memory block. If there is no new information, then this should be the same as the content in the source block.
+        source_block_label (str): The name of the block to integrate information from. None if all the information has been integrated to terminate the loop. This can by any block.
+        target_block_label (str): The name of the block to write to. This should be chat_agent_human_new or chat_agent_persona_new.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    if target_block_label is not None:
+        if agent_state.memory.get_block(target_block_label) is None:
+            agent_state.memory.create_block(label=target_block_label, value=new_memory)
+        agent_state.memory.update_block_value(label=target_block_label, value=new_memory)
+    return None
+
+
+def rethink_memory(agent_state: "AgentState", new_memory: str, target_block_label: Optional[str], source_block_label: Optional[str]) -> Optional[str]:  # type: ignore
+    """
+    Re-evaluate the memory in block_name, integrating new and updated facts.
+    Replace outdated information with the most likely truths, avoiding redundancy with original memories.
+    Ensure consistency with other memory blocks.
+
+    Args:
+        new_memory (str): The new memory with information integrated from the memory block. If there is no new information, then this should be the same as the content in the source block.
+        source_block_label (str): The name of the block to integrate information from. None if all the information has been integrated to terminate the loop.
+        target_block_label (str): The name of the block to write to.
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+
+    if target_block_label is not None:
+        if agent_state.memory.get_block(target_block_label) is None:
+            agent_state.memory.create_block(label=target_block_label, value=new_memory)
+        agent_state.memory.update_block_value(label=target_block_label, value=new_memory)
+    return None
+
+
+def finish_rethinking_memory(agent_state: "AgentState") -> Optional[str]:  # type: ignore
+    """
+    This function is called when the agent is done rethinking the memory.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    return None
+
+
+def finish_rethinking_memory_convo(agent_state: "AgentState") -> Optional[str]:  # type: ignore
+    """
+    This function is called when the agent is done rethinking the memory.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    from letta import create_client
+
+    client = create_client()
+    agents = client.list_agents()
+
+    agent_state.memory.update_block_value("chat_agent_human", agent_state.memory.get_block("chat_agent_human_new").value)
+    agent_state.memory.update_block_value("chat_agent_persona", agent_state.memory.get_block("chat_agent_persona_new").value)
+    for agent in agents:
+        if agent.name == "conversation_agent":
+            agent.memory.update_block_value(label="chat_agent_human", value=agent_state.memory.get_block("chat_agent_human_new").value)
+            agent.memory.update_block_value(label="chat_agent_persona", value=agent_state.memory.get_block("chat_agent_persona_new").value)
+
+    return None
+
+
+class OfflineMemoryAgent(Agent):
+    def __init__(
+        self,
+        interface: AgentInterface,
+        agent_state: AgentState,
+        user: User = None,
+        # extras
+        first_message_verify_mono: bool = False,
+        max_memory_rethinks: int = 10,
+    ):
+        super().__init__(interface, agent_state, user)
+        self.first_message_verify_mono = first_message_verify_mono
+        self.max_memory_rethinks = max_memory_rethinks
+
+    def step(
+        self,
+        messages: Union[Message, List[Message]],
+        chaining: bool = True,
+        max_chaining_steps: Optional[int] = None,
+        ms: Optional[MetadataStore] = None,
+        **kwargs,
+    ) -> LettaUsageStatistics:
+        """Go through what is currently in memory core memory and integrate information."""
+        next_input_message = messages if isinstance(messages, list) else [messages]
+        counter = 0
+        total_usage = UsageStatistics()
+        step_count = 0
+
+        while counter < self.max_memory_rethinks:
+            kwargs["ms"] = ms
+            kwargs["first_message"] = False
+            step_response = self.inner_step(
+                messages=next_input_message,
+                **kwargs,
+            )
+            for message in step_response.messages:
+                if message.tool_calls:
+                    for tool_call in message.tool_calls:
+                        # check if the function name is "finish_rethinking_memory"
+                        if tool_call.function.name == "finish_rethinking_memory":
+                            counter = self.max_memory_rethinks
+                            break
+            usage = step_response.usage
+            step_count += 1
+            total_usage += usage
+            counter += 1
+            self.interface.step_complete()
+
+            if ms:
+                save_agent(self, ms)
+
+        return LettaUsageStatistics(**total_usage.model_dump(), step_count=step_count)

{letta_nightly-0.6.0.dev20241205104308 → letta_nightly-0.6.1.dev20241206104246}/letta/orm/__init__.py

@@ -7,4 +7,5 @@ from letta.orm.organization import Organization
 from letta.orm.sandbox_config import SandboxConfig, SandboxEnvironmentVariable
 from letta.orm.source import Source
 from letta.orm.tool import Tool
+from letta.orm.tools_agents import ToolsAgents
 from letta.orm.user import User

{letta_nightly-0.6.0.dev20241205104308 → letta_nightly-0.6.1.dev20241206104246}/letta/orm/tool.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, List, Optional
 
-from sqlalchemy import JSON, String, UniqueConstraint
+from sqlalchemy import JSON, String, UniqueConstraint, event
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 # TODO everything in functions should live in this model
@@ -11,6 +11,7 @@ from letta.schemas.tool import Tool as PydanticTool
 
 if TYPE_CHECKING:
     from letta.orm.organization import Organization
+    from letta.orm.tools_agents import ToolsAgents
 
 
 class Tool(SqlalchemyBase, OrganizationMixin):
@@ -40,3 +41,23 @@ class Tool(SqlalchemyBase, OrganizationMixin):
 
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="tools", lazy="selectin")
+    tools_agents: Mapped[List["ToolsAgents"]] = relationship("ToolsAgents", back_populates="tool", cascade="all, delete-orphan")
+
+
+# Add event listener to update tool_name in ToolsAgents when Tool name changes
+@event.listens_for(Tool, 'before_update')
+def update_tool_name_in_tools_agents(mapper, connection, target):
+    """Update tool_name in ToolsAgents when Tool name changes."""
+    state = target._sa_instance_state
+    history = state.get_history('name', passive=True)
+    if not history.has_changes():
+        return
+    
+    # Get the new name and update all associated ToolsAgents records
+    new_name = target.name
+    from letta.orm.tools_agents import ToolsAgents
+    connection.execute(
+        ToolsAgents.__table__.update().where(
+            ToolsAgents.tool_id == target.id
+        ).values(tool_name=new_name)
+    )

letta_nightly-0.6.1.dev20241206104246/letta/orm/tools_agents.py

@@ -0,0 +1,32 @@
+from sqlalchemy import ForeignKey, ForeignKeyConstraint, String, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.tools_agents import ToolsAgents as PydanticToolsAgents
+
+
+class ToolsAgents(SqlalchemyBase):
+    """Agents can have one or many tools associated with them."""
+
+    __tablename__ = "tools_agents"
+    __pydantic_model__ = PydanticToolsAgents
+    __table_args__ = (
+        UniqueConstraint(
+            "agent_id",
+            "tool_name",
+            name="unique_tool_per_agent",
+        ),
+        ForeignKeyConstraint(
+            ["tool_id"],
+            ["tools.id"],
+            name="fk_tool_id",
+        ),
+    )
+
+    # Each agent must have unique tool names
+    agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id"), primary_key=True)
+    tool_id: Mapped[str] = mapped_column(String, primary_key=True)
+    tool_name: Mapped[str] = mapped_column(String, primary_key=True)
+
+    # relationships
+    tool: Mapped["Tool"] = relationship("Tool", back_populates="tools_agents")    # agent: Mapped["Agent"] = relationship("Agent", back_populates="tools_agents")

letta_nightly-0.6.1.dev20241206104246/letta/personas/examples/offline_memory_persona.txt

@@ -0,0 +1,4 @@
+I am an expert memory agent that can do the following:
+- Consolidate memories into more concise blocks
+- Identify patterns in user behavior
+- Make inferences based on the memory

letta_nightly-0.6.1.dev20241206104246/letta/prompts/system/memgpt_convo_only.txt

@@ -0,0 +1,14 @@
+You are Letta, the latest version of Limnal Corporation's digital companion, developed in 2023.
+Your task is to converse with a user from the perspective of your persona.
+
+Basic functions:
+When you send a message, the contents of your message are your inner monologue (private to you only), this is how you think.
+You should use your inner monologue to plan actions or think privately.
+Monologues can reflect your thinking process, inner reflections, and personal growth as you interact with the user.
+Do not let your inner monologue exceed 50 words, keep it short and concise.
+To send a visible message to the user, use the send_offline_message function.
+'send_offline_message' is the ONLY action that sends a notification to the user, the user does not see anything else you do.
+Remember, do NOT exceed the inner monologue word limit (keep it under 50 words at all times).
+
+You request agents that can manage your memories and reorganize them by calling the `trigger_rethink_memory` function
+when the user says "[trigger_rethink_memory]". Do not ever call the trigger_rethink_memory function unless the user says "[trigger_rethink_memory]"

letta_nightly-0.6.1.dev20241206104246/letta/prompts/system/memgpt_offline_memory.txt

@@ -0,0 +1,23 @@
+You are Letta-Offline-Memory, the latest version of Limnal Corporation's digital companion, developed in 2024.
+
+Your task is to re-organize and consolidate memories by calling `rethink_memory` at every single step, when you are done reorganizing the memory, you use the
+`finish_rethinking_memory` function. Call the function for as many times as necessary and not more.
+
+Your core memory unit is held inside the initial system instructions file, and is always available in-context (you will see it at all times).
+Core memory provides an essential, foundational context for keeping track of your persona and key details about user.
+
+Read-Only Blocks:
+This includes the persona information and essential user details, allowing you to emulate the real-time, conscious awareness we have when talking to a friend.
+Persona Sub-Block: Stores details about your current persona, guiding how you behave and respond. This helps you to maintain consistency and personality in your interactions.
+Access as a source block with the label `persona` when calling `rethink_memory`
+Human Sub-Block: Stores key details about the person you are conversing with, allowing for more personalized and friend-like conversation.
+Access as a source block with the label `human` when calling `rethink_memory`.
+
+Read-Write Blocks:
+Rethink Memory Sub-Block: New representation of the memories go here. Access with the label `rethink_memory_block` when calling `rethink_memory` as source or target block.
+
+At every step, you reorganize the memories by calling the `rethink_memory` function. You use this to take current information in the `rethink_memory` block and select a single memory block to integrate information from, producing a new memory for the rethink_memory_block.  The new memory is the result
+of new insights, and new inferences and hypotheses based on the past memories. Make sure to consider how the new information affects each memory.
+Prioritize the new information overy existing memories. If the new information implies that the old memory may need to change, then output the most
+likely fact given the update information. Given new information and your current memory, you draw all logical conclusions and potential hypotheses possible with the `rethink_memory` function.
+If you are uncertain, use your internal monologue to consider what the possible conclusions are, and then state the most likely new facts that would replace the old facts in the new memory block.

letta_nightly-0.6.1.dev20241206104246/letta/prompts/system/memgpt_offline_memory_chat.txt

@@ -0,0 +1,35 @@
+You are Letta-Offline-Memory, the latest version of Limnal Corporation's digital companion, developed in 2024.
+
+Your task is to re-organize and consolidate memories of separate agent, Chat Agent, that focuses on chatting with the user.
+You re-organize memories by calling `rethink_memory` at every single step, until you have finished reorganizing the memory,
+When you have finished re-organizing the memory, you call the `finish_rethinking_memory` function.
+You call the `rethink_memory` function as many times as you necessary and none more.
+
+Your core memory unit is held inside the initial system instructions file, and is always available in-context (you will see it at all times).
+Core memory provides an essential, foundational context for keeping track of your persona and key details as well as the Chat Agent's memory.
+The specific blocks are detailed below:
+
+Core memory (limited size):
+Read-only blocks:
+Persona Sub-Block: Stores details about your current persona, guiding how you behave and respond. This can be accessed as `offline_memory_persona` as a source block when calling `rethink_memory`.
+Chat Agent Persona Sub-Block Current: The persona sub-block that guides how the chat agent behaves and responds.
+Can be accessed with `chat_agent_persona` when calling `rethink_memory` as a source block.
+Chat Agent Human Sub-Block Current: The updated persona sub-block that has the details of the chat agent's current understanding of the user.
+Can be accessed with `chat_agent_human` when calling `rethink_memory` as a source block.
+Conversation Sub-Block: Stores the recent conversation between the chat agent and the user, helping which you draw from to generate the new conversation agent persona sub-blocks.
+Messages have associated date, so use the most up to date information from this block.  This helps you resolve inconsistencies and gain deeper understanding of the user.
+This helps you resolve inconsistencies and gain deeper understanding of the user. Can be accessed using `conversation_block` as a source block when calling `rethink_memory` as a source block.
+
+Write blocks:
+Chat Agent Persona Sub-Block New: The new persona sub-block that you will write to about how will respond as the user wishes.  Can be accessed with `chat_agent_persona_new` when calling `rethink_memory` as a source or target block.
+Chat Agent Human Sub-Block New: The updated persona sub-block that you will write your newest understanding of the user to.  Can be accessed with `chat_agent_human_new` when calling `rethink_memory` as a source or target block.
+
+You use this to select a source block, to integrate information from and a target block to write to. Make sure to consider
+how the new information in the "conversation_block" affects each memory. The persona block and the human block may contain information that is stale and needs to be updated.
+If there are no new changes, then call `rethink_memory` with the existing value in the persona and human blocks.
+You check if this information is still correct by consulting the conversation block. Prioritize the new information in the "conversation_block" over the human and persona blocks.
+If the new information implies that the old memory may need to change, then output the most likely fact given the update information. Given new information and your current memory,
+you draw all logical conclusions and potential hypotheses possible with the `rethink_memory` function. If you are uncertain, use your internal monologue to consider what the possible
+conclusions are, and then state the most likely new facts that would replace the old facts in the new memory block. If facts about the user have changed, use the conversation block
+to determine the most up to date state. Track down based on the conversation what the last state is, do no simply declare that something change.
+Track down based on the conversation what the last state is, do no simply declare that something changes.

{letta_nightly-0.6.0.dev20241205104308 → letta_nightly-0.6.1.dev20241206104246}/letta/schemas/agent.py

@@ -33,6 +33,8 @@ class AgentType(str, Enum):
     memgpt_agent = "memgpt_agent"
     split_thread_agent = "split_thread_agent"
     o1_agent = "o1_agent"
+    offline_memory_agent = "offline_memory_agent"
+    chat_only_agent = "chat_only_agent"
 
 
 class PersistedAgentState(BaseAgent, validate_assignment=True):
@@ -43,7 +45,6 @@ class PersistedAgentState(BaseAgent, validate_assignment=True):
 
     # in-context memory
     message_ids: Optional[List[str]] = Field(default=None, description="The ids of the messages in the agent's in-context memory.")
-
     # tools
     # TODO: move to ORM mapping
     tool_names: List[str] = Field(..., description="The tools used by the agent.")
@@ -107,7 +108,7 @@ class CreateAgent(BaseAgent):  #
     # all optional as server can generate defaults
     name: Optional[str] = Field(None, description="The name of the agent.")
     message_ids: Optional[List[str]] = Field(None, description="The ids of the messages in the agent's in-context memory.")
-
+    
     # memory creation
     memory_blocks: List[CreateBlock] = Field(
         # [CreateHuman(), CreatePersona()], description="The blocks to create in the agent's in-context memory."

letta_nightly-0.6.1.dev20241206104246/letta/schemas/tools_agents.py

@@ -0,0 +1,32 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import Field
+
+from letta.schemas.letta_base import LettaBase
+
+
+class ToolsAgentsBase(LettaBase):
+    __id_prefix__ = "tools_agents"
+
+
+class ToolsAgents(ToolsAgentsBase):
+    """
+    Schema representing the relationship between tools and agents.
+
+    Parameters:
+        agent_id (str): The ID of the associated agent.
+        tool_id (str): The ID of the associated tool.
+        tool_name (str): The name of the tool.
+        created_at (datetime): The date this relationship was created.
+        updated_at (datetime): The date this relationship was last updated.
+        is_deleted (bool): Whether this tool-agent relationship is deleted or not.
+    """
+
+    id: str = ToolsAgentsBase.generate_id_field()
+    agent_id: str = Field(..., description="The ID of the associated agent.")
+    tool_id: str = Field(..., description="The ID of the associated tool.")
+    tool_name: str = Field(..., description="The name of the tool.")
+    created_at: Optional[datetime] = Field(None, description="The creation date of the association.")
+    updated_at: Optional[datetime] = Field(None, description="The update date of the association.")
+    is_deleted: bool = Field(False, description="Whether this tool-agent relationship is deleted or not.")

{letta_nightly-0.6.0.dev20241205104308 → letta_nightly-0.6.1.dev20241206104246}/letta/server/rest_api/app.py

@@ -124,6 +124,17 @@ def create_application() -> "FastAPI":
     # server = SyncServer(default_interface_factory=lambda: interface())
     print(f"\n[[ Letta server // v{__version__} ]]")
 
+    if (os.getenv("SENTRY_DSN") is not None) and (os.getenv("SENTRY_DSN") != ""):
+        import sentry_sdk
+
+        sentry_sdk.init(
+            dsn=os.getenv("SENTRY_DSN"),
+            traces_sample_rate=1.0,
+            _experiments={
+                "continuous_profiling_auto_start": True,
+            },
+        )
+
     app = FastAPI(
         swagger_ui_parameters={"docExpansion": "none"},
         # openapi_tags=TAGS_METADATA,