letta-nightly 0.6.1.dev20241206104246__py3-none-any.whl → 0.6.1.dev20241208104134__py3-none-any.whl

letta/orm/sqlalchemy_base.py

@@ -1,8 +1,10 @@
+from datetime import datetime
+from enum import Enum
 from typing import TYPE_CHECKING, List, Literal, Optional, Type
 
-from sqlalchemy import String, select
+from sqlalchemy import String, func, select
 from sqlalchemy.exc import DBAPIError
-from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.orm import Mapped, Session, mapped_column
 
 from letta.log import get_logger
 from letta.orm.base import Base, CommonSqlalchemyMetaMixins
@@ -20,6 +22,11 @@ if TYPE_CHECKING:
 logger = get_logger(__name__)
 
 
+class AccessType(str, Enum):
+    ORGANIZATION = "organization"
+    USER = "user"
+
+
 class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
     __abstract__ = True
 
@@ -28,46 +35,68 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
     id: Mapped[str] = mapped_column(String, primary_key=True)
 
     @classmethod
-    def list(
-        cls, *, db_session: "Session", cursor: Optional[str] = None, limit: Optional[int] = 50, **kwargs
-    ) -> List[Type["SqlalchemyBase"]]:
-        """
-        List records with optional cursor (for pagination), limit, and automatic filtering.
+    def get(cls, *, db_session: Session, id: str) -> Optional["SqlalchemyBase"]:
+        """Get a record by ID.
 
         Args:
-            db_session: The database session to use.
-            cursor: Optional ID to start pagination from.
-            limit: Maximum number of records to return.
-            **kwargs: Filters passed as equality conditions or iterable for IN filtering.
+            db_session: SQLAlchemy session
+            id: Record ID to retrieve
 
         Returns:
-            A list of model instances matching the filters.
+            Optional[SqlalchemyBase]: The record if found, None otherwise
         """
-        logger.debug(f"Listing {cls.__name__} with filters {kwargs}")
+        try:
+            return db_session.query(cls).filter(cls.id == id).first()
+        except DBAPIError:
+            return None
+
+    @classmethod
+    def list(
+        cls,
+        *,
+        db_session: "Session",
+        cursor: Optional[str] = None,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None,
+        limit: Optional[int] = 50,
+        query_text: Optional[str] = None,
+        **kwargs,
+    ) -> List[Type["SqlalchemyBase"]]:
+        """List records with advanced filtering and pagination options."""
+        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:
-            # Start with a base query
             query = select(cls)
 
             # Apply filtering logic
             for key, value in kwargs.items():
                 column = getattr(cls, key)
-                if isinstance(value, (list, tuple, set)):  # Check for iterables
+                if isinstance(value, (list, tuple, set)):
                     query = query.where(column.in_(value))
-                else:  # Single value for equality filtering
+                else:
                     query = query.where(column == value)
 
-            # Apply cursor for pagination
+            # Date range filtering
+            if 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)
 
-            # Handle soft deletes if the class has the 'is_deleted' attribute
+            # Apply text search
+            if query_text:
+                query = query.filter(func.lower(cls.text).contains(func.lower(query_text)))
+
+            # Handle ordering and soft deletes
             if hasattr(cls, "is_deleted"):
                 query = query.where(cls.is_deleted == False)
-
-            # Add ordering and limit
             query = query.order_by(cls.id).limit(limit)
 
-            # Execute the query and return results as model instances
             return list(session.execute(query).scalars())
 
     @classmethod
@@ -77,6 +106,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         identifier: Optional[str] = None,
         actor: Optional["User"] = None,
         access: Optional[List[Literal["read", "write", "admin"]]] = ["read"],
+        access_type: AccessType = AccessType.ORGANIZATION,
         **kwargs,
     ) -> Type["SqlalchemyBase"]:
         """The primary accessor for an ORM record.
@@ -108,7 +138,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             query_conditions.append(", ".join(f"{key}='{value}'" for key, value in kwargs.items()))
 
         if actor:
-            query = cls.apply_access_predicate(query, actor, access)
+            query = cls.apply_access_predicate(query, actor, access, access_type)
             query_conditions.append(f"access level in {access} for actor='{actor}'")
 
         if hasattr(cls, "is_deleted"):
@@ -170,12 +200,66 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             session.refresh(self)
             return self
 
+    @classmethod
+    def size(
+        cls,
+        *,
+        db_session: "Session",
+        actor: Optional["User"] = None,
+        access: Optional[List[Literal["read", "write", "admin"]]] = ["read"],
+        access_type: AccessType = AccessType.ORGANIZATION,
+        **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
+        """
+        logger.debug(f"Calculating size for {cls.__name__} with filters {kwargs}")
+
+        with db_session as session:
+            query = select(func.count()).select_from(cls)
+
+            if actor:
+                query = cls.apply_access_predicate(query, actor, access, access_type)
+
+            # Apply filtering logic based on kwargs
+            for key, value in kwargs.items():
+                if value:
+                    column = getattr(cls, key, None)
+                    if not column:
+                        raise AttributeError(f"{cls.__name__} has no attribute '{key}'")
+                    if isinstance(value, (list, tuple, set)):  # Check for iterables
+                        query = query.where(column.in_(value))
+                    else:  # Single value for equality filtering
+                        query = query.where(column == value)
+
+            # Handle soft deletes if the class has the 'is_deleted' attribute
+            if hasattr(cls, "is_deleted"):
+                query = query.where(cls.is_deleted == False)
+
+            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
     def apply_access_predicate(
         cls,
         query: "Select",
         actor: "User",
         access: List[Literal["read", "write", "admin"]],
+        access_type: AccessType = AccessType.ORGANIZATION,
     ) -> "Select":
         """applies a WHERE clause restricting results to the given actor and access level
         Args:
@@ -189,10 +273,18 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             the sqlalchemy select statement restricted to the given access.
         """
         del access  # entrypoint for row-level permissions. Defaults to "same org as the actor, all permissions" at the moment
-        org_id = getattr(actor, "organization_id", None)
-        if not org_id:
-            raise ValueError(f"object {actor} has no organization accessor")
-        return query.where(cls.organization_id == org_id, cls.is_deleted == False)
+        if access_type == AccessType.ORGANIZATION:
+            org_id = getattr(actor, "organization_id", None)
+            if not org_id:
+                raise ValueError(f"object {actor} has no organization accessor")
+            return query.where(cls.organization_id == org_id, cls.is_deleted == False)
+        elif access_type == AccessType.USER:
+            user_id = getattr(actor, "id", None)
+            if not user_id:
+                raise ValueError(f"object {actor} has no user accessor")
+            return query.where(cls.user_id == user_id, cls.is_deleted == False)
+        else:
+            raise ValueError(f"unknown access_type: {access_type}")
 
     @classmethod
     def _handle_dbapi_error(cls, e: DBAPIError):

letta/schemas/letta_base.py

@@ -33,18 +33,19 @@ class LettaBase(BaseModel):
     def generate_id_field(cls, prefix: Optional[str] = None) -> "Field":
         prefix = prefix or cls.__id_prefix__
 
-        # TODO: generate ID from regex pattern?
-        def _generate_id() -> str:
-            return f"{prefix}-{uuid.uuid4()}"
-
         return Field(
             ...,
             description=cls._id_description(prefix),
             pattern=cls._id_regex_pattern(prefix),
             examples=[cls._id_example(prefix)],
-            default_factory=_generate_id,
+            default_factory=cls._generate_id,
         )
 
+    @classmethod
+    def _generate_id(cls, prefix: Optional[str] = None) -> str:
+        prefix = prefix or cls.__id_prefix__
+        return f"{prefix}-{uuid.uuid4()}"
+
     # def _generate_id(self) -> str:
     #    return f"{self.__id_prefix__}-{uuid.uuid4()}"
 
@@ -78,7 +79,7 @@ class LettaBase(BaseModel):
         """
         _ = values  # for SCA
         if isinstance(v, UUID):
-            logger.warning(f"Bare UUIDs are deprecated, please use the full prefixed id ({cls.__id_prefix__})!")
+            logger.debug(f"Bare UUIDs are deprecated, please use the full prefixed id ({cls.__id_prefix__})!")
             return f"{cls.__id_prefix__}-{v}"
         return v
 

letta/schemas/message.py

@@ -13,7 +13,7 @@ from letta.constants import (
 )
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.schemas.enums import MessageRole
-from letta.schemas.letta_base import LettaBase
+from letta.schemas.letta_base import OrmMetadataBase
 from letta.schemas.letta_message import (
     AssistantMessage,
     FunctionCall,
@@ -50,7 +50,7 @@ def add_inner_thoughts_to_tool_call(
         raise e
 
 
-class BaseMessage(LettaBase):
+class BaseMessage(OrmMetadataBase):
     __id_prefix__ = "message"
 
 
@@ -66,10 +66,9 @@ class MessageCreate(BaseMessage):
     name: Optional[str] = Field(None, description="The name of the participant.")
 
 
-class UpdateMessage(BaseMessage):
+class MessageUpdate(BaseMessage):
     """Request to update a message"""
 
-    id: str = Field(..., description="The id of the message.")
     role: Optional[MessageRole] = Field(None, description="The role of the participant.")
     text: Optional[str] = Field(None, description="The text of the message.")
     # NOTE: probably doesn't make sense to allow remapping user_id or agent_id (vs creating a new message)
@@ -105,13 +104,14 @@ class Message(BaseMessage):
     id: str = BaseMessage.generate_id_field()
     role: MessageRole = Field(..., description="The role of the participant.")
     text: Optional[str] = Field(None, description="The text of the message.")
-    user_id: Optional[str] = Field(None, description="The unique identifier of the user.")
+    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization.")
     agent_id: Optional[str] = Field(None, description="The unique identifier of the agent.")
     model: Optional[str] = Field(None, description="The model used to make the function call.")
     name: Optional[str] = Field(None, description="The name of the participant.")
-    created_at: datetime = Field(default_factory=get_utc_time, description="The time the message was created.")
     tool_calls: Optional[List[ToolCall]] = Field(None, description="The list of tool calls requested.")
     tool_call_id: Optional[str] = Field(None, description="The id of the tool call.")
+    # This overrides the optional base orm schema, created_at MUST exist on all messages objects
+    created_at: datetime = Field(default_factory=get_utc_time, description="The timestamp when the object was created.")
 
     @field_validator("role")
     @classmethod
@@ -281,7 +281,6 @@ class Message(BaseMessage):
             )
             if id is not None:
                 return Message(
-                    user_id=user_id,
                     agent_id=agent_id,
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
@@ -295,7 +294,6 @@ class Message(BaseMessage):
                 )
             else:
                 return Message(
-                    user_id=user_id,
                     agent_id=agent_id,
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
@@ -328,7 +326,6 @@ class Message(BaseMessage):
 
             if id is not None:
                 return Message(
-                    user_id=user_id,
                     agent_id=agent_id,
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
@@ -342,7 +339,6 @@ class Message(BaseMessage):
                 )
             else:
                 return Message(
-                    user_id=user_id,
                     agent_id=agent_id,
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
@@ -375,7 +371,6 @@ class Message(BaseMessage):
             # If we're going from tool-call style
             if id is not None:
                 return Message(
-                    user_id=user_id,
                     agent_id=agent_id,
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
@@ -389,7 +384,6 @@ class Message(BaseMessage):
                 )
             else:
                 return Message(
-                    user_id=user_id,
                     agent_id=agent_id,
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object

letta/schemas/tool.py

@@ -93,7 +93,7 @@ class ToolCreate(LettaBase):
     )
 
     @classmethod
-    def from_composio(cls, action: "ActionType") -> "ToolCreate":
+    def from_composio(cls, action_name: str, api_key: Optional[str] = None) -> "ToolCreate":
         """
         Class method to create an instance of Letta-compatible Composio Tool.
         Check https://docs.composio.dev/introduction/intro/overview to look at options for from_composio
@@ -101,15 +101,20 @@ class ToolCreate(LettaBase):
         This function will error if we find more than one tool, or 0 tools.
 
         Args:
-            action ActionType: A action name to filter tools by.
+            action_name str: A action name to filter tools by.
         Returns:
             Tool: A Letta Tool initialized with attributes derived from the Composio tool.
         """
         from composio import LogLevel
         from composio_langchain import ComposioToolSet
 
-        composio_toolset = ComposioToolSet(logging_level=LogLevel.ERROR)
-        composio_tools = composio_toolset.get_tools(actions=[action])
+        if api_key:
+            # Pass in an external API key
+            composio_toolset = ComposioToolSet(logging_level=LogLevel.ERROR, api_key=api_key)
+        else:
+            # Use environmental variable
+            composio_toolset = ComposioToolSet(logging_level=LogLevel.ERROR)
+        composio_tools = composio_toolset.get_tools(actions=[action_name])
 
         assert len(composio_tools) > 0, "User supplied parameters do not match any Composio tools"
         assert len(composio_tools) == 1, f"User supplied parameters match too many Composio tools; {len(composio_tools)} > 1"
@@ -119,7 +124,7 @@ class ToolCreate(LettaBase):
         description = composio_tool.description
         source_type = "python"
         tags = ["composio"]
-        wrapper_func_name, wrapper_function_str = generate_composio_tool_wrapper(action)
+        wrapper_func_name, wrapper_function_str = generate_composio_tool_wrapper(action_name)
         json_schema = generate_schema_from_args_schema_v2(composio_tool.args_schema, name=wrapper_func_name, description=description)
 
         return cls(
@@ -177,14 +182,16 @@ class ToolCreate(LettaBase):
 
     @classmethod
     def load_default_composio_tools(cls) -> List["ToolCreate"]:
-        from composio_langchain import Action
+        pass
 
-        calculator = ToolCreate.from_composio(action=Action.MATHEMATICAL_CALCULATOR)
-        serp_news = ToolCreate.from_composio(action=Action.SERPAPI_NEWS_SEARCH)
-        serp_google_search = ToolCreate.from_composio(action=Action.SERPAPI_SEARCH)
-        serp_google_maps = ToolCreate.from_composio(action=Action.SERPAPI_GOOGLE_MAPS_SEARCH)
+        # TODO: Disable composio tools for now
+        # TODO: Naming is causing issues
+        # calculator = ToolCreate.from_composio(action_name=Action.MATHEMATICAL_CALCULATOR.name)
+        # serp_news = ToolCreate.from_composio(action_name=Action.SERPAPI_NEWS_SEARCH.name)
+        # serp_google_search = ToolCreate.from_composio(action_name=Action.SERPAPI_SEARCH.name)
+        # serp_google_maps = ToolCreate.from_composio(action_name=Action.SERPAPI_GOOGLE_MAPS_SEARCH.name)
 
-        return [calculator, serp_news, serp_google_search, serp_google_maps]
+        return []
 
 
 class ToolUpdate(LettaBase):

letta/server/rest_api/app.py

@@ -144,9 +144,8 @@ def create_application() -> "FastAPI":
         debug=True,
     )
 
-    if (os.getenv("LETTA_SERVER_ADE") == "true") or "--ade" in sys.argv:
-        settings.cors_origins.append("https://app.letta.com")
-        print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard")
+    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}")

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

@@ -28,7 +28,7 @@ from letta.schemas.memory import (
     Memory,
     RecallMemorySummary,
 )
-from letta.schemas.message import Message, MessageCreate, UpdateMessage
+from letta.schemas.message import Message, MessageCreate, MessageUpdate
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source
 from letta.schemas.tool import Tool
@@ -409,7 +409,7 @@ def get_agent_messages(
     return server.get_agent_recall_cursor(
         user_id=actor.id,
         agent_id=agent_id,
-        before=before,
+        cursor=before,
         limit=limit,
         reverse=True,
         return_message_object=msg_object,
@@ -422,14 +422,13 @@ def get_agent_messages(
 def update_message(
     agent_id: str,
     message_id: str,
-    request: UpdateMessage = Body(...),
+    request: MessageUpdate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
     Update the details of a message associated with an agent.
     """
-    assert request.id == message_id, f"Message ID mismatch: {request.id} != {message_id}"
-    return server.update_agent_message(agent_id=agent_id, request=request)
+    return server.update_agent_message(agent_id=agent_id, message_id=message_id, request=request)
 
 
 @router.post(
@@ -465,7 +464,7 @@ async def send_message(
 @router.post(
     "/{agent_id}/messages/stream",
     response_model=None,
-    operation_id="create_agent_message",
+    operation_id="create_agent_message_stream",
     responses={
         200: {
             "description": "Successful response",
@@ -486,6 +485,8 @@ 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(
         server=server,

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

@@ -76,7 +76,7 @@ def get_block(
         raise HTTPException(status_code=404, detail="Block not found")
 
 
-@router.patch("/{block_id}/attach", response_model=Block, operation_id="update_agent_memory_block")
+@router.patch("/{block_id}/attach", response_model=Block, operation_id="link_agent_memory_block")
 def link_agent_memory_block(
     block_id: str,
     agent_id: str = Query(..., description="The unique identifier of the agent to attach the source to."),
@@ -96,7 +96,7 @@ def link_agent_memory_block(
     return block
 
 
-@router.patch("/{block_id}/detach", response_model=Memory, operation_id="update_agent_memory_block")
+@router.patch("/{block_id}/detach", response_model=Memory, operation_id="unlink_agent_memory_block")
 def unlink_agent_memory_block(
     block_id: str,
     agent_id: str = Query(..., description="The unique identifier of the agent to attach the source to."),

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

@@ -7,6 +7,7 @@ from letta.errors import LettaToolCreateError
 from letta.orm.errors import UniqueConstraintViolationError
 from letta.schemas.letta_message import FunctionReturn
 from letta.schemas.tool import Tool, ToolCreate, ToolRunFromSource, ToolUpdate
+from letta.schemas.user import User
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
 
@@ -213,22 +214,27 @@ def run_tool_from_source(
 
 
 @router.get("/composio/apps", response_model=List[AppModel], operation_id="list_composio_apps")
-def list_composio_apps(server: SyncServer = Depends(get_letta_server)):
+def list_composio_apps(server: SyncServer = Depends(get_letta_server), user_id: Optional[str] = Header(None, alias="user_id")):
     """
     Get a list of all Composio apps
     """
-    return server.get_composio_apps()
+    actor = server.get_user_or_default(user_id=user_id)
+    composio_api_key = get_composio_key(server, actor=actor)
+    return server.get_composio_apps(api_key=composio_api_key)
 
 
 @router.get("/composio/apps/{composio_app_name}/actions", response_model=List[ActionModel], operation_id="list_composio_actions_by_app")
 def list_composio_actions_by_app(
     composio_app_name: str,
     server: SyncServer = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
     Get a list of all Composio actions for a specific app
     """
-    return server.get_composio_actions_from_app_name(composio_app_name=composio_app_name)
+    actor = server.get_user_or_default(user_id=user_id)
+    composio_api_key = get_composio_key(server, actor=actor)
+    return server.get_composio_actions_from_app_name(composio_app_name=composio_app_name, api_key=composio_api_key)
 
 
 @router.post("/composio/{composio_action_name}", response_model=Tool, operation_id="add_composio_tool")
@@ -241,5 +247,21 @@ def add_composio_tool(
     Add a new Composio tool by action name (Composio refers to each tool as an `Action`)
     """
     actor = server.get_user_or_default(user_id=user_id)
-    tool_create = ToolCreate.from_composio(action=composio_action_name)
+    composio_api_key = get_composio_key(server, actor=actor)
+    tool_create = ToolCreate.from_composio(action_name=composio_action_name, api_key=composio_api_key)
     return server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=actor)
+
+
+# TODO: Factor this out to somewhere else
+def get_composio_key(server: SyncServer, actor: User):
+    api_keys = server.sandbox_config_manager.list_sandbox_env_vars_by_key(key="COMPOSIO_API_KEY", actor=actor)
+    if not api_keys:
+        raise HTTPException(
+            status_code=400,  # Bad Request
+            detail=f"No API keys found for Composio. Please add your Composio API Key as an environment variable for your sandbox configuration.",
+        )
+
+    # TODO: Add more protections around this
+    # Ideally, not tied to a specific sandbox, but for now we just get the first one
+    # Theoretically possible for someone to have different composio api keys per sandbox
+    return api_keys[0].value

letta/server/rest_api/utils.py

@@ -1,6 +1,5 @@
 import asyncio
 import json
-import traceback
 import warnings
 from enum import Enum
 from typing import AsyncGenerator, Optional, Union
@@ -62,6 +61,9 @@ async def sse_async_generator(
                     raise ValueError(f"Expected LettaUsageStatistics, got {type(usage)}")
                 yield sse_formatter({"usage": usage.model_dump()})
             except Exception as e:
+                import traceback
+
+                traceback.print_exc()
                 warnings.warn(f"Error getting usage data: {e}")
                 yield sse_formatter({"error": "Failed to get usage data"})