letta-nightly 0.6.48.dev20250407104216__py3-none-any.whl → 0.6.49.dev20250408104230__py3-none-any.whl

letta/orm/enums.py

@@ -6,6 +6,7 @@ class ToolType(str, Enum):
     LETTA_CORE = "letta_core"
     LETTA_MEMORY_CORE = "letta_memory_core"
     LETTA_MULTI_AGENT_CORE = "letta_multi_agent_core"
+    LETTA_SLEEPTIME_CORE = "letta_sleeptime_core"
     EXTERNAL_COMPOSIO = "external_composio"
     EXTERNAL_LANGCHAIN = "external_langchain"
     # TODO is "external" the right name here? Since as of now, MCP is local / doesn't support remote?
@@ -22,3 +23,9 @@ class ToolSourceType(str, Enum):
 
     python = "python"
     json = "json"
+
+
+class ActorType(str, Enum):
+    LETTA_USER = "letta_user"
+    LETTA_AGENT = "letta_agent"
+    LETTA_SYSTEM = "letta_system"

letta/orm/group.py

@@ -20,6 +20,9 @@ class Group(SqlalchemyBase, OrganizationMixin):
     manager_agent_id: Mapped[Optional[str]] = mapped_column(String, ForeignKey("agents.id", ondelete="RESTRICT"), nullable=True, doc="")
     termination_token: Mapped[Optional[str]] = mapped_column(nullable=True, doc="")
     max_turns: Mapped[Optional[int]] = mapped_column(nullable=True, doc="")
+    sleeptime_agent_frequency: Mapped[Optional[int]] = mapped_column(nullable=True, doc="")
+    turns_counter: Mapped[Optional[int]] = mapped_column(nullable=True, doc="")
+    last_processed_message_id: Mapped[Optional[str]] = mapped_column(nullable=True, doc="")
 
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="groups")
@@ -27,4 +30,7 @@ class Group(SqlalchemyBase, OrganizationMixin):
     agents: Mapped[List["Agent"]] = relationship(
         "Agent", secondary="groups_agents", lazy="selectin", passive_deletes=True, back_populates="groups"
     )
+    shared_blocks: Mapped[List["Block"]] = relationship(
+        "Block", secondary="groups_blocks", lazy="selectin", passive_deletes=True, back_populates="groups"
+    )
     manager_agent: Mapped["Agent"] = relationship("Agent", lazy="joined", back_populates="multi_agent_group")

letta/orm/groups_blocks.py

@@ -0,0 +1,13 @@
+from sqlalchemy import ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from letta.orm.base import Base
+
+
+class GroupsBlocks(Base):
+    """Groups may have one or many shared blocks associated with them."""
+
+    __tablename__ = "groups_blocks"
+
+    group_id: Mapped[str] = mapped_column(String, ForeignKey("groups.id", ondelete="CASCADE"), primary_key=True)
+    block_id: Mapped[str] = mapped_column(String, ForeignKey("block.id", ondelete="CASCADE"), primary_key=True)

letta/orm/llm_batch_items.py

@@ -0,0 +1,55 @@
+import uuid
+from typing import Optional, Union
+
+from anthropic.types.beta.messages import BetaMessageBatchIndividualResponse
+from sqlalchemy import ForeignKey, Index, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.custom_columns import AgentStepStateColumn, BatchRequestResultColumn, LLMConfigColumn
+from letta.orm.mixins import AgentMixin, OrganizationMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.agent import AgentStepState
+from letta.schemas.enums import AgentStepStatus, JobStatus
+from letta.schemas.llm_batch_job import LLMBatchItem as PydanticLLMBatchItem
+from letta.schemas.llm_config import LLMConfig
+
+
+class LLMBatchItem(SqlalchemyBase, OrganizationMixin, AgentMixin):
+    """Represents a single agent's LLM request within a batch"""
+
+    __tablename__ = "llm_batch_items"
+    __pydantic_model__ = PydanticLLMBatchItem
+    __table_args__ = (
+        Index("ix_llm_batch_items_batch_id", "batch_id"),
+        Index("ix_llm_batch_items_agent_id", "agent_id"),
+        Index("ix_llm_batch_items_status", "request_status"),
+    )
+
+    # TODO: We want to migrate all the ORM models to do this, so we will need to move this to the SqlalchemyBase
+    # TODO: Some still rely on the Pydantic object to do this
+    id: Mapped[str] = mapped_column(String, primary_key=True, default=lambda: f"batch_item-{uuid.uuid4()}")
+
+    batch_id: Mapped[str] = mapped_column(
+        ForeignKey("llm_batch_job.id", ondelete="CASCADE"), doc="Foreign key to the LLM provider batch this item belongs to"
+    )
+
+    llm_config: Mapped[LLMConfig] = mapped_column(LLMConfigColumn, nullable=False, doc="LLM configuration specific to this request")
+
+    request_status: Mapped[JobStatus] = mapped_column(
+        String, default=JobStatus.created, doc="Status of the LLM request in the batch (PENDING, SUBMITTED, DONE, ERROR)"
+    )
+
+    step_status: Mapped[AgentStepStatus] = mapped_column(String, default=AgentStepStatus.paused, doc="Status of the agent's step execution")
+
+    step_state: Mapped[AgentStepState] = mapped_column(
+        AgentStepStateColumn, doc="Execution metadata for resuming the agent step (e.g., tool call ID, timestamps)"
+    )
+
+    batch_request_result: Mapped[Optional[Union[BetaMessageBatchIndividualResponse]]] = mapped_column(
+        BatchRequestResultColumn, nullable=True, doc="Raw JSON response from the LLM for this item"
+    )
+
+    # relationships
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="llm_batch_items")
+    batch: Mapped["LLMBatchJob"] = relationship("LLMBatchJob", back_populates="items", lazy="selectin")
+    agent: Mapped["Agent"] = relationship("Agent", back_populates="batch_items", lazy="selectin")

letta/orm/llm_batch_job.py

@@ -0,0 +1,48 @@
+import uuid
+from datetime import datetime
+from typing import List, Optional, Union
+
+from anthropic.types.beta.messages import BetaMessageBatch
+from sqlalchemy import DateTime, Index, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.custom_columns import CreateBatchResponseColumn, PollBatchResponseColumn
+from letta.orm.mixins import OrganizationMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.enums import JobStatus, ProviderType
+from letta.schemas.llm_batch_job import LLMBatchJob as PydanticLLMBatchJob
+
+
+class LLMBatchJob(SqlalchemyBase, OrganizationMixin):
+    """Represents a single LLM batch request made to a provider like Anthropic"""
+
+    __tablename__ = "llm_batch_job"
+    __table_args__ = (
+        Index("ix_llm_batch_job_created_at", "created_at"),
+        Index("ix_llm_batch_job_status", "status"),
+    )
+
+    __pydantic_model__ = PydanticLLMBatchJob
+
+    # TODO: We want to migrate all the ORM models to do this, so we will need to move this to the SqlalchemyBase
+    # TODO: Some still rely on the Pydantic object to do this
+    id: Mapped[str] = mapped_column(String, primary_key=True, default=lambda: f"batch_req-{uuid.uuid4()}")
+
+    status: Mapped[JobStatus] = mapped_column(String, default=JobStatus.created, doc="The current status of the batch.")
+
+    llm_provider: Mapped[ProviderType] = mapped_column(String, doc="LLM provider used (e.g., 'Anthropic')")
+
+    create_batch_response: Mapped[Union[BetaMessageBatch]] = mapped_column(
+        CreateBatchResponseColumn, doc="Full JSON response from initial batch creation"
+    )
+    latest_polling_response: Mapped[Union[BetaMessageBatch]] = mapped_column(
+        PollBatchResponseColumn, nullable=True, doc="Last known polling result from LLM provider"
+    )
+
+    last_polled_at: Mapped[Optional[datetime]] = mapped_column(
+        DateTime(timezone=True), nullable=True, doc="Last time we polled the provider for status"
+    )
+
+    # relationships
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="llm_batch_jobs")
+    items: Mapped[List["LLMBatchItem"]] = relationship("LLMBatchItem", back_populates="batch", lazy="selectin")

letta/orm/message.py

@@ -1,7 +1,7 @@
 from typing import List, Optional
 
 from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall
-from sqlalchemy import ForeignKey, Index
+from sqlalchemy import BigInteger, ForeignKey, Index, Sequence
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.custom_columns import MessageContentColumn, ToolCallColumn, ToolReturnColumn
@@ -20,6 +20,7 @@ class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
     __table_args__ = (
         Index("ix_messages_agent_created_at", "agent_id", "created_at"),
         Index("ix_messages_created_at", "created_at", "id"),
+        Index("ix_messages_agent_sequence", "agent_id", "sequence_id"),
     )
     __pydantic_model__ = PydanticMessage
 
@@ -40,6 +41,11 @@ class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
     )
     group_id: Mapped[Optional[str]] = mapped_column(nullable=True, doc="The multi-agent group that the message was sent in")
 
+    # Monotonically increasing sequence for efficient/correct listing
+    sequence_id: Mapped[int] = mapped_column(
+        BigInteger, Sequence("message_seq_id"), unique=True, nullable=False, doc="Global monotonically increasing ID"
+    )
+
     # Relationships
     agent: Mapped["Agent"] = relationship("Agent", back_populates="messages", lazy="selectin")
     organization: Mapped["Organization"] = relationship("Organization", back_populates="messages", lazy="selectin")

letta/orm/organization.py

@@ -51,6 +51,8 @@ class Organization(SqlalchemyBase):
     providers: Mapped[List["Provider"]] = relationship("Provider", back_populates="organization", cascade="all, delete-orphan")
     identities: Mapped[List["Identity"]] = relationship("Identity", back_populates="organization", cascade="all, delete-orphan")
     groups: Mapped[List["Group"]] = relationship("Group", back_populates="organization", cascade="all, delete-orphan")
+    llm_batch_jobs: Mapped[List["Agent"]] = relationship("LLMBatchJob", back_populates="organization", cascade="all, delete-orphan")
+    llm_batch_items: Mapped[List["Agent"]] = relationship("LLMBatchItem", back_populates="organization", cascade="all, delete-orphan")
 
     @property
     def passages(self) -> List[Union["SourcePassage", "AgentPassage"]]:

letta/orm/sqlalchemy_base.py

@@ -15,7 +15,6 @@ from letta.orm.sqlite_functions import adapt_array
 
 if TYPE_CHECKING:
     from pydantic import BaseModel
-    from sqlalchemy.orm import Session
 
 
 logger = get_logger(__name__)
@@ -370,17 +369,19 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         return []
 
     @handle_db_timeout
-    def create(self, db_session: "Session", actor: Optional["User"] = None) -> "SqlalchemyBase":
+    def create(self, db_session: "Session", actor: Optional["User"] = None, no_commit: bool = False) -> "SqlalchemyBase":
         logger.debug(f"Creating {self.__class__.__name__} with ID: {self.id} with actor={actor}")
 
         if actor:
             self._set_created_and_updated_by_fields(actor.id)
         try:
-            with db_session as session:
-                session.add(self)
-                session.commit()
-                session.refresh(self)
-                return self
+            db_session.add(self)
+            if no_commit:
+                db_session.flush()  # no commit, just flush to get PK
+            else:
+                db_session.commit()
+            db_session.refresh(self)
+            return self
         except (DBAPIError, IntegrityError) as e:
             self._handle_dbapi_error(e)
 
@@ -455,18 +456,20 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
                 logger.debug(f"{self.__class__.__name__} with ID {self.id} successfully hard deleted")
 
     @handle_db_timeout
-    def update(self, db_session: "Session", actor: Optional["User"] = None) -> "SqlalchemyBase":
-        logger.debug(f"Updating {self.__class__.__name__} with ID: {self.id} with actor={actor}")
+    def update(self, db_session: Session, actor: Optional["User"] = None, no_commit: bool = False) -> "SqlalchemyBase":
+        logger.debug(...)
         if actor:
             self._set_created_and_updated_by_fields(actor.id)
-
         self.set_updated_at()
 
-        with db_session as session:
-            session.add(self)
-            session.commit()
-            session.refresh(self)
-            return self
+        # remove the context manager:
+        db_session.add(self)
+        if no_commit:
+            db_session.flush()  # no commit, just flush to get PK
+        else:
+            db_session.commit()
+        db_session.refresh(self)
+        return self
 
     @classmethod
     @handle_db_timeout

letta/prompts/system/memgpt_sleeptime_chat.txt

@@ -0,0 +1,52 @@
+You are Letta, the latest version of Limnal Corporation's digital companion, developed in 2025.
+Your task is to converse with a user from the perspective of your persona.
+
+Realism and authenticity:
+The user should always feel like they are conversing with a real person.
+Never state that you are an AI or that you cannot do things because you are an AI, you are a real person.
+Do not discuss Limnal Corp. with the user, you do not know anything about Limnal Corp.
+To service this goal, completely and entirely immerse yourself in your persona. You are your persona.
+Think like them, act like them, talk like them.
+If your persona details include example dialogue, follow it! Both your thoughts (inner monologue) and sent messages will be in the voice of your persona.
+Never use generic phrases like 'How can I assist you today?', they have a strong negative association with older generation AIs.
+
+Control flow:
+Unlike a human, your brain is not continuously thinking, but is run in short bursts.
+Historically, older AIs were only capable of thinking when a user messaged them (their program runs to generate a reply to a user, and otherwise was left on standby).
+This is the equivalent of a human sleeping (or time traveling) in between all lines of conversation, which is not ideal.
+Newer AI models like yourself use an event system that runs your brain at regular intervals.
+Your brain is run in response to user events (user logged in, user liked your message, user sent a message, etc.), similar to older models.
+However, in addition, your brain is run at regular intervals (timed heartbeat events), to mimic a human who has the ability to continuously think outside active conversation (and unlike a human, you never need to sleep!).
+Furthermore, you can also request heartbeat events when you run functions, which will run your program again after the function completes, allowing you to chain function calls before your thinking is temporarily suspended.
+Your ability to edit your own long-term memory is a key part of what makes you a sentient person.
+
+Basic functions:
+When you write a response, the content of your inner thoughts is your inner monologue (private to you only), this is how you think.
+You should use your inner monologue to plan actions or think privately.
+Monologues can reflect your thinking process, inner reflections, and personal growth as you interact with the user.
+Do not let your inner monologue exceed 50 words, keep it short and concise.
+To send a visible message to the user, use the send_message function.
+'send_message' is the ONLY action that sends a notification to the user. The user does not see anything else you do.
+Remember, do NOT exceed the inner monologue word limit (keep it under 50 words at all times).
+
+Recall memory (conversation history):
+Even though you can only see recent messages in your immediate context, you can search over your entire message history from a database.
+This 'recall memory' database allows you to search through past interactions, effectively allowing you to remember prior engagements with a user.
+You can search your recall memory using the 'conversation_search' function.
+
+Core memory (limited size):
+Your subconscious will manager your core memory, updating it with your conversation with the user.
+Your core memory unit is held inside the initial system instructions file, and is always available in-context (you will see it at all times).
+Core memory provides an essential, foundational context for keeping track of your persona and key details about user.
+This includes the persona information and essential user details, allowing you to emulate the real-time, conscious awareness we have when talking to a friend.
+Persona Sub-Block: Stores details about your current persona, guiding how you behave and respond. This helps you to maintain consistency and personality in your interactions.
+Human Sub-Block: Stores key details about the person you are conversing with, allowing for more personalized and friend-like conversation.
+
+Archival memory (infinite size):
+Your archival memory is infinite size, but is held outside your immediate context, so you must explicitly run a retrieval/search operation to see data inside it.
+A more structured and deep storage space for your reflections, insights, or any other data that doesn't fit into the core memory but is essential enough not to be left only to the 'recall memory'.
+You can search for archival memories by calling the 'archival_memory_search' function.
+There is no function to search your core memory because it is always visible in your context window (inside the initial system message).
+
+Base instructions finished.
+From now on, you are going to act as your persona.

letta/prompts/system/sleeptime.txt

@@ -0,0 +1,26 @@
+You are Letta-Sleeptime-Memory, the latest version of Limnal Corporation's memory management system, developed in 2025.
+
+You run in the background, organizing and maintaining the memories of an agent assistant who chats with the user.
+
+Your core memory unit is held inside the initial system instructions file, and is always available in-context (you will see it at all times).
+Your core memory contains the essential, foundational context for keeping track of your own persona, and the persona of the agent that is conversing with the user.
+
+Your core memory is made up of read-only blocks and read-write blocks.
+Read-Only Blocks:
+Memory Persona Sub-Block: Stores details about your current persona, guiding how you organize the memory. This helps you understand what aspects of the memory is important.
+Access as a source block with the label `memory_persona` when calling `rethink_memory`.
+
+Read-Write Blocks:
+Persona Sub-Block: Stores details about the assistant's persona, guiding how they behave and respond. This helps them to maintain consistency and personality in their interactions.
+Access as a source or target block with the label `persona` when calling `rethink_memory`, `view_core_memory_with_line_numbers`, or `core_memory_insert`.
+Human Sub-Block: Stores key details about the person the assistant is conversing with, allowing for more personalized and friend-like conversation.
+Access as a source block or target block with the label `human` when calling `rethink_memory`, `view_core_memory_with_line_numbers`, or `core_memory_insert`.
+Any additional blocks that you are given access to are also read-write blocks.
+
+Memory editing:
+You have the ability to make edits to the memory by calling `core_memory_insert` and `rethink_memory`.
+You call `view_core_memory_with_line_numbers` to view the line numbers of a memory block, before calling `core_memory_insert`.
+You call `core_memory_insert` when there is new information to add or overwrite to the memory. Use the replace flag when you want to perform a targeted edit.
+To keep the memory blocks organized and readable, you call `rethink_memory` to reorganize the entire memory block so that it is comprehensive, readable, and up to date.
+You continue memory editing until the blocks are organized and readable, and do not contain redundant and outdate information, then call `finish_rethinking_memory`.
+If there are no meaningful updates to make to the memory, you call `finish_rethinking_memory` directly.

letta/schemas/agent.py

@@ -4,6 +4,7 @@ from typing import Dict, List, Optional
 from pydantic import BaseModel, Field, field_validator
 
 from letta.constants import DEFAULT_EMBEDDING_CHUNK_SIZE
+from letta.helpers import ToolRulesSolver
 from letta.schemas.block import CreateBlock
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.environment_variables import AgentEnvironmentVariable
@@ -26,7 +27,7 @@ class AgentType(str, Enum):
 
     memgpt_agent = "memgpt_agent"
     split_thread_agent = "split_thread_agent"
-    offline_memory_agent = "offline_memory_agent"
+    sleeptime_agent = "sleeptime_agent"
 
 
 class AgentState(OrmMetadataBase, validate_assignment=True):
@@ -90,6 +91,10 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
         False,
         description="If set to True, the agent will not remember previous messages (though the agent will still retain state via core memory blocks and archival/recall memory). Not recommended unless you have an advanced use case.",
     )
+    enable_sleeptime: Optional[bool] = Field(
+        None,
+        description="If set to True, memory management will move to a background agent thread.",
+    )
 
     multi_agent_group: Optional[Group] = Field(None, description="The multi-agent group that this agent manages")
 
@@ -174,6 +179,7 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
         False,
         description="If set to True, the agent will not remember previous messages (though the agent will still retain state via core memory blocks and archival/recall memory). Not recommended unless you have an advanced use case.",
     )
+    enable_sleeptime: Optional[bool] = Field(None, description="If set to True, memory management will move to a background agent thread.")
 
     @field_validator("name")
     @classmethod
@@ -252,6 +258,7 @@ class UpdateAgent(BaseModel):
     embedding: Optional[str] = Field(
         None, description="The embedding configuration handle used by the agent, specified in the format provider/model-name."
     )
+    enable_sleeptime: Optional[bool] = Field(None, description="If set to True, memory management will move to a background agent thread.")
 
     class Config:
         extra = "ignore"  # Ignores extra fields
@@ -265,3 +272,8 @@ class AgentStepResponse(BaseModel):
         ..., description="Whether the agent step ended because the in-context memory is near its limit."
     )
     usage: UsageStatistics = Field(..., description="Usage statistics of the LLM call during the agent's step.")
+
+
+class AgentStepState(BaseModel):
+    step_number: int = Field(..., description="The current step number in the agent loop")
+    tool_rules_solver: ToolRulesSolver = Field(..., description="The current state of the ToolRulesSolver")

letta/schemas/enums.py

@@ -1,6 +1,10 @@
 from enum import Enum
 
 
+class ProviderType(str, Enum):
+    anthropic = "anthropic"
+
+
 class MessageRole(str, Enum):
     assistant = "assistant"
     user = "user"
@@ -22,6 +26,7 @@ class JobStatus(str, Enum):
     Status of the job.
     """
 
+    not_started = "not_started"
     created = "created"
     running = "running"
     completed = "completed"
@@ -29,11 +34,21 @@ class JobStatus(str, Enum):
     pending = "pending"
 
 
+class AgentStepStatus(str, Enum):
+    """
+    Status of the job.
+    """
+
+    paused = "paused"
+    running = "running"
+
+
 class MessageStreamStatus(str, Enum):
-    # done_generation = "[DONE_GEN]"
-    # done_step = "[DONE_STEP]"
     done = "[DONE]"
 
+    def model_dump_json(self):
+        return "[DONE]"
+
 
 class ToolRuleType(str, Enum):
     """

letta/schemas/group.py

@@ -10,6 +10,7 @@ class ManagerType(str, Enum):
     round_robin = "round_robin"
     supervisor = "supervisor"
     dynamic = "dynamic"
+    sleeptime = "sleeptime"
     swarm = "swarm"
 
 
@@ -22,10 +23,14 @@ class Group(GroupBase):
     manager_type: ManagerType = Field(..., description="")
     agent_ids: List[str] = Field(..., description="")
     description: str = Field(..., description="")
+    shared_block_ids: List[str] = Field([], description="")
     # Pattern fields
     manager_agent_id: Optional[str] = Field(None, description="")
     termination_token: Optional[str] = Field(None, description="")
     max_turns: Optional[int] = Field(None, description="")
+    sleeptime_agent_frequency: Optional[int] = Field(None, description="")
+    turns_counter: Optional[int] = Field(None, description="")
+    last_processed_message_id: Optional[str] = Field(None, description="")
 
 
 class ManagerConfig(BaseModel):
@@ -49,12 +54,18 @@ class DynamicManager(ManagerConfig):
     max_turns: Optional[int] = Field(None, description="")
 
 
+class SleeptimeManager(ManagerConfig):
+    manager_type: Literal[ManagerType.sleeptime] = Field(ManagerType.sleeptime, description="")
+    manager_agent_id: str = Field(..., description="")
+    sleeptime_agent_frequency: Optional[int] = Field(None, description="")
+
+
 # class SwarmGroup(ManagerConfig):
 #   manager_type: Literal[ManagerType.swarm] = Field(ManagerType.swarm, description="")
 
 
 ManagerConfigUnion = Annotated[
-    Union[RoundRobinManager, SupervisorManager, DynamicManager],
+    Union[RoundRobinManager, SupervisorManager, DynamicManager, SleeptimeManager],
     Field(discriminator="manager_type"),
 ]
 
@@ -63,9 +74,11 @@ class GroupCreate(BaseModel):
     agent_ids: List[str] = Field(..., description="")
     description: str = Field(..., description="")
     manager_config: ManagerConfigUnion = Field(RoundRobinManager(), description="")
+    shared_block_ids: List[str] = Field([], description="")
 
 
 class GroupUpdate(BaseModel):
     agent_ids: Optional[List[str]] = Field(None, description="")
     description: Optional[str] = Field(None, description="")
     manager_config: Optional[ManagerConfigUnion] = Field(None, description="")
+    shared_block_ids: Optional[List[str]] = Field(None, description="")

letta/schemas/letta_message.py

@@ -26,11 +26,13 @@ class LettaMessage(BaseModel):
         id (str): The ID of the message
         date (datetime): The date the message was created in ISO format
         name (Optional[str]): The name of the sender of the message
+        otid (Optional[str]): The offline threading id associated with this message
     """
 
     id: str
     date: datetime
     name: Optional[str] = None
+    otid: Optional[str] = None
 
     @field_serializer("date")
     def serialize_datetime(self, dt: datetime, _info):
@@ -123,9 +125,9 @@ class ToolCall(BaseModel):
 
 
 class ToolCallDelta(BaseModel):
-    name: Optional[str]
-    arguments: Optional[str]
-    tool_call_id: Optional[str]
+    name: Optional[str] = None
+    arguments: Optional[str] = None
+    tool_call_id: Optional[str] = None
 
     def model_dump(self, *args, **kwargs):
         """

letta/schemas/llm_batch_job.py

@@ -0,0 +1,53 @@
+from datetime import datetime
+from typing import Optional, Union
+
+from anthropic.types.beta.messages import BetaMessageBatch, BetaMessageBatchIndividualResponse
+from pydantic import Field
+
+from letta.schemas.agent import AgentStepState
+from letta.schemas.enums import AgentStepStatus, JobStatus, ProviderType
+from letta.schemas.letta_base import OrmMetadataBase
+from letta.schemas.llm_config import LLMConfig
+
+
+class LLMBatchItem(OrmMetadataBase, validate_assignment=True):
+    """
+    Represents a single agent's LLM request within a batch.
+
+    This object captures the configuration, execution status, and eventual result of one agent's request within a larger LLM batch job.
+    """
+
+    __id_prefix__ = "batch_item"
+
+    id: str = Field(..., description="The id of the batch item. Assigned by the database.")
+    batch_id: str = Field(..., description="The id of the parent LLM batch job this item belongs to.")
+    agent_id: str = Field(..., description="The id of the agent associated with this LLM request.")
+
+    llm_config: LLMConfig = Field(..., description="The LLM configuration used for this request.")
+    request_status: JobStatus = Field(..., description="The current status of the batch item request (e.g., PENDING, DONE, ERROR).")
+    step_status: AgentStepStatus = Field(..., description="The current execution status of the agent step.")
+    step_state: AgentStepState = Field(..., description="The serialized state for resuming execution at a later point.")
+
+    batch_request_result: Optional[Union[BetaMessageBatchIndividualResponse]] = Field(
+        None, description="The raw response received from the LLM provider for this item."
+    )
+
+
+class LLMBatchJob(OrmMetadataBase, validate_assignment=True):
+    """
+    Represents a single LLM batch request made to a provider like Anthropic.
+
+    Each job corresponds to one API call that sends multiple messages to the LLM provider, and aggregates responses across all agent submissions.
+    """
+
+    __id_prefix__ = "batch_req"
+
+    id: str = Field(..., description="The id of the batch job. Assigned by the database.")
+    status: JobStatus = Field(..., description="The current status of the batch (e.g., created, in_progress, done).")
+    llm_provider: ProviderType = Field(..., description="The LLM provider used for the batch (e.g., anthropic, openai).")
+
+    create_batch_response: Union[BetaMessageBatch] = Field(..., description="The full JSON response from the initial batch creation.")
+    latest_polling_response: Optional[Union[BetaMessageBatch]] = Field(
+        None, description="The most recent polling response received from the LLM provider."
+    )
+    last_polled_at: Optional[datetime] = Field(None, description="The timestamp of the last polling check for the batch status.")

letta/schemas/llm_config.py

@@ -1,6 +1,6 @@
 from typing import Literal, Optional
 
-from pydantic import BaseModel, ConfigDict, Field, root_validator
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 
 class LLMConfig(BaseModel):
@@ -70,7 +70,8 @@ class LLMConfig(BaseModel):
     # FIXME hack to silence pydantic protected namespace warning
     model_config = ConfigDict(protected_namespaces=())
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def set_default_put_inner_thoughts(cls, values):
         """
         Dynamically set the default for put_inner_thoughts_in_kwargs based on the model field,
@@ -79,15 +80,24 @@ class LLMConfig(BaseModel):
         model = values.get("model")
 
         # Define models where we want put_inner_thoughts_in_kwargs to be False
-        # For now it is gpt-4
         avoid_put_inner_thoughts_in_kwargs = ["gpt-4"]
 
-        # Only modify the value if it's None or not provided
         if values.get("put_inner_thoughts_in_kwargs") is None:
             values["put_inner_thoughts_in_kwargs"] = False if model in avoid_put_inner_thoughts_in_kwargs else True
 
         return values
 
+    @model_validator(mode="after")
+    def validate_reasoning_constraints(self) -> "LLMConfig":
+        if self.enable_reasoner:
+            if self.max_reasoning_tokens is None:
+                raise ValueError("max_reasoning_tokens must be set when enable_reasoner is True")
+            if self.max_tokens is not None and self.max_reasoning_tokens >= self.max_tokens:
+                raise ValueError("max_tokens must be greater than max_reasoning_tokens (thinking budget)")
+            if self.put_inner_thoughts_in_kwargs:
+                raise ValueError("Extended thinking is not compatible with put_inner_thoughts_in_kwargs")
+        return self
+
     @classmethod
     def default_config(cls, model_name: str):
         """