letta-nightly 0.5.1.dev20241105104128__tar.gz → 0.5.1.dev20241106104104__tar.gz

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.5.1.dev20241105104128
+Version: 0.5.1.dev20241106104104
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -99,7 +99,7 @@ Description-Content-Type: text/markdown
 </h3>
 
 **👾 Letta** is an open source framework for building stateful LLM applications. You can use Letta to build **stateful agents** with advanced reasoning capabilities and transparent long-term memory. The Letta framework is white box and model-agnostic.
-  
+
 [![Discord](https://img.shields.io/discord/1161736243340640419?label=Discord&logo=discord&logoColor=5865F2&style=flat-square&color=5865F2)](https://discord.gg/letta)
 [![Twitter Follow](https://img.shields.io/badge/Follow-%40Letta__AI-1DA1F2?style=flat-square&logo=x&logoColor=white)](https://twitter.com/Letta_AI)
 [![arxiv 2310.08560](https://img.shields.io/badge/Research-2310.08560-B31B1B?logo=arxiv&style=flat-square)](https://arxiv.org/abs/2310.08560)

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/README.md

@@ -16,7 +16,7 @@
 </h3>
 
 **👾 Letta** is an open source framework for building stateful LLM applications. You can use Letta to build **stateful agents** with advanced reasoning capabilities and transparent long-term memory. The Letta framework is white box and model-agnostic.
-  
+
 [![Discord](https://img.shields.io/discord/1161736243340640419?label=Discord&logo=discord&logoColor=5865F2&style=flat-square&color=5865F2)](https://discord.gg/letta)
 [![Twitter Follow](https://img.shields.io/badge/Follow-%40Letta__AI-1DA1F2?style=flat-square&logo=x&logoColor=white)](https://twitter.com/Letta_AI)
 [![arxiv 2310.08560](https://img.shields.io/badge/Research-2310.08560-B31B1B?logo=arxiv&style=flat-square)](https://arxiv.org/abs/2310.08560)

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/agent.py

@@ -3,6 +3,7 @@ import inspect
 import traceback
 import warnings
 from abc import ABC, abstractmethod
+from lib2to3.fixer_util import is_list
 from typing import List, Literal, Optional, Tuple, Union
 
 from tqdm import tqdm
@@ -250,6 +251,9 @@ class Agent(BaseAgent):
             # if there are tool rules, print out a warning
             warnings.warn("Tool rules only work reliably for the latest OpenAI models that support structured outputs.")
         # add default rule for having send_message be a terminal tool
+
+        if not is_list(agent_state.tool_rules):
+            agent_state.tool_rules = []
         agent_state.tool_rules.append(TerminalToolRule(tool_name="send_message"))
         self.tool_rules_solver = ToolRulesSolver(tool_rules=agent_state.tool_rules)
 

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/agent_store/db.py

@@ -358,26 +358,26 @@ class PostgresStorageConnector(SQLStorageConnector):
         # construct URI from enviornment variables
         if settings.pg_uri:
             self.uri = settings.pg_uri
+
+        # use config URI
+        # TODO: remove this eventually (config should NOT contain URI)
+        if table_type == TableType.ARCHIVAL_MEMORY or table_type == TableType.PASSAGES:
+            self.uri = self.config.archival_storage_uri
+            self.db_model = PassageModel
+            if self.config.archival_storage_uri is None:
+                raise ValueError(f"Must specify archival_storage_uri in config {self.config.config_path}")
+        elif table_type == TableType.RECALL_MEMORY:
+            self.uri = self.config.recall_storage_uri
+            self.db_model = MessageModel
+            if self.config.recall_storage_uri is None:
+                raise ValueError(f"Must specify recall_storage_uri in config {self.config.config_path}")
+        elif table_type == TableType.FILES:
+            self.uri = self.config.metadata_storage_uri
+            self.db_model = FileMetadataModel
+            if self.config.metadata_storage_uri is None:
+                raise ValueError(f"Must specify metadata_storage_uri in config {self.config.config_path}")
         else:
-            # use config URI
-            # TODO: remove this eventually (config should NOT contain URI)
-            if table_type == TableType.ARCHIVAL_MEMORY or table_type == TableType.PASSAGES:
-                self.uri = self.config.archival_storage_uri
-                self.db_model = PassageModel
-                if self.config.archival_storage_uri is None:
-                    raise ValueError(f"Must specify archival_storage_uri in config {self.config.config_path}")
-            elif table_type == TableType.RECALL_MEMORY:
-                self.uri = self.config.recall_storage_uri
-                self.db_model = MessageModel
-                if self.config.recall_storage_uri is None:
-                    raise ValueError(f"Must specify recall_storage_uri in config {self.config.config_path}")
-            elif table_type == TableType.FILES:
-                self.uri = self.config.metadata_storage_uri
-                self.db_model = FileMetadataModel
-                if self.config.metadata_storage_uri is None:
-                    raise ValueError(f"Must specify metadata_storage_uri in config {self.config.config_path}")
-            else:
-                raise ValueError(f"Table type {table_type} not implemented")
+            raise ValueError(f"Table type {table_type} not implemented")
 
         for c in self.db_model.__table__.columns:
             if c.name == "embedding":

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/client/client.py

@@ -612,7 +612,12 @@ class RESTClient(AbstractClient):
             agent_id (str): ID of the agent
         """
         # TODO: implement this
-        raise NotImplementedError
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents", headers=self.headers, params={"name": agent_name})
+        agents = [AgentState(**agent) for agent in response.json()]
+        if len(agents) == 0:
+            return None
+        assert len(agents) == 1, f"Multiple agents with the same name: {agents}"
+        return agents[0].id
 
     # memory
     def get_in_context_memory(self, agent_id: str) -> Memory:
@@ -2267,18 +2272,18 @@ class LocalClient(AbstractClient):
             langchain_tool=langchain_tool,
             additional_imports_module_attr_map=additional_imports_module_attr_map,
         )
-        return self.server.tool_manager.create_or_update_tool(tool_create, actor=self.user)
+        return self.server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), 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,
         )
-        return self.server.tool_manager.create_or_update_tool(tool_create, actor=self.user)
+        return self.server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=self.user)
 
     def load_composio_tool(self, action: "ActionType") -> Tool:
         tool_create = ToolCreate.from_composio(action=action)
-        return self.server.tool_manager.create_or_update_tool(tool_create, actor=self.user)
+        return self.server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=self.user)
 
     # TODO: Use the above function `add_tool` here as there is duplicate logic
     def create_tool(
@@ -2310,7 +2315,7 @@ class LocalClient(AbstractClient):
 
         # call server function
         return self.server.tool_manager.create_or_update_tool(
-            ToolCreate(
+            Tool(
                 source_type=source_type,
                 source_code=source_code,
                 name=name,
@@ -2738,7 +2743,7 @@ class LocalClient(AbstractClient):
         return self.server.list_embedding_models()
 
     def create_org(self, name: Optional[str] = None) -> Organization:
-        return self.server.organization_manager.create_organization(name=name)
+        return self.server.organization_manager.create_organization(pydantic_org=Organization(name=name))
 
     def list_orgs(self, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[Organization]:
         return self.server.organization_manager.list_organizations(cursor=cursor, limit=limit)

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/orm/base.py

@@ -67,7 +67,7 @@ class CommonSqlalchemyMetaMixins(Base):
         prop_value = getattr(self, full_prop, None)
         if not prop_value:
             return
-        return f"user-{prop_value}"
+        return prop_value
 
     def _user_id_setter(self, prop: str, value: str) -> None:
         """returns the user id for the specified property"""
@@ -75,6 +75,9 @@ class CommonSqlalchemyMetaMixins(Base):
         if not value:
             setattr(self, full_prop, None)
             return
+        # Safety check
         prefix, id_ = value.split("-", 1)
         assert prefix == "user", f"{prefix} is not a valid id prefix for a user id"
-        setattr(self, full_prop, id_)
+
+        # Set the full value
+        setattr(self, full_prop, value)

letta_nightly-0.5.1.dev20241106104104/letta/orm/mixins.py

@@ -0,0 +1,31 @@
+from uuid import UUID
+
+from sqlalchemy import ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from letta.orm.base import Base
+
+
+def is_valid_uuid4(uuid_string: str) -> bool:
+    """Check if a string is a valid UUID4."""
+    try:
+        uuid_obj = UUID(uuid_string)
+        return uuid_obj.version == 4
+    except ValueError:
+        return False
+
+
+class OrganizationMixin(Base):
+    """Mixin for models that belong to an organization."""
+
+    __abstract__ = True
+
+    organization_id: Mapped[str] = mapped_column(String, ForeignKey("organizations.id"))
+
+
+class UserMixin(Base):
+    """Mixin for models that belong to a user."""
+
+    __abstract__ = True
+
+    user_id: Mapped[str] = mapped_column(String, ForeignKey("users.id"))

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/orm/organization.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, List
 
+from sqlalchemy import String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.sqlalchemy_base import SqlalchemyBase
@@ -14,9 +15,10 @@ if TYPE_CHECKING:
 class Organization(SqlalchemyBase):
     """The highest level of the object tree. All Entities belong to one and only one Organization."""
 
-    __tablename__ = "organization"
+    __tablename__ = "organizations"
     __pydantic_model__ = PydanticOrganization
 
+    id: Mapped[str] = mapped_column(String, primary_key=True)
     name: Mapped[str] = mapped_column(doc="The display name of the organization.")
 
     users: Mapped[List["User"]] = relationship("User", back_populates="organization", cascade="all, delete-orphan")

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/orm/sqlalchemy_base.py

@@ -1,14 +1,11 @@
 from typing import TYPE_CHECKING, List, Literal, Optional, Type
-from uuid import uuid4
 
-from humps import depascalize
-from sqlalchemy import Boolean, String, select
+from sqlalchemy import String, select
 from sqlalchemy.orm import Mapped, mapped_column
 
 from letta.log import get_logger
 from letta.orm.base import Base, CommonSqlalchemyMetaMixins
 from letta.orm.errors import NoResultFound
-from letta.orm.mixins import is_valid_uuid4
 
 if TYPE_CHECKING:
     from pydantic import BaseModel
@@ -24,27 +21,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
     __order_by_default__ = "created_at"
 
-    _id: Mapped[str] = mapped_column(String, primary_key=True, default=lambda: f"{uuid4()}")
-
-    deleted: Mapped[bool] = mapped_column(Boolean, default=False, doc="Is this record deleted? Used for universal soft deletes.")
-
-    @classmethod
-    def __prefix__(cls) -> str:
-        return depascalize(cls.__name__)
-
-    @property
-    def id(self) -> Optional[str]:
-        if self._id:
-            return f"{self.__prefix__()}-{self._id}"
-
-    @id.setter
-    def id(self, value: str) -> None:
-        if not value:
-            return
-        prefix, id_ = value.split("-", 1)
-        assert prefix == self.__prefix__(), f"{prefix} is not a valid id prefix for {self.__class__.__name__}"
-        assert is_valid_uuid4(id_), f"{id_} is not a valid uuid4"
-        self._id = id_
+    id: Mapped[str] = mapped_column(String, primary_key=True)
 
     @classmethod
     def list(
@@ -57,11 +34,10 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
             # Add a cursor condition if provided
             if cursor:
-                cursor_uuid = cls.get_uid_from_identifier(cursor)  # Assuming the cursor is an _id value
-                query = query.where(cls._id > cursor_uuid)
+                query = query.where(cls.id > cursor)
 
             # Add a limit to the query if provided
-            query = query.order_by(cls._id).limit(limit)
+            query = query.order_by(cls.id).limit(limit)
 
             # Handle soft deletes if the class has the 'is_deleted' attribute
             if hasattr(cls, "is_deleted"):
@@ -70,20 +46,6 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             # Execute the query and return the results as a list of model instances
             return list(session.execute(query).scalars())
 
-    @classmethod
-    def get_uid_from_identifier(cls, identifier: str, indifferent: Optional[bool] = False) -> str:
-        """converts the id into a uuid object
-        Args:
-            identifier: the string identifier, such as `organization-xxxx-xx...`
-            indifferent: if True, will not enforce the prefix check
-        """
-        try:
-            uuid_string = identifier.split("-", 1)[1] if indifferent else identifier.replace(f"{cls.__prefix__()}-", "")
-            assert is_valid_uuid4(uuid_string)
-            return uuid_string
-        except ValueError as e:
-            raise ValueError(f"{identifier} is not a valid identifier for class {cls.__name__}") from e
-
     @classmethod
     def read(
         cls,
@@ -112,8 +74,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
         # 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)
+            query = query.where(cls.id == identifier)
             query_conditions.append(f"id='{identifier}'")
 
         if kwargs:
@@ -183,7 +144,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         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)
+        return query.where(cls.organization_id == org_id, cls.is_deleted == False)
 
     @property
     def __pydantic_model__(self) -> Type["BaseModel"]:

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/orm/tool.py

@@ -21,13 +21,14 @@ class Tool(SqlalchemyBase, OrganizationMixin):
     more granular permissions.
     """
 
-    __tablename__ = "tool"
+    __tablename__ = "tools"
     __pydantic_model__ = PydanticTool
 
     # 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"),)
+    __table_args__ = (UniqueConstraint("name", "organization_id", name="uix_name_organization"),)
 
+    id: Mapped[str] = mapped_column(String, primary_key=True)
     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.")
     tags: Mapped[List] = mapped_column(JSON, doc="Metadata tags used to filter tools.")

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/orm/user.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING
 
+from sqlalchemy import String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.mixins import OrganizationMixin
@@ -13,9 +14,10 @@ if TYPE_CHECKING:
 class User(SqlalchemyBase, OrganizationMixin):
     """User ORM class"""
 
-    __tablename__ = "user"
+    __tablename__ = "users"
     __pydantic_model__ = PydanticUser
 
+    id: Mapped[str] = mapped_column(String, primary_key=True)
     name: Mapped[str] = mapped_column(nullable=False, doc="The display name of the user.")
 
     # relationships

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/schemas/memory.py

@@ -106,6 +106,10 @@ class Memory(BaseModel, validate_assignment=True):
             # New format
             obj.prompt_template = state["prompt_template"]
             for key, value in state["memory"].items():
+                # TODO: This is migration code, please take a look at a later time to get rid of this
+                if "name" in value:
+                    value["template_name"] = value["name"]
+                    value.pop("name")
                 obj.memory[key] = Block(**value)
         else:
             # Old format (pre-template)

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/schemas/organization.py

@@ -4,16 +4,16 @@ from typing import Optional
 from pydantic import Field
 
 from letta.schemas.letta_base import LettaBase
-from letta.utils import get_utc_time
+from letta.utils import create_random_username, get_utc_time
 
 
 class OrganizationBase(LettaBase):
-    __id_prefix__ = "organization"
+    __id_prefix__ = "org"
 
 
 class Organization(OrganizationBase):
-    id: str = Field(..., description="The id of the organization.")
-    name: str = Field(..., description="The name of the organization.")
+    id: str = OrganizationBase.generate_id_field()
+    name: str = Field(create_random_username(), description="The name of the organization.")
     created_at: Optional[datetime] = Field(default_factory=get_utc_time, description="The creation date of the organization.")
 
 

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/schemas/tool.py

@@ -33,21 +33,21 @@ class Tool(BaseTool):
 
     """
 
-    id: str = Field(..., description="The id of the tool.")
+    id: str = BaseTool.generate_id_field()
     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.")
-    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.")
+    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the tool.")
+    name: Optional[str] = Field(None, description="The name of the function.")
+    tags: List[str] = Field([], description="Metadata tags.")
 
     # code
     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.")
+    json_schema: Optional[Dict] = Field(None, 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.")
+    created_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
+    last_updated_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
 
     def to_dict(self):
         """

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/schemas/user.py

@@ -21,7 +21,7 @@ class User(UserBase):
         created_at (datetime): The creation date of the user.
     """
 
-    id: str = Field(..., description="The id of the user.")
+    id: str = UserBase.generate_id_field()
     organization_id: Optional[str] = Field(OrganizationManager.DEFAULT_ORG_ID, description="The organization id of the user")
     name: str = Field(..., description="The name of the user.")
     created_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="The creation date of the user.")

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/server/rest_api/routers/v1/agents.py

@@ -40,6 +40,7 @@ router = APIRouter(prefix="/agents", tags=["agents"])
 
 @router.get("/", response_model=List[AgentState], operation_id="list_agents")
 def list_agents(
+    name: Optional[str] = Query(None, description="Name of the agent"),
     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
 ):
@@ -49,7 +50,11 @@ def list_agents(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    return server.list_agents(user_id=actor.id)
+    agents = server.list_agents(user_id=actor.id)
+    # TODO: move this logic to the ORM
+    if name:
+        agents = [a for a in agents if a.name == name]
+    return agents
 
 
 @router.get("/{agent_id}/context", response_model=ContextWindowOverview, operation_id="get_agent_context_window")

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/server/rest_api/routers/v1/organizations.py

@@ -38,7 +38,8 @@ def create_org(
     """
     Create a new org in the database
     """
-    org = server.organization_manager.create_organization(name=request.name)
+    org = Organization(**request.model_dump())
+    org = server.organization_manager.create_organization(pydantic_org=org)
     return org
 
 

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/server/rest_api/routers/v1/tools.py

@@ -89,7 +89,8 @@ def create_tool(
     actor = server.get_user_or_default(user_id=user_id)
 
     # Send request to create the tool
-    return server.tool_manager.create_or_update_tool(tool_create=request, actor=actor)
+    tool = Tool(**request.model_dump())
+    return server.tool_manager.create_or_update_tool(pydantic_tool=tool, actor=actor)
 
 
 @router.patch("/{tool_id}", response_model=Tool, operation_id="update_tool")

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/server/rest_api/routers/v1/users.py

@@ -51,8 +51,8 @@ def create_user(
     """
     Create a new user in the database
     """
-
-    user = server.user_manager.create_user(request)
+    user = User(**request.model_dump())
+    user = server.user_manager.create_user(user)
     return user
 
 

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/server/server.py

@@ -824,7 +824,7 @@ class SyncServer(Server):
                 source_type = "python"
                 tags = ["memory", "memgpt-base"]
                 tool = self.tool_manager.create_or_update_tool(
-                    ToolCreate(
+                    Tool(
                         source_code=source_code,
                         source_type=source_type,
                         tags=tags,
@@ -1766,7 +1766,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, actor=actor)
+                self.tool_manager.create_or_update_tool(Tool(**tool_create.model_dump()), actor=actor)
             except Exception as e:
                 warnings.warn(f"An error occurred while creating tool {tool_create}: {e}")
                 warnings.warn(traceback.format_exc())

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/services/organization_manager.py

@@ -3,13 +3,13 @@ from typing import List, Optional
 from letta.orm.errors import NoResultFound
 from letta.orm.organization import Organization as OrganizationModel
 from letta.schemas.organization import Organization as PydanticOrganization
-from letta.utils import create_random_username, enforce_types
+from letta.utils import enforce_types
 
 
 class OrganizationManager:
     """Manager class to handle business logic related to Organizations."""
 
-    DEFAULT_ORG_ID = "organization-00000000-0000-4000-8000-000000000000"
+    DEFAULT_ORG_ID = "org-00000000-0000-4000-8000-000000000000"
     DEFAULT_ORG_NAME = "default_org"
 
     def __init__(self):
@@ -37,10 +37,10 @@ class OrganizationManager:
                 raise ValueError(f"Organization with id {org_id} not found.")
 
     @enforce_types
-    def create_organization(self, name: Optional[str] = None) -> PydanticOrganization:
+    def create_organization(self, pydantic_org: PydanticOrganization) -> PydanticOrganization:
         """Create a new organization. If a name is provided, it is used, otherwise, a random one is generated."""
         with self.session_maker() as session:
-            org = OrganizationModel(name=name if name else create_random_username())
+            org = OrganizationModel(**pydantic_org.model_dump())
             org.create(session)
             return org.to_pydantic()
 

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/services/tool_manager.py

@@ -7,10 +7,9 @@ from letta.functions.functions import derive_openai_json_schema, load_function_s
 
 # TODO: Remove this once we translate all of these to the ORM
 from letta.orm.errors import NoResultFound
-from letta.orm.organization import Organization as OrganizationModel
 from letta.orm.tool import Tool as ToolModel
 from letta.schemas.tool import Tool as PydanticTool
-from letta.schemas.tool import ToolCreate, ToolUpdate
+from letta.schemas.tool import ToolUpdate
 from letta.schemas.user import User as PydanticUser
 from letta.utils import enforce_types, printd
 
@@ -33,20 +32,20 @@ class ToolManager:
         self.session_maker = db_context
 
     @enforce_types
-    def create_or_update_tool(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
+    def create_or_update_tool(self, pydantic_tool: PydanticTool, 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(
-            source_code=tool_create.source_code, name=tool_create.name
+        derived_json_schema = pydantic_tool.json_schema or derive_openai_json_schema(
+            source_code=pydantic_tool.source_code, name=pydantic_tool.name
         )
-        derived_name = tool_create.name or derived_json_schema["name"]
+        derived_name = pydantic_tool.name or derived_json_schema["name"]
 
         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(tool_name=derived_name, actor=actor)
             # Put to dict and remove fields that should not be reset
-            update_data = tool_create.model_dump(exclude={"module"}, exclude_unset=True)
+            update_data = pydantic_tool.model_dump(exclude={"module"}, exclude_unset=True, exclude_none=True)
             # Remove redundant update fields
             update_data = {key: value for key, value in update_data.items() if getattr(tool, key) != value}
 
@@ -55,22 +54,24 @@ class ToolManager:
                 self.update_tool_by_id(tool.id, ToolUpdate(**update_data), actor)
             else:
                 printd(
-                    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."
+                    f"`create_or_update_tool` was called with user_id={actor.id}, organization_id={actor.organization_id}, name={pydantic_tool.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, actor=actor)
+            pydantic_tool.json_schema = derived_json_schema
+            pydantic_tool.name = derived_name
+            tool = self.create_tool(pydantic_tool, actor=actor)
 
         return tool
 
     @enforce_types
-    def create_tool(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
+    def create_tool(self, pydantic_tool: PydanticTool, actor: PydanticUser) -> PydanticTool:
         """Create a new tool based on the ToolCreate schema."""
         # Create the tool
         with self.session_maker() as session:
-            create_data = tool_create.model_dump()
-            tool = ToolModel(**create_data, organization_id=actor.organization_id)  # Unpack everything directly into ToolModel
+            # Set the organization id at the ORM layer
+            pydantic_tool.organization_id = actor.organization_id
+            tool_data = pydantic_tool.model_dump()
+            tool = ToolModel(**tool_data)
             tool.create(session, actor=actor)
 
         return tool.to_pydantic()
@@ -99,7 +100,7 @@ class ToolManager:
                 db_session=session,
                 cursor=cursor,
                 limit=limit,
-                _organization_id=OrganizationModel.get_uid_from_identifier(actor.organization_id),
+                organization_id=actor.organization_id,
             )
             return [tool.to_pydantic() for tool in tools]
 
@@ -176,7 +177,7 @@ class ToolManager:
                 # create to tool
                 tools.append(
                     self.create_or_update_tool(
-                        ToolCreate(
+                        PydanticTool(
                             name=name,
                             tags=tags,
                             source_type="python",

{letta_nightly-0.5.1.dev20241105104128 → letta_nightly-0.5.1.dev20241106104104}/letta/services/user_manager.py

@@ -4,7 +4,7 @@ from letta.orm.errors import NoResultFound
 from letta.orm.organization import Organization as OrganizationModel
 from letta.orm.user import User as UserModel
 from letta.schemas.user import User as PydanticUser
-from letta.schemas.user import UserCreate, UserUpdate
+from letta.schemas.user import UserUpdate
 from letta.services.organization_manager import OrganizationManager
 from letta.utils import enforce_types
 
@@ -42,10 +42,10 @@ class UserManager:
             return user.to_pydantic()
 
     @enforce_types
-    def create_user(self, user_create: UserCreate) -> PydanticUser:
+    def create_user(self, pydantic_user: PydanticUser) -> PydanticUser:
         """Create a new user if it doesn't already exist."""
         with self.session_maker() as session:
-            new_user = UserModel(**user_create.model_dump())
+            new_user = UserModel(**pydantic_user.model_dump())
             new_user.create(session)
             return new_user.to_pydantic()