letta-nightly 0.9.0.dev20250726104256__tar.gz → 0.9.1.dev20250727063635__tar.gz

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.9.0.dev20250726104256
+Version: 0.9.1.dev20250727063635
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -45,6 +45,7 @@ Requires-Dist: e2b-code-interpreter (>=1.0.3,<2.0.0) ; extra == "cloud-tool-sand
 Requires-Dist: faker (>=36.1.0,<37.0.0)
 Requires-Dist: fastapi (>=0.115.6,<0.116.0) ; extra == "server" or extra == "desktop" or extra == "all"
 Requires-Dist: firecrawl-py (>=2.8.0,<3.0.0) ; extra == "external-tools"
+Requires-Dist: google-cloud-profiler (>=4.1.0,<5.0.0) ; extra == "experimental" or extra == "all"
 Requires-Dist: google-genai (>=1.15.0,<2.0.0) ; extra == "google"
 Requires-Dist: granian[reload,uvloop] (>=2.3.2,<3.0.0) ; extra == "experimental" or extra == "all"
 Requires-Dist: grpcio (>=1.68.1,<2.0.0)
@@ -56,7 +57,7 @@ Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
 Requires-Dist: langchain (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: langchain-community (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
-Requires-Dist: letta_client (>=0.1.219,<0.2.0)
+Requires-Dist: letta_client (>=0.1.220,<0.2.0)
 Requires-Dist: llama-index (>=0.12.2,<0.13.0)
 Requires-Dist: llama-index-embeddings-openai (>=0.3.1,<0.4.0)
 Requires-Dist: locust (>=2.31.5,<3.0.0) ; extra == "dev" or extra == "desktop" or extra == "all"

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/__init__.py

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

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/agents/base_agent.py

@@ -122,7 +122,7 @@ class BaseAgent(ABC):
             curr_dynamic_section = extract_dynamic_section(curr_system_message_text)
 
             # generate just the memory string with current state for comparison
-            curr_memory_str = agent_state.memory.compile(
+            curr_memory_str = await agent_state.memory.compile_async(
                 tool_usage_rules=tool_constraint_block, sources=agent_state.sources, max_files_open=agent_state.max_files_open
             )
             new_dynamic_section = extract_dynamic_section(curr_memory_str)

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/agents/letta_agent.py

@@ -359,6 +359,8 @@ class LettaAgent(BaseAgent):
             # Update step if it needs to be updated
             finally:
                 if settings.track_stop_reason:
+                    if step_progression == StepProgression.FINISHED and should_continue:
+                        continue
                     self.logger.info("Running final update. Step Progression: %s", step_progression)
                     try:
                         if step_progression < StepProgression.STEP_LOGGED:
@@ -586,6 +588,8 @@ class LettaAgent(BaseAgent):
                 # Update step if it needs to be updated
             finally:
                 if settings.track_stop_reason:
+                    if step_progression == StepProgression.FINISHED and should_continue:
+                        continue
                     self.logger.info("Running final update. Step Progression: %s", step_progression)
                     try:
                         if step_progression < StepProgression.STEP_LOGGED:
@@ -897,6 +901,8 @@ class LettaAgent(BaseAgent):
             # Update step if it needs to be updated
             finally:
                 if settings.track_stop_reason:
+                    if step_progression == StepProgression.FINISHED and should_continue:
+                        continue
                     self.logger.info("Running final update. Step Progression: %s", step_progression)
                     try:
                         if step_progression < StepProgression.STEP_LOGGED:

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/helpers/datetime_helpers.py

@@ -42,7 +42,7 @@ def get_local_time_timezone(timezone=DEFAULT_TIMEZONE):
     return formatted_time
 
 
-def get_local_time(timezone=DEFAULT_TIMEZONE):
+def get_local_time(timezone: str | None = DEFAULT_TIMEZONE):
     if timezone is not None:
         time_str = get_local_time_timezone(timezone)
     else:

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/helpers/json_helpers.py

@@ -7,7 +7,7 @@ def json_loads(data):
     return json.loads(data, strict=False)
 
 
-def json_dumps(data, indent=2):
+def json_dumps(data, indent=2) -> str:
     def safe_serializer(obj):
         if isinstance(obj, datetime):
             return obj.isoformat()

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/orm/agent.py

@@ -10,7 +10,7 @@ from sqlalchemy.orm import Mapped, mapped_column, relationship
 from letta.orm.block import Block
 from letta.orm.custom_columns import EmbeddingConfigColumn, LLMConfigColumn, ResponseFormatColumn, ToolRulesColumn
 from letta.orm.identity import Identity
-from letta.orm.mixins import OrganizationMixin
+from letta.orm.mixins import OrganizationMixin, ProjectMixin
 from letta.orm.organization import Organization
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.agent import AgentState as PydanticAgentState
@@ -31,7 +31,7 @@ if TYPE_CHECKING:
     from letta.orm.tool import Tool
 
 
-class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
+class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, AsyncAttrs):
     __tablename__ = "agents"
     __pydantic_model__ = PydanticAgentState
     __table_args__ = (Index("ix_agents_created_at", "created_at", "id"),)
@@ -67,7 +67,6 @@ class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
     embedding_config: Mapped[Optional[EmbeddingConfig]] = mapped_column(
         EmbeddingConfigColumn, doc="the embedding configuration object for this agent."
     )
-    project_id: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="The id of the project the agent belongs to.")
     template_id: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="The id of the template the agent belongs to.")
     base_template_id: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="The base template id of the agent.")
 

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/orm/agents_tags.py

@@ -9,6 +9,7 @@ class AgentsTags(Base):
     __table_args__ = (
         UniqueConstraint("agent_id", "tag", name="unique_agent_tag"),
         Index("ix_agents_tags_agent_id_tag", "agent_id", "tag"),
+        Index("ix_agents_tags_tag_agent_id", "tag", "agent_id"),
     )
 
     # # agent generates its own id

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/orm/block.py

@@ -6,7 +6,7 @@ from sqlalchemy.orm import Mapped, attributes, declared_attr, mapped_column, rel
 from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT
 from letta.orm.block_history import BlockHistory
 from letta.orm.blocks_agents import BlocksAgents
-from letta.orm.mixins import OrganizationMixin
+from letta.orm.mixins import OrganizationMixin, ProjectMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.block import Block as PydanticBlock
 from letta.schemas.block import Human, Persona
@@ -16,7 +16,7 @@ if TYPE_CHECKING:
     from letta.orm.identity import Identity
 
 
-class Block(OrganizationMixin, SqlalchemyBase):
+class Block(OrganizationMixin, SqlalchemyBase, ProjectMixin):
     """Blocks are sections of the LLM context, representing a specific part of the total Memory"""
 
     __tablename__ = "block"

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/orm/group.py

@@ -4,12 +4,12 @@ from typing import List, Optional
 from sqlalchemy import JSON, ForeignKey, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
-from letta.orm.mixins import OrganizationMixin
+from letta.orm.mixins import OrganizationMixin, ProjectMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.group import Group as PydanticGroup
 
 
-class Group(SqlalchemyBase, OrganizationMixin):
+class Group(SqlalchemyBase, OrganizationMixin, ProjectMixin):
 
     __tablename__ = "groups"
     __pydantic_model__ = PydanticGroup

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/orm/identity.py

@@ -1,17 +1,17 @@
 import uuid
-from typing import List, Optional
+from typing import List
 
 from sqlalchemy import String, UniqueConstraint
 from sqlalchemy.dialects.postgresql import JSON
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
-from letta.orm.mixins import OrganizationMixin
+from letta.orm.mixins import OrganizationMixin, ProjectMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.identity import Identity as PydanticIdentity
 from letta.schemas.identity import IdentityProperty
 
 
-class Identity(SqlalchemyBase, OrganizationMixin):
+class Identity(SqlalchemyBase, OrganizationMixin, ProjectMixin):
     """Identity ORM class"""
 
     __tablename__ = "identities"
@@ -32,7 +32,6 @@ class Identity(SqlalchemyBase, OrganizationMixin):
     identifier_key: Mapped[str] = mapped_column(nullable=False, doc="External, user-generated identifier key of the identity.")
     name: Mapped[str] = mapped_column(nullable=False, doc="The name of the identity.")
     identity_type: Mapped[str] = mapped_column(nullable=False, doc="The type of the identity.")
-    project_id: Mapped[Optional[str]] = mapped_column(nullable=True, doc="The project id of the identity.")
     properties: Mapped[List["IdentityProperty"]] = mapped_column(
         JSON, nullable=False, default=list, doc="List of properties associated with the identity"
     )

letta_nightly-0.9.1.dev20250727063635/letta/orm/mcp_oauth.py

@@ -0,0 +1,62 @@
+import uuid
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+from sqlalchemy import DateTime, ForeignKey, String, Text
+from sqlalchemy.orm import Mapped, mapped_column
+
+from letta.orm.mixins import OrganizationMixin, UserMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+
+
+class OAuthSessionStatus(str, Enum):
+    """OAuth session status enumeration."""
+
+    PENDING = "pending"
+    AUTHORIZED = "authorized"
+    ERROR = "error"
+
+
+class MCPOAuth(SqlalchemyBase, OrganizationMixin, UserMixin):
+    """OAuth session model for MCP server authentication."""
+
+    __tablename__ = "mcp_oauth"
+
+    # Override the id field to match database UUID generation
+    id: Mapped[str] = mapped_column(String, primary_key=True, default=lambda: f"{uuid.uuid4()}")
+
+    # Core session information
+    state: Mapped[str] = mapped_column(String(255), unique=True, nullable=False, doc="OAuth state parameter")
+    server_id: Mapped[str] = mapped_column(String(255), ForeignKey("mcp_server.id", ondelete="CASCADE"), nullable=True, doc="MCP server ID")
+    server_url: Mapped[str] = mapped_column(Text, nullable=False, doc="MCP server URL")
+    server_name: Mapped[str] = mapped_column(Text, nullable=False, doc="MCP server display name")
+
+    # OAuth flow data
+    authorization_url: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth authorization URL")
+    authorization_code: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth authorization code")
+
+    # Token data
+    access_token: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth access token")
+    refresh_token: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth refresh token")
+    token_type: Mapped[str] = mapped_column(String(50), default="Bearer", doc="Token type")
+    expires_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), nullable=True, doc="Token expiry time")
+    scope: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth scope")
+
+    # Client configuration
+    client_id: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth client ID")
+    client_secret: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth client secret")
+    redirect_uri: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth redirect URI")
+
+    # Session state
+    status: Mapped[OAuthSessionStatus] = mapped_column(String(20), default=OAuthSessionStatus.PENDING, doc="Session status")
+
+    # Timestamps
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(), doc="Session creation time")
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(), onupdate=lambda: datetime.now(), doc="Last update time"
+    )
+
+    # Relationships (if needed in the future)
+    # user: Mapped[Optional["User"]] = relationship("User", back_populates="oauth_sessions")
+    # organization: Mapped["Organization"] = relationship("Organization", back_populates="oauth_sessions")

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/orm/step.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Dict, List, Optional
 from sqlalchemy import JSON, ForeignKey, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
+from letta.orm.mixins import ProjectMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.letta_stop_reason import StopReasonType
 from letta.schemas.step import Step as PydanticStep
@@ -13,7 +14,7 @@ if TYPE_CHECKING:
     from letta.orm.provider import Provider
 
 
-class Step(SqlalchemyBase):
+class Step(SqlalchemyBase, ProjectMixin):
     """Tracks all metadata for agent step."""
 
     __tablename__ = "steps"
@@ -53,9 +54,6 @@ class Step(SqlalchemyBase):
     feedback: Mapped[Optional[str]] = mapped_column(
         None, nullable=True, doc="The feedback for this step. Must be either 'positive' or 'negative'."
     )
-    project_id: Mapped[Optional[str]] = mapped_column(
-        None, nullable=True, doc="The project that the agent that executed this step belongs to (cloud only)."
-    )
 
     # Relationships (foreign keys)
     organization: Mapped[Optional["Organization"]] = relationship("Organization")

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/schemas/agent_file.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel, Field
 
@@ -8,6 +8,7 @@ from letta.schemas.block import Block, CreateBlock
 from letta.schemas.enums import MessageRole
 from letta.schemas.file import FileAgent, FileAgentBase, FileMetadata, FileMetadataBase
 from letta.schemas.group import GroupCreate
+from letta.schemas.mcp import MCPServer
 from letta.schemas.message import Message, MessageCreate
 from letta.schemas.source import Source, SourceCreate
 from letta.schemas.tool import Tool
@@ -264,9 +265,34 @@ class ToolSchema(Tool):
         return cls(**tool.model_dump())
 
 
-# class MCPServerSchema(RegisterMCPServer):
-#     """MCP Server with human-readable ID for agent file"""
-#     id: str = Field(..., description="Human-readable identifier for this MCP server in the file")
+class MCPServerSchema(BaseModel):
+    """MCP server schema for agent files with remapped ID."""
+
+    __id_prefix__ = "mcp_server"
+
+    id: str = Field(..., description="Human-readable MCP server ID")
+    server_type: str
+    server_name: str
+    server_url: Optional[str] = None
+    stdio_config: Optional[Dict[str, Any]] = None
+    metadata_: Optional[Dict[str, Any]] = None
+
+    @classmethod
+    def from_mcp_server(cls, mcp_server: MCPServer) -> "MCPServerSchema":
+        """Convert MCPServer to MCPServerSchema (excluding auth fields)."""
+        return cls(
+            id=mcp_server.id,  # remapped by serialization manager
+            server_type=mcp_server.server_type,
+            server_name=mcp_server.server_name,
+            server_url=mcp_server.server_url,
+            # exclude token, custom_headers, and the env field in stdio_config that may contain authentication credentials
+            stdio_config=cls.strip_env_from_stdio_config(mcp_server.stdio_config.model_dump()) if mcp_server.stdio_config else None,
+            metadata_=mcp_server.metadata_,
+        )
+
+    def strip_env_from_stdio_config(stdio_config: Dict[str, Any]) -> Dict[str, Any]:
+        """Strip out the env field from the stdio config."""
+        return {k: v for k, v in stdio_config.items() if k != "env"}
 
 
 class AgentFileSchema(BaseModel):
@@ -278,7 +304,7 @@ class AgentFileSchema(BaseModel):
     files: List[FileSchema] = Field(..., description="List of files in this agent file")
     sources: List[SourceSchema] = Field(..., description="List of sources in this agent file")
     tools: List[ToolSchema] = Field(..., description="List of tools in this agent file")
-    # mcp_servers: List[MCPServerSchema] = Field(..., description="List of MCP servers in this agent file")
+    mcp_servers: List[MCPServerSchema] = Field(..., description="List of MCP servers in this agent file")
     metadata: Dict[str, str] = Field(
         default_factory=dict, description="Metadata for this agent file, including revision_id and other export information."
     )

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/schemas/block.py

@@ -19,6 +19,7 @@ class BaseBlock(LettaBase, validate_assignment=True):
     value: str = Field(..., description="Value of the block.")
     limit: int = Field(CORE_MEMORY_BLOCK_CHAR_LIMIT, description="Character limit of the block.")
 
+    project_id: Optional[str] = Field(None, description="The associated project id.")
     # template data (optional)
     template_name: Optional[str] = Field(None, description="Name of the block if it is a template.", alias="name")
     is_template: bool = Field(False, description="Whether the block is a template (e.g. saved human/persona options).")
@@ -112,6 +113,7 @@ class BlockUpdate(BaseBlock):
 
     limit: Optional[int] = Field(None, description="Character limit of the block.")
     value: Optional[str] = Field(None, description="Value of the block.")
+    project_id: Optional[str] = Field(None, description="The associated project id.")
 
     class Config:
         extra = "ignore"  # Ignores extra fields
@@ -124,6 +126,7 @@ class CreateBlock(BaseBlock):
     limit: int = Field(CORE_MEMORY_BLOCK_CHAR_LIMIT, description="Character limit of the block.")
     value: str = Field(..., description="Value of the block.")
 
+    project_id: Optional[str] = Field(None, description="The associated project id.")
     # block templates
     is_template: bool = False
     template_name: Optional[str] = Field(None, description="Name of the block if it is a template.", alias="name")

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/schemas/enums.py

@@ -102,6 +102,10 @@ class FileProcessingStatus(str, Enum):
     COMPLETED = "completed"
     ERROR = "error"
 
+    def is_terminal_state(self) -> bool:
+        """Check if the processing status is in a terminal state (completed or error)."""
+        return self in (FileProcessingStatus.COMPLETED, FileProcessingStatus.ERROR)
+
 
 class ToolType(str, Enum):
     CUSTOM = "custom"

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/schemas/group.py

@@ -24,6 +24,7 @@ class Group(GroupBase):
     manager_type: ManagerType = Field(..., description="")
     agent_ids: List[str] = Field(..., description="")
     description: str = Field(..., description="")
+    project_id: Optional[str] = Field(None, description="The associated project id.")
     shared_block_ids: List[str] = Field([], description="")
     # Pattern fields
     manager_agent_id: Optional[str] = Field(None, description="")
@@ -138,6 +139,7 @@ class GroupCreate(BaseModel):
     agent_ids: List[str] = Field(..., description="")
     description: str = Field(..., description="")
     manager_config: ManagerConfigUnion = Field(RoundRobinManager(), description="")
+    project_id: Optional[str] = Field(None, description="The associated project id.")
     shared_block_ids: List[str] = Field([], description="")
 
 
@@ -145,4 +147,5 @@ class GroupUpdate(BaseModel):
     agent_ids: Optional[List[str]] = Field(None, description="")
     description: Optional[str] = Field(None, description="")
     manager_config: Optional[ManagerConfigUpdateUnion] = Field(None, description="")
+    project_id: Optional[str] = Field(None, description="The associated project id.")
     shared_block_ids: Optional[List[str]] = Field(None, description="")

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/schemas/mcp.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import Any, Dict, Optional, Union
 
 from pydantic import Field
@@ -10,6 +11,7 @@ from letta.functions.mcp_client.types import (
     StdioServerConfig,
     StreamableHTTPServerConfig,
 )
+from letta.orm.mcp_oauth import OAuthSessionStatus
 from letta.schemas.letta_base import LettaBase
 
 
@@ -119,3 +121,71 @@ class UpdateStreamableHTTPMCPServer(LettaBase):
 
 UpdateMCPServer = Union[UpdateSSEMCPServer, UpdateStdioMCPServer, UpdateStreamableHTTPMCPServer]
 RegisterMCPServer = Union[RegisterSSEMCPServer, RegisterStdioMCPServer, RegisterStreamableHTTPMCPServer]
+
+
+# OAuth-related schemas
+class BaseMCPOAuth(LettaBase):
+    __id_prefix__ = "mcp-oauth"
+
+
+class MCPOAuthSession(BaseMCPOAuth):
+    """OAuth session for MCP server authentication."""
+
+    id: str = BaseMCPOAuth.generate_id_field()
+    state: str = Field(..., description="OAuth state parameter")
+    server_id: Optional[str] = Field(None, description="MCP server ID")
+    server_url: str = Field(..., description="MCP server URL")
+    server_name: str = Field(..., description="MCP server display name")
+
+    # User and organization context
+    user_id: Optional[str] = Field(None, description="User ID associated with the session")
+    organization_id: str = Field(..., description="Organization ID associated with the session")
+
+    # OAuth flow data
+    authorization_url: Optional[str] = Field(None, description="OAuth authorization URL")
+    authorization_code: Optional[str] = Field(None, description="OAuth authorization code")
+
+    # Token data
+    access_token: Optional[str] = Field(None, description="OAuth access token")
+    refresh_token: Optional[str] = Field(None, description="OAuth refresh token")
+    token_type: str = Field(default="Bearer", description="Token type")
+    expires_at: Optional[datetime] = Field(None, description="Token expiry time")
+    scope: Optional[str] = Field(None, description="OAuth scope")
+
+    # Client configuration
+    client_id: Optional[str] = Field(None, description="OAuth client ID")
+    client_secret: Optional[str] = Field(None, description="OAuth client secret")
+    redirect_uri: Optional[str] = Field(None, description="OAuth redirect URI")
+
+    # Session state
+    status: OAuthSessionStatus = Field(default=OAuthSessionStatus.PENDING, description="Session status")
+
+    # Timestamps
+    created_at: datetime = Field(default_factory=datetime.now, description="Session creation time")
+    updated_at: datetime = Field(default_factory=datetime.now, description="Last update time")
+
+
+class MCPOAuthSessionCreate(BaseMCPOAuth):
+    """Create a new OAuth session."""
+
+    server_url: str = Field(..., description="MCP server URL")
+    server_name: str = Field(..., description="MCP server display name")
+    user_id: Optional[str] = Field(None, description="User ID associated with the session")
+    organization_id: str = Field(..., description="Organization ID associated with the session")
+    state: Optional[str] = Field(None, description="OAuth state parameter")
+
+
+class MCPOAuthSessionUpdate(BaseMCPOAuth):
+    """Update an existing OAuth session."""
+
+    authorization_url: Optional[str] = Field(None, description="OAuth authorization URL")
+    authorization_code: Optional[str] = Field(None, description="OAuth authorization code")
+    access_token: Optional[str] = Field(None, description="OAuth access token")
+    refresh_token: Optional[str] = Field(None, description="OAuth refresh token")
+    token_type: Optional[str] = Field(None, description="Token type")
+    expires_at: Optional[datetime] = Field(None, description="Token expiry time")
+    scope: Optional[str] = Field(None, description="OAuth scope")
+    client_id: Optional[str] = Field(None, description="OAuth client ID")
+    client_secret: Optional[str] = Field(None, description="OAuth client secret")
+    redirect_uri: Optional[str] = Field(None, description="OAuth redirect URI")
+    status: Optional[OAuthSessionStatus] = Field(None, description="Session status")

{letta_nightly-0.9.0.dev20250726104256 → letta_nightly-0.9.1.dev20250727063635}/letta/schemas/memory.py

@@ -133,6 +133,25 @@ class Memory(BaseModel, validate_assignment=True):
         except Exception as e:
             raise ValueError(f"Prompt template is not compatible with current memory structure: {str(e)}")
 
+    async def set_prompt_template_async(self, prompt_template: str):
+        """
+        Async version of set_prompt_template that doesn't block the event loop.
+        """
+        try:
+            # Validate Jinja2 syntax with async enabled
+            Template(prompt_template, enable_async=True)
+
+            # Validate compatibility with current memory structure - use async rendering
+            template = Template(prompt_template, enable_async=True)
+            await template.render_async(blocks=self.blocks, file_blocks=self.file_blocks, sources=[], max_files_open=None)
+
+            # If we get here, the template is valid and compatible
+            self.prompt_template = prompt_template
+        except TemplateSyntaxError as e:
+            raise ValueError(f"Invalid Jinja2 template syntax: {str(e)}")
+        except Exception as e:
+            raise ValueError(f"Prompt template is not compatible with current memory structure: {str(e)}")
+
     def compile(self, tool_usage_rules=None, sources=None, max_files_open=None) -> str:
         """Generate a string representation of the memory in-context using the Jinja2 template"""
         try:
@@ -149,6 +168,22 @@ class Memory(BaseModel, validate_assignment=True):
         except Exception as e:
             raise ValueError(f"Prompt template is not compatible with current memory structure: {str(e)}")
 
+    async def compile_async(self, tool_usage_rules=None, sources=None, max_files_open=None) -> str:
+        """Async version of compile that doesn't block the event loop"""
+        try:
+            template = Template(self.prompt_template, enable_async=True)
+            return await template.render_async(
+                blocks=self.blocks,
+                file_blocks=self.file_blocks,
+                tool_usage_rules=tool_usage_rules,
+                sources=sources,
+                max_files_open=max_files_open,
+            )
+        except TemplateSyntaxError as e:
+            raise ValueError(f"Invalid Jinja2 template syntax: {str(e)}")
+        except Exception as e:
+            raise ValueError(f"Prompt template is not compatible with current memory structure: {str(e)}")
+
     def list_block_labels(self) -> List[str]:
         """Return a list of the block names held inside the memory object"""
         # return list(self.memory.keys())