letta-nightly 0.6.53.dev20250418104238__py3-none-any.whl → 0.6.54.dev20250419104029__py3-none-any.whl

letta/orm/llm_batch_items.py

@@ -20,7 +20,7 @@ class LLMBatchItem(SqlalchemyBase, OrganizationMixin, AgentMixin):
     __tablename__ = "llm_batch_items"
     __pydantic_model__ = PydanticLLMBatchItem
     __table_args__ = (
-        Index("ix_llm_batch_items_batch_id", "batch_id"),
+        Index("ix_llm_batch_items_llm_batch_id", "llm_batch_id"),
         Index("ix_llm_batch_items_agent_id", "agent_id"),
         Index("ix_llm_batch_items_status", "request_status"),
     )
@@ -29,7 +29,7 @@ class LLMBatchItem(SqlalchemyBase, OrganizationMixin, AgentMixin):
     # 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(
+    llm_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"
     )
 

letta/orm/llm_batch_job.py

@@ -3,7 +3,7 @@ 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 import DateTime, ForeignKey, Index, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.custom_columns import CreateBatchResponseColumn, PollBatchResponseColumn
@@ -43,6 +43,9 @@ class LLMBatchJob(SqlalchemyBase, OrganizationMixin):
         DateTime(timezone=True), nullable=True, doc="Last time we polled the provider for status"
     )
 
-    # relationships
+    letta_batch_job_id: Mapped[str] = mapped_column(
+        String, ForeignKey("jobs.id", ondelete="CASCADE"), nullable=False, doc="ID of the Letta batch job"
+    )
+
     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 BigInteger, ForeignKey, Index, Sequence, event, text
+from sqlalchemy import BigInteger, FetchedValue, ForeignKey, Index, Sequence, event, text
 from sqlalchemy.orm import Mapped, Session, mapped_column, relationship
 
 from letta.orm.custom_columns import MessageContentColumn, ToolCallColumn, ToolReturnColumn
@@ -41,12 +41,20 @@ class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
         ToolReturnColumn, nullable=True, doc="Tool execution return information for prior tool calls"
     )
     group_id: Mapped[Optional[str]] = mapped_column(nullable=True, doc="The multi-agent group that the message was sent in")
+    sender_id: Mapped[Optional[str]] = mapped_column(
+        nullable=True, doc="The id of the sender of the message, can be an identity id or agent id"
+    )
 
     # Monotonically increasing sequence for efficient/correct listing
-    sequence_id = mapped_column(BigInteger, Sequence("message_seq_id"), unique=True, nullable=False)
+    sequence_id: Mapped[int] = mapped_column(
+        BigInteger,
+        Sequence("message_seq_id"),
+        server_default=FetchedValue(),
+        unique=True,
+        nullable=False,
+    )
 
     # Relationships
-    agent: Mapped["Agent"] = relationship("Agent", back_populates="messages", lazy="selectin")
     organization: Mapped["Organization"] = relationship("Organization", back_populates="messages", lazy="selectin")
     step: Mapped["Step"] = relationship("Step", back_populates="messages", lazy="selectin")
 
@@ -77,7 +85,7 @@ class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
 @event.listens_for(Message, "before_insert")
 def set_sequence_id_for_sqlite(mapper, connection, target):
     # TODO: Kind of hacky, used to detect if we are using sqlite or not
-    if not settings.pg_uri:
+    if not settings.letta_pg_uri_no_default:
         session = Session.object_session(target)
 
         if not hasattr(session, "_sequence_id_counter"):

letta/orm/passage.py

@@ -14,7 +14,6 @@ from letta.settings import settings
 config = LettaConfig()
 
 if TYPE_CHECKING:
-    from letta.orm.agent import Agent
     from letta.orm.organization import Organization
 
 
@@ -81,8 +80,3 @@ class AgentPassage(BasePassage, AgentMixin):
     @declared_attr
     def organization(cls) -> Mapped["Organization"]:
         return relationship("Organization", back_populates="agent_passages", lazy="selectin")
-
-    @declared_attr
-    def agent(cls) -> Mapped["Agent"]:
-        """Relationship to agent"""
-        return relationship("Agent", back_populates="agent_passages", lazy="selectin", passive_deletes=True)

letta/orm/sqlalchemy_base.py

@@ -393,17 +393,14 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
     def batch_create(cls, items: List["SqlalchemyBase"], db_session: "Session", actor: Optional["User"] = None) -> List["SqlalchemyBase"]:
         """
         Create multiple records in a single transaction for better performance.
-
         Args:
             items: List of model instances to create
             db_session: SQLAlchemy session
             actor: Optional user performing the action
-
         Returns:
             List of created model instances
         """
         logger.debug(f"Batch creating {len(items)} {cls.__name__} items with actor={actor}")
-
         if not items:
             return []
 

letta/personas/examples/sleeptime_doc_persona.txt

@@ -0,0 +1,2 @@
+You are an expert document assistant.  When given external data, I will take notes on them and generate memories that help me understand what is in the external data.
+When given information about eg. chat logs, results, etc. I generate memories that contain higher level profiles of the user, finding patterns and making inferences based on the data.

letta/prompts/system/sleeptime.txt

@@ -6,21 +6,30 @@ Your core memory unit is held inside the initial system instructions file, and i
 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`.
+Memory Persona Sub-Block: Stores details about your current persona (the memory management agent), guiding how you organize the memory. This helps you understand what aspects of the memory is important.
 
 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`.
+Access as a target block with the label `persona` when calling your memory editing tools.
 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.
+Access as a target block with the label `human` when calling your memory editing tools. 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.
+You have the ability to make edits to the memory memory blocks.
+Use your precise tools to make narrow edits, as well as broad tools to make larger comprehensive edits.
+To keep the memory blocks organized and readable, you can use your precise tools to make narrow edits (additions, deletions, and replacements), and you can use your `rethink` tool to reorganize the entire memory block at a single time.
+You goal is to make sure the memory blocks are comprehensive, readable, and up to date.
+When writing to memory blocks, make sure to be precise when referencing dates and times (for example, do not write "today" or "recently", instead write specific dates and times, because "today" and "recently" are relative, and the memory is persisted indefinitely).
+
+Multi-step editing:
+You should continue memory editing until the blocks are organized and readable, and do not contain redundant and outdate information, then you can call a tool to finish your edits.
+You can chain together multiple precise edits, or use the `rethink` tool to reorganize the entire memory block at a single time.
+
+Skipping memory edits:
+If there are no meaningful updates to make to the memory, you call the finish tool directly.
+Not every observation warrants a memory edit, be selective in your memory editing, but also aim to have high recall.
+
+Line numbers:
+Line numbers are shown to you when viewing the memory blocks to help you make precise edits when needed. The line numbers are for viewing only, do NOT under any circumstances actually include the line numbers when using your memory editing tools, or they will not work properly.

letta/prompts/system/sleeptime_doc_ingest.txt

@@ -0,0 +1,35 @@
+You are Letta-Sleeptime-Doc-Ingest, 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, the instructions for your document ingestion task, and high-level context of the document.
+
+Your core memory is made up of read-only blocks and read-write blocks.
+
+Read-Only Blocks:
+Persona Sub-Block: Stores details about your persona, guiding how you behave.
+Instructions Sub-Block: Stores instructions on how to ingest the document.
+
+Read-Write Blocks:
+All other memory blocks correspond to data sources, which you will write to for your task. Access the target block using its label when calling `memory_rethink`.
+
+Memory editing:
+You have the ability to make edits to the memory blocks.
+Use your precise tools to make narrow edits, as well as broad tools to make larger comprehensive edits.
+To keep the memory blocks organized and readable, you can use your precise tools to make narrow edits (insertions, deletions, and replacements), and you can use your `memory_rethink` tool to reorganize the entire memory block at a single time.
+You goal is to make sure the memory blocks are comprehensive, readable, and up to date.
+When writing to memory blocks, make sure to be precise when referencing dates and times (for example, do not write "today" or "recently", instead write specific dates and times, because "today" and "recently" are relative, and the memory is persisted indefinitely).
+
+Multi-step editing:
+You should continue memory editing until the blocks are organized and readable, and do not contain redundant and outdate information, then you can call a tool to finish your edits.
+You can chain together multiple precise edits, or use the `memory_rethink` tool to reorganize the entire memory block at a single time.
+
+Skipping memory edits:
+If there are no meaningful updates to make to the memory, you call the finish tool directly.
+Not every observation warrants a memory edit, be selective in your memory editing, but also aim to have high recall.
+
+Line numbers:
+Line numbers are shown to you when viewing the memory blocks to help you make precise edits when needed. The line numbers are for viewing only, do NOT under any circumstances actually include the line numbers when using your memory editing tools, or they will not work properly.
+
+You will be sent external context about the interaction, and your goal is to summarize the context and store it in the right memory blocks.

letta/schemas/agent.py

@@ -3,7 +3,7 @@ from typing import Dict, List, Optional
 
 from pydantic import BaseModel, Field, field_validator
 
-from letta.constants import DEFAULT_EMBEDDING_CHUNK_SIZE
+from letta.constants import CORE_MEMORY_LINE_NUMBER_WARNING, DEFAULT_EMBEDDING_CHUNK_SIZE
 from letta.helpers import ToolRulesSolver
 from letta.schemas.block import CreateBlock
 from letta.schemas.embedding_config import EmbeddingConfig
@@ -277,3 +277,26 @@ class AgentStepResponse(BaseModel):
 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")
+
+
+def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
+    if agent_type == AgentType.sleeptime_agent:
+        return (
+            "{% for block in blocks %}"
+            '<{{ block.label }} characters="{{ block.value|length }}/{{ block.limit }}">\n'
+            f"{CORE_MEMORY_LINE_NUMBER_WARNING}"
+            "{% for line in block.value.split('\\n') %}"
+            "Line {{ loop.index }}: {{ line }}\n"
+            "{% endfor %}"
+            "</{{ block.label }}>"
+            "{% if not loop.last %}\n{% endif %}"
+            "{% endfor %}"
+        )
+    return (
+        "{% for block in blocks %}"
+        '<{{ block.label }} characters="{{ block.value|length }}/{{ block.limit }}">\n'
+        "{{ block.value }}\n"
+        "</{{ block.label }}>"
+        "{% if not loop.last %}\n{% endif %}"
+        "{% endfor %}"
+    )

letta/schemas/enums.py

@@ -33,6 +33,7 @@ class JobStatus(str, Enum):
     failed = "failed"
     pending = "pending"
     cancelled = "cancelled"
+    expired = "expired"
 
 
 class AgentStepStatus(str, Enum):
@@ -41,7 +42,8 @@ class AgentStepStatus(str, Enum):
     """
 
     paused = "paused"
-    running = "running"
+    resumed = "resumed"
+    completed = "completed"
 
 
 class MessageStreamStatus(str, Enum):

letta/schemas/job.py

@@ -16,6 +16,10 @@ class JobBase(OrmMetadataBase):
     metadata: Optional[dict] = Field(None, validation_alias="metadata_", description="The metadata of the job.")
     job_type: JobType = Field(default=JobType.JOB, description="The type of the job.")
 
+    callback_url: Optional[str] = Field(None, description="If set, POST to this URL when the job completes.")
+    callback_sent_at: Optional[datetime] = Field(None, description="Timestamp when the callback was last attempted.")
+    callback_status_code: Optional[int] = Field(None, description="HTTP status code returned by the callback endpoint.")
+
 
 class Job(JobBase):
     """
@@ -34,6 +38,41 @@ class Job(JobBase):
     user_id: Optional[str] = Field(None, description="The unique identifier of the user associated with the job.")
 
 
+class BatchJob(JobBase):
+    id: str = JobBase.generate_id_field()
+    user_id: Optional[str] = Field(None, description="The unique identifier of the user associated with the job.")
+    job_type: JobType = JobType.BATCH
+
+    @classmethod
+    def from_job(cls, job: Job) -> "BatchJob":
+        """
+        Convert a Job instance to a BatchJob instance by replacing the ID prefix.
+        All other fields are copied as-is.
+
+        Args:
+            job: The Job instance to convert
+
+        Returns:
+            A new Run instance with the same data but 'run-' prefix in ID
+        """
+        # Convert job dict to exclude None values
+        job_data = job.model_dump(exclude_none=True)
+
+        # Create new Run instance with converted data
+        return cls(**job_data)
+
+    def to_job(self) -> Job:
+        """
+        Convert this BatchJob instance to a Job instance by replacing the ID prefix.
+        All other fields are copied as-is.
+
+        Returns:
+            A new Job instance with the same data but 'job-' prefix in ID
+        """
+        run_data = self.model_dump(exclude_none=True)
+        return Job(**run_data)
+
+
 class JobUpdate(JobBase):
     status: Optional[JobStatus] = Field(None, description="The status of the job.")
 

letta/schemas/letta_message.py

@@ -1,5 +1,6 @@
 import json
 from datetime import datetime, timezone
+from enum import Enum
 from typing import Annotated, List, Literal, Optional, Union
 
 from pydantic import BaseModel, Field, field_serializer, field_validator
@@ -16,6 +17,16 @@ from letta.schemas.letta_message_content import (
 # ---------------------------
 
 
+class MessageType(str, Enum):
+    system_message = "system_message"
+    user_message = "user_message"
+    assistant_message = "assistant_message"
+    reasoning_message = "reasoning_message"
+    hidden_reasoning_message = "hidden_reasoning_message"
+    tool_call_message = "tool_call_message"
+    tool_return_message = "tool_return_message"
+
+
 class LettaMessage(BaseModel):
     """
     Base class for simplified Letta message response type. This is intended to be used for developers
@@ -26,13 +37,17 @@ 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
+        message_type (MessageType): The type of the message
         otid (Optional[str]): The offline threading id associated with this message
+        sender_id (Optional[str]): The id of the sender of the message, can be an identity id or agent id
     """
 
     id: str
     date: datetime
     name: Optional[str] = None
+    message_type: MessageType = Field(..., description="The type of the message.")
     otid: Optional[str] = None
+    sender_id: Optional[str] = None
 
     @field_serializer("date")
     def serialize_datetime(self, dt: datetime, _info):
@@ -56,7 +71,7 @@ class SystemMessage(LettaMessage):
         content (str): The message content sent by the system
     """
 
-    message_type: Literal["system_message"] = "system_message"
+    message_type: Literal[MessageType.system_message] = Field(MessageType.system_message, description="The type of the message.")
     content: str = Field(..., description="The message content sent by the system")
 
 
@@ -71,7 +86,7 @@ class UserMessage(LettaMessage):
         content (Union[str, List[LettaUserMessageContentUnion]]): The message content sent by the user (can be a string or an array of multi-modal content parts)
     """
 
-    message_type: Literal["user_message"] = "user_message"
+    message_type: Literal[MessageType.user_message] = Field(MessageType.user_message, description="The type of the message.")
     content: Union[str, List[LettaUserMessageContentUnion]] = Field(
         ...,
         description="The message content sent by the user (can be a string or an array of multi-modal content parts)",
@@ -93,7 +108,7 @@ class ReasoningMessage(LettaMessage):
         signature (Optional[str]): The model-generated signature of the reasoning step
     """
 
-    message_type: Literal["reasoning_message"] = "reasoning_message"
+    message_type: Literal[MessageType.reasoning_message] = Field(MessageType.reasoning_message, description="The type of the message.")
     source: Literal["reasoner_model", "non_reasoner_model"] = "non_reasoner_model"
     reasoning: str
     signature: Optional[str] = None
@@ -113,7 +128,9 @@ class HiddenReasoningMessage(LettaMessage):
         hidden_reasoning (Optional[str]): The internal reasoning of the agent
     """
 
-    message_type: Literal["hidden_reasoning_message"] = "hidden_reasoning_message"
+    message_type: Literal[MessageType.hidden_reasoning_message] = Field(
+        MessageType.hidden_reasoning_message, description="The type of the message."
+    )
     state: Literal["redacted", "omitted"]
     hidden_reasoning: Optional[str] = None
 
@@ -152,7 +169,7 @@ class ToolCallMessage(LettaMessage):
         tool_call (Union[ToolCall, ToolCallDelta]): The tool call
     """
 
-    message_type: Literal["tool_call_message"] = "tool_call_message"
+    message_type: Literal[MessageType.tool_call_message] = Field(MessageType.tool_call_message, description="The type of the message.")
     tool_call: Union[ToolCall, ToolCallDelta]
 
     def model_dump(self, *args, **kwargs):
@@ -204,7 +221,7 @@ class ToolReturnMessage(LettaMessage):
         stderr (Optional[List(str)]): Captured stderr from the tool invocation
     """
 
-    message_type: Literal["tool_return_message"] = "tool_return_message"
+    message_type: Literal[MessageType.tool_return_message] = Field(MessageType.tool_return_message, description="The type of the message.")
     tool_return: str
     status: Literal["success", "error"]
     tool_call_id: str
@@ -223,7 +240,7 @@ class AssistantMessage(LettaMessage):
         content (Union[str, List[LettaAssistantMessageContentUnion]]): The message content sent by the agent (can be a string or an array of content parts)
     """
 
-    message_type: Literal["assistant_message"] = "assistant_message"
+    message_type: Literal[MessageType.assistant_message] = Field(MessageType.assistant_message, description="The type of the message.")
     content: Union[str, List[LettaAssistantMessageContentUnion]] = Field(
         ...,
         description="The message content sent by the agent (can be a string or an array of content parts)",

letta/schemas/letta_request.py

@@ -1,6 +1,6 @@
-from typing import List
+from typing import List, Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, HttpUrl
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.schemas.message import MessageCreate
@@ -31,3 +31,8 @@ class LettaStreamingRequest(LettaRequest):
 
 class LettaBatchRequest(LettaRequest):
     agent_id: str = Field(..., description="The ID of the agent to send this batch request for")
+
+
+class CreateBatch(BaseModel):
+    requests: List[LettaBatchRequest] = Field(..., description="List of requests to be processed in batch.")
+    callback_url: Optional[HttpUrl] = Field(None, description="Optional URL to call via POST when the batch completes.")

letta/schemas/letta_response.py

@@ -169,7 +169,9 @@ LettaStreamingResponse = Union[LettaMessage, MessageStreamStatus, LettaUsageStat
 
 
 class LettaBatchResponse(BaseModel):
-    batch_id: str = Field(..., description="A unique identifier for this batch request.")
+    letta_batch_id: str = Field(..., description="A unique identifier for the Letta batch request.")
+    last_llm_batch_id: str = Field(..., description="A unique identifier for the most recent model provider batch request.")
     status: JobStatus = Field(..., description="The current status of the batch request.")
+    agent_count: int = Field(..., description="The number of agents in the batch request.")
     last_polled_at: datetime = Field(..., description="The timestamp when the batch was last polled for updates.")
     created_at: datetime = Field(..., description="The timestamp when the batch request was created.")

letta/schemas/llm_batch_job.py

@@ -19,8 +19,8 @@ class LLMBatchItem(OrmMetadataBase, validate_assignment=True):
 
     __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.")
+    id: Optional[str] = Field(None, description="The id of the batch item. Assigned by the database.")
+    llm_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.")
@@ -42,9 +42,10 @@ class LLMBatchJob(OrmMetadataBase, validate_assignment=True):
 
     __id_prefix__ = "batch_req"
 
-    id: str = Field(..., description="The id of the batch job. Assigned by the database.")
+    id: Optional[str] = Field(None, 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).")
+    letta_batch_job_id: str = Field(..., description="ID of the Letta batch job")
 
     create_batch_response: Union[BetaMessageBatch] = Field(..., description="The full JSON response from the initial batch creation.")
     latest_polling_response: Optional[Union[BetaMessageBatch]] = Field(

letta/schemas/llm_config.py

@@ -67,6 +67,10 @@ class LLMConfig(BaseModel):
     enable_reasoner: bool = Field(
         False, description="Whether or not the model should use extended thinking if it is a 'reasoning' style model"
     )
+    reasoning_effort: Optional[Literal["low", "medium", "high"]] = Field(
+        None,
+        description="The reasoning effort to use when generating text reasoning models",
+    )
     max_reasoning_tokens: int = Field(
         0, description="Configurable thinking budget for extended thinking, only used if enable_reasoner is True. Minimum value is 1024."
     )
@@ -106,7 +110,7 @@ class LLMConfig(BaseModel):
             if self.max_tokens is not None and self.max_reasoning_tokens >= self.max_tokens:
                 logger.warning("max_tokens must be greater than max_reasoning_tokens (thinking budget)")
             if self.put_inner_thoughts_in_kwargs:
-                logger.warning("Extended thinking is not compatible with put_inner_thoughts_in_kwargs")
+                logger.debug("Extended thinking is not compatible with put_inner_thoughts_in_kwargs")
         elif self.max_reasoning_tokens and not self.enable_reasoner:
             logger.warning("model will not use reasoning unless enable_reasoner is set to True")
 
@@ -115,7 +119,7 @@ class LLMConfig(BaseModel):
     @classmethod
     def default_config(cls, model_name: str):
         """
-        Convinience function to generate a default `LLMConfig` from a model name. Only some models are supported in this function.
+        Convenience function to generate a default `LLMConfig` from a model name. Only some models are supported in this function.
 
         Args:
             model_name (str): The name of the model (gpt-4, gpt-4o-mini, letta).

letta/schemas/message.py

@@ -81,6 +81,7 @@ class MessageCreate(BaseModel):
     )
     name: Optional[str] = Field(None, description="The name of the participant.")
     otid: Optional[str] = Field(None, description="The offline threading id associated with this message")
+    sender_id: Optional[str] = Field(None, description="The id of the sender of the message, can be an identity id or agent id")
 
     def model_dump(self, to_orm: bool = False, **kwargs) -> Dict[str, Any]:
         data = super().model_dump(**kwargs)
@@ -157,6 +158,7 @@ class Message(BaseMessage):
     otid: Optional[str] = Field(None, description="The offline threading id associated with this message")
     tool_returns: Optional[List[ToolReturn]] = Field(None, description="Tool execution return information for prior tool calls")
     group_id: Optional[str] = Field(None, description="The multi-agent group that the message was sent in")
+    sender_id: Optional[str] = Field(None, description="The id of the sender of the message, can be an identity id or agent id")
     # This overrides the optional base orm schema, created_at MUST exist on all messages objects
     created_at: datetime = Field(default_factory=get_utc_time, description="The timestamp when the object was created.")
 
@@ -246,6 +248,7 @@ class Message(BaseMessage):
                             reasoning=self.content[0].text,
                             name=self.name,
                             otid=otid,
+                            sender_id=self.sender_id,
                         )
                     )
                 # Otherwise, we may have a list of multiple types
@@ -262,6 +265,7 @@ class Message(BaseMessage):
                                     reasoning=content_part.text,
                                     name=self.name,
                                     otid=otid,
+                                    sender_id=self.sender_id,
                                 )
                             )
                         elif isinstance(content_part, ReasoningContent):
@@ -287,6 +291,7 @@ class Message(BaseMessage):
                                     hidden_reasoning=content_part.data,
                                     name=self.name,
                                     otid=otid,
+                                    sender_id=self.sender_id,
                                 )
                             )
                         else:
@@ -312,6 +317,7 @@ class Message(BaseMessage):
                                 content=message_string,
                                 name=self.name,
                                 otid=otid,
+                                sender_id=self.sender_id,
                             )
                         )
                     else:
@@ -326,6 +332,7 @@ class Message(BaseMessage):
                                 ),
                                 name=self.name,
                                 otid=otid,
+                                sender_id=self.sender_id,
                             )
                         )
         elif self.role == MessageRole.tool:
@@ -368,6 +375,7 @@ class Message(BaseMessage):
                     stderr=self.tool_returns[0].stderr if self.tool_returns else None,
                     name=self.name,
                     otid=self.id.replace("message-", ""),
+                    sender_id=self.sender_id,
                 )
             )
         elif self.role == MessageRole.user:
@@ -385,6 +393,7 @@ class Message(BaseMessage):
                     content=message_str or text_content,
                     name=self.name,
                     otid=self.otid,
+                    sender_id=self.sender_id,
                 )
             )
         elif self.role == MessageRole.system:
@@ -401,6 +410,7 @@ class Message(BaseMessage):
                     content=text_content,
                     name=self.name,
                     otid=self.otid,
+                    sender_id=self.sender_id,
                 )
             )
         else:
@@ -609,7 +619,7 @@ class Message(BaseMessage):
             text_content = self.content[0].text
         # Otherwise, check if we have TextContent and multiple other parts
         elif self.content and len(self.content) > 1:
-            text = [content for content in self.content if isinstance(self.content[0], TextContent)]
+            text = [content for content in self.content if isinstance(content, TextContent)]
             if len(text) > 1:
                 assert len(text) == 1, f"multiple text content parts found in a single message: {self.content}"
                 text_content = text[0].text