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

letta/schemas/enums.py

@@ -33,3 +33,17 @@ class MessageStreamStatus(str, Enum):
     done_generation = "[DONE_GEN]"
     done_step = "[DONE_STEP]"
     done = "[DONE]"
+
+
+class ToolRuleType(str, Enum):
+    """
+    Type of tool rule.
+    """
+
+    # note: some of these should be renamed when we do the data migration
+
+    run_first = "InitToolRule"
+    exit_loop = "TerminalToolRule"  # reasoning loop should exit
+    continue_loop = "continue_loop"  # reasoning loop should continue
+    constrain_child_tools = "ToolRule"
+    require_parent_tools = "require_parent_tools"

letta/schemas/letta_base.py

@@ -63,7 +63,7 @@ class LettaBase(BaseModel):
     @classmethod
     def _id_example(cls, prefix: str):
         """generates an example id for a given prefix"""
-        return [prefix + "-123e4567-e89b-12d3-a456-426614174000"]
+        return f"{prefix}-123e4567-e89b-12d3-a456-426614174000"
 
     @classmethod
     def _id_description(cls, prefix: str):

letta/schemas/letta_request.py

@@ -8,33 +8,21 @@ from letta.schemas.message import Message, MessageCreate
 
 class LettaRequest(BaseModel):
     messages: Union[List[MessageCreate], List[Message]] = Field(..., description="The messages to be sent to the agent.")
-    run_async: bool = Field(default=False, description="Whether to asynchronously send the messages to the agent.")  # TODO: implement
-
-    stream_steps: bool = Field(
-        default=False, description="Flag to determine if the response should be streamed. Set to True for streaming agent steps."
-    )
-    stream_tokens: bool = Field(
-        default=False,
-        description="Flag to determine if individual tokens should be streamed. Set to True for token streaming (requires stream_steps = True).",
-    )
-
-    return_message_object: bool = Field(
-        default=False,
-        description="Set True to return the raw Message object. Set False to return the Message in the format of the Letta API.",
-    )
 
     # Flags to support the use of AssistantMessage message types
 
-    use_assistant_message: bool = Field(
-        default=False,
-        description="[Only applicable if return_message_object is False] If true, returns AssistantMessage objects when the agent calls a designated message tool. If false, return FunctionCallMessage objects for all tool calls.",
-    )
-
-    assistant_message_function_name: str = Field(
+    assistant_message_tool_name: str = Field(
         default=DEFAULT_MESSAGE_TOOL,
-        description="[Only applicable if use_assistant_message is True] The name of the designated message tool.",
+        description="The name of the designated message tool.",
     )
-    assistant_message_function_kwarg: str = Field(
+    assistant_message_tool_kwarg: str = Field(
         default=DEFAULT_MESSAGE_TOOL_KWARG,
-        description="[Only applicable if use_assistant_message is True] The name of the message argument in the designated message tool.",
+        description="The name of the message argument in the designated message tool.",
+    )
+
+
+class LettaStreamingRequest(LettaRequest):
+    stream_tokens: bool = Field(
+        default=False,
+        description="Flag to determine if individual tokens should be streamed. Set to True for token streaming (requires stream_steps = True).",
     )

letta/schemas/letta_response.py

@@ -7,7 +7,6 @@ from pydantic import BaseModel, Field
 
 from letta.schemas.enums import MessageStreamStatus
 from letta.schemas.letta_message import LettaMessage, LettaMessageUnion
-from letta.schemas.message import Message
 from letta.schemas.usage import LettaUsageStatistics
 from letta.utils import json_dumps
 
@@ -24,7 +23,7 @@ class LettaResponse(BaseModel):
         usage (LettaUsageStatistics): The usage statistics
     """
 
-    messages: Union[List[Message], List[LettaMessageUnion]] = Field(..., description="The messages returned by the agent.")
+    messages: List[LettaMessageUnion] = Field(..., description="The messages returned by the agent.")
     usage: LettaUsageStatistics = Field(..., description="The usage statistics of the agent.")
 
     def __str__(self):

letta/schemas/memory.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Dict, List, Optional
+from typing import TYPE_CHECKING, List, Optional
 
 from jinja2 import Template, TemplateSyntaxError
 from pydantic import BaseModel, Field
@@ -55,19 +55,16 @@ class ContextWindowOverview(BaseModel):
 class Memory(BaseModel, validate_assignment=True):
     """
 
-    Represents the in-context memory of the agent. This includes both the `Block` objects (labelled by sections), as well as tools to edit the blocks.
-
-    Attributes:
-        memory (Dict[str, Block]): Mapping from memory block section to memory block.
+    Represents the in-context memory (i.e. Core memory) of the agent. This includes both the `Block` objects (labelled by sections), as well as tools to edit the blocks.
 
     """
 
-    # Memory.memory is a dict mapping from memory block label to memory block.
-    memory: Dict[str, Block] = Field(default_factory=dict, description="Mapping from memory block section to memory block.")
+    # Memory.block contains the list of memory blocks in the core memory
+    blocks: List[Block] = Field(..., description="Memory blocks contained in the agent's in-context memory")
 
     # Memory.template is a Jinja2 template for compiling memory module into a prompt string.
     prompt_template: str = Field(
-        default="{% for block in memory.values() %}"
+        default="{% for block in blocks %}"
         '<{{ block.label }} characters="{{ block.value|length }}/{{ block.limit }}">\n'
         "{{ block.value }}\n"
         "</{{ block.label }}>"
@@ -90,7 +87,7 @@ class Memory(BaseModel, validate_assignment=True):
             Template(prompt_template)
 
             # Validate compatibility with current memory structure
-            test_render = Template(prompt_template).render(memory=self.memory)
+            test_render = Template(prompt_template).render(blocks=self.blocks)
 
             # If we get here, the template is valid and compatible
             self.prompt_template = prompt_template
@@ -99,107 +96,49 @@ class Memory(BaseModel, validate_assignment=True):
         except Exception as e:
             raise ValueError(f"Prompt template is not compatible with current memory structure: {str(e)}")
 
-    @classmethod
-    def load(cls, state: dict):
-        """Load memory from dictionary object"""
-        obj = cls()
-        if len(state.keys()) == 2 and "memory" in state and "prompt_template" in state:
-            # New format
-            obj.prompt_template = state["prompt_template"]
-            for key, value in state["memory"].items():
-                # TODO: This is migration code, please take a look at a later time to get rid of this
-                if "name" in value:
-                    value["template_name"] = value["name"]
-                    value.pop("name")
-                obj.memory[key] = Block(**value)
-        else:
-            # Old format (pre-template)
-            for key, value in state.items():
-                obj.memory[key] = Block(**value)
-        return obj
-
     def compile(self) -> str:
         """Generate a string representation of the memory in-context using the Jinja2 template"""
         template = Template(self.prompt_template)
-        return template.render(memory=self.memory)
-
-    def to_dict(self):
-        """Convert to dictionary representation"""
-        return {
-            "memory": {key: value.model_dump() for key, value in self.memory.items()},
-            "prompt_template": self.prompt_template,
-        }
-
-    def to_flat_dict(self):
-        """Convert to a dictionary that maps directly from block label to values"""
-        return {k: v.value for k, v in self.memory.items() if v is not None}
+        return template.render(blocks=self.blocks)
 
     def list_block_labels(self) -> List[str]:
         """Return a list of the block names held inside the memory object"""
-        return list(self.memory.keys())
+        # return list(self.memory.keys())
+        return [block.label for block in self.blocks]
 
     # TODO: these should actually be label, not name
     def get_block(self, label: str) -> Block:
         """Correct way to index into the memory.memory field, returns a Block"""
-        if label not in self.memory:
-            raise KeyError(f"Block field {label} does not exist (available sections = {', '.join(list(self.memory.keys()))})")
-        else:
-            return self.memory[label]
+        keys = []
+        for block in self.blocks:
+            if block.label == label:
+                return block
+            keys.append(block.label)
+        raise KeyError(f"Block field {label} does not exist (available sections = {', '.join(keys)})")
 
     def get_blocks(self) -> List[Block]:
         """Return a list of the blocks held inside the memory object"""
-        return list(self.memory.values())
-
-    def link_block(self, block: Block, override: Optional[bool] = False):
-        """Link a new block to the memory object"""
-        if not isinstance(block, Block):
-            raise ValueError(f"Param block must be type Block (not {type(block)})")
-        if not override and block.label in self.memory:
-            raise ValueError(f"Block with label {block.label} already exists")
-
-        self.memory[block.label] = block
+        # return list(self.memory.values())
+        return self.blocks
 
-    def unlink_block(self, block_label: str) -> Block:
-        """Unlink a block from the memory object"""
-        if block_label not in self.memory:
-            raise ValueError(f"Block with label {block_label} does not exist")
-
-        return self.memory.pop(block_label)
+    def set_block(self, block: Block):
+        """Set a block in the memory object"""
+        for i, b in enumerate(self.blocks):
+            if b.label == block.label:
+                self.blocks[i] = block
+                return
+        self.blocks.append(block)
 
     def update_block_value(self, label: str, value: str):
         """Update the value of a block"""
-        if label not in self.memory:
-            raise ValueError(f"Block with label {label} does not exist")
         if not isinstance(value, str):
             raise ValueError(f"Provided value must be a string")
 
-        self.memory[label].value = value
-
-    def update_block_label(self, current_label: str, new_label: str):
-        """Update the label of a block"""
-        if current_label not in self.memory:
-            raise ValueError(f"Block with label {current_label} does not exist")
-        if not isinstance(new_label, str):
-            raise ValueError(f"Provided new label must be a string")
-
-        # First change the label of the block
-        self.memory[current_label].label = new_label
-
-        # Then swap the block to the new label
-        self.memory[new_label] = self.memory.pop(current_label)
-
-    def update_block_limit(self, label: str, limit: int):
-        """Update the limit of a block"""
-        if label not in self.memory:
-            raise ValueError(f"Block with label {label} does not exist")
-        if not isinstance(limit, int):
-            raise ValueError(f"Provided limit must be an integer")
-
-        # Check to make sure the new limit is greater than the current length of the block
-        if len(self.memory[label].value) > limit:
-            raise ValueError(f"New limit {limit} is less than the current length of the block {len(self.memory[label].value)}")
-
-        self.memory[label].limit = limit
+        for block in self.blocks:
+            if block.label == label:
+                block.value = value
+                return
+        raise ValueError(f"Block with label {label} does not exist")
 
 
 # TODO: ideally this is refactored into ChatMemory and the subclasses are given more specific names.
@@ -222,13 +161,7 @@ class BasicBlockMemory(Memory):
         Args:
             blocks (List[Block]): List of blocks to be linked to the memory object.
         """
-        super().__init__()
-        for block in blocks:
-            # TODO: centralize these internal schema validations
-            # assert block.name is not None and block.name != "", "each existing chat block must have a name"
-            # self.link_block(name=block.name, block=block)
-            assert block.label is not None and block.label != "", "each existing chat block must have a name"
-            self.link_block(block=block)
+        super().__init__(blocks=blocks)
 
     def core_memory_append(agent_state: "AgentState", label: str, content: str) -> Optional[str]:  # type: ignore
         """
@@ -280,9 +213,7 @@ class ChatMemory(BasicBlockMemory):
             human (str): The starter value for the human block.
             limit (int): The character limit for each block.
         """
-        super().__init__()
-        self.link_block(block=Block(value=persona, limit=limit, label="persona"))
-        self.link_block(block=Block(value=human, limit=limit, label="human"))
+        super().__init__(blocks=[Block(value=persona, limit=limit, label="persona"), Block(value=human, limit=limit, label="human")])
 
 
 class UpdateMemory(BaseModel):

letta/schemas/message.py

@@ -134,8 +134,8 @@ class Message(BaseMessage):
     def to_letta_message(
         self,
         assistant_message: bool = False,
-        assistant_message_function_name: str = DEFAULT_MESSAGE_TOOL,
-        assistant_message_function_kwarg: str = DEFAULT_MESSAGE_TOOL_KWARG,
+        assistant_message_tool_name: str = DEFAULT_MESSAGE_TOOL,
+        assistant_message_tool_kwarg: str = DEFAULT_MESSAGE_TOOL_KWARG,
     ) -> List[LettaMessage]:
         """Convert message object (in DB format) to the style used by the original Letta API"""
 
@@ -156,7 +156,7 @@ class Message(BaseMessage):
                 for tool_call in self.tool_calls:
                     # If we're supporting using assistant message,
                     # then we want to treat certain function calls as a special case
-                    if assistant_message and tool_call.function.name == assistant_message_function_name:
+                    if assistant_message and tool_call.function.name == assistant_message_tool_name:
                         # We need to unpack the actual message contents from the function call
                         try:
                             func_args = json.loads(tool_call.function.arguments)

letta/schemas/tool_rule.py

@@ -1,21 +1,24 @@
-from typing import List
+from typing import List, Union
 
 from pydantic import Field
 
+from letta.schemas.enums import ToolRuleType
 from letta.schemas.letta_base import LettaBase
 
 
 class BaseToolRule(LettaBase):
     __id_prefix__ = "tool_rule"
     tool_name: str = Field(..., description="The name of the tool. Must exist in the database for the user's organization.")
+    type: ToolRuleType
 
 
-class ToolRule(BaseToolRule):
+class ChildToolRule(BaseToolRule):
     """
     A ToolRule represents a tool that can be invoked by the agent.
     """
 
-    type: str = Field("ToolRule")
+    # type: str = Field("ToolRule")
+    type: ToolRuleType = ToolRuleType.constrain_child_tools
     children: List[str] = Field(..., description="The children tools that can be invoked.")
 
 
@@ -24,7 +27,8 @@ class InitToolRule(BaseToolRule):
     Represents the initial tool rule configuration.
     """
 
-    type: str = Field("InitToolRule")
+    # type: str = Field("InitToolRule")
+    type: ToolRuleType = ToolRuleType.run_first
 
 
 class TerminalToolRule(BaseToolRule):
@@ -32,4 +36,8 @@ class TerminalToolRule(BaseToolRule):
     Represents a terminal tool rule configuration where if this tool gets called, it must end the agent loop.
     """
 
-    type: str = Field("TerminalToolRule")
+    # type: str = Field("TerminalToolRule")
+    type: ToolRuleType = ToolRuleType.exit_loop
+
+
+ToolRule = Union[ChildToolRule, InitToolRule, TerminalToolRule]

letta/server/rest_api/interface.py

@@ -271,9 +271,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         self,
         multi_step=True,
         # Related to if we want to try and pass back the AssistantMessage as a special case function
-        use_assistant_message=False,
-        assistant_message_function_name=DEFAULT_MESSAGE_TOOL,
-        assistant_message_function_kwarg=DEFAULT_MESSAGE_TOOL_KWARG,
+        assistant_message_tool_name=DEFAULT_MESSAGE_TOOL,
+        assistant_message_tool_kwarg=DEFAULT_MESSAGE_TOOL_KWARG,
         # Related to if we expect inner_thoughts to be in the kwargs
         inner_thoughts_in_kwargs=True,
         inner_thoughts_kwarg=INNER_THOUGHTS_KWARG,
@@ -287,7 +286,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         self.streaming_chat_completion_mode_function_name = None  # NOTE: sadly need to track state during stream
         # If chat completion mode, we need a special stream reader to
         # turn function argument to send_message into a normal text stream
-        self.streaming_chat_completion_json_reader = FunctionArgumentsStreamHandler(json_key=assistant_message_function_kwarg)
+        self.streaming_chat_completion_json_reader = FunctionArgumentsStreamHandler(json_key=assistant_message_tool_kwarg)
 
         self._chunks = deque()
         self._event = asyncio.Event()  # Use an event to notify when chunks are available
@@ -300,9 +299,9 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         self.multi_step_gen_indicator = MessageStreamStatus.done_generation
 
         # Support for AssistantMessage
-        self.use_assistant_message = use_assistant_message
-        self.assistant_message_function_name = assistant_message_function_name
-        self.assistant_message_function_kwarg = assistant_message_function_kwarg
+        self.use_assistant_message = False  # TODO: Remove this
+        self.assistant_message_tool_name = assistant_message_tool_name
+        self.assistant_message_tool_kwarg = assistant_message_tool_kwarg
 
         # Support for inner_thoughts_in_kwargs
         self.inner_thoughts_in_kwargs = inner_thoughts_in_kwargs
@@ -455,17 +454,14 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
                 # If we get a "hit" on the special keyword we're looking for, we want to skip to the next chunk
                 # TODO I don't think this handles the function name in multi-pieces problem. Instead, we should probably reset the streaming_chat_completion_mode_function_name when we make this hit?
-                # if self.streaming_chat_completion_mode_function_name == self.assistant_message_function_name:
-                if tool_call.function.name == self.assistant_message_function_name:
+                # if self.streaming_chat_completion_mode_function_name == self.assistant_message_tool_name:
+                if tool_call.function.name == self.assistant_message_tool_name:
                     self.streaming_chat_completion_json_reader.reset()
                     # early exit to turn into content mode
                     return None
 
                 # if we're in the middle of parsing a send_message, we'll keep processing the JSON chunks
-                if (
-                    tool_call.function.arguments
-                    and self.streaming_chat_completion_mode_function_name == self.assistant_message_function_name
-                ):
+                if tool_call.function.arguments and self.streaming_chat_completion_mode_function_name == self.assistant_message_tool_name:
                     # Strip out any extras tokens
                     cleaned_func_args = self.streaming_chat_completion_json_reader.process_json_chunk(tool_call.function.arguments)
                     # In the case that we just have the prefix of something, no message yet, then we should early exit to move to the next chunk
@@ -500,9 +496,6 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                     )
 
             elif self.inner_thoughts_in_kwargs and tool_call.function:
-                if self.use_assistant_message:
-                    raise NotImplementedError("inner_thoughts_in_kwargs with use_assistant_message not yet supported")
-
                 processed_chunk = None
 
                 if tool_call.function.name:
@@ -909,13 +902,13 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
                     if (
                         self.use_assistant_message
-                        and function_call.function.name == self.assistant_message_function_name
-                        and self.assistant_message_function_kwarg in func_args
+                        and function_call.function.name == self.assistant_message_tool_name
+                        and self.assistant_message_tool_kwarg in func_args
                     ):
                         processed_chunk = AssistantMessage(
                             id=msg_obj.id,
                             date=msg_obj.created_at,
-                            assistant_message=func_args[self.assistant_message_function_kwarg],
+                            assistant_message=func_args[self.assistant_message_tool_kwarg],
                         )
                     else:
                         processed_chunk = FunctionCallMessage(

letta/server/rest_api/routers/openai/assistants/threads.py

@@ -117,7 +117,7 @@ def create_message(
         tool_call_id=None,
         name=None,
     )
-    agent = server._get_or_load_agent(agent_id=agent_id)
+    agent = server.load_agent(agent_id=agent_id)
     # add message to agent
     agent._append_to_messages([message])
 
@@ -161,7 +161,6 @@ def list_messages(
         before=before_uuid,
         order_by="created_at",
         reverse=reverse,
-        return_message_object=True,
     )
     assert isinstance(json_messages, List)
     assert all([isinstance(message, Message) for message in json_messages])
@@ -247,7 +246,7 @@ def create_run(
     # TODO: add request.instructions as a message?
     agent_id = thread_id
     # TODO: override preset of agent with request.assistant_id
-    agent = server._get_or_load_agent(agent_id=agent_id)
+    agent = server.load_agent(agent_id=agent_id)
     agent.inner_step(messages=[])  # already has messages added
     run_id = str(uuid.uuid4())
     create_time = int(get_utc_time().timestamp())

letta/server/rest_api/routers/openai/chat_completions/chat_completions.py

@@ -68,7 +68,6 @@ async def create_chat_completion(
             stream_tokens=True,
             # Turn on ChatCompletion mode (eg remaps send_message to content)
             chat_completion_mode=True,
-            return_message_object=False,
         )
 
     else:
@@ -86,7 +85,6 @@ async def create_chat_completion(
             # Turn streaming OFF
             stream_steps=False,
             stream_tokens=False,
-            return_message_object=False,
         )
         # print(response_messages)