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

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
@@ -235,6 +236,7 @@ class Agent(BaseAgent):
         # extras
         messages_total: Optional[int] = None,  # TODO remove?
         first_message_verify_mono: bool = True,  # TODO move to config?
+        initial_message_sequence: Optional[List[Message]] = None,
     ):
         assert isinstance(agent_state.memory, Memory), f"Memory object is not of type Memory: {type(agent_state.memory)}"
         # Hold a copy of the state that was used to init the agent
@@ -249,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)
 
@@ -294,6 +299,7 @@ class Agent(BaseAgent):
 
         else:
             printd(f"Agent.__init__ :: creating, state={agent_state.message_ids}")
+            assert self.agent_state.id is not None and self.agent_state.user_id is not None
 
             # Generate a sequence of initial messages to put in the buffer
             init_messages = initialize_message_sequence(
@@ -306,14 +312,40 @@ class Agent(BaseAgent):
                 include_initial_boot_message=True,
             )
 
-            # Cast the messages to actual Message objects to be synced to the DB
-            init_messages_objs = []
-            for msg in init_messages:
-                init_messages_objs.append(
+            if initial_message_sequence is not None:
+                # We always need the system prompt up front
+                system_message_obj = Message.dict_to_message(
+                    agent_id=self.agent_state.id,
+                    user_id=self.agent_state.user_id,
+                    model=self.model,
+                    openai_message_dict=init_messages[0],
+                )
+                # Don't use anything else in the pregen sequence, instead use the provided sequence
+                init_messages = [system_message_obj] + initial_message_sequence
+
+            else:
+                # Basic "more human than human" initial message sequence
+                init_messages = initialize_message_sequence(
+                    model=self.model,
+                    system=self.system,
+                    memory=self.memory,
+                    archival_memory=None,
+                    recall_memory=None,
+                    memory_edit_timestamp=get_utc_time(),
+                    include_initial_boot_message=True,
+                )
+                # Cast to Message objects
+                init_messages = [
                     Message.dict_to_message(
                         agent_id=self.agent_state.id, user_id=self.agent_state.user_id, model=self.model, openai_message_dict=msg
                     )
-                )
+                    for msg in init_messages
+                ]
+
+            # Cast the messages to actual Message objects to be synced to the DB
+            init_messages_objs = []
+            for msg in init_messages:
+                init_messages_objs.append(msg)
             assert all([isinstance(msg, Message) for msg in init_messages_objs]), (init_messages_objs, init_messages)
 
             # Put the messages inside the message buffer

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/cli/cli.py

@@ -282,10 +282,10 @@ def run(
         system_prompt = system if system else None
 
         memory = ChatMemory(human=human_obj.value, persona=persona_obj.value, limit=core_memory_limit)
-        metadata = {"human": human_obj.name, "persona": persona_obj.name}
+        metadata = {"human": human_obj.template_name, "persona": persona_obj.template_name}
 
-        typer.secho(f"->  {ASSISTANT_MESSAGE_CLI_SYMBOL} Using persona profile: '{persona_obj.name}'", fg=typer.colors.WHITE)
-        typer.secho(f"->  🧑 Using human profile: '{human_obj.name}'", fg=typer.colors.WHITE)
+        typer.secho(f"->  {ASSISTANT_MESSAGE_CLI_SYMBOL} Using persona profile: '{persona_obj.template_name}'", fg=typer.colors.WHITE)
+        typer.secho(f"->  🧑 Using human profile: '{human_obj.template_name}'", fg=typer.colors.WHITE)
 
         # add tools
         agent_state = client.create_agent(

letta/cli/cli_config.py

@@ -59,13 +59,13 @@ def list(arg: Annotated[ListChoice, typer.Argument]):
         """List all humans"""
         table.field_names = ["Name", "Text"]
         for human in client.list_humans():
-            table.add_row([human.name, human.value.replace("\n", "")[:100]])
+            table.add_row([human.template_name, human.value.replace("\n", "")[:100]])
         print(table)
     elif arg == ListChoice.personas:
         """List all personas"""
         table.field_names = ["Name", "Text"]
         for persona in client.list_personas():
-            table.add_row([persona.name, persona.value.replace("\n", "")[:100]])
+            table.add_row([persona.template_name, persona.value.replace("\n", "")[:100]])
         print(table)
     elif arg == ListChoice.sources:
         """List all data sources"""

letta/client/client.py

@@ -376,6 +376,7 @@ class RESTClient(AbstractClient):
         # metadata
         metadata: Optional[Dict] = {"human:": DEFAULT_HUMAN, "persona": DEFAULT_PERSONA},
         description: Optional[str] = None,
+        initial_message_sequence: Optional[List[Message]] = None,
     ) -> AgentState:
         """Create an agent
 
@@ -428,9 +429,18 @@ class RESTClient(AbstractClient):
             agent_type=agent_type,
             llm_config=llm_config if llm_config else self._default_llm_config,
             embedding_config=embedding_config if embedding_config else self._default_embedding_config,
+            initial_message_sequence=initial_message_sequence,
+        )
+
+        # Use model_dump_json() instead of model_dump()
+        # If we use model_dump(), the datetime objects will not be serialized correctly
+        # response = requests.post(f"{self.base_url}/{self.api_prefix}/agents", json=request.model_dump(), headers=self.headers)
+        response = requests.post(
+            f"{self.base_url}/{self.api_prefix}/agents",
+            data=request.model_dump_json(),  # Use model_dump_json() instead of json=model_dump()
+            headers={"Content-Type": "application/json", **self.headers},
         )
 
-        response = requests.post(f"{self.base_url}/{self.api_prefix}/agents", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Status {response.status_code} - Failed to create agent: {response.text}")
         return AgentState(**response.json())
@@ -602,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:
@@ -859,8 +874,8 @@ class RESTClient(AbstractClient):
         else:
             return [Block(**block) for block in response.json()]
 
-    def create_block(self, label: str, text: str, name: Optional[str] = None, template: bool = False) -> Block:  #
-        request = CreateBlock(label=label, value=text, template=template, name=name)
+    def create_block(self, label: str, text: str, template_name: Optional[str] = None, template: bool = False) -> Block:  #
+        request = CreateBlock(label=label, value=text, template=template, template_name=template_name)
         response = requests.post(f"{self.base_url}/{self.api_prefix}/blocks", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to create block: {response.text}")
@@ -872,7 +887,7 @@ class RESTClient(AbstractClient):
             return Block(**response.json())
 
     def update_block(self, block_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Block:
-        request = UpdateBlock(id=block_id, name=name, value=text)
+        request = UpdateBlock(id=block_id, template_name=name, value=text)
         response = requests.post(f"{self.base_url}/{self.api_prefix}/blocks/{block_id}", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to update block: {response.text}")
@@ -926,7 +941,7 @@ class RESTClient(AbstractClient):
         Returns:
             human (Human): Human block
         """
-        return self.create_block(label="human", name=name, text=text, template=True)
+        return self.create_block(label="human", template_name=name, text=text, template=True)
 
     def update_human(self, human_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Human:
         """
@@ -939,7 +954,7 @@ class RESTClient(AbstractClient):
         Returns:
             human (Human): Updated human block
         """
-        request = UpdateHuman(id=human_id, name=name, value=text)
+        request = UpdateHuman(id=human_id, template_name=name, value=text)
         response = requests.post(f"{self.base_url}/{self.api_prefix}/blocks/{human_id}", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to update human: {response.text}")
@@ -966,7 +981,7 @@ class RESTClient(AbstractClient):
         Returns:
             persona (Persona): Persona block
         """
-        return self.create_block(label="persona", name=name, text=text, template=True)
+        return self.create_block(label="persona", template_name=name, text=text, template=True)
 
     def update_persona(self, persona_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Persona:
         """
@@ -979,7 +994,7 @@ class RESTClient(AbstractClient):
         Returns:
             persona (Persona): Updated persona block
         """
-        request = UpdatePersona(id=persona_id, name=name, value=text)
+        request = UpdatePersona(id=persona_id, template_name=name, value=text)
         response = requests.post(f"{self.base_url}/{self.api_prefix}/blocks/{persona_id}", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to update persona: {response.text}")
@@ -1648,6 +1663,7 @@ class LocalClient(AbstractClient):
         # metadata
         metadata: Optional[Dict] = {"human:": DEFAULT_HUMAN, "persona": DEFAULT_PERSONA},
         description: Optional[str] = None,
+        initial_message_sequence: Optional[List[Message]] = None,
     ) -> AgentState:
         """Create an agent
 
@@ -1702,6 +1718,7 @@ class LocalClient(AbstractClient):
                 agent_type=agent_type,
                 llm_config=llm_config if llm_config else self._default_llm_config,
                 embedding_config=embedding_config if embedding_config else self._default_embedding_config,
+                initial_message_sequence=initial_message_sequence,
             ),
             actor=self.user,
         )
@@ -2116,7 +2133,7 @@ class LocalClient(AbstractClient):
         Returns:
             human (Human): Human block
         """
-        return self.server.create_block(CreateHuman(name=name, value=text, user_id=self.user_id), user_id=self.user_id)
+        return self.server.create_block(CreateHuman(template_name=name, value=text, user_id=self.user_id), user_id=self.user_id)
 
     def create_persona(self, name: str, text: str):
         """
@@ -2129,7 +2146,7 @@ class LocalClient(AbstractClient):
         Returns:
             persona (Persona): Persona block
         """
-        return self.server.create_block(CreatePersona(name=name, value=text, user_id=self.user_id), user_id=self.user_id)
+        return self.server.create_block(CreatePersona(template_name=name, value=text, user_id=self.user_id), user_id=self.user_id)
 
     def list_humans(self):
         """
@@ -2255,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(
@@ -2298,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,
@@ -2635,7 +2652,7 @@ class LocalClient(AbstractClient):
         """
         return self.server.get_blocks(label=label, template=templates_only)
 
-    def create_block(self, label: str, text: str, name: Optional[str] = None, template: bool = False) -> Block:  #
+    def create_block(self, label: str, text: str, template_name: Optional[str] = None, template: bool = False) -> Block:  #
         """
         Create a block
 
@@ -2648,7 +2665,7 @@ class LocalClient(AbstractClient):
             block (Block): Created block
         """
         return self.server.create_block(
-            CreateBlock(label=label, name=name, value=text, user_id=self.user_id, template=template), user_id=self.user_id
+            CreateBlock(label=label, template_name=template_name, value=text, user_id=self.user_id, template=template), user_id=self.user_id
         )
 
     def update_block(self, block_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Block:
@@ -2663,7 +2680,7 @@ class LocalClient(AbstractClient):
         Returns:
             block (Block): Updated block
         """
-        return self.server.update_block(UpdateBlock(id=block_id, name=name, value=text))
+        return self.server.update_block(UpdateBlock(id=block_id, template_name=name, value=text))
 
     def get_block(self, block_id: str) -> Block:
         """
@@ -2726,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/functions/schema_generator.py

@@ -139,32 +139,73 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[
     return schema
 
 
-def generate_schema_from_args_schema(
+def generate_schema_from_args_schema_v1(
     args_schema: Type[V1BaseModel], name: Optional[str] = None, description: Optional[str] = None, append_heartbeat: bool = True
 ) -> Dict[str, Any]:
     properties = {}
     required = []
     for field_name, field in args_schema.__fields__.items():
-        if field.type_.__name__ == "str":
+        if field.type_ == str:
             field_type = "string"
-        elif field.type_.__name__ == "int":
+        elif field.type_ == int:
             field_type = "integer"
-        elif field.type_.__name__ == "bool":
+        elif field.type_ == bool:
             field_type = "boolean"
         else:
             field_type = field.type_.__name__
-        properties[field_name] = {"type": field_type, "description": field.field_info.description}
+
+        properties[field_name] = {
+            "type": field_type,
+            "description": field.field_info.description,
+        }
         if field.required:
             required.append(field_name)
 
-    # Construct the OpenAI function call JSON object
     function_call_json = {
         "name": name,
         "description": description,
         "parameters": {"type": "object", "properties": properties, "required": required},
     }
 
-    # append heartbeat (necessary for triggering another reasoning step after this tool call)
+    if append_heartbeat:
+        function_call_json["parameters"]["properties"]["request_heartbeat"] = {
+            "type": "boolean",
+            "description": "Request an immediate heartbeat after function execution. Set to `True` if you want to send a follow-up message or run a follow-up function.",
+        }
+        function_call_json["parameters"]["required"].append("request_heartbeat")
+
+    return function_call_json
+
+
+def generate_schema_from_args_schema_v2(
+    args_schema: Type[BaseModel], name: Optional[str] = None, description: Optional[str] = None, append_heartbeat: bool = True
+) -> Dict[str, Any]:
+    properties = {}
+    required = []
+    for field_name, field in args_schema.model_fields.items():
+        field_type_annotation = field.annotation
+        if field_type_annotation == str:
+            field_type = "string"
+        elif field_type_annotation == int:
+            field_type = "integer"
+        elif field_type_annotation == bool:
+            field_type = "boolean"
+        else:
+            field_type = field_type_annotation.__name__
+
+        properties[field_name] = {
+            "type": field_type,
+            "description": field.description,
+        }
+        if field.is_required():
+            required.append(field_name)
+
+    function_call_json = {
+        "name": name,
+        "description": description,
+        "parameters": {"type": "object", "properties": properties, "required": required},
+    }
+
     if append_heartbeat:
         function_call_json["parameters"]["properties"]["request_heartbeat"] = {
             "type": "boolean",

letta/metadata.py

@@ -348,7 +348,7 @@ class BlockModel(Base):
     id = Column(String, primary_key=True, nullable=False)
     value = Column(String, nullable=False)
     limit = Column(BIGINT)
-    name = Column(String)
+    template_name = Column(String, nullable=True, default=None)
     template = Column(Boolean, default=False)  # True: listed as possible human/persona
     label = Column(String, nullable=False)
     metadata_ = Column(JSON)
@@ -357,7 +357,7 @@ class BlockModel(Base):
     Index(__tablename__ + "_idx_user", user_id),
 
     def __repr__(self) -> str:
-        return f"<Block(id='{self.id}', name='{self.name}', template='{self.template}', label='{self.label}', user_id='{self.user_id}')>"
+        return f"<Block(id='{self.id}', template_name='{self.template_name}', template='{self.template_name}', label='{self.label}', user_id='{self.user_id}')>"
 
     def to_record(self) -> Block:
         if self.label == "persona":
@@ -365,7 +365,7 @@ class BlockModel(Base):
                 id=self.id,
                 value=self.value,
                 limit=self.limit,
-                name=self.name,
+                template_name=self.template_name,
                 template=self.template,
                 label=self.label,
                 metadata_=self.metadata_,
@@ -377,7 +377,7 @@ class BlockModel(Base):
                 id=self.id,
                 value=self.value,
                 limit=self.limit,
-                name=self.name,
+                template_name=self.template_name,
                 template=self.template,
                 label=self.label,
                 metadata_=self.metadata_,
@@ -389,7 +389,7 @@ class BlockModel(Base):
                 id=self.id,
                 value=self.value,
                 limit=self.limit,
-                name=self.name,
+                template_name=self.template_name,
                 template=self.template,
                 label=self.label,
                 metadata_=self.metadata_,
@@ -512,7 +512,7 @@ class MetadataStore:
             # with a given name doesn't exist.
             if (
                 session.query(BlockModel)
-                .filter(BlockModel.name == block.name)
+                .filter(BlockModel.template_name == block.template_name)
                 .filter(BlockModel.user_id == block.user_id)
                 .filter(BlockModel.template == True)
                 .filter(BlockModel.label == block.label)
@@ -520,7 +520,7 @@ class MetadataStore:
                 > 0
             ):
 
-                raise ValueError(f"Block with name {block.name} already exists")
+                raise ValueError(f"Block with name {block.template_name} already exists")
             session.add(BlockModel(**vars(block)))
             session.commit()
 
@@ -658,7 +658,7 @@ class MetadataStore:
         user_id: Optional[str],
         label: Optional[str] = None,
         template: Optional[bool] = None,
-        name: Optional[str] = None,
+        template_name: Optional[str] = None,
         id: Optional[str] = None,
     ) -> Optional[List[Block]]:
         """List available blocks"""
@@ -671,8 +671,8 @@ class MetadataStore:
             if label:
                 query = query.filter(BlockModel.label == label)
 
-            if name:
-                query = query.filter(BlockModel.name == name)
+            if template_name:
+                query = query.filter(BlockModel.template_name == template_name)
 
             if id:
                 query = query.filter(BlockModel.id == id)

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/orm/mixins.py

@@ -1,11 +1,9 @@
-from typing import Optional
 from uuid import UUID
 
 from sqlalchemy import ForeignKey, String
 from sqlalchemy.orm import Mapped, mapped_column
 
 from letta.orm.base import Base
-from letta.orm.errors import MalformedIdError
 
 
 def is_valid_uuid4(uuid_string: str) -> bool:
@@ -17,53 +15,12 @@ def is_valid_uuid4(uuid_string: str) -> bool:
         return False
 
 
-def _relation_getter(instance: "Base", prop: str) -> Optional[str]:
-    """Get relation and return id with prefix as a string."""
-    prefix = prop.replace("_", "")
-    formatted_prop = f"_{prop}_id"
-    try:
-        id_ = getattr(instance, formatted_prop)  # Get the string id directly
-        return f"{prefix}-{id_}"
-    except AttributeError:
-        return None
-
-
-def _relation_setter(instance: "Base", prop: str, value: str) -> None:
-    """Set relation using the id with prefix, ensuring the id is a valid UUIDv4."""
-    formatted_prop = f"_{prop}_id"
-    prefix = prop.replace("_", "")
-    if not value:
-        setattr(instance, formatted_prop, None)
-        return
-    try:
-        found_prefix, id_ = value.split("-", 1)
-    except ValueError as e:
-        raise MalformedIdError(f"{value} is not a valid ID.") from e
-
-    # Ensure prefix matches
-    assert found_prefix == prefix, f"{found_prefix} is not a valid id prefix, expecting {prefix}"
-
-    # Validate that the id is a valid UUID4 string
-    if not is_valid_uuid4(id_):
-        raise MalformedIdError(f"Hash segment of {value} is not a valid UUID4")
-
-    setattr(instance, formatted_prop, id_)  # Store id as a string
-
-
 class OrganizationMixin(Base):
     """Mixin for models that belong to an organization."""
 
     __abstract__ = True
 
-    _organization_id: Mapped[str] = mapped_column(String, ForeignKey("organization._id"))
-
-    @property
-    def organization_id(self) -> str:
-        return _relation_getter(self, "organization")
-
-    @organization_id.setter
-    def organization_id(self, value: str) -> None:
-        _relation_setter(self, "organization", value)
+    organization_id: Mapped[str] = mapped_column(String, ForeignKey("organizations.id"))
 
 
 class UserMixin(Base):
@@ -71,12 +28,4 @@ class UserMixin(Base):
 
     __abstract__ = True
 
-    _user_id: Mapped[str] = mapped_column(String, ForeignKey("user._id"))
-
-    @property
-    def user_id(self) -> str:
-        return _relation_getter(self, "user")
-
-    @user_id.setter
-    def user_id(self, value: str) -> None:
-        _relation_setter(self, "user", value)
+    user_id: Mapped[str] = mapped_column(String, ForeignKey("users.id"))

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")