letta-nightly 0.11.7.dev20251007104119__py3-none-any.whl → 0.12.0.dev20251009104148__py3-none-any.whl

letta/schemas/enums.py

@@ -28,6 +28,7 @@ class AgentType(str, Enum):
 
     memgpt_agent = "memgpt_agent"  # the OG set of memgpt tools
     memgpt_v2_agent = "memgpt_v2_agent"  # memgpt style tools, but refreshed
+    letta_v1_agent = "letta_v1_agent"  # simplification of the memgpt loop, no heartbeats or forced tool calls
     react_agent = "react_agent"  # basic react agent, no memory tools
     workflow_agent = "workflow_agent"  # workflow with auto-clearing message buffer
     split_thread_agent = "split_thread_agent"
@@ -50,6 +51,11 @@ class MessageRole(str, Enum):
     approval = "approval"
 
 
+class MessageSourceType(str, Enum):
+    input = "input"  # external input
+    output = "output"  # internal output
+
+
 class OptionState(str, Enum):
     """Useful for kwargs that are bool + default option"""
 
@@ -77,6 +83,18 @@ class JobStatus(StrEnum):
         return self in (JobStatus.completed, JobStatus.failed, JobStatus.cancelled, JobStatus.expired)
 
 
+class RunStatus(StrEnum):
+    """
+    Status of the run.
+    """
+
+    created = "created"
+    running = "running"
+    completed = "completed"
+    failed = "failed"
+    cancelled = "cancelled"
+
+
 class AgentStepStatus(str, Enum):
     """
     Status of agent step.
@@ -134,12 +152,13 @@ class ToolType(str, Enum):
     LETTA_VOICE_SLEEPTIME_CORE = "letta_voice_sleeptime_core"
     LETTA_BUILTIN = "letta_builtin"
     LETTA_FILES_CORE = "letta_files_core"
-    EXTERNAL_COMPOSIO = "external_composio"
-    EXTERNAL_LANGCHAIN = "external_langchain"
+    EXTERNAL_LANGCHAIN = "external_langchain" # DEPRECATED
+    EXTERNAL_COMPOSIO = "external_composio" # DEPRECATED
     # TODO is "external" the right name here? Since as of now, MCP is local / doesn't support remote?
     EXTERNAL_MCP = "external_mcp"
 
 
+
 class JobType(str, Enum):
     JOB = "job"
     RUN = "run"

letta/schemas/job.py

@@ -1,8 +1,11 @@
 from datetime import datetime
-from typing import List, Optional
+from typing import TYPE_CHECKING, List, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
+if TYPE_CHECKING:
+    from letta.schemas.letta_request import LettaRequest
+
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.schemas.enums import JobStatus, JobType
@@ -24,9 +27,9 @@ 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.")
 
-    ## TODO: Run-specific fields
-    # background: Optional[bool] = Field(None, description="Whether the job was created in background mode.")
-    # agent_id: Optional[str] = Field(None, description="The agent associated with this job/run.")
+    # Run-specific fields
+    background: Optional[bool] = Field(None, description="Whether the job was created in background mode.")
+    agent_id: Optional[str] = Field(None, description="The agent associated with this job/run.")
 
     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.")
@@ -112,3 +115,13 @@ class LettaRequestConfig(BaseModel):
     include_return_message_types: Optional[List[MessageType]] = Field(
         default=None, description="Only return specified message types in the response. If `None` (default) returns all messages."
     )
+
+    @classmethod
+    def from_letta_request(cls, request: "LettaRequest") -> "LettaRequestConfig":
+        """Create a LettaRequestConfig from a LettaRequest."""
+        return cls(
+            use_assistant_message=request.use_assistant_message,
+            assistant_message_tool_name=request.assistant_message_tool_name,
+            assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
+            include_return_message_types=request.include_return_message_types,
+        )

letta/schemas/letta_message_content.py

@@ -1,6 +1,7 @@
 from enum import Enum
-from typing import Annotated, Literal, Optional, Union
+from typing import Annotated, List, Literal, Optional, Union
 
+from openai.types import Reasoning
 from pydantic import BaseModel, Field
 
 
@@ -9,9 +10,13 @@ class MessageContentType(str, Enum):
     image = "image"
     tool_call = "tool_call"
     tool_return = "tool_return"
+    # For Anthropic extended thinking
     reasoning = "reasoning"
     redacted_reasoning = "redacted_reasoning"
+    # Generic "hidden" (unsavailable) reasoning
     omitted_reasoning = "omitted_reasoning"
+    # For OpenAI Responses API
+    summarized_reasoning = "summarized_reasoning"
 
 
 class MessageContent(BaseModel):
@@ -34,6 +39,9 @@ class MessageContent(BaseModel):
 class TextContent(MessageContent):
     type: Literal[MessageContentType.text] = Field(default=MessageContentType.text, description="The type of the message.")
     text: str = Field(..., description="The text content of the message.")
+    signature: Optional[str] = Field(
+        default=None, description="Stores a unique identifier for any reasoning associated with this text content."
+    )
 
     def to_text(self) -> str:
         """Return the text content."""
@@ -183,6 +191,9 @@ class ToolCallContent(MessageContent):
     input: dict = Field(
         ..., description="The parameters being passed to the tool, structured as a dictionary of parameter names to values."
     )
+    signature: Optional[str] = Field(
+        default=None, description="Stores a unique identifier for any reasoning associated with this tool call."
+    )
 
     def to_text(self) -> str:
         """Return a text representation of the tool call."""
@@ -207,6 +218,8 @@ class ToolReturnContent(MessageContent):
 
 
 class ReasoningContent(MessageContent):
+    """Sent via the Anthropic Messages API"""
+
     type: Literal[MessageContentType.reasoning] = Field(
         default=MessageContentType.reasoning, description="Indicates this is a reasoning/intermediate step."
     )
@@ -220,6 +233,8 @@ class ReasoningContent(MessageContent):
 
 
 class RedactedReasoningContent(MessageContent):
+    """Sent via the Anthropic Messages API"""
+
     type: Literal[MessageContentType.redacted_reasoning] = Field(
         default=MessageContentType.redacted_reasoning, description="Indicates this is a redacted thinking step."
     )
@@ -227,16 +242,70 @@ class RedactedReasoningContent(MessageContent):
 
 
 class OmittedReasoningContent(MessageContent):
+    """A placeholder for reasoning content we know is present, but isn't returned by the provider (e.g. OpenAI GPT-5 on ChatCompletions)"""
+
     type: Literal[MessageContentType.omitted_reasoning] = Field(
         default=MessageContentType.omitted_reasoning, description="Indicates this is an omitted reasoning step."
     )
+    signature: Optional[str] = Field(default=None, description="A unique identifier for this reasoning step.")
     # NOTE: dropping because we don't track this kind of information for the other reasoning types
     # tokens: int = Field(..., description="The reasoning token count for intermediate reasoning content.")
 
 
+class SummarizedReasoningContentPart(BaseModel):
+    index: int = Field(..., description="The index of the summary part.")
+    text: str = Field(..., description="The text of the summary part.")
+
+
+class SummarizedReasoningContent(MessageContent):
+    """The style of reasoning content returned by the OpenAI Responses API"""
+
+    # TODO consider expanding ReasoningContent to support this superset?
+    # Or alternatively, rename `ReasoningContent` to `AnthropicReasoningContent`,
+    # and rename this one to `OpenAIReasoningContent`?
+
+    # NOTE: I think the argument for putting thie in ReasoningContent as an additional "summary" field is that it keeps the
+    # rendering and GET / listing code a lot simpler, you just need to know how to render "TextContent" and "ReasoningContent"
+    # vs breaking out into having to know how to render additional types
+    # NOTE: I think the main issue is that we need to track provenance of which provider the reasoning came from
+    # so that we don't attempt eg to put Anthropic encrypted reasoning into a GPT-5 responses payload
+    type: Literal[MessageContentType.summarized_reasoning] = Field(
+        default=MessageContentType.summarized_reasoning, description="Indicates this is a summarized reasoning step."
+    )
+
+    # OpenAI requires holding a string
+    id: str = Field(..., description="The unique identifier for this reasoning step.")  # NOTE: I don't think this is actually needed?
+    # OpenAI returns a list of summary objects, each a string
+    # Straying a bit from the OpenAI schema so that we can enforce ordering on the deltas that come out
+    # summary: List[str] = Field(..., description="Summaries of the reasoning content.")
+    summary: List[SummarizedReasoningContentPart] = Field(..., description="Summaries of the reasoning content.")
+    encrypted_content: str = Field(default=None, description="The encrypted reasoning content.")
+
+    # Temporary stop-gap until the SDKs are updated
+    def to_reasoning_content(self) -> Optional[ReasoningContent]:
+        # Merge the summary parts with a '\n' join
+        parts = [s.text for s in self.summary if s.text != ""]
+        if not parts or len(parts) == 0:
+            return None
+        else:
+            combined_summary = "\n\n".join(parts)
+            return ReasoningContent(
+                is_native=True,
+                reasoning=combined_summary,
+                signature=self.encrypted_content,
+            )
+
+
 LettaMessageContentUnion = Annotated[
     Union[
-        TextContent, ImageContent, ToolCallContent, ToolReturnContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent
+        TextContent,
+        ImageContent,
+        ToolCallContent,
+        ToolReturnContent,
+        ReasoningContent,
+        RedactedReasoningContent,
+        OmittedReasoningContent,
+        SummarizedReasoningContent,
     ],
     Field(discriminator="type"),
 ]

letta/schemas/letta_stop_reason.py

@@ -3,7 +3,7 @@ from typing import Literal
 
 from pydantic import BaseModel, Field
 
-from letta.schemas.enums import JobStatus
+from letta.schemas.enums import RunStatus
 
 
 class StopReasonType(str, Enum):
@@ -19,14 +19,14 @@ class StopReasonType(str, Enum):
     requires_approval = "requires_approval"
 
     @property
-    def run_status(self) -> JobStatus:
+    def run_status(self) -> RunStatus:
         if self in (
             StopReasonType.end_turn,
             StopReasonType.max_steps,
             StopReasonType.tool_rule,
             StopReasonType.requires_approval,
         ):
-            return JobStatus.completed
+            return RunStatus.completed
         elif self in (
             StopReasonType.error,
             StopReasonType.invalid_tool_call,
@@ -34,9 +34,9 @@ class StopReasonType(str, Enum):
             StopReasonType.invalid_llm_response,
             StopReasonType.llm_api_error,
         ):
-            return JobStatus.failed
+            return RunStatus.failed
         elif self == StopReasonType.cancelled:
-            return JobStatus.cancelled
+            return RunStatus.cancelled
         else:
             raise ValueError("Unknown StopReasonType")
 

letta/schemas/llm_config.py

@@ -1,10 +1,10 @@
-from typing import Literal, Optional
+from typing import TYPE_CHECKING, Literal, Optional
 
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 from letta.constants import LETTA_MODEL_ENDPOINT
 from letta.log import get_logger
-from letta.schemas.enums import ProviderCategory
+from letta.schemas.enums import AgentType, ProviderCategory
 
 logger = get_logger(__name__)
 
@@ -259,7 +259,57 @@ class LLMConfig(BaseModel):
         return config.model_endpoint_type == "openai" and config.model.startswith("gpt-5")
 
     @classmethod
-    def apply_reasoning_setting_to_config(cls, config: "LLMConfig", reasoning: bool):
+    def apply_reasoning_setting_to_config(cls, config: "LLMConfig", reasoning: bool, agent_type: Optional["AgentType"] = None):
+        """
+        Normalize reasoning-related flags on the config based on the requested
+        "reasoning" setting, model capabilities, and optionally the agent type.
+
+        For AgentType.letta_v1_agent, we enforce stricter semantics:
+        - OpenAI native reasoning (o1/o3/o4/gpt-5): force enabled (non-togglable)
+        - Anthropic (claude 3.7 / 4): toggle honored (default on elsewhere)
+        - Google Gemini (2.5 family): force disabled until native reasoning supported
+        - All others: disabled (no simulated reasoning via kwargs)
+        """
+        # V1 agent policy: do not allow simulated reasoning for non-native models
+        if agent_type is not None and agent_type == AgentType.letta_v1_agent:
+            # OpenAI native reasoning models: always on
+            if cls.is_openai_reasoning_model(config):
+                config.put_inner_thoughts_in_kwargs = False
+                config.enable_reasoner = True
+                if config.reasoning_effort is None:
+                    if config.model.startswith("gpt-5"):
+                        config.reasoning_effort = "minimal"
+                    else:
+                        config.reasoning_effort = "medium"
+                if config.model.startswith("gpt-5") and config.verbosity is None:
+                    config.verbosity = "medium"
+                return config
+
+            # Anthropic 3.7/4 and Gemini: toggle honored
+            is_google_reasoner_with_configurable_thinking = (
+                cls.is_google_vertex_reasoning_model(config) or cls.is_google_ai_reasoning_model(config)
+            ) and not config.model.startswith("gemini-2.5-pro")
+            if cls.is_anthropic_reasoning_model(config) or is_google_reasoner_with_configurable_thinking:
+                config.enable_reasoner = bool(reasoning)
+                config.put_inner_thoughts_in_kwargs = False
+                if config.enable_reasoner and config.max_reasoning_tokens == 0:
+                    config.max_reasoning_tokens = 1024
+                return config
+
+            # Google Gemini 2.5 Pro: not possible to disable
+            if config.model.startswith("gemini-2.5-pro"):
+                config.put_inner_thoughts_in_kwargs = False
+                config.enable_reasoner = True
+                if config.max_reasoning_tokens == 0:
+                    config.max_reasoning_tokens = 1024
+                return config
+
+            # Everything else: disabled (no inner_thoughts-in-kwargs simulation)
+            config.put_inner_thoughts_in_kwargs = False
+            config.enable_reasoner = False
+            config.max_reasoning_tokens = 0
+            return config
+
         if not reasoning:
             if cls.is_openai_reasoning_model(config):
                 logger.warning("Reasoning cannot be disabled for OpenAI o1/o3/gpt-5 models")

letta/schemas/memory.py

@@ -271,7 +271,7 @@ class Memory(BaseModel, validate_assignment=True):
         raw_type = self.agent_type.value if hasattr(self.agent_type, "value") else (self.agent_type or "")
         norm_type = raw_type.lower()
         is_react = norm_type in ("react_agent", "workflow_agent")
-        is_line_numbered = norm_type in ("sleeptime_agent", "memgpt_v2_agent")
+        is_line_numbered = norm_type in ("sleeptime_agent", "memgpt_v2_agent", "letta_v1_agent")
 
         # Memory blocks (not for react/workflow). Always include wrapper for preview/tests.
         if not is_react: