letta-nightly 0.5.1.dev20241104104148__py3-none-any.whl → 0.5.1.dev20241106104104__py3-none-any.whl

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/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/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/schemas/agent.py

@@ -1,4 +1,3 @@
-import uuid
 from datetime import datetime
 from enum import Enum
 from typing import Dict, List, Optional
@@ -105,7 +104,7 @@ class AgentState(BaseAgent, validate_assignment=True):
 class CreateAgent(BaseAgent):
     # all optional as server can generate defaults
     name: Optional[str] = Field(None, description="The name of the agent.")
-    message_ids: Optional[List[uuid.UUID]] = Field(None, description="The ids of the messages in the agent's in-context memory.")
+    message_ids: Optional[List[str]] = Field(None, description="The ids of the messages in the agent's in-context memory.")
     memory: Optional[Memory] = Field(None, description="The in-context memory of the agent.")
     tools: Optional[List[str]] = Field(None, description="The tools used by the agent.")
     tool_rules: Optional[List[BaseToolRule]] = Field(None, description="The tool rules governing the agent.")
@@ -113,6 +112,11 @@ class CreateAgent(BaseAgent):
     agent_type: Optional[AgentType] = Field(None, description="The type of agent.")
     llm_config: Optional[LLMConfig] = Field(None, description="The LLM configuration used by the agent.")
     embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the agent.")
+    # Note: if this is None, then we'll populate with the standard "more human than human" initial message sequence
+    # If the client wants to make this empty, then the client can set the arg to an empty list
+    initial_message_sequence: Optional[List[Message]] = Field(
+        None, description="The initial set of messages to put in the agent's in-context memory."
+    )
 
     @field_validator("name")
     @classmethod

letta/schemas/block.py

@@ -18,7 +18,7 @@ class BaseBlock(LettaBase, validate_assignment=True):
     limit: int = Field(2000, description="Character limit of the block.")
 
     # template data (optional)
-    name: Optional[str] = Field(None, description="Name of the block if it is a template.")
+    template_name: Optional[str] = Field(None, description="Name of the block if it is a template.")
     template: bool = Field(False, description="Whether the block is a template (e.g. saved human/persona options).")
 
     # context window label

letta/schemas/letta_base.py

@@ -21,6 +21,8 @@ class LettaBase(BaseModel):
         from_attributes=True,
         # throw errors if attributes are given that don't belong
         extra="forbid",
+        # handle datetime serialization consistently across all models
+        # json_encoders={datetime: lambda dt: (dt.replace(tzinfo=timezone.utc) if dt.tzinfo is None else dt).isoformat()},
     )
 
     # def __id_prefix__(self):

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/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/schemas/tool.py

@@ -8,7 +8,10 @@ from letta.functions.helpers import (
     generate_crewai_tool_wrapper,
     generate_langchain_tool_wrapper,
 )
-from letta.functions.schema_generator import generate_schema_from_args_schema
+from letta.functions.schema_generator import (
+    generate_schema_from_args_schema_v1,
+    generate_schema_from_args_schema_v2,
+)
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.openai.chat_completions import ToolCall
 
@@ -30,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):
         """
@@ -97,7 +100,7 @@ class ToolCreate(LettaBase):
         source_type = "python"
         tags = ["composio"]
         wrapper_func_name, wrapper_function_str = generate_composio_tool_wrapper(action)
-        json_schema = generate_schema_from_args_schema(composio_tool.args_schema, name=wrapper_func_name, description=description)
+        json_schema = generate_schema_from_args_schema_v2(composio_tool.args_schema, name=wrapper_func_name, description=description)
 
         return cls(
             name=wrapper_func_name,
@@ -129,7 +132,7 @@ class ToolCreate(LettaBase):
         tags = ["langchain"]
         # NOTE: langchain tools may come from different packages
         wrapper_func_name, wrapper_function_str = generate_langchain_tool_wrapper(langchain_tool, additional_imports_module_attr_map)
-        json_schema = generate_schema_from_args_schema(langchain_tool.args_schema, name=wrapper_func_name, description=description)
+        json_schema = generate_schema_from_args_schema_v1(langchain_tool.args_schema, name=wrapper_func_name, description=description)
 
         return cls(
             name=wrapper_func_name,
@@ -159,7 +162,7 @@ class ToolCreate(LettaBase):
         source_type = "python"
         tags = ["crew-ai"]
         wrapper_func_name, wrapper_function_str = generate_crewai_tool_wrapper(crewai_tool, additional_imports_module_attr_map)
-        json_schema = generate_schema_from_args_schema(crewai_tool.args_schema, name=wrapper_func_name, description=description)
+        json_schema = generate_schema_from_args_schema_v1(crewai_tool.args_schema, name=wrapper_func_name, description=description)
 
         return cls(
             name=wrapper_func_name,

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/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/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/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/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/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,
@@ -857,7 +857,10 @@ class SyncServer(Server):
                     agent_state=agent_state,
                     tools=tool_objs,
                     # gpt-3.5-turbo tends to omit inner monologue, relax this requirement for now
-                    first_message_verify_mono=True if (llm_config.model is not None and "gpt-4" in llm_config.model) else False,
+                    first_message_verify_mono=(
+                        True if (llm_config and llm_config.model is not None and "gpt-4" in llm_config.model) else False
+                    ),
+                    initial_message_sequence=request.initial_message_sequence,
                 )
             elif request.agent_type == AgentType.o1_agent:
                 agent = O1Agent(
@@ -865,7 +868,9 @@ class SyncServer(Server):
                     agent_state=agent_state,
                     tools=tool_objs,
                     # gpt-3.5-turbo tends to omit inner monologue, relax this requirement for now
-                    first_message_verify_mono=True if (llm_config.model is not None and "gpt-4" in llm_config.model) else False,
+                    first_message_verify_mono=(
+                        True if (llm_config and llm_config.model is not None and "gpt-4" in llm_config.model) else False
+                    ),
                 )
             # rebuilding agent memory on agent create in case shared memory blocks
             # were specified in the new agent's memory config. we're doing this for two reasons:
@@ -1084,7 +1089,7 @@ class SyncServer(Server):
         id: Optional[str] = None,
     ) -> Optional[List[Block]]:
 
-        return self.ms.get_blocks(user_id=user_id, label=label, template=template, name=name, id=id)
+        return self.ms.get_blocks(user_id=user_id, label=label, template=template, template_name=name, id=id)
 
     def get_block(self, block_id: str):
 
@@ -1096,14 +1101,18 @@ class SyncServer(Server):
         return blocks[0]
 
     def create_block(self, request: CreateBlock, user_id: str, update: bool = False) -> Block:
-        existing_blocks = self.ms.get_blocks(name=request.name, user_id=user_id, template=request.template, label=request.label)
-        if existing_blocks is not None:
+        existing_blocks = self.ms.get_blocks(
+            template_name=request.template_name, user_id=user_id, template=request.template, label=request.label
+        )
+
+        # for templates, update existing block template if exists
+        if existing_blocks is not None and request.template:
             existing_block = existing_blocks[0]
             assert len(existing_blocks) == 1
             if update:
                 return self.update_block(UpdateBlock(id=existing_block.id, **vars(request)))
             else:
-                raise ValueError(f"Block with name {request.name} already exists")
+                raise ValueError(f"Block with name {request.template_name} already exists")
         block = Block(**vars(request))
         self.ms.create_block(block)
         return block
@@ -1112,7 +1121,7 @@ class SyncServer(Server):
         block = self.get_block(request.id)
         block.limit = request.limit if request.limit is not None else block.limit
         block.value = request.value if request.value is not None else block.value
-        block.name = request.name if request.name is not None else block.name
+        block.template_name = request.template_name if request.template_name is not None else block.template_name
         self.ms.update_block(block=block)
         return self.ms.get_block(block_id=request.id)
 
@@ -1757,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())
@@ -1773,12 +1782,12 @@ class SyncServer(Server):
         for persona_file in list_persona_files():
             text = open(persona_file, "r", encoding="utf-8").read()
             name = os.path.basename(persona_file).replace(".txt", "")
-            self.create_block(CreatePersona(user_id=user_id, name=name, value=text, template=True), user_id=user_id, update=True)
+            self.create_block(CreatePersona(user_id=user_id, template_name=name, value=text, template=True), user_id=user_id, update=True)
 
         for human_file in list_human_files():
             text = open(human_file, "r", encoding="utf-8").read()
             name = os.path.basename(human_file).replace(".txt", "")
-            self.create_block(CreateHuman(user_id=user_id, name=name, value=text, template=True), user_id=user_id, update=True)
+            self.create_block(CreateHuman(user_id=user_id, template_name=name, value=text, template=True), user_id=user_id, update=True)
 
     def get_agent_message(self, agent_id: str, message_id: str) -> Optional[Message]:
         """Get a single message from the agent's memory"""

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/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/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()
 

{letta_nightly-0.5.1.dev20241104104148.dist-info → letta_nightly-0.5.1.dev20241106104104.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.5.1.dev20241104104148
+Version: 0.5.1.dev20241106104104
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -52,7 +52,7 @@ Requires-Dist: pg8000 (>=1.30.3,<2.0.0) ; extra == "postgres"
 Requires-Dist: pgvector (>=0.2.3,<0.3.0) ; extra == "postgres"
 Requires-Dist: pre-commit (>=3.5.0,<4.0.0) ; extra == "dev"
 Requires-Dist: prettytable (>=3.9.0,<4.0.0)
-Requires-Dist: psycopg2 (>=2.9.10,<3.0.0)
+Requires-Dist: psycopg2 (>=2.9.10,<3.0.0) ; extra == "postgres"
 Requires-Dist: psycopg2-binary (>=2.9.10,<3.0.0) ; extra == "postgres"
 Requires-Dist: pyautogen (==0.2.22) ; extra == "autogen"
 Requires-Dist: pydantic (>=2.7.4,<3.0.0)
@@ -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)