letta-nightly 0.7.15.dev20250514104255__py3-none-any.whl → 0.7.16.dev20250515205957__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/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