letta-nightly 0.10.0.dev20250806104523__py3-none-any.whl → 0.11.0.dev20250807000848__py3-none-any.whl

letta/orm/archive.py

@@ -0,0 +1,86 @@
+import uuid
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, List, Optional
+
+from sqlalchemy import JSON, Index, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.mixins import OrganizationMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.archive import Archive as PydanticArchive
+from letta.settings import DatabaseChoice, settings
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+    from sqlalchemy.orm import Session
+
+    from letta.orm.archives_agents import ArchivesAgents
+    from letta.orm.organization import Organization
+    from letta.schemas.user import User
+
+
+class Archive(SqlalchemyBase, OrganizationMixin):
+    """An archive represents a collection of archival passages that can be shared between agents"""
+
+    __tablename__ = "archives"
+    __pydantic_model__ = PydanticArchive
+
+    __table_args__ = (
+        Index("ix_archives_created_at", "created_at", "id"),
+        Index("ix_archives_organization_id", "organization_id"),
+    )
+
+    # archive generates its own id
+    # 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"archive-{uuid.uuid4()}")
+
+    # archive-specific fields
+    name: Mapped[str] = mapped_column(String, nullable=False, doc="The name of the archive")
+    description: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="A description of the archive")
+    metadata_: Mapped[Optional[dict]] = mapped_column(JSON, nullable=True, doc="Additional metadata for the archive")
+
+    # relationships
+    archives_agents: Mapped[List["ArchivesAgents"]] = relationship(
+        "ArchivesAgents",
+        back_populates="archive",
+        cascade="all, delete-orphan",  # this will delete junction entries when archive is deleted
+        lazy="noload",
+    )
+
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="archives", lazy="selectin")
+
+    def create(
+        self,
+        db_session: "Session",
+        actor: Optional["User"] = None,
+        no_commit: bool = False,
+    ) -> "Archive":
+        """Override create to handle SQLite timestamp issues"""
+        # For SQLite, explicitly set timestamps as server_default may not work
+        if settings.database_engine == DatabaseChoice.SQLITE:
+            now = datetime.now(timezone.utc)
+            if not self.created_at:
+                self.created_at = now
+            if not self.updated_at:
+                self.updated_at = now
+
+        return super().create(db_session, actor=actor, no_commit=no_commit)
+
+    async def create_async(
+        self,
+        db_session: "AsyncSession",
+        actor: Optional["User"] = None,
+        no_commit: bool = False,
+        no_refresh: bool = False,
+    ) -> "Archive":
+        """Override create_async to handle SQLite timestamp issues"""
+        # For SQLite, explicitly set timestamps as server_default may not work
+        if settings.database_engine == DatabaseChoice.SQLITE:
+            now = datetime.now(timezone.utc)
+            if not self.created_at:
+                self.created_at = now
+            if not self.updated_at:
+                self.updated_at = now
+
+        return await super().create_async(db_session, actor=actor, no_commit=no_commit, no_refresh=no_refresh)

letta/orm/archives_agents.py

@@ -0,0 +1,27 @@
+from datetime import datetime
+
+from sqlalchemy import Boolean, DateTime, ForeignKey, String, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.base import Base
+
+
+class ArchivesAgents(Base):
+    """Many-to-many relationship between agents and archives"""
+
+    __tablename__ = "archives_agents"
+
+    # TODO: Remove this unique constraint when we support multiple archives per agent
+    # For now, each agent can only have one archive
+    __table_args__ = (UniqueConstraint("agent_id", name="unique_agent_archive"),)
+
+    agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id", ondelete="CASCADE"), primary_key=True)
+    archive_id: Mapped[str] = mapped_column(String, ForeignKey("archives.id", ondelete="CASCADE"), primary_key=True)
+
+    # track when the relationship was created and if agent is owner
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default="now()")
+    is_owner: Mapped[bool] = mapped_column(Boolean, default=False, doc="Whether this agent created/owns the archive")
+
+    # relationships
+    agent: Mapped["Agent"] = relationship("Agent", back_populates="archives_agents")
+    archive: Mapped["Archive"] = relationship("Archive", back_populates="archives_agents")

letta/orm/job.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from typing import TYPE_CHECKING, List, Optional
 
-from sqlalchemy import JSON, Index, String
+from sqlalchemy import JSON, BigInteger, Index, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.mixins import UserMixin
@@ -46,6 +46,10 @@ class Job(SqlalchemyBase, UserMixin):
         nullable=True, doc="Optional error message from attempting to POST the callback endpoint."
     )
 
+    # timing metrics (in nanoseconds for precision)
+    ttft_ns: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, doc="Time to first token in nanoseconds")
+    total_duration_ns: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, doc="Total run duration in nanoseconds")
+
     # relationships
     user: Mapped["User"] = relationship("User", back_populates="jobs")
     job_messages: Mapped[List["JobMessage"]] = relationship("JobMessage", back_populates="job", cascade="all, delete-orphan")

letta/orm/mixins.py

@@ -70,3 +70,11 @@ class ProjectMixin(Base):
     __abstract__ = True
 
     project_id: Mapped[str] = mapped_column(String, nullable=True, doc="The associated project id.")
+
+
+class ArchiveMixin(Base):
+    """Mixin for models that belong to an archive."""
+
+    __abstract__ = True
+
+    archive_id: Mapped[str] = mapped_column(String, ForeignKey("archives.id", ondelete="CASCADE"))

letta/orm/organization.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, List, Union
+from typing import TYPE_CHECKING, List
 
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
@@ -8,13 +8,14 @@ from letta.schemas.organization import Organization as PydanticOrganization
 if TYPE_CHECKING:
     from letta.orm import Source
     from letta.orm.agent import Agent
+    from letta.orm.archive import Archive
     from letta.orm.block import Block
     from letta.orm.group import Group
     from letta.orm.identity import Identity
     from letta.orm.llm_batch_items import LLMBatchItem
     from letta.orm.llm_batch_job import LLMBatchJob
     from letta.orm.message import Message
-    from letta.orm.passage import AgentPassage, SourcePassage
+    from letta.orm.passage import ArchivalPassage, SourcePassage
     from letta.orm.provider import Provider
     from letta.orm.sandbox_config import AgentEnvironmentVariable, SandboxConfig, SandboxEnvironmentVariable
     from letta.orm.tool import Tool
@@ -52,7 +53,10 @@ class Organization(SqlalchemyBase):
     source_passages: Mapped[List["SourcePassage"]] = relationship(
         "SourcePassage", back_populates="organization", cascade="all, delete-orphan"
     )
-    agent_passages: Mapped[List["AgentPassage"]] = relationship("AgentPassage", back_populates="organization", cascade="all, delete-orphan")
+    archival_passages: Mapped[List["ArchivalPassage"]] = relationship(
+        "ArchivalPassage", back_populates="organization", cascade="all, delete-orphan"
+    )
+    archives: Mapped[List["Archive"]] = relationship("Archive", back_populates="organization", cascade="all, delete-orphan")
     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")
@@ -60,8 +64,3 @@ class Organization(SqlalchemyBase):
     llm_batch_items: Mapped[List["LLMBatchItem"]] = relationship(
         "LLMBatchItem", back_populates="organization", cascade="all, delete-orphan"
     )
-
-    @property
-    def passages(self) -> List[Union["SourcePassage", "AgentPassage"]]:
-        """Convenience property to get all passages"""
-        return self.source_passages + self.agent_passages

letta/orm/passage.py

@@ -6,7 +6,7 @@ from sqlalchemy.orm import Mapped, declared_attr, mapped_column, relationship
 from letta.config import LettaConfig
 from letta.constants import MAX_EMBEDDING_DIM
 from letta.orm.custom_columns import CommonVector, EmbeddingConfigColumn
-from letta.orm.mixins import AgentMixin, FileMixin, OrganizationMixin, SourceMixin
+from letta.orm.mixins import ArchiveMixin, FileMixin, OrganizationMixin, SourceMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.passage import Passage as PydanticPassage
 from letta.settings import DatabaseChoice, settings
@@ -70,26 +70,28 @@ class SourcePassage(BasePassage, FileMixin, SourceMixin):
         )
 
 
-class AgentPassage(BasePassage, AgentMixin):
-    """Passages created by agents as archival memories"""
+class ArchivalPassage(BasePassage, ArchiveMixin):
+    """Passages stored in archives as archival memories"""
 
-    __tablename__ = "agent_passages"
+    __tablename__ = "archival_passages"
 
     @declared_attr
     def organization(cls) -> Mapped["Organization"]:
-        return relationship("Organization", back_populates="agent_passages", lazy="selectin")
+        return relationship("Organization", back_populates="archival_passages", lazy="selectin")
 
     @declared_attr
     def __table_args__(cls):
         if settings.database_engine is DatabaseChoice.POSTGRES:
             return (
-                Index("agent_passages_org_idx", "organization_id"),
-                Index("ix_agent_passages_org_agent", "organization_id", "agent_id"),
-                Index("agent_passages_created_at_id_idx", "created_at", "id"),
+                Index("archival_passages_org_idx", "organization_id"),
+                Index("ix_archival_passages_org_archive", "organization_id", "archive_id"),
+                Index("archival_passages_created_at_id_idx", "created_at", "id"),
+                Index("ix_archival_passages_archive_id", "archive_id"),
                 {"extend_existing": True},
             )
         return (
-            Index("ix_agent_passages_org_agent", "organization_id", "agent_id"),
-            Index("agent_passages_created_at_id_idx", "created_at", "id"),
+            Index("ix_archival_passages_org_archive", "organization_id", "archive_id"),
+            Index("archival_passages_created_at_id_idx", "created_at", "id"),
+            Index("ix_archival_passages_archive_id", "archive_id"),
             {"extend_existing": True},
         )

letta/orm/sqlite_functions.py

@@ -152,7 +152,7 @@ def register_functions(dbapi_connection, connection_record):
             if is_aiosqlite_connection:
                 # For aiosqlite connections, we cannot use async operations in sync event handlers
                 # The extension will need to be loaded per-connection when actually used
-                logger.info("Detected aiosqlite connection - sqlite-vec will be loaded per-query")
+                logger.debug("Detected aiosqlite connection - sqlite-vec will be loaded per-query")
             else:
                 # For sync connections
                 # dbapi_connection.enable_load_extension(True)
@@ -173,7 +173,7 @@ def register_functions(dbapi_connection, connection_record):
                 raw_conn = getattr(actual_connection, "_connection", actual_connection)
                 if hasattr(raw_conn, "create_function"):
                     raw_conn.create_function("cosine_distance", 2, cosine_distance)
-                    logger.info("Successfully registered cosine_distance for aiosqlite")
+                    logger.debug("Successfully registered cosine_distance for aiosqlite")
             else:
                 dbapi_connection.create_function("cosine_distance", 2, cosine_distance)
                 logger.info("Successfully registered cosine_distance for sync connection")

letta/orm/tool.py

@@ -3,11 +3,11 @@ from typing import TYPE_CHECKING, List, Optional
 from sqlalchemy import JSON, Index, String, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
-# TODO everything in functions should live in this model
-from letta.orm.enums import ToolType
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
-from letta.schemas.enums import ToolSourceType
+
+# TODO everything in functions should live in this model
+from letta.schemas.enums import ToolSourceType, ToolType
 from letta.schemas.tool import Tool as PydanticTool
 
 if TYPE_CHECKING:
@@ -43,11 +43,12 @@ class Tool(SqlalchemyBase, OrganizationMixin):
     tags: Mapped[List] = mapped_column(JSON, doc="Metadata tags used to filter tools.")
     source_type: Mapped[ToolSourceType] = mapped_column(String, doc="The type of the source code.", default=ToolSourceType.json)
     source_code: Mapped[Optional[str]] = mapped_column(String, doc="The source code of the function.")
-    json_schema: Mapped[Optional[dict]] = mapped_column(JSON, default=lambda: {}, doc="The OAI compatable JSON schema of the function.")
+    json_schema: Mapped[Optional[dict]] = mapped_column(JSON, default=lambda: {}, doc="The OAI compatible JSON schema of the function.")
     args_json_schema: Mapped[Optional[dict]] = mapped_column(JSON, default=lambda: {}, doc="The JSON schema of the function arguments.")
     pip_requirements: Mapped[Optional[List]] = mapped_column(
         JSON, nullable=True, doc="Optional list of pip packages required by this tool."
     )
+    npm_requirements: Mapped[list | None] = mapped_column(JSON, doc="Optional list of npm packages required by this tool.")
     metadata_: Mapped[Optional[dict]] = mapped_column(JSON, default=lambda: {}, doc="A dictionary of additional metadata for the tool.")
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="tools", lazy="selectin")

letta/schemas/agent.py

@@ -186,8 +186,8 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     include_multi_agent_tools: bool = Field(
         False, description="If true, attaches the Letta multi-agent tools (e.g. sending a message to another agent)."
     )
-    include_base_tool_rules: bool = Field(
-        True, description="If true, attaches the Letta base tool rules (e.g. deny all tools not explicitly allowed)."
+    include_base_tool_rules: Optional[bool] = Field(
+        None, description="If true, attaches the Letta base tool rules (e.g. deny all tools not explicitly allowed)."
     )
     include_default_source: bool = Field(
         False, description="If true, automatically creates and attaches a default data source for this agent."
@@ -212,6 +212,7 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
         None, description="The maximum number of tokens to generate for reasoning step. If not set, the model will use its default value."
     )
     enable_reasoner: Optional[bool] = Field(False, description="Whether to enable internal extended thinking step for a reasoner model.")
+    reasoning: Optional[bool] = Field(None, description="Whether to enable reasoning for this agent.")
     from_template: Optional[str] = Field(None, description="The template id used to configure the agent")
     template: bool = Field(False, description="Whether the agent is a template")
     project: Optional[str] = Field(
@@ -335,6 +336,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."
     )
+    reasoning: Optional[bool] = Field(None, description="Whether to enable reasoning for this agent.")
     enable_sleeptime: Optional[bool] = Field(None, description="If set to True, memory management will move to a background agent thread.")
     response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the agent.")
     last_run_completion: Optional[datetime] = Field(None, description="The timestamp when the agent last completed a run.")

letta/schemas/agent_file.py

@@ -7,7 +7,7 @@ from letta.schemas.agent import AgentState, CreateAgent
 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.group import Group, GroupCreate
 from letta.schemas.mcp import MCPServer
 from letta.schemas.message import Message, MessageCreate
 from letta.schemas.source import Source, SourceCreate
@@ -99,6 +99,7 @@ class AgentSchema(CreateAgent):
     )
     messages: List[MessageSchema] = Field(default_factory=list, description="List of messages in the agent's conversation history")
     files_agents: List[FileAgentSchema] = Field(default_factory=list, description="List of file-agent relationships for this agent")
+    group_ids: List[str] = Field(default_factory=list, description="List of groups that the agent manages")
 
     @classmethod
     async def from_agent_state(
@@ -163,6 +164,7 @@ class AgentSchema(CreateAgent):
             in_context_message_ids=agent_state.message_ids or [],
             messages=message_schemas,  # Messages will be populated separately by the manager
             files_agents=[FileAgentSchema.from_file_agent(f) for f in files_agents],
+            group_ids=[agent_state.multi_agent_group.id] if agent_state.multi_agent_group else [],
             **create_agent.model_dump(),
         )
 
@@ -173,6 +175,21 @@ class GroupSchema(GroupCreate):
     __id_prefix__ = "group"
     id: str = Field(..., description="Human-readable identifier for this group in the file")
 
+    @classmethod
+    def from_group(cls, group: Group) -> "GroupSchema":
+        """Convert Group to GroupSchema"""
+
+        create_group = GroupCreate(
+            agent_ids=group.agent_ids,
+            description=group.description,
+            manager_config=group.manager_config,
+            project_id=group.project_id,
+            shared_block_ids=group.shared_block_ids,
+        )
+
+        # Create GroupSchema with the group's ID (will be remapped later)
+        return cls(id=group.id, **create_group.model_dump())
+
 
 class BlockSchema(CreateBlock):
     """Block with human-readable ID for agent file"""

letta/schemas/archive.py

@@ -0,0 +1,44 @@
+from datetime import datetime
+from typing import Dict, Optional
+
+from pydantic import Field
+
+from letta.schemas.letta_base import OrmMetadataBase
+
+
+class ArchiveBase(OrmMetadataBase):
+    __id_prefix__ = "archive"
+
+    name: str = Field(..., description="The name of the archive")
+    description: Optional[str] = Field(None, description="A description of the archive")
+    organization_id: str = Field(..., description="The organization this archive belongs to")
+    metadata: Optional[Dict] = Field(default_factory=dict, validation_alias="metadata_", description="Additional metadata")
+
+
+class Archive(ArchiveBase):
+    """
+    Representation of an archive - a collection of archival passages that can be shared between agents.
+
+    Parameters:
+        id (str): The unique identifier of the archive.
+        name (str): The name of the archive.
+        description (str): A description of the archive.
+        organization_id (str): The organization this archive belongs to.
+        created_at (datetime): The creation date of the archive.
+        metadata (dict): Additional metadata for the archive.
+    """
+
+    id: str = ArchiveBase.generate_id_field()
+    created_at: datetime = Field(..., description="The creation date of the archive")
+
+
+class ArchiveCreate(ArchiveBase):
+    """Create a new archive"""
+
+
+class ArchiveUpdate(ArchiveBase):
+    """Update an existing archive"""
+
+    name: Optional[str] = Field(None, description="The name of the archive")
+    description: Optional[str] = Field(None, description="A description of the archive")
+    metadata: Optional[Dict] = Field(None, validation_alias="metadata_", description="Additional metadata")

letta/schemas/embedding_config.py

@@ -6,21 +6,7 @@ from letta.constants import DEFAULT_EMBEDDING_CHUNK_SIZE
 
 
 class EmbeddingConfig(BaseModel):
-    """
-
-    Embedding model configuration. This object specifies all the information necessary to access an embedding model to usage with Letta, except for secret keys.
-
-    Attributes:
-        embedding_endpoint_type (str): The endpoint type for the model.
-        embedding_endpoint (str): The endpoint for the model.
-        embedding_model (str): The model for the embedding.
-        embedding_dim (int): The dimension of the embedding.
-        embedding_chunk_size (int): The chunk size of the embedding.
-        azure_endpoint (:obj:`str`, optional): The Azure endpoint for the model (Azure only).
-        azure_version (str): The Azure version for the model (Azure only).
-        azure_deployment (str): The Azure deployment for the model (Azure only).
-
-    """
+    """Configuration for embedding model connection and processing parameters."""
 
     embedding_endpoint_type: Literal[
         "openai",
@@ -77,7 +63,7 @@ class EmbeddingConfig(BaseModel):
             )
         elif model_name == "letta":
             return cls(
-                embedding_endpoint="https://embeddings.memgpt.ai",
+                embedding_endpoint="https://bun-function-production-e310.up.railway.app/v1",
                 embedding_model="BAAI/bge-large-en-v1.5",
                 embedding_dim=1024,
                 embedding_chunk_size=DEFAULT_EMBEDDING_CHUNK_SIZE,

letta/schemas/enums.py

@@ -132,7 +132,8 @@ class ToolSourceType(str, Enum):
     """Defines what a tool was derived from"""
 
     python = "python"
-    json = "json"
+    typescript = "typescript"
+    json = "json"  # TODO (cliandy): is this still valid?
 
 
 class ActorType(str, Enum):

letta/schemas/group.py

@@ -15,6 +15,10 @@ class ManagerType(str, Enum):
     swarm = "swarm"
 
 
+class ManagerConfig(BaseModel):
+    manager_type: ManagerType = Field(..., description="")
+
+
 class GroupBase(LettaBase):
     __id_prefix__ = "group"
 
@@ -42,9 +46,30 @@ class Group(GroupBase):
         description="The desired minimum length of messages in the context window of the convo agent. This is a best effort, and may be off-by-one due to user/assistant interleaving.",
     )
 
-
-class ManagerConfig(BaseModel):
-    manager_type: ManagerType = Field(..., description="")
+    @property
+    def manager_config(self) -> ManagerConfig:
+        match self.manager_type:
+            case ManagerType.round_robin:
+                return RoundRobinManager(max_turns=self.max_turns)
+            case ManagerType.supervisor:
+                return SupervisorManager(manager_agent_id=self.manager_agent_id)
+            case ManagerType.dynamic:
+                return DynamicManager(
+                    manager_agent_id=self.manager_agent_id,
+                    termination_token=self.termination_token,
+                    max_turns=self.max_turns,
+                )
+            case ManagerType.sleeptime:
+                return SleeptimeManager(
+                    manager_agent_id=self.manager_agent_id,
+                    sleeptime_agent_frequency=self.sleeptime_agent_frequency,
+                )
+            case ManagerType.voice_sleeptime:
+                return VoiceSleeptimeManager(
+                    manager_agent_id=self.manager_agent_id,
+                    max_message_buffer_length=self.max_message_buffer_length,
+                    min_message_buffer_length=self.min_message_buffer_length,
+                )
 
 
 class RoundRobinManager(ManagerConfig):

letta/schemas/job.py

@@ -21,6 +21,10 @@ class JobBase(OrmMetadataBase):
     callback_status_code: Optional[int] = Field(None, description="HTTP status code returned by the callback endpoint.")
     callback_error: Optional[str] = Field(None, description="Optional error message from attempting to POST the callback endpoint.")
 
+    # Timing metrics (in nanoseconds for precision)
+    ttft_ns: int | None = Field(None, description="Time to first token for a run in nanoseconds")
+    total_duration_ns: int | None = Field(None, description="Total run duration in nanoseconds")
+
 
 class Job(JobBase):
     """

letta/schemas/llm_config.py

@@ -10,19 +10,7 @@ logger = get_logger(__name__)
 
 
 class LLMConfig(BaseModel):
-    """
-    Configuration for a Language Model (LLM) model. This object specifies all the information necessary to access an LLM model to usage with Letta, except for secret keys.
-
-    Attributes:
-        model (str): The name of the LLM model.
-        model_endpoint_type (str): The endpoint type for the model.
-        model_endpoint (str): The endpoint for the model.
-        model_wrapper (str): The wrapper for the model. This is used to wrap additional text around the input/output of the model. This is useful for text-to-text completions, such as the Completions API in OpenAI.
-        context_window (int): The context window size for the model.
-        put_inner_thoughts_in_kwargs (bool): Puts `inner_thoughts` as a kwarg in the function call if this is set to True. This helps with function calling performance and also the generation of inner thoughts.
-        temperature (float): The temperature to use when generating text with the model. A higher temperature will result in more random text.
-        max_tokens (int): The maximum number of tokens to generate.
-    """
+    """Configuration for Language Model (LLM) connection and generation parameters."""
 
     model: str = Field(..., description="LLM model name. ")
     model_endpoint_type: Literal[
@@ -185,7 +173,7 @@ class LLMConfig(BaseModel):
                 model="memgpt-openai",
                 model_endpoint_type="openai",
                 model_endpoint=LETTA_MODEL_ENDPOINT,
-                context_window=8192,
+                context_window=30000,
             )
         else:
             raise ValueError(f"Model {model_name} not supported.")
@@ -196,3 +184,30 @@ class LLMConfig(BaseModel):
             + (f" [type={self.model_endpoint_type}]" if self.model_endpoint_type else "")
             + (f" [ip={self.model_endpoint}]" if self.model_endpoint else "")
         )
+
+    @classmethod
+    def apply_reasoning_setting_to_config(cls, config: "LLMConfig", reasoning: bool):
+        if reasoning:
+            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)
+            ) or (
+                config.model_endpoint_type == "google_vertex" and ("gemini-2.5-flash" in config.model or "gemini-2.0-pro" in config.model)
+            ):
+                config.put_inner_thoughts_in_kwargs = False
+                config.enable_reasoner = True
+                if config.max_reasoning_tokens == 0:
+                    config.max_reasoning_tokens = 1024
+            elif config.model_endpoint_type == "openai" and (
+                config.model.startswith("o1") or config.model.startswith("o3") or config.model.startswith("o4")
+            ):
+                config.put_inner_thoughts_in_kwargs = True
+                config.enable_reasoner = True
+                if config.reasoning_effort is None:
+                    config.reasoning_effort = "medium"
+            else:
+                config.put_inner_thoughts_in_kwargs = True
+                config.enable_reasoner = False
+        else:
+            config.put_inner_thoughts_in_kwargs = False
+            config.enable_reasoner = False

letta/schemas/memory.py

@@ -1,3 +1,4 @@
+import asyncio
 import logging
 from typing import TYPE_CHECKING, List, Optional
 
@@ -142,11 +143,11 @@ class Memory(BaseModel, validate_assignment=True):
         """
         try:
             # Validate Jinja2 syntax with async enabled
-            Template(prompt_template, enable_async=True)
+            Template(prompt_template)
 
             # 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)
+            template = Template(prompt_template)
+            await asyncio.to_thread(template.render, 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
@@ -189,6 +190,11 @@ class Memory(BaseModel, validate_assignment=True):
         except Exception as e:
             raise ValueError(f"Prompt template is not compatible with current memory structure: {str(e)}")
 
+    @trace_method
+    async def compile_in_thread_async(self, tool_usage_rules=None, sources=None, max_files_open=None) -> str:
+        """Compile the memory in a thread"""
+        return await asyncio.to_thread(self.compile, tool_usage_rules=tool_usage_rules, sources=sources, max_files_open=max_files_open)
+
     def list_block_labels(self) -> List[str]:
         """Return a list of the block names held inside the memory object"""
         # return list(self.memory.keys())

letta/schemas/npm_requirement.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, Field
+
+
+class NpmRequirement(BaseModel):
+    name: str = Field(..., min_length=1, description="Name of the npm package.")
+    version: str | None = Field(None, description="Optional version of the package, following semantic versioning.")
+
+    def __str__(self) -> str:
+        """Return a npm-installable string format."""
+        if self.version:
+            return f'{self.name}@"{self.version}"'
+        return self.name

letta/schemas/passage.py

@@ -16,7 +16,7 @@ class PassageBase(OrmMetadataBase):
 
     # associated user/agent
     organization_id: Optional[str] = Field(None, description="The unique identifier of the user associated with the passage.")
-    agent_id: Optional[str] = Field(None, description="The unique identifier of the agent associated with the passage.")
+    archive_id: Optional[str] = Field(None, description="The unique identifier of the archive containing this passage.")
 
     # origin data source
     source_id: Optional[str] = Field(None, description="The data source of the passage.")
@@ -36,8 +36,8 @@ class Passage(PassageBase):
         embedding (List[float]): The embedding of the passage.
         embedding_config (EmbeddingConfig): The embedding configuration used by the passage.
         created_at (datetime): The creation date of the passage.
-        user_id (str): The unique identifier of the user associated with the passage.
-        agent_id (str): The unique identifier of the agent associated with the passage.
+        organization_id (str): The unique identifier of the organization associated with the passage.
+        archive_id (str): The unique identifier of the archive containing this passage.
         source_id (str): The data source of the passage.
         file_id (str): The unique identifier of the file associated with the passage.
     """

letta/schemas/providers/letta.py

@@ -31,7 +31,7 @@ class LettaProvider(Provider):
             EmbeddingConfig(
                 embedding_model="letta-free",  # NOTE: renamed
                 embedding_endpoint_type="hugging-face",
-                embedding_endpoint="https://embeddings.memgpt.ai",
+                embedding_endpoint="https://bun-function-production-e310.up.railway.app/v1",
                 embedding_dim=1024,
                 embedding_chunk_size=DEFAULT_EMBEDDING_CHUNK_SIZE,
                 handle=self.get_handle("letta-free", is_embedding=True),