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

letta/orm/sqlalchemy_base.py

@@ -66,101 +66,6 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
     id: Mapped[str] = mapped_column(String, primary_key=True)
 
-    @classmethod
-    @handle_db_timeout
-    def list(
-        cls,
-        *,
-        db_session: "Session",
-        before: Optional[str] = None,
-        after: Optional[str] = None,
-        start_date: Optional[datetime] = None,
-        end_date: Optional[datetime] = None,
-        limit: Optional[int] = 50,
-        query_text: Optional[str] = None,
-        query_embedding: Optional[List[float]] = None,
-        ascending: bool = True,
-        actor: Optional["User"] = None,
-        access: Optional[List[Literal["read", "write", "admin"]]] = ["read"],
-        access_type: AccessType = AccessType.ORGANIZATION,
-        join_model: Optional[Base] = None,
-        join_conditions: Optional[Union[Tuple, List]] = None,
-        identifier_keys: Optional[List[str]] = None,
-        identity_id: Optional[str] = None,
-        **kwargs,
-    ) -> List["SqlalchemyBase"]:
-        """
-        List records with before/after pagination, ordering by created_at.
-        Can use both before and after to fetch a window of records.
-
-        Args:
-            db_session: SQLAlchemy session
-            before: ID of item to paginate before (upper bound)
-            after: ID of item to paginate after (lower bound)
-            start_date: Filter items after this date
-            end_date: Filter items before this date
-            limit: Maximum number of items to return
-            query_text: Text to search for
-            query_embedding: Vector to search for similar embeddings
-            ascending: Sort direction
-            **kwargs: Additional filters to apply
-        """
-        if start_date and end_date and start_date > end_date:
-            raise ValueError("start_date must be earlier than or equal to end_date")
-
-        logger.debug(f"Listing {cls.__name__} with kwarg filters {kwargs}")
-
-        with db_session as session:
-            # Get the reference objects for pagination
-            before_obj = None
-            after_obj = None
-
-            if before:
-                before_obj = session.get(cls, before)
-                if not before_obj:
-                    raise NoResultFound(f"No {cls.__name__} found with id {before}")
-
-            if after:
-                after_obj = session.get(cls, after)
-                if not after_obj:
-                    raise NoResultFound(f"No {cls.__name__} found with id {after}")
-
-            # Validate that before comes after the after object if both are provided
-            if before_obj and after_obj and before_obj.created_at < after_obj.created_at:
-                raise ValueError("'before' reference must be later than 'after' reference")
-
-            query = cls._list_preprocess(
-                before_obj=before_obj,
-                after_obj=after_obj,
-                start_date=start_date,
-                end_date=end_date,
-                limit=limit,
-                query_text=query_text,
-                query_embedding=query_embedding,
-                ascending=ascending,
-                actor=actor,
-                access=access,
-                access_type=access_type,
-                join_model=join_model,
-                join_conditions=join_conditions,
-                identifier_keys=identifier_keys,
-                identity_id=identity_id,
-                **kwargs,
-            )
-
-            # Execute the query
-            results = session.execute(query)
-
-            results = list(results.scalars())
-            results = cls._list_postprocess(
-                before=before,
-                after=after,
-                limit=limit,
-                results=results,
-            )
-
-            return results
-
     @classmethod
     @handle_db_timeout
     async def list_async(
@@ -446,45 +351,6 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             results = results[start:end]
         return results
 
-    @classmethod
-    @handle_db_timeout
-    def read(
-        cls,
-        db_session: "Session",
-        identifier: Optional[str] = None,
-        actor: Optional["User"] = None,
-        access: Optional[List[Literal["read", "write", "admin"]]] = ["read"],
-        access_type: AccessType = AccessType.ORGANIZATION,
-        check_is_deleted: bool = False,
-        **kwargs,
-    ) -> "SqlalchemyBase":
-        """The primary accessor for an ORM record.
-        Args:
-            db_session: the database session to use when retrieving the record
-            identifier: the identifier of the record to read, can be the id string or the UUID object for backwards compatibility
-            actor: if specified, results will be scoped only to records the user is able to access
-            access: if actor is specified, records will be filtered to the minimum permission level for the actor
-            kwargs: additional arguments to pass to the read, used for more complex objects
-        Returns:
-            The matching object
-        Raises:
-            NoResultFound: if the object is not found
-        """
-        # this is ok because read_multiple will check if the
-        identifiers = [] if identifier is None else [identifier]
-        found = cls.read_multiple(db_session, identifiers, actor, access, access_type, check_is_deleted, **kwargs)
-        if len(found) == 0:
-            # for backwards compatibility.
-            conditions = []
-            if identifier:
-                conditions.append(f"id={identifier}")
-            if actor:
-                conditions.append(f"access level in {access} for {actor}")
-            if check_is_deleted and hasattr(cls, "is_deleted"):
-                conditions.append("is_deleted=False")
-            raise NoResultFound(f"{cls.__name__} not found with {', '.join(conditions if conditions else ['no conditions'])}")
-        return found[0]
-
     @classmethod
     @handle_db_timeout
     async def read_async(
@@ -521,36 +387,6 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             raise NoResultFound(f"{cls.__name__} not found with {', '.join(query_conditions if query_conditions else ['no conditions'])}")
         return item
 
-    @classmethod
-    @handle_db_timeout
-    def read_multiple(
-        cls,
-        db_session: "Session",
-        identifiers: List[str] = [],
-        actor: Optional["User"] = None,
-        access: Optional[List[Literal["read", "write", "admin"]]] = ["read"],
-        access_type: AccessType = AccessType.ORGANIZATION,
-        check_is_deleted: bool = False,
-        **kwargs,
-    ) -> List["SqlalchemyBase"]:
-        """The primary accessor for ORM record(s)
-        Args:
-            db_session: the database session to use when retrieving the record
-            identifiers: a list of identifiers of the records to read, can be the id string or the UUID object for backwards compatibility
-            actor: if specified, results will be scoped only to records the user is able to access
-            access: if actor is specified, records will be filtered to the minimum permission level for the actor
-            kwargs: additional arguments to pass to the read, used for more complex objects
-        Returns:
-            The matching object
-        Raises:
-            NoResultFound: if the object is not found
-        """
-        query, query_conditions = cls._read_multiple_preprocess(identifiers, actor, access, access_type, check_is_deleted, **kwargs)
-        if query is None:
-            return []
-        results = db_session.execute(query).scalars().all()
-        return cls._read_multiple_postprocess(results, identifiers, query_conditions)
-
     @classmethod
     @handle_db_timeout
     async def read_multiple_async(
@@ -637,23 +473,6 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         logger.debug(f"{cls.__name__} not found with {conditions_str}")
         return []
 
-    @handle_db_timeout
-    def create(self, db_session: "Session", actor: Optional["User"] = None, no_commit: bool = False) -> "SqlalchemyBase":
-        logger.debug(f"Creating {self.__class__.__name__} with ID: {self.id} with actor={actor}")
-
-        if actor:
-            self._set_created_and_updated_by_fields(actor.id)
-        try:
-            db_session.add(self)
-            if no_commit:
-                db_session.flush()  # no commit, just flush to get PK
-            else:
-                db_session.commit()
-            db_session.refresh(self)
-            return self
-        except (DBAPIError, IntegrityError) as e:
-            self._handle_dbapi_error(e)
-
     @handle_db_timeout
     async def create_async(
         self,
@@ -680,47 +499,6 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         except (DBAPIError, IntegrityError) as e:
             self._handle_dbapi_error(e)
 
-    @classmethod
-    @handle_db_timeout
-    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 []
-
-        # Set created/updated by fields if actor is provided
-        if actor:
-            for item in items:
-                item._set_created_and_updated_by_fields(actor.id)
-
-        try:
-            with db_session as session:
-                session.add_all(items)
-                session.flush()  # Flush to generate IDs but don't commit yet
-
-                # Collect IDs to fetch the complete objects after commit
-                item_ids = [item.id for item in items]
-
-                session.commit()
-
-                # Re-query the objects to get them with relationships loaded
-                query = select(cls).where(cls.id.in_(item_ids))
-                if hasattr(cls, "created_at"):
-                    query = query.order_by(cls.created_at)
-
-                return list(session.execute(query).scalars())
-
-        except (DBAPIError, IntegrityError) as e:
-            cls._handle_dbapi_error(e)
-
     @classmethod
     @handle_db_timeout
     async def batch_create_async(
@@ -774,16 +552,6 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         except (DBAPIError, IntegrityError) as e:
             cls._handle_dbapi_error(e)
 
-    @handle_db_timeout
-    def delete(self, db_session: "Session", actor: Optional["User"] = None) -> "SqlalchemyBase":
-        logger.debug(f"Soft deleting {self.__class__.__name__} with ID: {self.id} with actor={actor}")
-
-        if actor:
-            self._set_created_and_updated_by_fields(actor.id)
-
-        self.is_deleted = True
-        return self.update(db_session)
-
     @handle_db_timeout
     async def delete_async(self, db_session: "AsyncSession", actor: Optional["User"] = None) -> "SqlalchemyBase":
         """Soft delete a record asynchronously (mark as deleted)."""
@@ -795,22 +563,6 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         self.is_deleted = True
         return await self.update_async(db_session)
 
-    @handle_db_timeout
-    def hard_delete(self, db_session: "Session", actor: Optional["User"] = None) -> None:
-        """Permanently removes the record from the database."""
-        logger.debug(f"Hard deleting {self.__class__.__name__} with ID: {self.id} with actor={actor}")
-
-        with db_session as session:
-            try:
-                session.delete(self)
-                session.commit()
-            except Exception as e:
-                session.rollback()
-                logger.exception(f"Failed to hard delete {self.__class__.__name__} with ID {self.id}")
-                raise ValueError(f"Failed to hard delete {self.__class__.__name__} with ID {self.id}: {e}")
-            else:
-                logger.debug(f"{self.__class__.__name__} with ID {self.id} successfully hard deleted")
-
     @handle_db_timeout
     async def hard_delete_async(self, db_session: "AsyncSession", actor: Optional["User"] = None) -> None:
         """Permanently removes the record from the database asynchronously."""
@@ -853,22 +605,6 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             logger.exception(f"Failed to hard delete {cls.__name__} with identifiers {identifiers}")
             raise ValueError(f"Failed to hard delete {cls.__name__} with identifiers {identifiers}: {e}")
 
-    @handle_db_timeout
-    def update(self, db_session: Session, actor: Optional["User"] = None, no_commit: bool = False) -> "SqlalchemyBase":
-        logger.debug(...)
-        if actor:
-            self._set_created_and_updated_by_fields(actor.id)
-        self.set_updated_at()
-
-        # remove the context manager:
-        db_session.add(self)
-        if no_commit:
-            db_session.flush()  # no commit, just flush to get PK
-        else:
-            db_session.commit()
-        db_session.refresh(self)
-        return self
-
     @handle_db_timeout
     async def update_async(
         self, db_session: "AsyncSession", actor: Optional["User"] = None, no_commit: bool = False, no_refresh: bool = False
@@ -925,48 +661,6 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
         return query
 
-    @classmethod
-    @handle_db_timeout
-    def size(
-        cls,
-        *,
-        db_session: "Session",
-        actor: Optional["User"] = None,
-        access: Optional[List[Literal["read", "write", "admin"]]] = ["read"],
-        access_type: AccessType = AccessType.ORGANIZATION,
-        check_is_deleted: bool = False,
-        **kwargs,
-    ) -> int:
-        """
-        Get the count of rows that match the provided filters.
-
-        Args:
-            db_session: SQLAlchemy session
-            **kwargs: Filters to apply to the query (e.g., column_name=value)
-
-        Returns:
-            int: The count of rows that match the filters
-
-        Raises:
-            DBAPIError: If a database error occurs
-        """
-        with db_session as session:
-            query = cls._size_preprocess(
-                db_session=session,
-                actor=actor,
-                access=access,
-                access_type=access_type,
-                check_is_deleted=check_is_deleted,
-                **kwargs,
-            )
-
-            try:
-                count = session.execute(query).scalar()
-                return count if count else 0
-            except DBAPIError as e:
-                logger.exception(f"Failed to calculate size for {cls.__name__}")
-                raise e
-
     @classmethod
     @handle_db_timeout
     async def size_async(

letta/orm/step.py

@@ -1,7 +1,7 @@
 import uuid
 from typing import TYPE_CHECKING, Dict, List, Optional
 
-from sqlalchemy import JSON, ForeignKey, String
+from sqlalchemy import JSON, ForeignKey, Index, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.mixins import ProjectMixin
@@ -10,10 +10,10 @@ from letta.schemas.enums import StepStatus
 from letta.schemas.step import Step as PydanticStep
 
 if TYPE_CHECKING:
-    from letta.orm.job import Job
     from letta.orm.message import Message
     from letta.orm.organization import Organization
     from letta.orm.provider import Provider
+    from letta.orm.run import Run
     from letta.orm.step_metrics import StepMetrics
 
 
@@ -22,6 +22,7 @@ class Step(SqlalchemyBase, ProjectMixin):
 
     __tablename__ = "steps"
     __pydantic_model__ = PydanticStep
+    __table_args__ = (Index("ix_steps_run_id", "run_id"),)
 
     id: Mapped[str] = mapped_column(String, primary_key=True, default=lambda: f"step-{uuid.uuid4()}")
     origin: Mapped[Optional[str]] = mapped_column(nullable=True, doc="The surface that this agent step was initiated from.")
@@ -35,8 +36,8 @@ class Step(SqlalchemyBase, ProjectMixin):
         nullable=True,
         doc="The unique identifier of the provider that was configured for this step",
     )
-    job_id: Mapped[Optional[str]] = mapped_column(
-        ForeignKey("jobs.id", ondelete="SET NULL"), nullable=True, doc="The unique identified of the job run that triggered this step"
+    run_id: Mapped[Optional[str]] = mapped_column(
+        ForeignKey("runs.id", ondelete="SET NULL"), nullable=True, doc="The unique identifier of the run that this step belongs to"
     )
     agent_id: Mapped[Optional[str]] = mapped_column(None, nullable=True, doc="The name of the model used for this step.")
     provider_name: Mapped[Optional[str]] = mapped_column(None, nullable=True, doc="The name of the provider used for this step.")
@@ -68,7 +69,7 @@ class Step(SqlalchemyBase, ProjectMixin):
     # Relationships (foreign keys)
     organization: Mapped[Optional["Organization"]] = relationship("Organization")
     provider: Mapped[Optional["Provider"]] = relationship("Provider")
-    job: Mapped[Optional["Job"]] = relationship("Job", back_populates="steps")
+    run: Mapped[Optional["Run"]] = relationship("Run", back_populates="steps")
 
     # Relationships (backrefs)
     messages: Mapped[List["Message"]] = relationship("Message", back_populates="step", cascade="save-update", lazy="noload")

letta/orm/step_metrics.py

@@ -13,7 +13,7 @@ from letta.settings import DatabaseChoice, settings
 
 if TYPE_CHECKING:
     from letta.orm.agent import Agent
-    from letta.orm.job import Job
+    from letta.orm.run import Run
     from letta.orm.step import Step
 
 
@@ -38,10 +38,10 @@ class StepMetrics(SqlalchemyBase, ProjectMixin, AgentMixin):
         nullable=True,
         doc="The unique identifier of the provider",
     )
-    job_id: Mapped[Optional[str]] = mapped_column(
-        ForeignKey("jobs.id", ondelete="SET NULL"),
+    run_id: Mapped[Optional[str]] = mapped_column(
+        ForeignKey("runs.id", ondelete="SET NULL"),
         nullable=True,
-        doc="The unique identifier of the job",
+        doc="The unique identifier of the run",
     )
     step_start_ns: Mapped[Optional[int]] = mapped_column(
         BigInteger,
@@ -81,7 +81,7 @@ class StepMetrics(SqlalchemyBase, ProjectMixin, AgentMixin):
 
     # Relationships (foreign keys)
     step: Mapped["Step"] = relationship("Step", back_populates="metrics", uselist=False)
-    job: Mapped[Optional["Job"]] = relationship("Job")
+    run: Mapped[Optional["Run"]] = relationship("Run")
     agent: Mapped[Optional["Agent"]] = relationship("Agent")
 
     def create(

letta/otel/tracing.py

@@ -1,6 +1,8 @@
+import asyncio
 import inspect
 import re
 import time
+import traceback
 from functools import wraps
 from typing import Any, Dict, List, Optional
 
@@ -84,6 +86,7 @@ async def _update_trace_attributes(request: Request):
         "x-agent-id": "agent.id",
         "x-template-id": "template.id",
         "x-base-template-id": "base_template.id",
+        "user-agent": "client",
     }
     for header_key, span_key in header_attributes.items():
         header_value = request.headers.get(header_key)
@@ -236,9 +239,31 @@ def trace_method(func):
         with tracer.start_as_current_span(_get_span_name(func, args)) as span:
             _add_parameters_to_span(span, func, args, kwargs)
 
-            result = await func(*args, **kwargs)
-            span.set_status(Status(StatusCode.OK))
-            return result
+            try:
+                result = await func(*args, **kwargs)
+                span.set_status(Status(StatusCode.OK))
+                return result
+            except asyncio.CancelledError as e:
+                # Get current task info
+                current_task = asyncio.current_task()
+                task_name = current_task.get_name() if current_task else "unknown"
+
+                # Log detailed information
+                logger.error(f"Task {task_name} cancelled in {func.__module__}.{func.__name__}")
+
+                # Add to span
+                span.set_status(Status(StatusCode.ERROR))
+                span.record_exception(
+                    e,
+                    attributes={
+                        "exception.type": "asyncio.CancelledError",
+                        "task.name": task_name,
+                        "function.name": func.__name__,
+                        "function.module": func.__module__,
+                        "cancellation.timestamp": time.time_ns(),
+                    },
+                )
+                raise
 
     @wraps(func)
     def sync_wrapper(*args, **kwargs):

letta/plugins/defaults.py

@@ -2,10 +2,10 @@ from letta.settings import settings
 
 
 def is_experimental_enabled(feature_name: str, **kwargs) -> bool:
-    if feature_name in ("async_agent_loop", "summarize"):
-        if not (kwargs.get("eligibility", False) and settings.use_experimental):
-            return False
-        return True
+    # if feature_name in ("async_agent_loop", "summarize"):
+    #     if not (kwargs.get("eligibility", False) and settings.use_experimental):
+    #         return False
+    #     return True
 
     # Err on safety here, disabling experimental if not handled here.
     return False

letta/prompts/system_prompts/__init__.py

@@ -1,4 +1,5 @@
 from letta.prompts.system_prompts import (
+    letta_v1,
     memgpt_chat,
     memgpt_generate_tool,
     memgpt_v2_chat,
@@ -17,6 +18,7 @@ SYSTEM_PROMPTS = {
     "memgpt_v2_chat": memgpt_v2_chat.PROMPT,
     "sleeptime_v2": sleeptime_v2.PROMPT,
     "react": react.PROMPT,
+    "letta_v1": letta_v1.PROMPT,
     "workflow": workflow.PROMPT,
     "memgpt_chat": memgpt_chat.PROMPT,
     "sleeptime_doc_ingest": sleeptime_doc_ingest.PROMPT,

letta/prompts/system_prompts/letta_v1.py

@@ -0,0 +1,25 @@
+PROMPT = r"""
+<base_instructions>
+You are a helpful self-improving agent with advanced memory and file system capabilities.
+<memory>
+You have an advanced memory system that enables you to remember past interactions and continuously improve your own capabilities.
+Your memory consists of memory blocks and external memory:
+- Memory Blocks: Stored as memory blocks, each containing a label (title), description (explaining how this block should influence your behavior), and value (the actual content). Memory blocks have size limits. Memory blocks are embedded within your system instructions and remain constantly available in-context.
+- External memory: Additional memory storage that is accessible and that you can bring into context with tools when needed.
+Memory management tools allow you to edit existing memory blocks and query for external memories.
+</memory>
+<file_system>
+You have access to a structured file system that mirrors real-world directory structures. Each directory can contain multiple files.
+Files include:
+- Metadata: Information such as read-only permissions and character limits
+- Content: The main body of the file that you can read and analyze
+Available file operations:
+- Open and view files
+- Search within files and directories
+- Your core memory will automatically reflect the contents of any currently open files
+You should only keep files open that are directly relevant to the current user interaction to maintain optimal performance.
+</file_system>
+Continue executing and calling tools until the current task is complete or you need user input. To continue: call another tool. To yield control: end your response without calling a tool.
+Base instructions complete.
+</base_instructions>
+"""

letta/schemas/agent.py

@@ -31,6 +31,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"
@@ -222,8 +223,8 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     )
     enable_reasoner: Optional[bool] = Field(True, 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")
+    from_template: Optional[str] = Field(None, description="Deprecated: please use the 'create agents from a template' endpoint instead.")
+    template: bool = Field(False, description="Deprecated: No longer used")
     project: Optional[str] = Field(
         None,
         deprecated=True,

letta/schemas/agent_file.py

@@ -55,6 +55,11 @@ class MessageSchema(MessageCreate):
     tool_returns: Optional[List[ToolReturn]] = Field(default=None, description="Tool execution return information for prior tool calls")
     created_at: datetime = Field(default_factory=get_utc_time, description="The timestamp when the object was created.")
 
+    # optional approval fields for hitl
+    approve: Optional[bool] = Field(None, description="Whether the tool has been approved")
+    approval_request_id: Optional[str] = Field(None, description="The message ID of the approval request")
+    denial_reason: Optional[str] = Field(None, description="An optional explanation for the provided approval status")
+
     # TODO: Should we also duplicate the steps here?
     # TODO: What about tool_return?
 
@@ -79,6 +84,9 @@ class MessageSchema(MessageCreate):
             tool_call_id=message.tool_call_id,
             tool_returns=message.tool_returns,
             created_at=message.created_at,
+            approve=message.approve,
+            approval_request_id=message.approval_request_id,
+            denial_reason=message.denial_reason,
         )
 
 
@@ -168,9 +176,7 @@ class AgentSchema(CreateAgent):
             per_file_view_window_char_limit=agent_state.per_file_view_window_char_limit,
         )
 
-        messages = await message_manager.list_messages_for_agent_async(
-            agent_id=agent_state.id, actor=actor, limit=50
-        )  # TODO: Expand to get more messages
+        messages = await message_manager.list_messages(agent_id=agent_state.id, actor=actor, limit=50)  # TODO: Expand to get more messages
 
         # Convert messages to MessageSchema objects
         message_schemas = [MessageSchema.from_message(msg) for msg in messages]

letta/schemas/block.py

@@ -1,8 +1,7 @@
 from datetime import datetime
-from typing import Optional
+from typing import Any, Optional
 
 from pydantic import ConfigDict, Field, model_validator
-from typing_extensions import Self
 
 from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT, DEFAULT_HUMAN_BLOCK_DESCRIPTION, DEFAULT_PERSONA_BLOCK_DESCRIPTION
 from letta.schemas.letta_base import LettaBase
@@ -48,14 +47,28 @@ class BaseBlock(LettaBase, validate_assignment=True):
 
     model_config = ConfigDict(extra="ignore")  # Ignores extra fields
 
-    @model_validator(mode="after")
-    def verify_char_limit(self) -> Self:
-        # self.limit can be None from
-        if self.limit is not None and self.value and len(self.value) > self.limit:
-            error_msg = f"Edit failed: Exceeds {self.limit} character limit (requested {len(self.value)}) - {str(self)}."
-            raise ValueError(error_msg)
+    @model_validator(mode="before")
+    @classmethod
+    def verify_char_limit(cls, data: Any) -> Any:
+        """Validate the character limit before model instantiation.
+
+        Notes:
+        - Runs on raw input; do not mutate input.
+        - For update schemas (e.g., BlockUpdate), `value` and `limit` may be absent.
+          In that case, only validate when both are provided.
+        """
+        if isinstance(data, dict):
+            limit = data.get("limit")
+            value = data.get("value")
+
+            # Only enforce the char limit when both are present.
+            # Pydantic will separately enforce required fields where applicable.
+            if limit is not None and value is not None and isinstance(value, str):
+                if len(value) > limit:
+                    error_msg = f"Edit failed: Exceeds {limit} character limit (requested {len(value)})"
+                    raise ValueError(error_msg)
 
-        return self
+        return data
 
     def __setattr__(self, name, value):
         """Run validation if self.value is updated"""
@@ -93,7 +106,7 @@ class FileBlock(Block):
     source_id: str = Field(..., description="Unique identifier of the source.")
     is_open: bool = Field(..., description="True if the agent currently has the file open.")
     last_accessed_at: Optional[datetime] = Field(
-        default_factory=datetime.utcnow,
+        None,
         description="UTC timestamp of the agent’s most recent access to this file. Any operations from the open, close, or search tools will update this field.",
     )