letta-nightly 0.6.2.dev20241210030340__py3-none-any.whl → 0.6.2.dev20241211031658__py3-none-any.whl

letta/orm/organization.py

@@ -33,7 +33,10 @@ class Organization(SqlalchemyBase):
     sandbox_environment_variables: Mapped[List["SandboxEnvironmentVariable"]] = relationship(
         "SandboxEnvironmentVariable", back_populates="organization", cascade="all, delete-orphan"
     )
+
+    # relationships
     messages: Mapped[List["Message"]] = relationship("Message", back_populates="organization", cascade="all, delete-orphan")
+    passages: Mapped[List["Passage"]] = relationship("Passage", back_populates="organization", cascade="all, delete-orphan")
 
     # TODO: Map these relationships later when we actually make these models
     # below is just a suggestion

letta/orm/passage.py

@@ -0,0 +1,72 @@
+from datetime import datetime
+from typing import List, Optional, TYPE_CHECKING
+from sqlalchemy import Column, String, DateTime, Index, JSON, UniqueConstraint, ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.types import TypeDecorator, BINARY
+
+import numpy as np
+import base64
+
+from letta.orm.source import EmbeddingConfigColumn
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.orm.mixins import AgentMixin, FileMixin, OrganizationMixin
+from letta.schemas.passage import Passage as PydanticPassage
+
+from letta.config import LettaConfig
+from letta.constants import MAX_EMBEDDING_DIM
+from letta.settings import settings
+
+config = LettaConfig()
+
+if TYPE_CHECKING:
+    from letta.orm.file import File
+    from letta.orm.organization import Organization
+
+class CommonVector(TypeDecorator):
+    """Common type for representing vectors in SQLite"""
+    impl = BINARY
+    cache_ok = True
+
+    def load_dialect_impl(self, dialect):
+        return dialect.type_descriptor(BINARY())
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return value
+        if isinstance(value, list):
+            value = np.array(value, dtype=np.float32)
+        return base64.b64encode(value.tobytes())
+
+    def process_result_value(self, value, dialect):
+        if not value:
+            return value
+        if dialect.name == "sqlite":
+            value = base64.b64decode(value)
+        return np.frombuffer(value, dtype=np.float32)
+
+# TODO: After migration to Passage, will need to manually delete passages where files 
+#       are deleted on web
+class Passage(SqlalchemyBase, OrganizationMixin, FileMixin):
+    """Defines data model for storing Passages"""
+    __tablename__ = "passages"
+    __table_args__ = {"extend_existing": True}
+    __pydantic_model__ = PydanticPassage
+
+    id: Mapped[str] = mapped_column(primary_key=True, doc="Unique passage identifier")
+    text: Mapped[str] = mapped_column(doc="Passage text content")
+    source_id: Mapped[Optional[str]] = mapped_column(nullable=True, doc="Source identifier")
+    embedding_config: Mapped[dict] = mapped_column(EmbeddingConfigColumn, doc="Embedding configuration")
+    metadata_: Mapped[dict] = mapped_column(JSON, doc="Additional metadata")
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=datetime.utcnow)
+    if settings.letta_pg_uri_no_default:
+        from pgvector.sqlalchemy import Vector
+        embedding = mapped_column(Vector(MAX_EMBEDDING_DIM))
+    else:
+        embedding = Column(CommonVector)
+
+    # Foreign keys
+    agent_id: Mapped[Optional[str]] = mapped_column(String, ForeignKey("agents.id"), nullable=True)
+
+    # Relationships
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="passages", lazy="selectin")
+    file: Mapped["FileMetadata"] = relationship("FileMetadata", back_populates="passages", lazy="selectin")

letta/orm/sqlalchemy_base.py

@@ -1,13 +1,15 @@
 from datetime import datetime
 from enum import Enum
 from typing import TYPE_CHECKING, List, Literal, Optional, Type
+import sqlite3
 
-from sqlalchemy import String, func, select
+from sqlalchemy import String, desc, func, or_, select
 from sqlalchemy.exc import DBAPIError
 from sqlalchemy.orm import Mapped, Session, mapped_column
 
 from letta.log import get_logger
 from letta.orm.base import Base, CommonSqlalchemyMetaMixins
+from letta.orm.sqlite_functions import adapt_array, convert_array, cosine_distance
 from letta.orm.errors import (
     ForeignKeyConstraintViolationError,
     NoResultFound,
@@ -60,14 +62,26 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         end_date: Optional[datetime] = None,
         limit: Optional[int] = 50,
         query_text: Optional[str] = None,
+        query_embedding: Optional[List[float]] = None,
+        ascending: bool = True,
         **kwargs,
     ) -> List[Type["SqlalchemyBase"]]:
-        """List records with advanced filtering and pagination options."""
+        """
+        List records with cursor-based pagination, ordering by created_at.
+        Cursor is an ID, but pagination is based on the cursor object's created_at value.
+        """
         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:
+            # If cursor provided, get the reference object
+            cursor_obj = None
+            if cursor:
+                cursor_obj = session.get(cls, cursor)
+                if not cursor_obj:
+                    raise NoResultFound(f"No {cls.__name__} found with id {cursor}")
+
             query = select(cls)
 
             # Apply filtering logic
@@ -80,22 +94,64 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
             # Date range filtering
             if start_date:
-                query = query.filter(cls.created_at >= start_date)
+                query = query.filter(cls.created_at > start_date)
             if end_date:
-                query = query.filter(cls.created_at <= end_date)
-
-            # Cursor-based pagination
-            if cursor:
-                query = query.where(cls.id > cursor)
+                query = query.filter(cls.created_at < end_date)
+
+            # Cursor-based pagination using created_at
+            # TODO: There is a really nasty race condition issue here with Sqlite
+            # TODO: If they have the same created_at timestamp, this query does NOT match for whatever reason
+            if cursor_obj:
+                if ascending:
+                    query = query.where(cls.created_at >= cursor_obj.created_at).where(
+                        or_(cls.created_at > cursor_obj.created_at, cls.id > cursor_obj.id)
+                    )
+                else:
+                    query = query.where(cls.created_at <= cursor_obj.created_at).where(
+                        or_(cls.created_at < cursor_obj.created_at, cls.id < cursor_obj.id)
+                    )
 
             # Apply text search
             if query_text:
+                from sqlalchemy import func
                 query = query.filter(func.lower(cls.text).contains(func.lower(query_text)))
 
+            # Apply embedding search (Passages)
+            is_ordered = False
+            if query_embedding:
+                # check if embedding column exists. should only exist for passages
+                if not hasattr(cls, "embedding"):
+                    raise ValueError(f"Class {cls.__name__} does not have an embedding column")
+                
+                from letta.settings import settings
+                if settings.letta_pg_uri_no_default:
+                    # PostgreSQL with pgvector
+                    from pgvector.sqlalchemy import Vector
+                    query = query.order_by(cls.embedding.cosine_distance(query_embedding).asc())
+                else:
+                    # SQLite with custom vector type
+                    from sqlalchemy import func
+
+                    query_embedding_binary = adapt_array(query_embedding)
+                    query = query.order_by(
+                        func.cosine_distance(cls.embedding, query_embedding_binary).asc(),
+                        cls.created_at.asc(),
+                        cls.id.asc()
+                    )
+                    is_ordered = True
+
             # Handle ordering and soft deletes
             if hasattr(cls, "is_deleted"):
                 query = query.where(cls.is_deleted == False)
-            query = query.order_by(cls.id).limit(limit)
+            
+            # Apply ordering by created_at
+            if not is_ordered:
+                if ascending:
+                    query = query.order_by(cls.created_at, cls.id)
+                else:
+                    query = query.order_by(desc(cls.created_at), desc(cls.id))
+
+            query = query.limit(limit)
 
             return list(session.execute(query).scalars())
 
@@ -342,4 +398,4 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
     def to_record(self) -> Type["BaseModel"]:
         """Deprecated accessor for to_pydantic"""
         logger.warning("to_record is deprecated, use to_pydantic instead.")
-        return self.to_pydantic()
+        return self.to_pydantic()

letta/orm/sqlite_functions.py

@@ -0,0 +1,140 @@
+from typing import Optional, Union
+
+import base64
+import numpy as np
+from sqlalchemy import event
+from sqlalchemy.engine import Engine
+import sqlite3
+
+from letta.constants import MAX_EMBEDDING_DIM
+
+def adapt_array(arr):
+    """
+    Converts numpy array to binary for SQLite storage
+    """
+    if arr is None:
+        return None
+
+    if isinstance(arr, list):
+        arr = np.array(arr, dtype=np.float32)
+    elif not isinstance(arr, np.ndarray):
+        raise ValueError(f"Unsupported type: {type(arr)}")
+    
+    # Convert to bytes and then base64 encode
+    bytes_data = arr.tobytes()
+    base64_data = base64.b64encode(bytes_data)
+    return sqlite3.Binary(base64_data)
+
+def convert_array(text):
+    """
+    Converts binary back to numpy array
+    """
+    if text is None:
+        return None
+    if isinstance(text, list):
+        return np.array(text, dtype=np.float32)
+    if isinstance(text, np.ndarray):
+        return text
+
+    # Handle both bytes and sqlite3.Binary
+    binary_data = bytes(text) if isinstance(text, sqlite3.Binary) else text
+    
+    try:
+        # First decode base64
+        decoded_data = base64.b64decode(binary_data)
+        # Then convert to numpy array
+        return np.frombuffer(decoded_data, dtype=np.float32)
+    except Exception as e:
+        return None
+
+def verify_embedding_dimension(embedding: np.ndarray, expected_dim: int = MAX_EMBEDDING_DIM) -> bool:
+    """
+    Verifies that an embedding has the expected dimension
+    
+    Args:
+        embedding: Input embedding array
+        expected_dim: Expected embedding dimension (default: 4096)
+        
+    Returns:
+        bool: True if dimension matches, False otherwise
+    """
+    if embedding is None:
+        return False
+    return embedding.shape[0] == expected_dim
+
+def validate_and_transform_embedding(
+    embedding: Union[bytes, sqlite3.Binary, list, np.ndarray],
+    expected_dim: int = MAX_EMBEDDING_DIM,
+    dtype: np.dtype = np.float32
+) -> Optional[np.ndarray]:
+    """
+    Validates and transforms embeddings to ensure correct dimensionality.
+    
+    Args:
+        embedding: Input embedding in various possible formats
+        expected_dim: Expected embedding dimension (default 4096)
+        dtype: NumPy dtype for the embedding (default float32)
+        
+    Returns:
+        np.ndarray: Validated and transformed embedding
+        
+    Raises:
+        ValueError: If embedding dimension doesn't match expected dimension
+    """
+    if embedding is None:
+        return None
+        
+    # Convert to numpy array based on input type
+    if isinstance(embedding, (bytes, sqlite3.Binary)):
+        vec = convert_array(embedding)
+    elif isinstance(embedding, list):
+        vec = np.array(embedding, dtype=dtype)
+    elif isinstance(embedding, np.ndarray):
+        vec = embedding.astype(dtype)
+    else:
+        raise ValueError(f"Unsupported embedding type: {type(embedding)}")
+    
+    # Validate dimension
+    if vec.shape[0] != expected_dim:
+        raise ValueError(
+            f"Invalid embedding dimension: got {vec.shape[0]}, expected {expected_dim}"
+        )
+    
+    return vec
+
+def cosine_distance(embedding1, embedding2, expected_dim=MAX_EMBEDDING_DIM):
+    """
+    Calculate cosine distance between two embeddings
+    
+    Args:
+        embedding1: First embedding
+        embedding2: Second embedding
+        expected_dim: Expected embedding dimension (default 4096)
+        
+    Returns:
+        float: Cosine distance
+    """
+    
+    if embedding1 is None or embedding2 is None:
+        return 0.0  # Maximum distance if either embedding is None
+    
+    try:
+        vec1 = validate_and_transform_embedding(embedding1, expected_dim)
+        vec2 = validate_and_transform_embedding(embedding2, expected_dim)
+    except ValueError as e:
+        return 0.0
+        
+    similarity = np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
+    distance = float(1.0 - similarity)
+    
+    return distance
+
+@event.listens_for(Engine, "connect")
+def register_functions(dbapi_connection, connection_record):
+    """Register SQLite functions"""
+    if isinstance(dbapi_connection, sqlite3.Connection):
+        dbapi_connection.create_function("cosine_distance", 2, cosine_distance)
+    
+# Register adapters and converters for numpy arrays
+sqlite3.register_adapter(np.ndarray, adapt_array)
+sqlite3.register_converter("ARRAY", convert_array)

letta/orm/user.py

@@ -20,7 +20,7 @@ class User(SqlalchemyBase, OrganizationMixin):
 
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="users")
-    jobs: Mapped[List["Job"]] = relationship("Job", back_populates="user", doc="the jobs associated with this user.")
+    jobs: Mapped[List["Job"]] = relationship("Job", back_populates="user", doc="the jobs associated with this user.", cascade="all, delete-orphan")
 
     # TODO: Add this back later potentially
     # agents: Mapped[List["Agent"]] = relationship(

letta/schemas/agent.py

@@ -4,6 +4,7 @@ from typing import Dict, List, Optional
 
 from pydantic import BaseModel, Field, field_validator
 
+from letta.constants import BASE_MEMORY_TOOLS, BASE_TOOLS
 from letta.schemas.block import CreateBlock
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.letta_base import LettaBase
@@ -108,7 +109,7 @@ class CreateAgent(BaseAgent):  #
     # all optional as server can generate defaults
     name: Optional[str] = Field(None, description="The name of the agent.")
     message_ids: Optional[List[str]] = Field(None, description="The ids of the messages in the agent's in-context memory.")
-    
+
     # memory creation
     memory_blocks: List[CreateBlock] = Field(
         # [CreateHuman(), CreatePersona()], description="The blocks to create in the agent's in-context memory."
@@ -116,11 +117,11 @@ class CreateAgent(BaseAgent):  #
         description="The blocks to create in the agent's in-context memory.",
     )
 
-    tools: Optional[List[str]] = Field(None, description="The tools used by the agent.")
+    tools: List[str] = Field(BASE_TOOLS + BASE_MEMORY_TOOLS, description="The tools used by the agent.")
     tool_rules: Optional[List[ToolRule]] = Field(None, description="The tool rules governing the agent.")
     tags: Optional[List[str]] = Field(None, description="The tags associated with the agent.")
     system: Optional[str] = Field(None, description="The system prompt used by the agent.")
-    agent_type: Optional[AgentType] = Field(None, description="The type of agent.")
+    agent_type: AgentType = Field(AgentType.memgpt_agent, description="The type of agent.")
     llm_config: Optional[LLMConfig] = Field(None, description="The LLM configuration used by the agent.")
     embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the agent.")
     # Note: if this is None, then we'll populate with the standard "more human than human" initial message sequence

letta/schemas/letta_message.py

@@ -1,6 +1,6 @@
 import json
 from datetime import datetime, timezone
-from typing import Annotated, Literal, Optional, Union
+from typing import Annotated, List, Literal, Optional, Union
 
 from pydantic import BaseModel, Field, field_serializer, field_validator
 
@@ -150,12 +150,16 @@ class FunctionReturn(LettaMessage):
         id (str): The ID of the message
         date (datetime): The date the message was created in ISO format
         function_call_id (str): A unique identifier for the function call that generated this message
+        stdout (Optional[List(str)]): Captured stdout (e.g. prints, logs) from the function invocation
+        stderr (Optional[List(str)]): Captured stderr from the function invocation
     """
 
     message_type: Literal["function_return"] = "function_return"
     function_return: str
     status: Literal["success", "error"]
     function_call_id: str
+    stdout: Optional[List[str]] = None
+    stderr: Optional[List[str]] = None
 
 
 # Legacy Letta API had an additional type "assistant_message" and the "function_call" was a formatted string

letta/schemas/letta_request.py

@@ -1,13 +1,13 @@
-from typing import List, Union
+from typing import List
 
 from pydantic import BaseModel, Field
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
-from letta.schemas.message import Message, MessageCreate
+from letta.schemas.message import MessageCreate
 
 
 class LettaRequest(BaseModel):
-    messages: Union[List[MessageCreate], List[Message]] = Field(..., description="The messages to be sent to the agent.")
+    messages: List[MessageCreate] = Field(..., description="The messages to be sent to the agent.")
 
     # Flags to support the use of AssistantMessage message types
 

letta/schemas/passage.py

@@ -5,15 +5,17 @@ from pydantic import Field, field_validator
 
 from letta.constants import MAX_EMBEDDING_DIM
 from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.letta_base import LettaBase
+from letta.schemas.letta_base import OrmMetadataBase
 from letta.utils import get_utc_time
 
 
-class PassageBase(LettaBase):
-    __id_prefix__ = "passage"
+class PassageBase(OrmMetadataBase):
+    __id_prefix__ = "passage_legacy"
+
+    is_deleted: bool = Field(False, description="Whether this passage is deleted or not.")
 
     # associated user/agent
-    user_id: Optional[str] = Field(None, description="The unique identifier of the user associated with the passage.")
+    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.")
 
     # origin data source

letta/schemas/sandbox_config.py

@@ -19,6 +19,7 @@ class SandboxRunResult(BaseModel):
     func_return: Optional[Any] = Field(None, description="The function return object")
     agent_state: Optional[AgentState] = Field(None, description="The agent state")
     stdout: Optional[List[str]] = Field(None, description="Captured stdout (e.g. prints, logs) from the function invocation")
+    stderr: Optional[List[str]] = Field(None, description="Captured stderr from the function invocation")
     sandbox_config_fingerprint: str = Field(None, description="The fingerprint of the config for the sandbox")
 
 

letta/schemas/tool_rule.py

@@ -17,7 +17,6 @@ class ChildToolRule(BaseToolRule):
     A ToolRule represents a tool that can be invoked by the agent.
     """
 
-    # type: str = Field("ToolRule")
     type: ToolRuleType = ToolRuleType.constrain_child_tools
     children: List[str] = Field(..., description="The children tools that can be invoked.")
 
@@ -27,7 +26,6 @@ class InitToolRule(BaseToolRule):
     Represents the initial tool rule configuration.
     """
 
-    # type: str = Field("InitToolRule")
     type: ToolRuleType = ToolRuleType.run_first
 
 
@@ -36,7 +34,6 @@ class TerminalToolRule(BaseToolRule):
     Represents a terminal tool rule configuration where if this tool gets called, it must end the agent loop.
     """
 
-    # type: str = Field("TerminalToolRule")
     type: ToolRuleType = ToolRuleType.exit_loop
 
 

letta/server/rest_api/app.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from typing import Optional
 
 import uvicorn
-from fastapi import FastAPI
+from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.middleware.cors import CORSMiddleware
@@ -109,7 +109,13 @@ random_password = os.getenv("LETTA_SERVER_PASSWORD") or generate_password()
 
 
 class CheckPasswordMiddleware(BaseHTTPMiddleware):
+
     async def dispatch(self, request, call_next):
+
+        # Exclude health check endpoint from password protection
+        if request.url.path == "/v1/health/" or request.url.path == "/latest/health/":
+            return await call_next(request)
+
         if request.headers.get("X-BARE-PASSWORD") == f"password {random_password}":
             return await call_next(request)
 
@@ -136,17 +142,18 @@ def create_application() -> "FastAPI":
             },
         )
 
+    debug_mode = "--debug" in sys.argv
     app = FastAPI(
         swagger_ui_parameters={"docExpansion": "none"},
         # openapi_tags=TAGS_METADATA,
         title="Letta",
         summary="Create LLM agents with long-term memory and custom tools 📚🦙",
         version="1.0.0",  # TODO wire this up to the version in the package
-        debug=True,
+        debug=debug_mode,  # if True, the stack trace will be printed in the response
     )
 
     @app.exception_handler(Exception)
-    async def generic_error_handler(request, exc):
+    async def generic_error_handler(request: Request, exc: Exception):
         # Log the actual error for debugging
         log.error(f"Unhandled error: {exc}", exc_info=True)
 
@@ -166,16 +173,19 @@ def create_application() -> "FastAPI":
             },
         )
 
+    @app.exception_handler(ValueError)
+    async def value_error_handler(request: Request, exc: ValueError):
+        return JSONResponse(status_code=400, content={"detail": str(exc)})
+
     @app.exception_handler(LettaAgentNotFoundError)
-    async def agent_not_found_handler(request, exc):
+    async def agent_not_found_handler(request: Request, exc: LettaAgentNotFoundError):
         return JSONResponse(status_code=404, content={"detail": "Agent not found"})
 
     @app.exception_handler(LettaUserNotFoundError)
-    async def user_not_found_handler(request, exc):
+    async def user_not_found_handler(request: Request, exc: LettaUserNotFoundError):
         return JSONResponse(status_code=404, content={"detail": "User not found"})
 
     settings.cors_origins.append("https://app.letta.com")
-    print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard")
 
     if (os.getenv("LETTA_SERVER_SECURE") == "true") or "--secure" in sys.argv:
         print(f"▶ Using secure mode with password: {random_password}")
@@ -254,9 +264,21 @@ def start_server(
         # Add the handler to the logger
         server_logger.addHandler(stream_handler)
 
-    print(f"▶ Server running at: http://{host or 'localhost'}:{port or REST_DEFAULT_PORT}\n")
-    uvicorn.run(
-        app,
-        host=host or "localhost",
-        port=port or REST_DEFAULT_PORT,
-    )
+    if (os.getenv("LOCAL_HTTPS") == "true") or "--localhttps" in sys.argv:
+        uvicorn.run(
+            app,
+            host=host or "localhost",
+            port=port or REST_DEFAULT_PORT,
+            ssl_keyfile="certs/localhost-key.pem",
+            ssl_certfile="certs/localhost.pem",
+        )
+        print(f"▶ Server running at: https://{host or 'localhost'}:{port or REST_DEFAULT_PORT}\n")
+    else:
+        uvicorn.run(
+            app,
+            host=host or "localhost",
+            port=port or REST_DEFAULT_PORT,
+        )
+        print(f"▶ Server running at: http://{host or 'localhost'}:{port or REST_DEFAULT_PORT}\n")
+
+    print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard")

letta/server/rest_api/routers/v1/agents.py

@@ -14,6 +14,7 @@ from fastapi import (
     status,
 )
 from fastapi.responses import JSONResponse, StreamingResponse
+from pydantic import Field
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.schemas.agent import AgentState, CreateAgent, UpdateAgentState
@@ -87,9 +88,18 @@ def get_agent_context_window(
     return server.get_agent_context_window(user_id=actor.id, agent_id=agent_id)
 
 
+class CreateAgentRequest(CreateAgent):
+    """
+    CreateAgent model specifically for POST request body, excluding user_id which comes from headers
+    """
+
+    # Override the user_id field to exclude it from the request body validation
+    user_id: Optional[str] = Field(None, exclude=True)
+
+
 @router.post("/", response_model=AgentState, operation_id="create_agent")
 def create_agent(
-    agent: CreateAgent = Body(...),
+    agent: CreateAgentRequest = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
@@ -165,7 +175,7 @@ def get_agent_state(
     return server.get_agent_state(user_id=actor.id, agent_id=agent_id)
 
 
-@router.delete("/{agent_id}", response_model=None, operation_id="delete_agent")
+@router.delete("/{agent_id}", response_model=AgentState, operation_id="delete_agent")
 def delete_agent(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
@@ -176,7 +186,12 @@ def delete_agent(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    return server.delete_agent(user_id=actor.id, agent_id=agent_id)
+    agent = server.get_agent(agent_id)
+    if not agent:
+        raise HTTPException(status_code=404, detail=f"Agent agent_id={agent_id} not found.")
+
+    server.delete_agent(user_id=actor.id, agent_id=agent_id)
+    return agent
 
 
 @router.get("/{agent_id}/sources", response_model=List[Source], operation_id="get_agent_sources")
@@ -354,8 +369,7 @@ def get_agent_archival_memory(
     return server.get_agent_archival_cursor(
         user_id=actor.id,
         agent_id=agent_id,
-        after=after,
-        before=before,
+        cursor=after, # TODO: deleting before, after. is this expected?
         limit=limit,
     )
 
@@ -420,7 +434,7 @@ def get_agent_messages(
     return server.get_agent_recall_cursor(
         user_id=actor.id,
         agent_id=agent_id,
-        cursor=before,
+        before=before,
         limit=limit,
         reverse=True,
         return_message_object=msg_object,
@@ -496,7 +510,6 @@ async def send_message_streaming(
     This endpoint accepts a message from a user and processes it through the agent.
     It will stream the steps of the response always, and stream the tokens if 'stream_tokens' is set to True.
     """
-    request.stream_tokens = False
 
     actor = server.get_user_or_default(user_id=user_id)
     result = await send_message_to_agent(