letta-nightly 0.11.0.dev20250808104456__tar.gz → 0.11.2.dev20250808210309__tar.gz

{letta_nightly-0.11.0.dev20250808104456 → letta_nightly-0.11.2.dev20250808210309}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.11.0.dev20250808104456
+Version: 0.11.2.dev20250808210309
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.11.0.dev20250808104456 → letta_nightly-0.11.2.dev20250808210309}/letta/__init__.py

@@ -5,7 +5,7 @@ try:
     __version__ = version("letta")
 except PackageNotFoundError:
     # Fallback for development installations
-    __version__ = "0.11.0"
+    __version__ = "0.11.2"
 
 if os.environ.get("LETTA_VERSION"):
     __version__ = os.environ["LETTA_VERSION"]

{letta_nightly-0.11.0.dev20250808104456 → letta_nightly-0.11.2.dev20250808210309}/letta/schemas/llm_config.py

@@ -187,9 +187,12 @@ class LLMConfig(BaseModel):
 
     @classmethod
     def apply_reasoning_setting_to_config(cls, config: "LLMConfig", reasoning: bool):
-        if reasoning:
-            config.enable_reasoner = True
+        if not reasoning:
+            config.put_inner_thoughts_in_kwargs = False
+            config.enable_reasoner = False
 
+        else:
+            config.enable_reasoner = True
             if (
                 config.model_endpoint_type == "anthropic"
                 and ("claude-opus-4" in config.model or "claude-sonnet-4" in config.model or "claude-3-7-sonnet" in config.model)
@@ -207,9 +210,6 @@ class LLMConfig(BaseModel):
                     config.reasoning_effort = "medium"
             else:
                 config.put_inner_thoughts_in_kwargs = True
-
-        else:
-            config.enable_reasoner = False
-            config.put_inner_thoughts_in_kwargs = False
+                config.enable_reasoner = False
 
         return config

{letta_nightly-0.11.0.dev20250808104456 → letta_nightly-0.11.2.dev20250808210309}/letta/serialize_schemas/marshmallow_agent.py

@@ -1,6 +1,7 @@
-from typing import Dict
+from typing import Dict, Optional
 
 from marshmallow import fields, post_dump, pre_load
+from sqlalchemy import func
 from sqlalchemy.orm import sessionmaker
 
 import letta
@@ -15,6 +16,7 @@ from letta.serialize_schemas.marshmallow_custom_fields import EmbeddingConfigFie
 from letta.serialize_schemas.marshmallow_message import SerializedMessageSchema
 from letta.serialize_schemas.marshmallow_tag import SerializedAgentTagSchema
 from letta.serialize_schemas.marshmallow_tool import SerializedToolSchema
+from letta.settings import DatabaseChoice, settings
 
 
 class MarshmallowAgentSchema(BaseSchema):
@@ -41,9 +43,10 @@ class MarshmallowAgentSchema(BaseSchema):
     tool_exec_environment_variables = fields.List(fields.Nested(SerializedAgentEnvironmentVariableSchema))
     tags = fields.List(fields.Nested(SerializedAgentTagSchema))
 
-    def __init__(self, *args, session: sessionmaker, actor: User, **kwargs):
+    def __init__(self, *args, session: sessionmaker, actor: User, max_steps: Optional[int] = None, **kwargs):
         super().__init__(*args, actor=actor, **kwargs)
         self.session = session
+        self.max_steps = max_steps
 
         # Propagate session and actor to nested schemas automatically
         for field in self.fields.values():
@@ -64,16 +67,103 @@ class MarshmallowAgentSchema(BaseSchema):
 
         with db_registry.session() as session:
             agent_id = data.get("id")
-            msgs = (
-                session.query(MessageModel)
-                .filter(
-                    MessageModel.agent_id == agent_id,
-                    MessageModel.organization_id == self.actor.organization_id,
+
+            if self.max_steps is not None:
+                # first, always get the system message
+                system_msg = (
+                    session.query(MessageModel)
+                    .filter(
+                        MessageModel.agent_id == agent_id,
+                        MessageModel.organization_id == self.actor.organization_id,
+                        MessageModel.role == "system",
+                    )
+                    .order_by(MessageModel.sequence_id.asc())
+                    .first()
+                )
+
+                if settings.database_engine is DatabaseChoice.POSTGRES:
+                    # efficient PostgreSQL approach using subquery
+                    user_msg_subquery = (
+                        session.query(MessageModel.sequence_id)
+                        .filter(
+                            MessageModel.agent_id == agent_id,
+                            MessageModel.organization_id == self.actor.organization_id,
+                            MessageModel.role == "user",
+                        )
+                        .order_by(MessageModel.sequence_id.desc())
+                        .limit(self.max_steps)
+                        .subquery()
+                    )
+
+                    # get the minimum sequence_id from the subquery
+                    cutoff_sequence_id = session.query(func.min(user_msg_subquery.c.sequence_id)).scalar()
+
+                    if cutoff_sequence_id:
+                        # get messages from cutoff, excluding system message to avoid duplicates
+                        step_msgs = (
+                            session.query(MessageModel)
+                            .filter(
+                                MessageModel.agent_id == agent_id,
+                                MessageModel.organization_id == self.actor.organization_id,
+                                MessageModel.sequence_id >= cutoff_sequence_id,
+                                MessageModel.role != "system",
+                            )
+                            .order_by(MessageModel.sequence_id.asc())
+                            .all()
+                        )
+                        # combine system message with step messages
+                        msgs = [system_msg] + step_msgs if system_msg else step_msgs
+                    else:
+                        # no user messages, just return system message
+                        msgs = [system_msg] if system_msg else []
+                else:
+                    # sqlite approach: get all user messages first, then get messages from cutoff
+                    user_messages = (
+                        session.query(MessageModel.sequence_id)
+                        .filter(
+                            MessageModel.agent_id == agent_id,
+                            MessageModel.organization_id == self.actor.organization_id,
+                            MessageModel.role == "user",
+                        )
+                        .order_by(MessageModel.sequence_id.desc())
+                        .limit(self.max_steps)
+                        .all()
+                    )
+
+                    if user_messages:
+                        # get the minimum sequence_id
+                        cutoff_sequence_id = min(msg.sequence_id for msg in user_messages)
+
+                        # get messages from cutoff, excluding system message to avoid duplicates
+                        step_msgs = (
+                            session.query(MessageModel)
+                            .filter(
+                                MessageModel.agent_id == agent_id,
+                                MessageModel.organization_id == self.actor.organization_id,
+                                MessageModel.sequence_id >= cutoff_sequence_id,
+                                MessageModel.role != "system",
+                            )
+                            .order_by(MessageModel.sequence_id.asc())
+                            .all()
+                        )
+                        # combine system message with step messages
+                        msgs = [system_msg] + step_msgs if system_msg else step_msgs
+                    else:
+                        # no user messages, just return system message
+                        msgs = [system_msg] if system_msg else []
+            else:
+                # if no limit, get all messages in ascending order
+                msgs = (
+                    session.query(MessageModel)
+                    .filter(
+                        MessageModel.agent_id == agent_id,
+                        MessageModel.organization_id == self.actor.organization_id,
+                    )
+                    .order_by(MessageModel.sequence_id.asc())
+                    .all()
                 )
-                .order_by(MessageModel.sequence_id.asc())
-                .all()
-            )
-            # overwrite the “messages” key with a fully serialized list
+
+            # overwrite the "messages" key with a fully serialized list
             data[self.FIELD_MESSAGES] = [SerializedMessageSchema(session=self.session, actor=self.actor).dump(m) for m in msgs]
 
         return data

{letta_nightly-0.11.0.dev20250808104456 → letta_nightly-0.11.2.dev20250808210309}/letta/server/rest_api/routers/v1/agents.py

@@ -146,6 +146,7 @@ class IndentedORJSONResponse(Response):
 @router.get("/{agent_id}/export", response_class=IndentedORJSONResponse, operation_id="export_agent_serialized")
 def export_agent_serialized(
     agent_id: str,
+    max_steps: int = 100,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: str | None = Header(None, alias="user_id"),
     # do not remove, used to autogeneration of spec
@@ -158,7 +159,7 @@ def export_agent_serialized(
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
     try:
-        agent = server.agent_manager.serialize(agent_id=agent_id, actor=actor)
+        agent = server.agent_manager.serialize(agent_id=agent_id, actor=actor, max_steps=max_steps)
         return agent.model_dump()
     except NoResultFound:
         raise HTTPException(status_code=404, detail=f"Agent with id={agent_id} not found for user_id={actor.id}.")

{letta_nightly-0.11.0.dev20250808104456 → letta_nightly-0.11.2.dev20250808210309}/letta/services/agent_manager.py

@@ -1446,10 +1446,10 @@ class AgentManager:
 
     @enforce_types
     @trace_method
-    def serialize(self, agent_id: str, actor: PydanticUser) -> AgentSchema:
+    def serialize(self, agent_id: str, actor: PydanticUser, max_steps: Optional[int] = None) -> AgentSchema:
         with db_registry.session() as session:
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
-            schema = MarshmallowAgentSchema(session=session, actor=actor)
+            schema = MarshmallowAgentSchema(session=session, actor=actor, max_steps=max_steps)
             data = schema.dump(agent)
             return AgentSchema(**data)
 

{letta_nightly-0.11.0.dev20250808104456 → letta_nightly-0.11.2.dev20250808210309}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.11.0.dev20250808104456"
+version = "0.11.2.dev20250808210309"
 packages = [
     {include = "letta"},
 ]