letta-nightly 0.7.15.dev20250515104317__py3-none-any.whl → 0.7.17.dev20250516090339__py3-none-any.whl

letta/interfaces/anthropic_streaming_interface.py

@@ -108,6 +108,8 @@ class AnthropicStreamingInterface:
             raise
 
     async def process(self, stream: AsyncStream[BetaRawMessageStreamEvent]) -> AsyncGenerator[LettaMessage, None]:
+        prev_message_type = None
+        message_index = 0
         try:
             async with stream:
                 async for event in stream:
@@ -137,14 +139,17 @@ class AnthropicStreamingInterface:
                             # TODO: Can capture signature, etc.
                         elif isinstance(content, BetaRedactedThinkingBlock):
                             self.anthropic_mode = EventMode.REDACTED_THINKING
-
+                            if prev_message_type and prev_message_type != "hidden_reasoning_message":
+                                message_index += 1
                             hidden_reasoning_message = HiddenReasoningMessage(
                                 id=self.letta_assistant_message_id,
                                 state="redacted",
                                 hidden_reasoning=content.data,
                                 date=datetime.now(timezone.utc).isoformat(),
+                                otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
                             )
                             self.reasoning_messages.append(hidden_reasoning_message)
+                            prev_message_type = hidden_reasoning_message.message_type
                             yield hidden_reasoning_message
 
                     elif isinstance(event, BetaRawContentBlockDeltaEvent):
@@ -175,12 +180,16 @@ class AnthropicStreamingInterface:
                             self.partial_tag_buffer = combined_text[-10:] if len(combined_text) > 10 else combined_text
                             self.accumulated_inner_thoughts.append(delta.text)
 
+                            if prev_message_type and prev_message_type != "reasoning_message":
+                                message_index += 1
                             reasoning_message = ReasoningMessage(
                                 id=self.letta_assistant_message_id,
                                 reasoning=self.accumulated_inner_thoughts[-1],
                                 date=datetime.now(timezone.utc).isoformat(),
+                                otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
                             )
                             self.reasoning_messages.append(reasoning_message)
+                            prev_message_type = reasoning_message.message_type
                             yield reasoning_message
 
                         elif isinstance(delta, BetaInputJSONDelta):
@@ -198,21 +207,30 @@ class AnthropicStreamingInterface:
                             inner_thoughts_diff = current_inner_thoughts[len(previous_inner_thoughts) :]
 
                             if inner_thoughts_diff:
+                                if prev_message_type and prev_message_type != "reasoning_message":
+                                    message_index += 1
                                 reasoning_message = ReasoningMessage(
                                     id=self.letta_assistant_message_id,
                                     reasoning=inner_thoughts_diff,
                                     date=datetime.now(timezone.utc).isoformat(),
+                                    otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
                                 )
                                 self.reasoning_messages.append(reasoning_message)
+                                prev_message_type = reasoning_message.message_type
                                 yield reasoning_message
 
                             # Check if inner thoughts are complete - if so, flush the buffer
                             if not self.inner_thoughts_complete and self._check_inner_thoughts_complete(self.accumulated_tool_call_args):
                                 self.inner_thoughts_complete = True
                                 # Flush all buffered tool call messages
-                                for buffered_msg in self.tool_call_buffer:
-                                    yield buffered_msg
-                                self.tool_call_buffer = []
+                                if len(self.tool_call_buffer) > 0:
+                                    if prev_message_type and prev_message_type != "tool_call_message":
+                                        message_index += 1
+                                    for buffered_msg in self.tool_call_buffer:
+                                        buffered_msg.otid = Message.generate_otid_from_id(self.letta_tool_message_id, message_index)
+                                        prev_message_type = buffered_msg.message_type
+                                        yield buffered_msg
+                                    self.tool_call_buffer = []
 
                             # Start detecting special case of "send_message"
                             if self.tool_call_name == DEFAULT_MESSAGE_TOOL and self.use_assistant_message:
@@ -222,11 +240,16 @@ class AnthropicStreamingInterface:
 
                                 # Only stream out if it's not an empty string
                                 if send_message_diff:
-                                    yield AssistantMessage(
+                                    if prev_message_type and prev_message_type != "assistant_message":
+                                        message_index += 1
+                                    assistant_msg = AssistantMessage(
                                         id=self.letta_assistant_message_id,
                                         content=[TextContent(text=send_message_diff)],
                                         date=datetime.now(timezone.utc).isoformat(),
+                                        otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
                                     )
+                                    prev_message_type = assistant_msg.message_type
+                                    yield assistant_msg
                             else:
                                 # Otherwise, it is a normal tool call - buffer or yield based on inner thoughts status
                                 tool_call_msg = ToolCallMessage(
@@ -234,8 +257,11 @@ class AnthropicStreamingInterface:
                                     tool_call=ToolCallDelta(arguments=delta.partial_json),
                                     date=datetime.now(timezone.utc).isoformat(),
                                 )
-
                                 if self.inner_thoughts_complete:
+                                    if prev_message_type and prev_message_type != "tool_call_message":
+                                        message_index += 1
+                                    tool_call_msg.otid = Message.generate_otid_from_id(self.letta_tool_message_id, message_index)
+                                    prev_message_type = tool_call_msg.message_type
                                     yield tool_call_msg
                                 else:
                                     self.tool_call_buffer.append(tool_call_msg)
@@ -249,13 +275,17 @@ class AnthropicStreamingInterface:
                                     f"Streaming integrity failed - received BetaThinkingBlock object while not in THINKING EventMode: {delta}"
                                 )
 
+                            if prev_message_type and prev_message_type != "reasoning_message":
+                                message_index += 1
                             reasoning_message = ReasoningMessage(
                                 id=self.letta_assistant_message_id,
                                 source="reasoner_model",
                                 reasoning=delta.thinking,
                                 date=datetime.now(timezone.utc).isoformat(),
+                                otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
                             )
                             self.reasoning_messages.append(reasoning_message)
+                            prev_message_type = reasoning_message.message_type
                             yield reasoning_message
                         elif isinstance(delta, BetaSignatureDelta):
                             # Safety check
@@ -264,14 +294,18 @@ class AnthropicStreamingInterface:
                                     f"Streaming integrity failed - received BetaSignatureDelta object while not in THINKING EventMode: {delta}"
                                 )
 
+                            if prev_message_type and prev_message_type != "reasoning_message":
+                                message_index += 1
                             reasoning_message = ReasoningMessage(
                                 id=self.letta_assistant_message_id,
                                 source="reasoner_model",
                                 reasoning="",
                                 date=datetime.now(timezone.utc).isoformat(),
                                 signature=delta.signature,
+                                otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
                             )
                             self.reasoning_messages.append(reasoning_message)
+                            prev_message_type = reasoning_message.message_type
                             yield reasoning_message
                     elif isinstance(event, BetaRawMessageStartEvent):
                         self.message_id = event.message.id

letta/interfaces/openai_streaming_interface.py

@@ -0,0 +1,303 @@
+from datetime import datetime, timezone
+from typing import AsyncGenerator, List, Optional
+
+from openai import AsyncStream
+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
+
+from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
+from letta.schemas.letta_message import AssistantMessage, LettaMessage, ReasoningMessage, ToolCallDelta, ToolCallMessage
+from letta.schemas.letta_message_content import TextContent
+from letta.schemas.message import Message
+from letta.schemas.openai.chat_completion_response import FunctionCall, ToolCall
+from letta.server.rest_api.json_parser import OptimisticJSONParser
+from letta.streaming_utils import JSONInnerThoughtsExtractor
+
+
+class OpenAIStreamingInterface:
+    """
+    Encapsulates the logic for streaming responses from OpenAI.
+    This class handles parsing of partial tokens, pre-execution messages,
+    and detection of tool call events.
+    """
+
+    def __init__(self, use_assistant_message: bool = False, put_inner_thoughts_in_kwarg: bool = False):
+        self.use_assistant_message = use_assistant_message
+        self.assistant_message_tool_name = DEFAULT_MESSAGE_TOOL
+        self.assistant_message_tool_kwarg = DEFAULT_MESSAGE_TOOL_KWARG
+
+        self.optimistic_json_parser: OptimisticJSONParser = OptimisticJSONParser()
+        self.function_args_reader = JSONInnerThoughtsExtractor(wait_for_first_key=True)  # TODO: pass in kward
+        self.function_name_buffer = None
+        self.function_args_buffer = None
+        self.function_id_buffer = None
+        self.last_flushed_function_name = None
+
+        # Buffer to hold function arguments until inner thoughts are complete
+        self.current_function_arguments = ""
+        self.current_json_parse_result = {}
+
+        # Premake IDs for database writes
+        self.letta_assistant_message_id = Message.generate_id()
+        self.letta_tool_message_id = Message.generate_id()
+
+        # token counters
+        self.input_tokens = 0
+        self.output_tokens = 0
+
+        self.content_buffer: List[str] = []
+        self.tool_call_name: Optional[str] = None
+        self.tool_call_id: Optional[str] = None
+        self.reasoning_messages = []
+
+    def get_reasoning_content(self) -> List[TextContent]:
+        content = "".join(self.reasoning_messages)
+        return [TextContent(text=content)]
+
+    def get_tool_call_object(self) -> ToolCall:
+        """Useful for agent loop"""
+        return ToolCall(
+            id=self.letta_tool_message_id,
+            function=FunctionCall(arguments=self.current_function_arguments, name=self.last_flushed_function_name),
+        )
+
+    async def process(self, stream: AsyncStream[ChatCompletionChunk]) -> AsyncGenerator[LettaMessage, None]:
+        """
+        Iterates over the OpenAI stream, yielding SSE events.
+        It also collects tokens and detects if a tool call is triggered.
+        """
+        async with stream:
+            prev_message_type = None
+            message_index = 0
+            async for chunk in stream:
+                # track usage
+                if chunk.usage:
+                    self.input_tokens += len(chunk.usage.prompt_tokens)
+                    self.output_tokens += len(chunk.usage.completion_tokens)
+
+                if chunk.choices:
+                    choice = chunk.choices[0]
+                    message_delta = choice.delta
+
+                    if message_delta.tool_calls is not None and len(message_delta.tool_calls) > 0:
+                        tool_call = message_delta.tool_calls[0]
+
+                        if tool_call.function.name:
+                            # If we're waiting for the first key, then we should hold back the name
+                            # ie add it to a buffer instead of returning it as a chunk
+                            if self.function_name_buffer is None:
+                                self.function_name_buffer = tool_call.function.name
+                            else:
+                                self.function_name_buffer += tool_call.function.name
+
+                        if tool_call.id:
+                            # Buffer until next time
+                            if self.function_id_buffer is None:
+                                self.function_id_buffer = tool_call.id
+                            else:
+                                self.function_id_buffer += tool_call.id
+
+                        if tool_call.function.arguments:
+                            # updates_main_json, updates_inner_thoughts = self.function_args_reader.process_fragment(tool_call.function.arguments)
+                            self.current_function_arguments += tool_call.function.arguments
+                            updates_main_json, updates_inner_thoughts = self.function_args_reader.process_fragment(
+                                tool_call.function.arguments
+                            )
+
+                            # If we have inner thoughts, we should output them as a chunk
+                            if updates_inner_thoughts:
+                                if prev_message_type and prev_message_type != "reasoning_message":
+                                    message_index += 1
+                                self.reasoning_messages.append(updates_inner_thoughts)
+                                reasoning_message = ReasoningMessage(
+                                    id=self.letta_tool_message_id,
+                                    date=datetime.now(timezone.utc),
+                                    reasoning=updates_inner_thoughts,
+                                    # name=name,
+                                    otid=Message.generate_otid_from_id(self.letta_tool_message_id, message_index),
+                                )
+                                prev_message_type = reasoning_message.message_type
+                                yield reasoning_message
+
+                                # Additionally inner thoughts may stream back with a chunk of main JSON
+                                # In that case, since we can only return a chunk at a time, we should buffer it
+                                if updates_main_json:
+                                    if self.function_args_buffer is None:
+                                        self.function_args_buffer = updates_main_json
+                                    else:
+                                        self.function_args_buffer += updates_main_json
+
+                            # If we have main_json, we should output a ToolCallMessage
+                            elif updates_main_json:
+
+                                # If there's something in the function_name buffer, we should release it first
+                                # NOTE: we could output it as part of a chunk that has both name and args,
+                                #       however the frontend may expect name first, then args, so to be
+                                #       safe we'll output name first in a separate chunk
+                                if self.function_name_buffer:
+
+                                    # use_assisitant_message means that we should also not release main_json raw, and instead should only release the contents of "message": "..."
+                                    if self.use_assistant_message and self.function_name_buffer == self.assistant_message_tool_name:
+
+                                        # Store the ID of the tool call so allow skipping the corresponding response
+                                        if self.function_id_buffer:
+                                            self.prev_assistant_message_id = self.function_id_buffer
+
+                                    else:
+                                        if prev_message_type and prev_message_type != "tool_call_message":
+                                            message_index += 1
+                                        self.tool_call_name = str(self.function_name_buffer)
+                                        tool_call_msg = ToolCallMessage(
+                                            id=self.letta_tool_message_id,
+                                            date=datetime.now(timezone.utc),
+                                            tool_call=ToolCallDelta(
+                                                name=self.function_name_buffer,
+                                                arguments=None,
+                                                tool_call_id=self.function_id_buffer,
+                                            ),
+                                            otid=Message.generate_otid_from_id(self.letta_tool_message_id, message_index),
+                                        )
+                                        prev_message_type = tool_call_msg.message_type
+                                        yield tool_call_msg
+
+                                    # Record what the last function name we flushed was
+                                    self.last_flushed_function_name = self.function_name_buffer
+                                    # Clear the buffer
+                                    self.function_name_buffer = None
+                                    self.function_id_buffer = None
+                                    # Since we're clearing the name buffer, we should store
+                                    # any updates to the arguments inside a separate buffer
+
+                                    # Add any main_json updates to the arguments buffer
+                                    if self.function_args_buffer is None:
+                                        self.function_args_buffer = updates_main_json
+                                    else:
+                                        self.function_args_buffer += updates_main_json
+
+                                # If there was nothing in the name buffer, we can proceed to
+                                # output the arguments chunk as a ToolCallMessage
+                                else:
+
+                                    # use_assisitant_message means that we should also not release main_json raw, and instead should only release the contents of "message": "..."
+                                    if self.use_assistant_message and (
+                                        self.last_flushed_function_name is not None
+                                        and self.last_flushed_function_name == self.assistant_message_tool_name
+                                    ):
+                                        # do an additional parse on the updates_main_json
+                                        if self.function_args_buffer:
+                                            updates_main_json = self.function_args_buffer + updates_main_json
+                                            self.function_args_buffer = None
+
+                                            # Pretty gross hardcoding that assumes that if we're toggling into the keywords, we have the full prefix
+                                            match_str = '{"' + self.assistant_message_tool_kwarg + '":"'
+                                            if updates_main_json == match_str:
+                                                updates_main_json = None
+
+                                        else:
+                                            # Some hardcoding to strip off the trailing "}"
+                                            if updates_main_json in ["}", '"}']:
+                                                updates_main_json = None
+                                            if updates_main_json and len(updates_main_json) > 0 and updates_main_json[-1:] == '"':
+                                                updates_main_json = updates_main_json[:-1]
+
+                                        if not updates_main_json:
+                                            # early exit to turn into content mode
+                                            continue
+
+                                        # There may be a buffer from a previous chunk, for example
+                                        # if the previous chunk had arguments but we needed to flush name
+                                        if self.function_args_buffer:
+                                            # In this case, we should release the buffer + new data at once
+                                            combined_chunk = self.function_args_buffer + updates_main_json
+
+                                            if prev_message_type and prev_message_type != "assistant_message":
+                                                message_index += 1
+                                            assistant_message = AssistantMessage(
+                                                id=self.letta_assistant_message_id,
+                                                date=datetime.now(timezone.utc),
+                                                content=combined_chunk,
+                                                otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
+                                            )
+                                            prev_message_type = assistant_message.message_type
+                                            yield assistant_message
+                                            # Store the ID of the tool call so allow skipping the corresponding response
+                                            if self.function_id_buffer:
+                                                self.prev_assistant_message_id = self.function_id_buffer
+                                            # clear buffer
+                                            self.function_args_buffer = None
+                                            self.function_id_buffer = None
+
+                                        else:
+                                            # If there's no buffer to clear, just output a new chunk with new data
+                                            # TODO: THIS IS HORRIBLE
+                                            # TODO: WE USE THE OLD JSON PARSER EARLIER (WHICH DOES NOTHING) AND NOW THE NEW JSON PARSER
+                                            # TODO: THIS IS TOTALLY WRONG AND BAD, BUT SAVING FOR A LARGER REWRITE IN THE NEAR FUTURE
+                                            parsed_args = self.optimistic_json_parser.parse(self.current_function_arguments)
+
+                                            if parsed_args.get(self.assistant_message_tool_kwarg) and parsed_args.get(
+                                                self.assistant_message_tool_kwarg
+                                            ) != self.current_json_parse_result.get(self.assistant_message_tool_kwarg):
+                                                new_content = parsed_args.get(self.assistant_message_tool_kwarg)
+                                                prev_content = self.current_json_parse_result.get(self.assistant_message_tool_kwarg, "")
+                                                # TODO: Assumes consistent state and that prev_content is subset of new_content
+                                                diff = new_content.replace(prev_content, "", 1)
+                                                self.current_json_parse_result = parsed_args
+                                                if prev_message_type and prev_message_type != "assistant_message":
+                                                    message_index += 1
+                                                assistant_message = AssistantMessage(
+                                                    id=self.letta_assistant_message_id,
+                                                    date=datetime.now(timezone.utc),
+                                                    content=diff,
+                                                    # name=name,
+                                                    otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
+                                                )
+                                                prev_message_type = assistant_message.message_type
+                                                yield assistant_message
+
+                                            # Store the ID of the tool call so allow skipping the corresponding response
+                                            if self.function_id_buffer:
+                                                self.prev_assistant_message_id = self.function_id_buffer
+                                            # clear buffers
+                                            self.function_id_buffer = None
+                                    else:
+
+                                        # There may be a buffer from a previous chunk, for example
+                                        # if the previous chunk had arguments but we needed to flush name
+                                        if self.function_args_buffer:
+                                            # In this case, we should release the buffer + new data at once
+                                            combined_chunk = self.function_args_buffer + updates_main_json
+                                            if prev_message_type and prev_message_type != "tool_call_message":
+                                                message_index += 1
+                                            tool_call_msg = ToolCallMessage(
+                                                id=self.letta_tool_message_id,
+                                                date=datetime.now(timezone.utc),
+                                                tool_call=ToolCallDelta(
+                                                    name=None,
+                                                    arguments=combined_chunk,
+                                                    tool_call_id=self.function_id_buffer,
+                                                ),
+                                                # name=name,
+                                                otid=Message.generate_otid_from_id(self.letta_tool_message_id, message_index),
+                                            )
+                                            prev_message_type = tool_call_msg.message_type
+                                            yield tool_call_msg
+                                            # clear buffer
+                                            self.function_args_buffer = None
+                                            self.function_id_buffer = None
+                                        else:
+                                            # If there's no buffer to clear, just output a new chunk with new data
+                                            if prev_message_type and prev_message_type != "tool_call_message":
+                                                message_index += 1
+                                            tool_call_msg = ToolCallMessage(
+                                                id=self.letta_tool_message_id,
+                                                date=datetime.now(timezone.utc),
+                                                tool_call=ToolCallDelta(
+                                                    name=None,
+                                                    arguments=updates_main_json,
+                                                    tool_call_id=self.function_id_buffer,
+                                                ),
+                                                # name=name,
+                                                otid=Message.generate_otid_from_id(self.letta_tool_message_id, message_index),
+                                            )
+                                            prev_message_type = tool_call_msg.message_type
+                                            yield tool_call_msg
+                                            self.function_id_buffer = None

letta/jobs/llm_batch_job_polling.py

@@ -180,7 +180,7 @@ async def poll_running_llm_batches(server: "SyncServer") -> List[LettaBatchRespo
 
     try:
         # 1. Retrieve running batch jobs
-        batches = server.batch_manager.list_running_llm_batches()
+        batches = await server.batch_manager.list_running_llm_batches_async()
         metrics.total_batches = len(batches)
 
         # TODO: Expand to more providers
@@ -220,7 +220,11 @@ async def poll_running_llm_batches(server: "SyncServer") -> List[LettaBatchRespo
                 )
 
             # launch them all at once
-            tasks = [_resume(server.batch_manager.get_llm_batch_job_by_id(bid)) for bid, *_ in completed]
+            async def get_and_resume(batch_id):
+                batch = await server.batch_manager.get_llm_batch_job_by_id_async(batch_id)
+                return await _resume(batch)
+
+            tasks = [get_and_resume(bid) for bid, *_ in completed]
             new_batch_responses = await asyncio.gather(*tasks, return_exceptions=True)
 
             return new_batch_responses

letta/orm/agent.py

@@ -2,6 +2,7 @@ import uuid
 from typing import TYPE_CHECKING, List, Optional, Set
 
 from sqlalchemy import JSON, Boolean, Index, String
+from sqlalchemy.ext.asyncio import AsyncAttrs
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.block import Block
@@ -26,7 +27,7 @@ if TYPE_CHECKING:
     from letta.orm.tool import Tool
 
 
-class Agent(SqlalchemyBase, OrganizationMixin):
+class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
     __tablename__ = "agents"
     __pydantic_model__ = PydanticAgentState
     __table_args__ = (Index("ix_agents_created_at", "created_at", "id"),)
@@ -200,3 +201,103 @@ class Agent(SqlalchemyBase, OrganizationMixin):
                 state[field_name] = resolver()
 
         return self.__pydantic_model__(**state)
+
+    async def to_pydantic_async(self, include_relationships: Optional[Set[str]] = None) -> PydanticAgentState:
+        """
+        Converts the SQLAlchemy Agent model into its Pydantic counterpart.
+
+        The following base fields are always included:
+          - id, agent_type, name, description, system, message_ids, metadata_,
+            llm_config, embedding_config, project_id, template_id, base_template_id,
+            tool_rules, message_buffer_autoclear, tags
+
+        Everything else (e.g., tools, sources, memory, etc.) is optional and only
+        included if specified in `include_fields`.
+
+        Args:
+            include_relationships (Optional[Set[str]]):
+                A set of additional field names to include in the output. If None or empty,
+                no extra fields are loaded beyond the base fields.
+
+        Returns:
+            PydanticAgentState: The Pydantic representation of the agent.
+        """
+        # Base fields: always included
+        state = {
+            "id": self.id,
+            "agent_type": self.agent_type,
+            "name": self.name,
+            "description": self.description,
+            "system": self.system,
+            "message_ids": self.message_ids,
+            "metadata": self.metadata_,  # Exposed as 'metadata' to Pydantic
+            "llm_config": self.llm_config,
+            "embedding_config": self.embedding_config,
+            "project_id": self.project_id,
+            "template_id": self.template_id,
+            "base_template_id": self.base_template_id,
+            "tool_rules": self.tool_rules,
+            "message_buffer_autoclear": self.message_buffer_autoclear,
+            "created_by_id": self.created_by_id,
+            "last_updated_by_id": self.last_updated_by_id,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            # optional field defaults
+            "tags": [],
+            "tools": [],
+            "sources": [],
+            "memory": Memory(blocks=[]),
+            "identity_ids": [],
+            "multi_agent_group": None,
+            "tool_exec_environment_variables": [],
+            "enable_sleeptime": None,
+            "response_format": self.response_format,
+        }
+        optional_fields = {
+            "tags": [],
+            "tools": [],
+            "sources": [],
+            "memory": Memory(blocks=[]),
+            "identity_ids": [],
+            "multi_agent_group": None,
+            "tool_exec_environment_variables": [],
+            "enable_sleeptime": None,
+            "response_format": self.response_format,
+        }
+
+        # Initialize include_relationships to an empty set if it's None
+        include_relationships = set(optional_fields.keys() if include_relationships is None else include_relationships)
+
+        # Only load requested relationships
+        if "tags" in include_relationships:
+            tags = await self.awaitable_attrs.tags
+            state["tags"] = [t.tag for t in tags]
+
+        if "tools" in include_relationships:
+            state["tools"] = await self.awaitable_attrs.tools
+
+        if "sources" in include_relationships:
+            sources = await self.awaitable_attrs.sources
+            state["sources"] = [s.to_pydantic() for s in sources]
+
+        if "memory" in include_relationships:
+            memory_blocks = await self.awaitable_attrs.core_memory
+            state["memory"] = Memory(
+                blocks=[b.to_pydantic() for b in memory_blocks],
+                prompt_template=get_prompt_template_for_agent_type(self.agent_type),
+            )
+
+        if "identity_ids" in include_relationships:
+            identities = await self.awaitable_attrs.identities
+            state["identity_ids"] = [i.id for i in identities]
+
+        if "multi_agent_group" in include_relationships:
+            state["multi_agent_group"] = await self.awaitable_attrs.multi_agent_group
+
+        if "tool_exec_environment_variables" in include_relationships:
+            state["tool_exec_environment_variables"] = await self.awaitable_attrs.tool_exec_environment_variables
+
+        if "enable_sleeptime" in include_relationships:
+            state["enable_sleeptime"] = await self.awaitable_attrs.enable_sleeptime
+
+        return self.__pydantic_model__(**state)

letta/orm/block.py

@@ -39,6 +39,9 @@ class Block(OrganizationMixin, SqlalchemyBase):
     limit: Mapped[BigInteger] = mapped_column(Integer, default=CORE_MEMORY_BLOCK_CHAR_LIMIT, doc="Character limit of the block.")
     metadata_: Mapped[Optional[dict]] = mapped_column(JSON, default={}, doc="arbitrary information related to the block.")
 
+    # permissions of the agent
+    read_only: Mapped[bool] = mapped_column(doc="whether the agent has read-only access to the block", default=False)
+
     # history pointers / locking mechanisms
     current_history_entry_id: Mapped[Optional[str]] = mapped_column(
         String, ForeignKey("block_history.id", name="fk_block_current_history_entry", use_alter=True), nullable=True, index=True