letta-nightly 0.5.5.dev20241122170833__py3-none-any.whl → 0.6.0.dev20241204051808__py3-none-any.whl

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,12 +1,13 @@
-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
 
 # Forward referencing to avoid circular import with Agent -> Memory -> Agent
 if TYPE_CHECKING:
-    from letta.agent import Agent
+    pass
 
+from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT
 from letta.schemas.block import Block
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_request import Tool
@@ -54,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 }}>"
@@ -89,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
@@ -98,74 +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())
+        # return list(self.memory.values())
+        return self.blocks
 
-    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
+    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
+        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.
@@ -188,15 +161,9 @@ 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)
-
-    def core_memory_append(self: "Agent", label: str, content: str) -> Optional[str]:  # type: ignore
+        super().__init__(blocks=blocks)
+
+    def core_memory_append(agent_state: "AgentState", label: str, content: str) -> Optional[str]:  # type: ignore
         """
         Append to the contents of core memory.
 
@@ -207,12 +174,12 @@ class BasicBlockMemory(Memory):
         Returns:
             Optional[str]: None is always returned as this function does not produce a response.
         """
-        current_value = str(self.memory.get_block(label).value)
+        current_value = str(agent_state.memory.get_block(label).value)
         new_value = current_value + "\n" + str(content)
-        self.memory.update_block_value(label=label, value=new_value)
+        agent_state.memory.update_block_value(label=label, value=new_value)
         return None
 
-    def core_memory_replace(self: "Agent", label: str, old_content: str, new_content: str) -> Optional[str]:  # type: ignore
+    def core_memory_replace(agent_state: "AgentState", label: str, old_content: str, new_content: str) -> Optional[str]:  # type: ignore
         """
         Replace the contents of core memory. To delete memories, use an empty string for new_content.
 
@@ -224,11 +191,11 @@ class BasicBlockMemory(Memory):
         Returns:
             Optional[str]: None is always returned as this function does not produce a response.
         """
-        current_value = str(self.memory.get_block(label).value)
+        current_value = str(agent_state.memory.get_block(label).value)
         if old_content not in current_value:
             raise ValueError(f"Old content '{old_content}' not found in memory block '{label}'")
         new_value = current_value.replace(str(old_content), str(new_content))
-        self.memory.update_block_value(label=label, value=new_value)
+        agent_state.memory.update_block_value(label=label, value=new_value)
         return None
 
 
@@ -237,7 +204,7 @@ class ChatMemory(BasicBlockMemory):
     ChatMemory initializes a BaseChatMemory with two default blocks, `human` and `persona`.
     """
 
-    def __init__(self, persona: str, human: str, limit: int = 2000):
+    def __init__(self, persona: str, human: str, limit: int = CORE_MEMORY_BLOCK_CHAR_LIMIT):
         """
         Initialize the ChatMemory object with a persona and human string.
 
@@ -246,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/sandbox_config.py

@@ -0,0 +1,114 @@
+import hashlib
+import json
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, Field
+
+from letta.schemas.agent import AgentState
+from letta.schemas.letta_base import LettaBase, OrmMetadataBase
+
+
+# Sandbox Config
+class SandboxType(str, Enum):
+    E2B = "e2b"
+    LOCAL = "local"
+
+
+class SandboxRunResult(BaseModel):
+    func_return: Optional[Any] = Field(None, description="The function return object")
+    agent_state: Optional[AgentState] = Field(None, description="The agent state")
+    stdout: Optional[List[str]] = Field(None, description="Captured stdout (e.g. prints, logs) from the function invocation")
+    sandbox_config_fingerprint: str = Field(None, description="The fingerprint of the config for the sandbox")
+
+
+class LocalSandboxConfig(BaseModel):
+    sandbox_dir: str = Field(..., description="Directory for the sandbox environment.")
+
+    @property
+    def type(self) -> "SandboxType":
+        return SandboxType.LOCAL
+
+
+class E2BSandboxConfig(BaseModel):
+    timeout: int = Field(5 * 60, description="Time limit for the sandbox (in seconds).")
+    template: Optional[str] = Field(None, description="The E2B template id (docker image).")
+    pip_requirements: Optional[List[str]] = Field(None, description="A list of pip packages to install on the E2B Sandbox")
+
+    @property
+    def type(self) -> "SandboxType":
+        return SandboxType.E2B
+
+
+class SandboxConfigBase(OrmMetadataBase):
+    __id_prefix__ = "sandbox"
+
+
+class SandboxConfig(SandboxConfigBase):
+    id: str = SandboxConfigBase.generate_id_field()
+    type: SandboxType = Field(None, description="The type of sandbox.")
+    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the sandbox.")
+    config: Dict = Field(default_factory=lambda: {}, description="The JSON sandbox settings data.")
+
+    def get_e2b_config(self) -> E2BSandboxConfig:
+        return E2BSandboxConfig(**self.config)
+
+    def get_local_config(self) -> LocalSandboxConfig:
+        return LocalSandboxConfig(**self.config)
+
+    def fingerprint(self) -> str:
+        # Only take into account type, org_id, and the config items
+        # Canonicalize input data into JSON with sorted keys
+        hash_input = json.dumps(
+            {
+                "type": self.type.value,
+                "organization_id": self.organization_id,
+                "config": self.config,
+            },
+            sort_keys=True,  # Ensure stable ordering
+            separators=(",", ":"),  # Minimize serialization differences
+        )
+
+        # Compute SHA-256 hash
+        hash_digest = hashlib.sha256(hash_input.encode("utf-8")).digest()
+
+        # Convert the digest to an integer for compatibility with Python's hash requirements
+        return str(int.from_bytes(hash_digest, byteorder="big"))
+
+
+class SandboxConfigCreate(LettaBase):
+    config: Union[LocalSandboxConfig, E2BSandboxConfig] = Field(..., description="The configuration for the sandbox.")
+
+
+class SandboxConfigUpdate(LettaBase):
+    """Pydantic model for updating SandboxConfig fields."""
+
+    config: Union[LocalSandboxConfig, E2BSandboxConfig] = Field(None, description="The JSON configuration data for the sandbox.")
+
+
+# Environment Variable
+class SandboxEnvironmentVariableBase(OrmMetadataBase):
+    __id_prefix__ = "sandbox-env"
+
+
+class SandboxEnvironmentVariable(SandboxEnvironmentVariableBase):
+    id: str = SandboxEnvironmentVariableBase.generate_id_field()
+    key: str = Field(..., description="The name of the environment variable.")
+    value: str = Field(..., description="The value of the environment variable.")
+    description: Optional[str] = Field(None, description="An optional description of the environment variable.")
+    sandbox_config_id: str = Field(..., description="The ID of the sandbox config this environment variable belongs to.")
+    organization_id: Optional[str] = Field(None, description="The ID of the organization this environment variable belongs to.")
+
+
+class SandboxEnvironmentVariableCreate(LettaBase):
+    key: str = Field(..., description="The name of the environment variable.")
+    value: str = Field(..., description="The value of the environment variable.")
+    description: Optional[str] = Field(None, description="An optional description of the environment variable.")
+
+
+class SandboxEnvironmentVariableUpdate(LettaBase):
+    """Pydantic model for updating SandboxEnvironmentVariable fields."""
+
+    key: Optional[str] = Field(None, description="The name of the environment variable.")
+    value: Optional[str] = Field(None, description="The value of the environment variable.")
+    description: Optional[str] = Field(None, description="An optional description of the environment variable.")

letta/schemas/tool.py

@@ -1,7 +1,8 @@
 from typing import Dict, List, Optional
 
-from pydantic import Field
+from pydantic import Field, model_validator
 
+from letta.functions.functions import derive_openai_json_schema
 from letta.functions.helpers import (
     generate_composio_tool_wrapper,
     generate_langchain_tool_wrapper,
@@ -44,6 +45,29 @@ class Tool(BaseTool):
     created_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
     last_updated_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
 
+    @model_validator(mode="after")
+    def populate_missing_fields(self):
+        """
+        Populate missing fields: name, description, and json_schema.
+        """
+        # Derive JSON schema if not provided
+        if not self.json_schema:
+            self.json_schema = derive_openai_json_schema(source_code=self.source_code)
+
+        # Derive name from the JSON schema if not provided
+        if not self.name:
+            # TODO: This in theory could error, but name should always be on json_schema
+            # TODO: Make JSON schema a typed pydantic object
+            self.name = self.json_schema.get("name")
+
+        # Derive description from the JSON schema if not provided
+        if not self.description:
+            # TODO: This in theory could error, but description should always be on json_schema
+            # TODO: Make JSON schema a typed pydantic object
+            self.description = self.json_schema.get("description")
+
+        return self
+
     def to_dict(self):
         """
         Convert tool into OpenAI representation.
@@ -177,3 +201,15 @@ class ToolUpdate(LettaBase):
     class Config:
         extra = "ignore"  # Allows extra fields without validation errors
         # TODO: Remove this, and clean usage of ToolUpdate everywhere else
+
+
+class ToolRun(LettaBase):
+    id: str = Field(..., description="The ID of the tool to run.")
+    args: str = Field(..., description="The arguments to pass to the tool (as stringified JSON).")
+
+
+class ToolRunFromSource(LettaBase):
+    source_code: str = Field(..., description="The source code of the function.")
+    args: str = Field(..., description="The arguments to pass to the tool (as stringified JSON).")
+    name: Optional[str] = Field(None, description="The name of the tool to run.")
+    source_type: Optional[str] = Field(None, description="The type of the source code.")

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/app.py

@@ -1,5 +1,6 @@
 import json
 import logging
+import os
 import sys
 from pathlib import Path
 from typing import Optional
@@ -103,7 +104,7 @@ def generate_password():
     return secrets.token_urlsafe(16)
 
 
-random_password = generate_password()
+random_password = os.getenv("LETTA_SERVER_PASSWORD") or generate_password()
 
 
 class CheckPasswordMiddleware(BaseHTTPMiddleware):
@@ -132,11 +133,11 @@ def create_application() -> "FastAPI":
         debug=True,
     )
 
-    if "--ade" in sys.argv:
+    if (os.getenv("LETTA_SERVER_ADE") == "true") or "--ade" in sys.argv:
         settings.cors_origins.append("https://app.letta.com")
-        print(f"▶ View using ADE at: https://app.letta.com/local-project/agents")
+        print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard")
 
-    if "--secure" in sys.argv:
+    if (os.getenv("LETTA_SERVER_SECURE") == "true") or "--secure" in sys.argv:
         print(f"▶ Using secure mode with password: {random_password}")
         app.add_middleware(CheckPasswordMiddleware)
 

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)
 

letta/server/rest_api/routers/v1/__init__.py

@@ -3,15 +3,10 @@ from letta.server.rest_api.routers.v1.blocks import router as blocks_router
 from letta.server.rest_api.routers.v1.health import router as health_router
 from letta.server.rest_api.routers.v1.jobs import router as jobs_router
 from letta.server.rest_api.routers.v1.llms import router as llm_router
+from letta.server.rest_api.routers.v1.sandbox_configs import (
+    router as sandbox_configs_router,
+)
 from letta.server.rest_api.routers.v1.sources import router as sources_router
 from letta.server.rest_api.routers.v1.tools import router as tools_router
 
-ROUTERS = [
-    tools_router,
-    sources_router,
-    agents_router,
-    llm_router,
-    blocks_router,
-    jobs_router,
-    health_router,
-]
+ROUTERS = [tools_router, sources_router, agents_router, llm_router, blocks_router, jobs_router, health_router, sandbox_configs_router]