letta-nightly 0.5.1.dev20241028104150__py3-none-any.whl → 0.5.1.dev20241029104141__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")

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

@@ -26,11 +26,13 @@ def delete_tool(
 def get_tool(
     tool_id: str,
     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
 ):
     """
     Get a tool by ID
     """
-    tool = server.tool_manager.get_tool_by_id(tool_id=tool_id)
+    actor = server.get_user_or_default(user_id=user_id)
+    tool = server.tool_manager.get_tool_by_id(tool_id=tool_id, actor=actor)
     if tool is None:
         # return 404 error
         raise HTTPException(status_code=404, detail=f"Tool with id {tool_id} not found.")
@@ -49,7 +51,7 @@ def get_tool_id(
     actor = server.get_user_or_default(user_id=user_id)
 
     try:
-        tool = server.tool_manager.get_tool_by_name_and_org_id(tool_name=tool_name, organization_id=actor.organization_id)
+        tool = server.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
         return tool.id
     except NoResultFound:
         raise HTTPException(status_code=404, detail=f"Tool with name {tool_name} and organization id {actor.organization_id} not found.")
@@ -67,7 +69,7 @@ def list_tools(
     """
     try:
         actor = server.get_user_or_default(user_id=user_id)
-        return server.tool_manager.list_tools_for_org(organization_id=actor.organization_id, cursor=cursor, limit=limit)
+        return server.tool_manager.list_tools(actor=actor, cursor=cursor, limit=limit)
     except Exception as e:
         # Log or print the full exception here for debugging
         print(f"Error occurred: {e}")
@@ -85,13 +87,9 @@ def create_tool(
     """
     # Derive user and org id from actor
     actor = server.get_user_or_default(user_id=user_id)
-    request.organization_id = actor.organization_id
-    request.user_id = actor.id
 
     # Send request to create the tool
-    return server.tool_manager.create_or_update_tool(
-        tool_create=request,
-    )
+    return server.tool_manager.create_or_update_tool(tool_create=request, actor=actor)
 
 
 @router.patch("/{tool_id}", response_model=Tool, operation_id="update_tool")
@@ -104,4 +102,5 @@ def update_tool(
     """
     Update an existing tool
     """
-    return server.tool_manager.update_tool_by_id(tool_id, request)
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.tool_manager.update_tool_by_id(tool_id, actor.id, request)

letta/server/server.py

@@ -37,11 +37,13 @@ from letta.log import get_logger
 from letta.memory import get_memory_functions
 from letta.metadata import Base, MetadataStore
 from letta.o1_agent import O1Agent
+from letta.orm.errors import NoResultFound
 from letta.prompts import gpt_system
 from letta.providers import (
     AnthropicProvider,
     AzureProvider,
     GoogleAIProvider,
+    GroqProvider,
     LettaProvider,
     OllamaProvider,
     OpenAIProvider,
@@ -73,6 +75,7 @@ from letta.schemas.memory import (
     RecallMemorySummary,
 )
 from letta.schemas.message import Message, MessageCreate, MessageRole, UpdateMessage
+from letta.schemas.organization import Organization
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source, SourceCreate, SourceUpdate
 from letta.schemas.tool import Tool, ToolCreate
@@ -251,12 +254,12 @@ class SyncServer(Server):
             self.default_org = self.organization_manager.create_default_organization()
             self.default_user = self.user_manager.create_default_user()
             self.add_default_blocks(self.default_user.id)
-            self.tool_manager.add_default_tools(module_name="base", user_id=self.default_user.id, org_id=self.default_org.id)
+            self.tool_manager.add_default_tools(module_name="base", actor=self.default_user)
 
             # If there is a default org/user
             # This logic may have to change in the future
             if settings.load_default_external_tools:
-                self.add_default_external_tools(user_id=self.default_user.id, org_id=self.default_org.id)
+                self.add_default_external_tools(actor=self.default_user)
 
         # collect providers (always has Letta as a default)
         self._enabled_providers: List[Provider] = [LettaProvider()]
@@ -296,6 +299,8 @@ class SyncServer(Server):
                     api_version=model_settings.azure_api_version,
                 )
             )
+        if model_settings.groq_api_key:
+            self._enabled_providers.append(GroqProvider(api_key=model_settings.groq_api_key))
         if model_settings.vllm_api_base:
             # vLLM exposes both a /chat/completions and a /completions endpoint
             self._enabled_providers.append(
@@ -345,10 +350,10 @@ class SyncServer(Server):
             }
         )
 
-    def _load_agent(self, user_id: str, agent_id: str, interface: Union[AgentInterface, None] = None) -> Agent:
+    def _load_agent(self, agent_id: str, actor: User, interface: Union[AgentInterface, None] = None) -> Agent:
         """Loads a saved agent into memory (if it doesn't exist, throw an error)"""
-        assert isinstance(user_id, str), user_id
         assert isinstance(agent_id, str), agent_id
+        user_id = actor.id
 
         # If an interface isn't specified, use the default
         if interface is None:
@@ -365,7 +370,7 @@ class SyncServer(Server):
             logger.debug(f"Creating an agent object")
             tool_objs = []
             for name in agent_state.tools:
-                tool_obj = self.tool_manager.get_tool_by_name_and_user_id(tool_name=name, user_id=user_id)
+                tool_obj = self.tool_manager.get_tool_by_name(tool_name=name, actor=actor)
                 if not tool_obj:
                     logger.exception(f"Tool {name} does not exist for user {user_id}")
                     raise ValueError(f"Tool {name} does not exist for user {user_id}")
@@ -396,13 +401,14 @@ class SyncServer(Server):
         if not agent_state:
             raise ValueError(f"Agent does not exist")
         user_id = agent_state.user_id
+        actor = self.user_manager.get_user_by_id(user_id)
 
         logger.debug(f"Checking for agent user_id={user_id} agent_id={agent_id}")
         # TODO: consider disabling loading cached agents due to potential concurrency issues
         letta_agent = self._get_agent(user_id=user_id, agent_id=agent_id)
         if not letta_agent:
             logger.debug(f"Agent not loaded, loading agent user_id={user_id} agent_id={agent_id}")
-            letta_agent = self._load_agent(user_id=user_id, agent_id=agent_id)
+            letta_agent = self._load_agent(agent_id=agent_id, actor=actor)
         return letta_agent
 
     def _step(
@@ -759,11 +765,12 @@ class SyncServer(Server):
     def create_agent(
         self,
         request: CreateAgent,
-        user_id: str,
+        actor: User,
         # interface
         interface: Union[AgentInterface, None] = None,
     ) -> AgentState:
         """Create a new agent using a config"""
+        user_id = actor.id
         if self.user_manager.get_user_by_id(user_id=user_id) is None:
             raise ValueError(f"User user_id={user_id} does not exist")
 
@@ -801,7 +808,7 @@ class SyncServer(Server):
             tool_objs = []
             if request.tools:
                 for tool_name in request.tools:
-                    tool_obj = self.tool_manager.get_tool_by_name_and_user_id(tool_name=tool_name, user_id=user_id)
+                    tool_obj = self.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
                     tool_objs.append(tool_obj)
 
             assert request.memory is not None
@@ -822,9 +829,8 @@ class SyncServer(Server):
                         source_type=source_type,
                         tags=tags,
                         json_schema=json_schema,
-                        user_id=user_id,
-                        organization_id=user.organization_id,
-                    )
+                    ),
+                    actor=actor,
                 )
                 tool_objs.append(tool)
                 if not request.tools:
@@ -887,11 +893,14 @@ class SyncServer(Server):
     def update_agent(
         self,
         request: UpdateAgentState,
-        user_id: str,
+        actor: User,
     ):
         """Update the agents core memory block, return the new state"""
-        if self.user_manager.get_user_by_id(user_id=user_id) is None:
-            raise ValueError(f"User user_id={user_id} does not exist")
+        try:
+            self.user_manager.get_user_by_id(user_id=actor.id)
+        except Exception:
+            raise ValueError(f"User user_id={actor.id} does not exist")
+
         if self.ms.get_agent(agent_id=request.id) is None:
             raise ValueError(f"Agent agent_id={request.id} does not exist")
 
@@ -902,7 +911,7 @@ class SyncServer(Server):
         if request.memory:
             assert isinstance(request.memory, Memory), type(request.memory)
             new_memory_contents = request.memory.to_flat_dict()
-            _ = self.update_agent_core_memory(user_id=user_id, agent_id=request.id, new_memory_contents=new_memory_contents)
+            _ = self.update_agent_core_memory(user_id=actor.id, agent_id=request.id, new_memory_contents=new_memory_contents)
 
         # update the system prompt
         if request.system:
@@ -922,7 +931,7 @@ class SyncServer(Server):
             # (1) get tools + make sure they exist
             tool_objs = []
             for tool_name in request.tools:
-                tool_obj = self.tool_manager.get_tool_by_name_and_user_id(tool_name=tool_name, user_id=user_id)
+                tool_obj = self.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
                 assert tool_obj, f"Tool {tool_name} does not exist"
                 tool_objs.append(tool_obj)
 
@@ -968,8 +977,11 @@ class SyncServer(Server):
         user_id: str,
     ):
         """Add tools from an existing agent"""
-        if self.user_manager.get_user_by_id(user_id=user_id) is None:
+        try:
+            user = self.user_manager.get_user_by_id(user_id=user_id)
+        except NoResultFound:
             raise ValueError(f"User user_id={user_id} does not exist")
+
         if self.ms.get_agent(agent_id=agent_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
 
@@ -978,12 +990,12 @@ class SyncServer(Server):
 
         # Get all the tool objects from the request
         tool_objs = []
-        tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool_id)
+        tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool_id, actor=user)
         assert tool_obj, f"Tool with id={tool_id} does not exist"
         tool_objs.append(tool_obj)
 
         for tool in letta_agent.tools:
-            tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool.id)
+            tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool.id, actor=user)
             assert tool_obj, f"Tool with id={tool.id} does not exist"
 
             # If it's not the already added tool
@@ -1007,8 +1019,11 @@ class SyncServer(Server):
         user_id: str,
     ):
         """Remove tools from an existing agent"""
-        if self.user_manager.get_user_by_id(user_id=user_id) is None:
+        try:
+            user = self.user_manager.get_user_by_id(user_id=user_id)
+        except NoResultFound:
             raise ValueError(f"User user_id={user_id} does not exist")
+
         if self.ms.get_agent(agent_id=agent_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
 
@@ -1018,7 +1033,7 @@ class SyncServer(Server):
         # Get all the tool_objs
         tool_objs = []
         for tool in letta_agent.tools:
-            tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool.id)
+            tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool.id, actor=user)
             assert tool_obj, f"Tool with id={tool.id} does not exist"
 
             # If it's not the tool we want to remove
@@ -1733,7 +1748,7 @@ class SyncServer(Server):
 
         return sources_with_metadata
 
-    def add_default_external_tools(self, user_id: str, org_id: str) -> bool:
+    def add_default_external_tools(self, actor: User) -> bool:
         """Add default langchain tools. Return true if successful, false otherwise."""
         success = True
         tool_creates = ToolCreate.load_default_langchain_tools() + ToolCreate.load_default_crewai_tools()
@@ -1741,7 +1756,7 @@ class SyncServer(Server):
             tool_creates += ToolCreate.load_default_composio_tools()
         for tool_create in tool_creates:
             try:
-                self.tool_manager.create_or_update_tool(tool_create)
+                self.tool_manager.create_or_update_tool(tool_create, actor=actor)
             except Exception as e:
                 warnings.warn(f"An error occurred while creating tool {tool_create}: {e}")
                 warnings.warn(traceback.format_exc())
@@ -1843,6 +1858,16 @@ class SyncServer(Server):
         except ValueError:
             raise HTTPException(status_code=404, detail=f"User with id {user_id} not found")
 
+    def get_organization_or_default(self, org_id: Optional[str]) -> Organization:
+        """Get the organization object for org_id if it exists, otherwise return the default organization object"""
+        if org_id is None:
+            org_id = self.organization_manager.DEFAULT_ORG_ID
+
+        try:
+            return self.organization_manager.get_organization_by_id(org_id=org_id)
+        except ValueError:
+            raise HTTPException(status_code=404, detail=f"Organization with id {org_id} not found")
+
     def list_llm_models(self) -> List[LLMConfig]:
         """List available models"""
 

letta/server/startup.sh

@@ -2,7 +2,7 @@
 echo "Starting MEMGPT server..."
 if [ "$MEMGPT_ENVIRONMENT" = "DEVELOPMENT" ] ; then
     echo "Starting in development mode!"
-    uvicorn letta.server.rest_api.app:app --reload --reload-dir /letta --host 0.0.0.0 --port 8083
+    uvicorn letta.server.rest_api.app:app --reload --reload-dir /letta --host 0.0.0.0 --port 8283
 else
-    uvicorn letta.server.rest_api.app:app --host 0.0.0.0 --port 8083
+    uvicorn letta.server.rest_api.app:app --host 0.0.0.0 --port 8283
 fi

letta/services/tool_manager.py

@@ -9,9 +9,9 @@ from letta.functions.functions import derive_openai_json_schema, load_function_s
 from letta.orm.errors import NoResultFound
 from letta.orm.organization import Organization as OrganizationModel
 from letta.orm.tool import Tool as ToolModel
-from letta.orm.user import User as UserModel
 from letta.schemas.tool import Tool as PydanticTool
 from letta.schemas.tool import ToolCreate, ToolUpdate
+from letta.schemas.user import User as PydanticUser
 from letta.utils import enforce_types
 
 
@@ -25,7 +25,7 @@ class ToolManager:
         self.session_maker = db_context
 
     @enforce_types
-    def create_or_update_tool(self, tool_create: ToolCreate) -> PydanticTool:
+    def create_or_update_tool(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
         """Create a new tool based on the ToolCreate schema."""
         # Derive json_schema
         derived_json_schema = tool_create.json_schema or derive_openai_json_schema(tool_create)
@@ -34,105 +34,72 @@ class ToolManager:
         try:
             # NOTE: We use the organization id here
             # This is important, because even if it's a different user, adding the same tool to the org should not happen
-            tool = self.get_tool_by_name_and_org_id(tool_name=derived_name, organization_id=tool_create.organization_id)
+            tool = self.get_tool_by_name(tool_name=derived_name, actor=actor)
             # Put to dict and remove fields that should not be reset
-            update_data = tool_create.model_dump(exclude={"user_id", "organization_id", "module", "terminal"}, exclude_unset=True)
+            update_data = tool_create.model_dump(exclude={"module", "terminal"}, exclude_unset=True)
             # Remove redundant update fields
             update_data = {key: value for key, value in update_data.items() if getattr(tool, key) != value}
 
             # If there's anything to update
             if update_data:
-                self.update_tool_by_id(tool.id, ToolUpdate(**update_data))
+                self.update_tool_by_id(tool.id, ToolUpdate(**update_data), actor)
             else:
                 warnings.warn(
-                    f"`create_or_update_tool` was called with user_id={tool_create.user_id}, organization_id={tool_create.organization_id}, name={tool_create.name}, but found existing tool with nothing to update."
+                    f"`create_or_update_tool` was called with user_id={actor.id}, organization_id={actor.organization_id}, name={tool_create.name}, but found existing tool with nothing to update."
                 )
         except NoResultFound:
             tool_create.json_schema = derived_json_schema
             tool_create.name = derived_name
-            tool = self.create_tool(tool_create)
+            tool = self.create_tool(tool_create, actor=actor)
 
         return tool
 
     @enforce_types
-    def create_tool(self, tool_create: ToolCreate) -> PydanticTool:
+    def create_tool(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
         """Create a new tool based on the ToolCreate schema."""
         # Create the tool
         with self.session_maker() as session:
-            # Include all fields except 'terminal' (which is not part of ToolModel) at the moment
+            # Include all fields except `terminal` (which is not part of ToolModel) at the moment
             create_data = tool_create.model_dump(exclude={"terminal"})
-            tool = ToolModel(**create_data)  # Unpack everything directly into ToolModel
-            tool.create(session)
+            tool = ToolModel(**create_data, organization_id=actor.organization_id)  # Unpack everything directly into ToolModel
+            tool.create(session, actor=actor)
 
         return tool.to_pydantic()
 
     @enforce_types
-    def get_tool_by_id(self, tool_id: str) -> PydanticTool:
+    def get_tool_by_id(self, tool_id: str, actor: PydanticUser) -> PydanticTool:
         """Fetch a tool by its ID."""
         with self.session_maker() as session:
-            try:
-                # Retrieve tool by id using the Tool model's read method
-                tool = ToolModel.read(db_session=session, identifier=tool_id)
-                # Convert the SQLAlchemy Tool object to PydanticTool
-                return tool.to_pydantic()
-            except NoResultFound:
-                raise ValueError(f"Tool with id {tool_id} not found.")
-
-    @enforce_types
-    def get_tool_by_name_and_user_id(self, tool_name: str, user_id: str) -> PydanticTool:
-        """Retrieve a tool by its name and organization_id."""
-        with self.session_maker() as session:
-            # Use the list method to apply filters
-            results = ToolModel.list(db_session=session, name=tool_name, _user_id=UserModel.get_uid_from_identifier(user_id))
-
-            # Ensure only one result is returned (since there is a unique constraint)
-            if not results:
-                raise NoResultFound(f"Tool with name {tool_name} and user_id {user_id} not found.")
-
-            if len(results) > 1:
-                raise RuntimeError(
-                    f"Multiple tools with name {tool_name} and user_id {user_id} were found. This is a serious error, and means that our table does not have uniqueness constraints properly set up. Please reach out to the letta development team if you see this error."
-                )
-
-            # Return the single result
-            return results[0]
+            # Retrieve tool by id using the Tool model's read method
+            tool = ToolModel.read(db_session=session, identifier=tool_id, actor=actor)
+            # Convert the SQLAlchemy Tool object to PydanticTool
+            return tool.to_pydantic()
 
     @enforce_types
-    def get_tool_by_name_and_org_id(self, tool_name: str, organization_id: str) -> PydanticTool:
-        """Retrieve a tool by its name and organization_id."""
+    def get_tool_by_name(self, tool_name: str, actor: PydanticUser):
+        """Retrieve a tool by its name and a user. We derive the organization from the user, and retrieve that tool."""
         with self.session_maker() as session:
-            # Use the list method to apply filters
-            results = ToolModel.list(
-                db_session=session, name=tool_name, _organization_id=OrganizationModel.get_uid_from_identifier(organization_id)
-            )
-
-            # Ensure only one result is returned (since there is a unique constraint)
-            if not results:
-                raise NoResultFound(f"Tool with name {tool_name} and organization_id {organization_id} not found.")
-
-            if len(results) > 1:
-                raise RuntimeError(
-                    f"Multiple tools with name {tool_name} and organization_id {organization_id} were found. This is a serious error, and means that our table does not have uniqueness constraints properly set up. Please reach out to the letta development team if you see this error."
-                )
-
-            # Return the single result
-            return results[0]
+            tool = ToolModel.read(db_session=session, name=tool_name, actor=actor)
+            return tool.to_pydantic()
 
     @enforce_types
-    def list_tools_for_org(self, organization_id: str, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[PydanticTool]:
+    def list_tools(self, actor: PydanticUser, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[PydanticTool]:
         """List all tools with optional pagination using cursor and limit."""
         with self.session_maker() as session:
             tools = ToolModel.list(
-                db_session=session, cursor=cursor, limit=limit, _organization_id=OrganizationModel.get_uid_from_identifier(organization_id)
+                db_session=session,
+                cursor=cursor,
+                limit=limit,
+                _organization_id=OrganizationModel.get_uid_from_identifier(actor.organization_id),
             )
             return [tool.to_pydantic() for tool in tools]
 
     @enforce_types
-    def update_tool_by_id(self, tool_id: str, tool_update: ToolUpdate) -> None:
+    def update_tool_by_id(self, tool_id: str, tool_update: ToolUpdate, actor: PydanticUser) -> None:
         """Update a tool by its ID with the given ToolUpdate object."""
         with self.session_maker() as session:
             # Fetch the tool by ID
-            tool = ToolModel.read(db_session=session, identifier=tool_id)
+            tool = ToolModel.read(db_session=session, identifier=tool_id, actor=actor)
 
             # Update tool attributes with only the fields that were explicitly set
             update_data = tool_update.model_dump(exclude_unset=True, exclude_none=True)
@@ -140,20 +107,20 @@ class ToolManager:
                 setattr(tool, key, value)
 
             # Save the updated tool to the database
-            tool.update(db_session=session)
+            tool.update(db_session=session, actor=actor)
 
     @enforce_types
-    def delete_tool_by_id(self, tool_id: str) -> None:
+    def delete_tool_by_id(self, tool_id: str, actor: PydanticUser) -> None:
         """Delete a tool by its ID."""
         with self.session_maker() as session:
             try:
                 tool = ToolModel.read(db_session=session, identifier=tool_id)
-                tool.delete(db_session=session)
+                tool.delete(db_session=session, actor=actor)
             except NoResultFound:
                 raise ValueError(f"Tool with id {tool_id} not found.")
 
     @enforce_types
-    def add_default_tools(self, user_id: str, org_id: str, module_name="base"):
+    def add_default_tools(self, actor: PydanticUser, module_name="base"):
         """Add default tools in {module_name}.py"""
         full_module_name = f"letta.functions.function_sets.{module_name}"
         try:
@@ -187,7 +154,6 @@ class ToolManager:
                     module=schema["module"],
                     source_code=source_code,
                     json_schema=schema["json_schema"],
-                    organization_id=org_id,
-                    user_id=user_id,
                 ),
+                actor=actor,
             )

letta/services/user_manager.py

@@ -85,11 +85,8 @@ class UserManager:
     def get_user_by_id(self, user_id: str) -> PydanticUser:
         """Fetch a user by ID."""
         with self.session_maker() as session:
-            try:
-                user = UserModel.read(db_session=session, identifier=user_id)
-                return user.to_pydantic()
-            except NoResultFound:
-                raise ValueError(f"User with id {user_id} not found.")
+            user = UserModel.read(db_session=session, identifier=user_id)
+            return user.to_pydantic()
 
     @enforce_types
     def get_default_user(self) -> PydanticUser:

{letta_nightly-0.5.1.dev20241028104150.dist-info → letta_nightly-0.5.1.dev20241029104141.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.5.1.dev20241028104150
+Version: 0.5.1.dev20241029104141
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.5.1.dev20241028104150.dist-info → letta_nightly-0.5.1.dev20241029104141.dist-info}/RECORD

@@ -9,11 +9,11 @@ letta/agent_store/qdrant.py,sha256=6_33V-FEDpT9LG5zmr6-3y9slw1YFLswxpahiyMkvHA,7
 letta/agent_store/storage.py,sha256=4gKvMRYBGm9cwyaDOzljxDKgqr4MxGXcC4yGhAdKcAA,6693
 letta/benchmark/benchmark.py,sha256=ebvnwfp3yezaXOQyGXkYCDYpsmre-b9hvNtnyx4xkG0,3701
 letta/benchmark/constants.py,sha256=aXc5gdpMGJT327VuxsT5FngbCK2J41PQYeICBO7g_RE,536
-letta/cli/cli.py,sha256=145g2WAApbeEfOjVgxBzuv6BbbDr-cZSfT_ekfj945I,16162
+letta/cli/cli.py,sha256=i6wFBaX8-WwZ6nl_T0FFptfozlnYEBM7RcShwBl-qfw,16106
 letta/cli/cli_config.py,sha256=ynsezKawQ0l95rymlv-AJ3QjbqiyaXZyuzsDfBYwMwg,8537
 letta/cli/cli_load.py,sha256=x4L8s15GwIW13xrhKYFWHo_y-IVGtoPDHWWKcHDRP10,4587
 letta/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/client/client.py,sha256=lWd5Fv9UkkEn5oDPHjtbGhKNowwXA4sbhS3_OuCBStk,93707
+letta/client/client.py,sha256=3tZfSKez9uCCpcItjtUJ0CMpRwoTSA-CGvX7I4pNBG4,92340
 letta/client/streaming.py,sha256=bfWlUu7z7EoPfKxBqIarYxGKyrL7Pj79BlliToqcCgI,4592
 letta/client/utils.py,sha256=OJlAKWrldc4I6M1WpcTWNtPJ4wfxlzlZqWLfCozkFtI,2872
 letta/config.py,sha256=eK-ip06ELHNYriInkgfidDvJxQ2tD1u49I-VLXB87nE,18929
@@ -40,7 +40,7 @@ letta/llm_api/azure_openai_constants.py,sha256=oXtKrgBFHf744gyt5l1thILXgyi8NDNUr
 letta/llm_api/cohere.py,sha256=vDRd-SUGp1t_JUIdwC3RkIhwMl0OY7n-tAU9uPORYkY,14826
 letta/llm_api/google_ai.py,sha256=3xZ074nSOCC22c15yerA5ngWzh0ex4wxeI-6faNbHPE,17708
 letta/llm_api/helpers.py,sha256=sGCmNA1U_7-AhRFgvT668jdp_xyzSliKQYbTvRR6O7c,9812
-letta/llm_api/llm_api_tools.py,sha256=GEBO7Dlt7xtAQud1sVsigKZKPpLOZOt2IWL8LwcNV4o,14869
+letta/llm_api/llm_api_tools.py,sha256=RRczEZ3h_fxIJLXbw1UT5YZwdsr1gZD6HRPVA9qopmE,14787
 letta/llm_api/mistral.py,sha256=fHdfD9ug-rQIk2qn8tRKay1U6w9maF11ryhKi91FfXM,1593
 letta/llm_api/openai.py,sha256=0hwAZhpjrmubYy549hvjzhw6zK_aBhSVuIQN0OsTq-w,23705
 letta/local_llm/README.md,sha256=hFJyw5B0TU2jrh9nb0zGZMgdH-Ei1dSRfhvPQG_NSoU,168
@@ -89,14 +89,14 @@ letta/openai_backcompat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 letta/openai_backcompat/openai_object.py,sha256=Y1ZS1sATP60qxJiOsjOP3NbwSzuzvkNAvb3DeuhM5Uk,13490
 letta/orm/__all__.py,sha256=2gh2MZTkA3Hw67VWVKK3JIStJOqTeLdpCvYSVYNeEDA,692
 letta/orm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/orm/base.py,sha256=9k7mwKDApJNpbrk6oXosQ7amlpeYhDzArdYTZ6BhfpQ,2405
+letta/orm/base.py,sha256=uK56wXg4Hv5jGuBsThSgmlFdl0e2u4VGiTX4RiRqTK4,2671
 letta/orm/enums.py,sha256=KfHcFt_fR6GUmSlmfsa-TetvmuRxGESNve8MStRYW64,145
 letta/orm/errors.py,sha256=somsGtotFlb3SDM6tKdZ5TDGwEEP3ppx47ICAvNMnkg,225
 letta/orm/mixins.py,sha256=hZJFYnmSGklryuAOypvVhMgXyU7pgatGEun-p-2f_Fc,2457
 letta/orm/organization.py,sha256=ccE0ShFWqWPdtXiCRkZCSeIERbtwU-a7AF99N3S6IRM,1468
-letta/orm/sqlalchemy_base.py,sha256=w3x8ShZhjQY59XjDj2nWiELSi7rJDLzTAnGUBKA1_c0,8880
-letta/orm/tool.py,sha256=EB8d9Q1n-ktM6hJ0PP7xK7bL-ankrYTS_vdFfTfS7hY,2541
-letta/orm/user.py,sha256=kaiqduMhHYcTLPWyzWyNTysNJijkReIhVtgIJ3qPfSY,1286
+letta/orm/sqlalchemy_base.py,sha256=LuV-or0T8kdg2M0H7Y8KEIcaeKD1DkARzA-LgAGR4qU,7721
+letta/orm/tool.py,sha256=mVOgN2TdszQ5SM6cHqY9Rl6405ccB7mXrq_DHisA1WU,2179
+letta/orm/user.py,sha256=69FU1rSXhlRJMaAUPYebxgFPn8UCQRU8TYUkjXLrALQ,1136
 letta/persistence_manager.py,sha256=LlLgEDpSafCPAiyKmuq0NvVAnfBkZo6TWbGIKYQjQBs,5200
 letta/personas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/personas/examples/anna_pa.txt,sha256=zgiNdSNhy1HQy58cF_6RFPzcg2i37F9v38YuL1CW40A,1849
@@ -120,7 +120,7 @@ letta/prompts/system/memgpt_gpt35_extralong.txt,sha256=FheNhYoIzNz6qnJKhVquZVSMj
 letta/prompts/system/memgpt_intuitive_knowledge.txt,sha256=sA7c3urYqREVnSBI81nTGImXAekqC0Fxc7RojFqud1g,2966
 letta/prompts/system/memgpt_modified_chat.txt,sha256=HOaPVurEftD8KsuwsclDgE2afIfklMjxhuSO96q1-6I,4656
 letta/prompts/system/memgpt_modified_o1.txt,sha256=AxxYVjYLZwpZ6yfifh1SuPtwlJGWTcTVzw53QbkN-Ao,5492
-letta/providers.py,sha256=tGnji2OlZSo5fgRaLiFaopqiyhKGOt5akngSjjM5RSI,19637
+letta/providers.py,sha256=nWvTvVsZH1EE2aHAwihJvCIDJpgfeWAOUE_YK1x5Zj4,19635
 letta/pytest.ini,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/schemas/agent.py,sha256=e69lAKJQYtx92w8tM9sdLdv1hDqZ_0V_qiUiQyI-uks,7138
 letta/schemas/api_key.py,sha256=u07yzzMn-hBAHZIIKbWY16KsgiFjSNR8lAghpMUo3_4,682
@@ -145,7 +145,7 @@ letta/schemas/openai/openai.py,sha256=Hilo5BiLAGabzxCwnwfzK5QrWqwYD8epaEKFa4Pwnd
 letta/schemas/organization.py,sha256=0MOUbaiDGTXkzTjaALLI2wj4E1bL5V_0jjI6jEgFKlA,635
 letta/schemas/passage.py,sha256=eYQMxD_XjHAi72jmqcGBU4wM4VZtSU0XK8uhQxxN3Ug,3563
 letta/schemas/source.py,sha256=hB4Ai6Nj8dFdbxv5_Qaf4uN_cmdGmnzgc-4QnHXcV3o,2562
-letta/schemas/tool.py,sha256=shkyJ-qM5QtyrfG15yKFt8qujZfeW1wfzz6n9yVS4Y8,10259
+letta/schemas/tool.py,sha256=itC9jIwrCPeE-w70CbkaJ7l8ueA5C9Heq_bGNmKHUcc,9598
 letta/schemas/usage.py,sha256=lvn1ooHwLEdv6gwQpw5PBUbcwn_gwdT6HA-fCiix6sY,817
 letta/schemas/user.py,sha256=toiA53UKB1hpH6k2xHyQNKVeDUoSB3RmLfxSwmKPAz4,1523
 letta/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -169,19 +169,19 @@ letta/server/rest_api/routers/openai/assistants/threads.py,sha256=WXVGBaBvSNPB7Z
 letta/server/rest_api/routers/openai/chat_completions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/chat_completions/chat_completions.py,sha256=-uye6cm4SnoQGwxhr1N1FrSXOlnO2Hvbfj6k8JSc45k,4918
 letta/server/rest_api/routers/v1/__init__.py,sha256=sqlVZa-u9DJwdRsp0_8YUGrac9DHguIB4wETlEDRylA,666
-letta/server/rest_api/routers/v1/agents.py,sha256=BY4rQOcwsi_WiWh6DwrO8Vz6Nu2JgMBKSHxiBqlaaYY,25397
+letta/server/rest_api/routers/v1/agents.py,sha256=EoUWyhiWYYxhtwZUg9agyDeCpixLqzsP9YXIk_zX7MM,25355
 letta/server/rest_api/routers/v1/blocks.py,sha256=0WekE_yBD2U3jYgPxI0DCFjACWavCAlvm_Ybw5SZBnw,2583
 letta/server/rest_api/routers/v1/health.py,sha256=pKCuVESlVOhGIb4VC4K-H82eZqfghmT6kvj2iOkkKuc,401
 letta/server/rest_api/routers/v1/jobs.py,sha256=a-j0v-5A0un0pVCOHpfeWnzpOWkVDQO6ti42k_qAlZY,2272
 letta/server/rest_api/routers/v1/llms.py,sha256=TcyvSx6MEM3je5F4DysL7ligmssL_pFlJaaO4uL95VY,877
 letta/server/rest_api/routers/v1/organizations.py,sha256=3XlHPUc6ZdMOVZNdarwDM8ZxYisoHunSZQ0ozzX5orU,2037
 letta/server/rest_api/routers/v1/sources.py,sha256=eY_pk9jRL2Y9yIZdsTjH6EuKsfH1neaTU15MKNL0dvw,8749
-letta/server/rest_api/routers/v1/tools.py,sha256=38raONlEbflpspGenk_m8kVdE9p0Ev0SMBvAy_D25Xo,3692
+letta/server/rest_api/routers/v1/tools.py,sha256=aVZcVxL68Oq8N6p3p_MsGrNxmnK3-UWAIHdVztFw_Nk,3794
 letta/server/rest_api/routers/v1/users.py,sha256=bxQ-YdevjDqmgNDfbSPAG_4KEVvPNBHD_-Lp1MdeMec,3374
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/utils.py,sha256=Fc2ZGKzLaBa2sEtSTVjJ8D5M0xIwsWC0CVAOIJaD3rY,2176
-letta/server/server.py,sha256=IqVfEU4qYybWbUTrhRwcNmSwtL8nh4Qu-I3-f9c4bl4,79467
-letta/server/startup.sh,sha256=jeGV7B_PS0hS-tT6o6GpACrUbV9WV1NI2L9aLoUDDtc,311
+letta/server/server.py,sha256=HeIucHAaf6CpV0izHTnrMfQwDX-Lbs7j9DHYogZpLAc,80255
+letta/server/startup.sh,sha256=o2dY9wc5Ew1j_10U6dK2FYevAj79udZ-T969j5rG-a0,311
 letta/server/static_files/assets/index-3ab03d5b.css,sha256=OrA9W4iKJ5h2Wlr7GwdAT4wow0CM8hVit1yOxEL49Qw,54295
 letta/server/static_files/assets/index-d6b3669a.js,sha256=i1nHReU0RPnj-a5W0nNPV4Y9bQ0FOW0ztjMz8a2AE-Y,1821560
 letta/server/static_files/favicon.ico,sha256=DezhLdFSbM8o81wCOZcV3riq7tFUOGQD4h6-vr-HuU0,342
@@ -195,15 +195,15 @@ letta/server/ws_api/protocol.py,sha256=M_-gM5iuDBwa1cuN2IGNCG5GxMJwU2d3XW93XALv9
 letta/server/ws_api/server.py,sha256=C2Kv48PCwl46DQFb0ZP30s86KJLQ6dZk2AhWQEZn9pY,6004
 letta/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/organization_manager.py,sha256=wW4wOmKaqhHC7oTGWU38OO-dFtmRI0JVmq_k8gI1b0A,3658
-letta/services/tool_manager.py,sha256=7elTmzk0vhceD8ezcywYfLvRaVEi0bxp7HFcw27CQzg,8877
-letta/services/user_manager.py,sha256=h6K06LnYIbzw7YoQia5WGmBNSXZg5AuHZTvS54aEmSI,4534
+letta/services/tool_manager.py,sha256=RAY7mNGuFoVfWfxe4mOmmPp53Ghm1Wy1UtLFuUwKPhA,7082
+letta/services/user_manager.py,sha256=5wjmnhLoxsc9FCKD0IPotfV24i_iCqmifOkhIBvshtc,4404
 letta/settings.py,sha256=yiYNmnYKj_BdTm0cBEIvQKYGU-lCmFntqsyVfRUy3_k,3411
 letta/streaming_interface.py,sha256=_FPUWy58j50evHcpXyd7zB1wWqeCc71NCFeWh_TBvnw,15736
 letta/streaming_utils.py,sha256=329fsvj1ZN0r0LpQtmMPZ2vSxkDBIUUwvGHZFkjm2I8,11745
 letta/system.py,sha256=buKYPqG5n2x41hVmWpu6JUpyd7vTWED9Km2_M7dLrvk,6960
 letta/utils.py,sha256=SXLEYhyp3gHyIjrxNIKNZZ5ittKo3KOj6zxgC_Trex0,31012
-letta_nightly-0.5.1.dev20241028104150.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.5.1.dev20241028104150.dist-info/METADATA,sha256=hHWbNCjBir7WYHKQCe19Ioek8Bu8GMcj_lSQswGMusk,10660
-letta_nightly-0.5.1.dev20241028104150.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.5.1.dev20241028104150.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.5.1.dev20241028104150.dist-info/RECORD,,
+letta_nightly-0.5.1.dev20241029104141.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.5.1.dev20241029104141.dist-info/METADATA,sha256=_xR7OpWIFvzC-jEsKBRLUsZ1cXbNOYvxH1ZlSB2U9EY,10660
+letta_nightly-0.5.1.dev20241029104141.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.5.1.dev20241029104141.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.5.1.dev20241029104141.dist-info/RECORD,,