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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.1.dev20241205211219
+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.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.1.dev20241205211219 → 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.1.dev20241205211219 → 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.1.dev20241205211219 → 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.1.dev20241205211219 → 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.1.dev20241205211219 → 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,

{letta_nightly-0.6.1.dev20241205211219 → letta_nightly-0.6.1.dev20241206104246}/letta/server/server.py

@@ -18,6 +18,7 @@ import letta.system as system
 from letta.agent import Agent, save_agent
 from letta.agent_store.db import attach_base
 from letta.agent_store.storage import StorageConnector, TableType
+from letta.chat_only_agent import ChatOnlyAgent
 from letta.credentials import LettaCredentials
 from letta.data_sources.connectors import DataConnector, load_data
 
@@ -27,6 +28,7 @@ from letta.interface import CLIInterface  # for printing to terminal
 from letta.log import get_logger
 from letta.metadata import MetadataStore
 from letta.o1_agent import O1Agent
+from letta.offline_memory_agent import OfflineMemoryAgent
 from letta.orm import Base
 from letta.orm.errors import NoResultFound
 from letta.prompts import gpt_system
@@ -75,6 +77,7 @@ from letta.schemas.user import User
 from letta.services.agents_tags_manager import AgentsTagsManager
 from letta.services.block_manager import BlockManager
 from letta.services.blocks_agents_manager import BlocksAgentsManager
+from letta.services.tools_agents_manager import ToolsAgentsManager
 from letta.services.job_manager import JobManager
 from letta.services.organization_manager import OrganizationManager
 from letta.services.per_agent_lock_manager import PerAgentLockManager
@@ -257,6 +260,7 @@ class SyncServer(Server):
         self.agents_tags_manager = AgentsTagsManager()
         self.sandbox_config_manager = SandboxConfigManager(tool_settings)
         self.blocks_agents_manager = BlocksAgentsManager()
+        self.tools_agents_manager = ToolsAgentsManager()
         self.job_manager = JobManager()
 
         # Managers that interface with parallelism
@@ -404,15 +408,21 @@ class SyncServer(Server):
             interface = interface or self.default_interface_factory()
             if agent_state.agent_type == AgentType.memgpt_agent:
                 agent = Agent(agent_state=agent_state, interface=interface, user=actor)
-            else:
+            elif agent_state.agent_type == AgentType.o1_agent:
                 agent = O1Agent(agent_state=agent_state, interface=interface, user=actor)
+            elif agent_state.agent_type == AgentType.offline_memory_agent:
+                agent = OfflineMemoryAgent(agent_state=agent_state, interface=interface, user=actor)
+            elif agent_state.agent_type == AgentType.chat_only_agent:
+                agent = ChatOnlyAgent(agent_state=agent_state, interface=interface, user=actor)
+            else: 
+                raise ValueError(f"Invalid agent type {agent_state.agent_type}")
 
             # Rebuild the system prompt - may be linked to new blocks now
             agent.rebuild_system_prompt()
 
             # Persist to agent
             save_agent(agent, self.ms)
-            return agent
+            return agent 
 
     def _step(
         self,
@@ -800,6 +810,10 @@ class SyncServer(Server):
                 request.system = gpt_system.get_system_text("memgpt_chat")
             elif request.agent_type == AgentType.o1_agent:
                 request.system = gpt_system.get_system_text("memgpt_modified_o1")
+            elif request.agent_type == AgentType.offline_memory_agent:
+                request.system = gpt_system.get_system_text("memgpt_offline_memory")
+            elif request.agent_type == AgentType.chat_only_agent:
+                request.system = gpt_system.get_system_text("memgpt_convo_only")
             else:
                 raise ValueError(f"Invalid agent type: {request.agent_type}")
 
@@ -1339,7 +1353,7 @@ class SyncServer(Server):
             records = records[::-1]
 
         return records
-
+      
     def get_server_config(self, include_defaults: bool = False) -> dict:
         """Return the base config"""