letta-nightly 0.5.1.dev20241028104150__py3-none-any.whl → 0.5.1.dev20241030104135__py3-none-any.whl

letta/cli/cli.py

@@ -218,9 +218,7 @@ def run(
         )
 
         # create agent
-        tools = [
-            server.tool_manager.get_tool_by_name_and_user_id(tool_name=tool_name, user_id=client.user_id) for tool_name in agent_state.tools
-        ]
+        tools = [server.tool_manager.get_tool_by_name(tool_name=tool_name, actor=client.user) for tool_name in agent_state.tools]
         letta_agent = Agent(agent_state=agent_state, interface=interface(), tools=tools)
 
     else:  # create new agent
@@ -300,7 +298,7 @@ def run(
         )
         assert isinstance(agent_state.memory, Memory), f"Expected Memory, got {type(agent_state.memory)}"
         typer.secho(f"->  🛠️  {len(agent_state.tools)} tools: {', '.join([t for t in agent_state.tools])}", fg=typer.colors.WHITE)
-        tools = [server.tool_manager.get_tool_by_name_and_user_id(tool_name, user_id=client.user_id) for tool_name in agent_state.tools]
+        tools = [server.tool_manager.get_tool_by_name(tool_name, actor=client.user) for tool_name in agent_state.tools]
 
         letta_agent = Agent(
             interface=interface(),

letta/client/client.py

@@ -276,10 +276,10 @@ class AbstractClient(object):
     ) -> List[Message]:
         raise NotImplementedError
 
-    def list_models(self) -> List[LLMConfig]:
+    def list_model_configs(self) -> List[LLMConfig]:
         raise NotImplementedError
 
-    def list_embedding_models(self) -> List[EmbeddingConfig]:
+    def list_embedding_configs(self) -> List[EmbeddingConfig]:
         raise NotImplementedError
 
 
@@ -1234,32 +1234,6 @@ class RESTClient(AbstractClient):
         assert response.status_code == 200, f"Failed to detach source from agent: {response.text}"
         return Source(**response.json())
 
-    # server configuration commands
-
-    def list_models(self):
-        """
-        List available LLM models
-
-        Returns:
-            models (List[LLMConfig]): List of LLM models
-        """
-        response = requests.get(f"{self.base_url}/{self.api_prefix}/models", headers=self.headers)
-        if response.status_code != 200:
-            raise ValueError(f"Failed to list models: {response.text}")
-        return [LLMConfig(**model) for model in response.json()]
-
-    def list_embedding_models(self):
-        """
-        List available embedding models
-
-        Returns:
-            models (List[EmbeddingConfig]): List of embedding models
-        """
-        response = requests.get(f"{self.base_url}/{self.api_prefix}/models/embedding", headers=self.headers)
-        if response.status_code != 200:
-            raise ValueError(f"Failed to list embedding models: {response.text}")
-        return [EmbeddingConfig(**model) for model in response.json()]
-
     # tools
 
     def get_tool_id(self, tool_name: str):
@@ -1546,6 +1520,9 @@ class LocalClient(AbstractClient):
             # get default user
             self.user_id = self.server.user_manager.DEFAULT_USER_ID
 
+        self.user = self.server.get_user_or_default(self.user_id)
+        self.organization = self.server.get_organization_or_default(self.org_id)
+
     # agents
     def list_agents(self) -> List[AgentState]:
         self.interface.clear()
@@ -1648,7 +1625,7 @@ class LocalClient(AbstractClient):
                 llm_config=llm_config if llm_config else self._default_llm_config,
                 embedding_config=embedding_config if embedding_config else self._default_embedding_config,
             ),
-            user_id=self.user_id,
+            actor=self.user,
         )
         return agent_state
 
@@ -1720,7 +1697,7 @@ class LocalClient(AbstractClient):
                 message_ids=message_ids,
                 memory=memory,
             ),
-            user_id=self.user_id,
+            actor=self.user,
         )
         return agent_state
 
@@ -2198,24 +2175,22 @@ class LocalClient(AbstractClient):
     def load_langchain_tool(self, langchain_tool: "LangChainBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> Tool:
         tool_create = ToolCreate.from_langchain(
             langchain_tool=langchain_tool,
-            user_id=self.user_id,
             organization_id=self.org_id,
             additional_imports_module_attr_map=additional_imports_module_attr_map,
         )
-        return self.server.tool_manager.create_or_update_tool(tool_create)
+        return self.server.tool_manager.create_or_update_tool(tool_create, actor=self.user)
 
     def load_crewai_tool(self, crewai_tool: "CrewAIBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> Tool:
         tool_create = ToolCreate.from_crewai(
             crewai_tool=crewai_tool,
             additional_imports_module_attr_map=additional_imports_module_attr_map,
-            user_id=self.user_id,
             organization_id=self.org_id,
         )
-        return self.server.tool_manager.create_or_update_tool(tool_create)
+        return self.server.tool_manager.create_or_update_tool(tool_create, actor=self.user)
 
     def load_composio_tool(self, action: "ActionType") -> Tool:
-        tool_create = ToolCreate.from_composio(action=action, user_id=self.user_id, organization_id=self.org_id)
-        return self.server.tool_manager.create_or_update_tool(tool_create)
+        tool_create = ToolCreate.from_composio(action=action, organization_id=self.org_id)
+        return self.server.tool_manager.create_or_update_tool(tool_create, actor=self.user)
 
     # TODO: Use the above function `add_tool` here as there is duplicate logic
     def create_tool(
@@ -2250,14 +2225,13 @@ class LocalClient(AbstractClient):
         # call server function
         return self.server.tool_manager.create_or_update_tool(
             ToolCreate(
-                user_id=self.user_id,
-                organization_id=self.org_id,
                 source_type=source_type,
                 source_code=source_code,
                 name=name,
                 tags=tags,
                 terminal=terminal,
             ),
+            actor=self.user,
         )
 
     def update_tool(
@@ -2289,7 +2263,7 @@ class LocalClient(AbstractClient):
         # Filter out any None values from the dictionary
         update_data = {key: value for key, value in update_data.items() if value is not None}
 
-        return self.server.tool_manager.update_tool_by_id(id, ToolUpdate(**update_data))
+        return self.server.tool_manager.update_tool_by_id(tool_id=id, tool_update=ToolUpdate(**update_data), actor=self.user)
 
     def list_tools(self, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[Tool]:
         """
@@ -2298,7 +2272,7 @@ class LocalClient(AbstractClient):
         Returns:
             tools (List[Tool]): List of tools
         """
-        return self.server.tool_manager.list_tools_for_org(cursor=cursor, limit=limit, organization_id=self.org_id)
+        return self.server.tool_manager.list_tools(cursor=cursor, limit=limit, actor=self.user)
 
     def get_tool(self, id: str) -> Optional[Tool]:
         """
@@ -2310,7 +2284,7 @@ class LocalClient(AbstractClient):
         Returns:
             tool (Tool): Tool
         """
-        return self.server.tool_manager.get_tool_by_id(id)
+        return self.server.tool_manager.get_tool_by_id(id, actor=self.user)
 
     def delete_tool(self, id: str):
         """
@@ -2319,7 +2293,7 @@ class LocalClient(AbstractClient):
         Args:
             id (str): ID of the tool
         """
-        return self.server.tool_manager.delete_tool_by_id(id)
+        return self.server.tool_manager.delete_tool_by_id(id, user_id=self.user_id)
 
     def get_tool_id(self, name: str) -> Optional[str]:
         """
@@ -2331,7 +2305,7 @@ class LocalClient(AbstractClient):
         Returns:
             id (str): ID of the tool (`None` if not found)
         """
-        tool = self.server.tool_manager.get_tool_by_name_and_org_id(tool_name=name, organization_id=self.org_id)
+        tool = self.server.tool_manager.get_tool_by_name(tool_name=name, actor=self.user)
         return tool.id
 
     def load_data(self, connector: DataConnector, source_name: str):
@@ -2572,24 +2546,6 @@ class LocalClient(AbstractClient):
             return_message_object=True,
         )
 
-    def list_models(self) -> List[LLMConfig]:
-        """
-        List available LLM models
-
-        Returns:
-            models (List[LLMConfig]): List of LLM models
-        """
-        return self.server.list_models()
-
-    def list_embedding_models(self) -> List[EmbeddingConfig]:
-        """
-        List available embedding models
-
-        Returns:
-            models (List[EmbeddingConfig]): List of embedding models
-        """
-        return [self.server.server_embedding_config]
-
     def list_blocks(self, label: Optional[str] = None, templates_only: Optional[bool] = True) -> List[Block]:
         """
         List available blocks

letta/llm_api/llm_api_tools.py

@@ -313,7 +313,6 @@ def create(
             stream_interface.stream_start()
         try:
             # groq uses the openai chat completions API, so this component should be reusable
-            assert model_settings.groq_api_key is not None, "Groq key is missing"
             response = openai_chat_completions_request(
                 url=llm_config.model_endpoint,
                 api_key=model_settings.groq_api_key,

letta/orm/base.py

@@ -1,9 +1,7 @@
 from datetime import datetime
 from typing import Optional
-from uuid import UUID
 
-from sqlalchemy import UUID as SQLUUID
-from sqlalchemy import Boolean, DateTime, func, text
+from sqlalchemy import Boolean, DateTime, String, func, text
 from sqlalchemy.orm import (
     DeclarativeBase,
     Mapped,
@@ -25,6 +23,13 @@ class CommonSqlalchemyMetaMixins(Base):
     updated_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), server_default=func.now(), server_onupdate=func.now())
     is_deleted: Mapped[bool] = mapped_column(Boolean, server_default=text("FALSE"))
 
+    def _set_created_and_updated_by_fields(self, actor_id: str) -> None:
+        """Populate created_by_id and last_updated_by_id based on actor."""
+        if not self.created_by_id:
+            self.created_by_id = actor_id
+        # Always set the last_updated_by_id when updating
+        self.last_updated_by_id = actor_id
+
     @declared_attr
     def _created_by_id(cls):
         return cls._user_by_id()
@@ -38,7 +43,7 @@ class CommonSqlalchemyMetaMixins(Base):
         """a flexible non-constrained record of a user.
         This way users can get added, deleted etc without history freaking out
         """
-        return mapped_column(SQLUUID(), nullable=True)
+        return mapped_column(String, nullable=True)
 
     @property
     def last_updated_by_id(self) -> Optional[str]:
@@ -72,4 +77,4 @@ class CommonSqlalchemyMetaMixins(Base):
             return
         prefix, id_ = value.split("-", 1)
         assert prefix == "user", f"{prefix} is not a valid id prefix for a user id"
-        setattr(self, full_prop, UUID(id_))
+        setattr(self, full_prop, id_)

letta/orm/sqlalchemy_base.py

@@ -1,5 +1,5 @@
-from typing import TYPE_CHECKING, List, Literal, Optional, Type, Union
-from uuid import UUID, uuid4
+from typing import TYPE_CHECKING, List, Literal, Optional, Type
+from uuid import uuid4
 
 from humps import depascalize
 from sqlalchemy import Boolean, String, select
@@ -88,7 +88,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
     def read(
         cls,
         db_session: "Session",
-        identifier: Union[str, UUID],
+        identifier: Optional[str] = None,
         actor: Optional["User"] = None,
         access: Optional[List[Literal["read", "write", "admin"]]] = ["read"],
         **kwargs,
@@ -105,19 +105,29 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         Raises:
             NoResultFound: if the object is not found
         """
-        del kwargs  # arity for more complex reads
-        identifier = cls.get_uid_from_identifier(identifier)
-        query = select(cls).where(cls._id == identifier)
-        # if actor:
-        #     query = cls.apply_access_predicate(query, actor, access)
+        # Start the query
+        query = select(cls)
+
+        # If an identifier is provided, add it to the query conditions
+        if identifier is not None:
+            identifier = cls.get_uid_from_identifier(identifier)
+            query = query.where(cls._id == identifier)
+
+        if kwargs:
+            query = query.filter_by(**kwargs)
+
+        if actor:
+            query = cls.apply_access_predicate(query, actor, access)
+
         if hasattr(cls, "is_deleted"):
             query = query.where(cls.is_deleted == False)
         if found := db_session.execute(query).scalar():
             return found
         raise NoResultFound(f"{cls.__name__} with id {identifier} not found")
 
-    def create(self, db_session: "Session") -> Type["SqlalchemyBase"]:
-        # self._infer_organization(db_session)
+    def create(self, db_session: "Session", actor: Optional["User"] = None) -> Type["SqlalchemyBase"]:
+        if actor:
+            self._set_created_and_updated_by_fields(actor.id)
 
         with db_session as session:
             session.add(self)
@@ -125,11 +135,17 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             session.refresh(self)
             return self
 
-    def delete(self, db_session: "Session") -> Type["SqlalchemyBase"]:
+    def delete(self, db_session: "Session", actor: Optional["User"] = None) -> Type["SqlalchemyBase"]:
+        if actor:
+            self._set_created_and_updated_by_fields(actor.id)
+
         self.is_deleted = True
         return self.update(db_session)
 
-    def update(self, db_session: "Session") -> Type["SqlalchemyBase"]:
+    def update(self, db_session: "Session", actor: Optional["User"] = None) -> Type["SqlalchemyBase"]:
+        if actor:
+            self._set_created_and_updated_by_fields(actor.id)
+
         with db_session as session:
             session.add(self)
             session.commit()
@@ -137,39 +153,28 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             return self
 
     @classmethod
-    def read_or_create(cls, *, db_session: "Session", **kwargs) -> Type["SqlalchemyBase"]:
-        """get an instance by search criteria or create it if it doesn't exist"""
-        try:
-            return cls.read(db_session=db_session, identifier=kwargs.get("id", None))
-        except NoResultFound:
-            clean_kwargs = {k: v for k, v in kwargs.items() if k in cls.__table__.columns}
-            return cls(**clean_kwargs).create(db_session=db_session)
-
-    # TODO: Add back later when access predicates are actually important
-    # The idea behind this is that you can add a WHERE clause restricting the actions you can take, e.g. R/W
-    # @classmethod
-    # def apply_access_predicate(
-    #     cls,
-    #     query: "Select",
-    #     actor: "User",
-    #     access: List[Literal["read", "write", "admin"]],
-    # ) -> "Select":
-    #     """applies a WHERE clause restricting results to the given actor and access level
-    #     Args:
-    #         query: The initial sqlalchemy select statement
-    #         actor: The user acting on the query. **Note**: this is called 'actor' to identify the
-    #                person or system acting. Users can act on users, making naming very sticky otherwise.
-    #         access:
-    #             what mode of access should the query restrict to? This will be used with granular permissions,
-    #             but because of how it will impact every query we want to be explicitly calling access ahead of time.
-    #     Returns:
-    #         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_uid = getattr(actor, "_organization_id", getattr(actor.organization, "_id", None))
-    #     if not org_uid:
-    #         raise ValueError("object %s has no organization accessor", actor)
-    #     return query.where(cls._organization_id == org_uid, cls.is_deleted == False)
+    def apply_access_predicate(
+        cls,
+        query: "Select",
+        actor: "User",
+        access: List[Literal["read", "write", "admin"]],
+    ) -> "Select":
+        """applies a WHERE clause restricting results to the given actor and access level
+        Args:
+            query: The initial sqlalchemy select statement
+            actor: The user acting on the query. **Note**: this is called 'actor' to identify the
+                   person or system acting. Users can act on users, making naming very sticky otherwise.
+            access:
+                what mode of access should the query restrict to? This will be used with granular permissions,
+                but because of how it will impact every query we want to be explicitly calling access ahead of time.
+        Returns:
+            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 == cls.get_uid_from_identifier(org_id, indifferent=True), cls.is_deleted == False)
 
     @property
     def __pydantic_model__(self) -> Type["BaseModel"]:
@@ -183,21 +188,3 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         """Deprecated accessor for to_pydantic"""
         logger.warning("to_record is deprecated, use to_pydantic instead.")
         return self.to_pydantic()
-
-    def _infer_organization(self, db_session: "Session") -> None:
-        """🪄 MAGIC ALERT! 🪄
-        Because so much of the original API is centered around user scopes,
-        this allows us to continue with that scope and then infer the org from the creating user.
-
-        IF a created_by_id is set, we will use that to infer the organization and magic set it at create time!
-        If not do nothing to the object. Mutates in place.
-        """
-        if self.created_by_id and hasattr(self, "_organization_id"):
-            try:
-                from letta.orm.user import User  # to avoid circular import
-
-                created_by = User.read(db_session, self.created_by_id)
-            except NoResultFound:
-                logger.warning(f"User {self.created_by_id} not found, unable to infer organization.")
-                return
-            self._organization_id = created_by._organization_id

letta/orm/tool.py

@@ -5,18 +5,15 @@ from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 # TODO everything in functions should live in this model
 from letta.orm.enums import ToolSourceType
-from letta.orm.mixins import OrganizationMixin, UserMixin
+from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.tool import Tool as PydanticTool
 
 if TYPE_CHECKING:
-    pass
-
     from letta.orm.organization import Organization
-    from letta.orm.user import User
 
 
-class Tool(SqlalchemyBase, OrganizationMixin, UserMixin):
+class Tool(SqlalchemyBase, OrganizationMixin):
     """Represents an available tool that the LLM can invoke.
 
     NOTE: polymorphic inheritance makes more sense here as a TODO. We want a superset of tools
@@ -29,10 +26,7 @@ class Tool(SqlalchemyBase, OrganizationMixin, UserMixin):
 
     # Add unique constraint on (name, _organization_id)
     # An organization should not have multiple tools with the same name
-    __table_args__ = (
-        UniqueConstraint("name", "_organization_id", name="uix_name_organization"),
-        UniqueConstraint("name", "_user_id", name="uix_name_user"),
-    )
+    __table_args__ = (UniqueConstraint("name", "_organization_id", name="uix_name_organization"),)
 
     name: Mapped[str] = mapped_column(doc="The display name of the tool.")
     description: Mapped[Optional[str]] = mapped_column(nullable=True, doc="The description of the tool.")
@@ -48,7 +42,4 @@ class Tool(SqlalchemyBase, OrganizationMixin, UserMixin):
     # This was an intentional decision by Sarah
 
     # relationships
-    # TODO: Possibly add in user in the future
-    # This will require some more thought and justification to add this in.
-    user: Mapped["User"] = relationship("User", back_populates="tools", lazy="selectin")
     organization: Mapped["Organization"] = relationship("Organization", back_populates="tools", lazy="selectin")

letta/orm/user.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING
 
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
@@ -8,7 +8,6 @@ from letta.schemas.user import User as PydanticUser
 
 if TYPE_CHECKING:
     from letta.orm.organization import Organization
-    from letta.orm.tool import Tool
 
 
 class User(SqlalchemyBase, OrganizationMixin):
@@ -21,7 +20,6 @@ class User(SqlalchemyBase, OrganizationMixin):
 
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="users")
-    tools: Mapped[List["Tool"]] = relationship("Tool", back_populates="user", cascade="all, delete-orphan")
 
     # TODO: Add this back later potentially
     # agents: Mapped[List["Agent"]] = relationship(

letta/providers.py

@@ -313,7 +313,7 @@ class GroqProvider(OpenAIProvider):
                 continue
             configs.append(
                 LLMConfig(
-                    model=model["id"], model_endpoint_type="openai", model_endpoint=self.base_url, context_window=model["context_window"]
+                    model=model["id"], model_endpoint_type="groq", model_endpoint=self.base_url, context_window=model["context_window"]
                 )
             )
         return configs

letta/schemas/tool.py

@@ -11,7 +11,6 @@ from letta.functions.schema_generator import generate_schema_from_args_schema
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.openai.chat_completions import ToolCall
 from letta.services.organization_manager import OrganizationManager
-from letta.services.user_manager import UserManager
 
 
 class BaseTool(LettaBase):
@@ -35,7 +34,6 @@ class Tool(BaseTool):
     description: Optional[str] = Field(None, description="The description of the tool.")
     source_type: Optional[str] = Field(None, description="The type of the source code.")
     module: Optional[str] = Field(None, description="The module of the function.")
-    user_id: str = Field(..., description="The unique identifier of the user associated with the tool.")
     organization_id: str = Field(..., description="The unique identifier of the organization associated with the tool.")
     name: str = Field(..., description="The name of the function.")
     tags: List[str] = Field(..., description="Metadata tags.")
@@ -44,6 +42,10 @@ class Tool(BaseTool):
     source_code: str = Field(..., description="The source code of the function.")
     json_schema: Dict = Field(default_factory=dict, description="The JSON schema of the function.")
 
+    # metadata fields
+    created_by_id: str = Field(..., description="The id of the user that made this Tool.")
+    last_updated_by_id: str = Field(..., description="The id of the user that made this Tool.")
+
     def to_dict(self):
         """
         Convert tool into OpenAI representation.
@@ -58,11 +60,6 @@ class Tool(BaseTool):
 
 
 class ToolCreate(LettaBase):
-    user_id: str = Field(UserManager.DEFAULT_USER_ID, description="The user that this tool belongs to. Defaults to the default user ID.")
-    organization_id: str = Field(
-        OrganizationManager.DEFAULT_ORG_ID,
-        description="The organization that this tool belongs to. Defaults to the default organization ID.",
-    )
     name: Optional[str] = Field(None, description="The name of the function (auto-generated from source_code if not provided).")
     description: Optional[str] = Field(None, description="The description of the tool.")
     tags: List[str] = Field([], description="Metadata tags.")
@@ -75,9 +72,7 @@ class ToolCreate(LettaBase):
     terminal: Optional[bool] = Field(None, description="Whether the tool is a terminal tool (allow requesting heartbeats).")
 
     @classmethod
-    def from_composio(
-        cls, action: "ActionType", user_id: str = UserManager.DEFAULT_USER_ID, organization_id: str = OrganizationManager.DEFAULT_ORG_ID
-    ) -> "ToolCreate":
+    def from_composio(cls, action: "ActionType", organization_id: str = OrganizationManager.DEFAULT_ORG_ID) -> "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
@@ -106,8 +101,6 @@ class ToolCreate(LettaBase):
         json_schema = generate_schema_from_args_schema(composio_tool.args_schema, name=wrapper_func_name, description=description)
 
         return cls(
-            user_id=user_id,
-            organization_id=organization_id,
             name=wrapper_func_name,
             description=description,
             source_type=source_type,
@@ -121,7 +114,6 @@ class ToolCreate(LettaBase):
         cls,
         langchain_tool: "LangChainBaseTool",
         additional_imports_module_attr_map: dict[str, str] = None,
-        user_id: str = UserManager.DEFAULT_USER_ID,
         organization_id: str = OrganizationManager.DEFAULT_ORG_ID,
     ) -> "ToolCreate":
         """
@@ -142,8 +134,6 @@ class ToolCreate(LettaBase):
         json_schema = generate_schema_from_args_schema(langchain_tool.args_schema, name=wrapper_func_name, description=description)
 
         return cls(
-            user_id=user_id,
-            organization_id=organization_id,
             name=wrapper_func_name,
             description=description,
             source_type=source_type,
@@ -157,7 +147,6 @@ class ToolCreate(LettaBase):
         cls,
         crewai_tool: "CrewAIBaseTool",
         additional_imports_module_attr_map: dict[str, str] = None,
-        user_id: str = UserManager.DEFAULT_USER_ID,
         organization_id: str = OrganizationManager.DEFAULT_ORG_ID,
     ) -> "ToolCreate":
         """
@@ -176,8 +165,6 @@ class ToolCreate(LettaBase):
         json_schema = generate_schema_from_args_schema(crewai_tool.args_schema, name=wrapper_func_name, description=description)
 
         return cls(
-            user_id=user_id,
-            organization_id=organization_id,
             name=wrapper_func_name,
             description=description,
             source_type=source_type,

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

@@ -84,7 +84,7 @@ def create_agent(
     blocks = agent.memory.get_blocks()
     agent.memory = BasicBlockMemory(blocks=blocks)
 
-    return server.create_agent(agent, user_id=actor.id)
+    return server.create_agent(agent, actor=actor)
 
 
 @router.patch("/{agent_id}", response_model=AgentState, operation_id="update_agent")
@@ -96,9 +96,7 @@ def update_agent(
 ):
     """Update an exsiting agent"""
     actor = server.get_user_or_default(user_id=user_id)
-
-    update_agent.id = agent_id
-    return server.update_agent(update_agent, user_id=actor.id)
+    return server.update_agent(update_agent, actor=actor)
 
 
 @router.get("/{agent_id}/tools", response_model=List[Tool], operation_id="get_tools_from_agent")
@@ -361,7 +359,7 @@ def update_message(
     return server.update_agent_message(agent_id=agent_id, request=request)
 
 
-@router.post("/{agent_id}/messages", response_model=LettaResponse, operation_id="create_agent_message")
+@router.post("/{agent_id}/messages", response_model=None, operation_id="create_agent_message")
 async def send_message(
     agent_id: str,
     server: SyncServer = Depends(get_letta_server),
@@ -375,16 +373,10 @@ async def send_message(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    # TODO(charles): support sending multiple messages
-    assert len(request.messages) == 1, f"Multiple messages not supported: {request.messages}"
-    request.messages[0]
-
     return await send_message_to_agent(
         server=server,
         agent_id=agent_id,
         user_id=actor.id,
-        # role=message.role,
-        # message=message.text,
         messages=request.messages,
         stream_steps=request.stream_steps,
         stream_tokens=request.stream_tokens,
@@ -465,8 +457,12 @@ async def send_message_to_agent(
         # Offload the synchronous message_func to a separate thread
         streaming_interface.stream_start()
         task = asyncio.create_task(
-            # asyncio.to_thread(message_func, user_id=user_id, agent_id=agent_id, message=message, timestamp=timestamp)
-            asyncio.to_thread(server.send_messages, user_id=user_id, agent_id=agent_id, messages=messages)
+            asyncio.to_thread(
+                server.send_messages,
+                user_id=user_id,
+                agent_id=agent_id,
+                messages=messages,
+            )
         )
 
         if stream_steps:
@@ -476,7 +472,11 @@ async def send_message_to_agent(
 
             # return a stream
             return StreamingResponse(
-                sse_async_generator(streaming_interface.get_generator(), finish_message=include_final_message),
+                sse_async_generator(
+                    streaming_interface.get_generator(),
+                    usage_task=task,
+                    finish_message=include_final_message,
+                ),
                 media_type="text/event-stream",
             )