letta-nightly 0.5.1.dev20241024104118__py3-none-any.whl → 0.5.1.dev20241026104101__py3-none-any.whl

letta/metadata.py

@@ -14,8 +14,6 @@ from sqlalchemy import (
     Integer,
     String,
     TypeDecorator,
-    asc,
-    or_,
 )
 from sqlalchemy.sql import func
 
@@ -32,7 +30,6 @@ from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
 from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
 from letta.schemas.source import Source
-from letta.schemas.tool import Tool
 from letta.schemas.user import User
 from letta.settings import settings
 from letta.utils import enforce_types, get_utc_time, printd
@@ -309,9 +306,9 @@ class BlockModel(Base):
     id = Column(String, primary_key=True, nullable=False)
     value = Column(String, nullable=False)
     limit = Column(BIGINT)
-    name = Column(String, nullable=False)
+    name = Column(String)
     template = Column(Boolean, default=False)  # True: listed as possible human/persona
-    label = Column(String)
+    label = Column(String, nullable=False)
     metadata_ = Column(JSON)
     description = Column(String)
     user_id = Column(String)
@@ -359,37 +356,6 @@ class BlockModel(Base):
             )
 
 
-class ToolModel(Base):
-    __tablename__ = "tools"
-    __table_args__ = {"extend_existing": True}
-
-    id = Column(String, primary_key=True)
-    name = Column(String, nullable=False)
-    user_id = Column(String)
-    description = Column(String)
-    source_type = Column(String)
-    source_code = Column(String)
-    json_schema = Column(JSON)
-    module = Column(String)
-    tags = Column(JSON)
-
-    def __repr__(self) -> str:
-        return f"<Tool(id='{self.id}', name='{self.name}')>"
-
-    def to_record(self) -> Tool:
-        return Tool(
-            id=self.id,
-            name=self.name,
-            user_id=self.user_id,
-            description=self.description,
-            source_type=self.source_type,
-            source_code=self.source_code,
-            json_schema=self.json_schema,
-            module=self.module,
-            tags=self.tags,
-        )
-
-
 class JobModel(Base):
     __tablename__ = "jobs"
     __table_args__ = {"extend_existing": True}
@@ -516,14 +482,6 @@ class MetadataStore:
             session.add(BlockModel(**vars(block)))
             session.commit()
 
-    @enforce_types
-    def create_tool(self, tool: Tool):
-        with self.session_maker() as session:
-            if self.get_tool(tool_id=tool.id, tool_name=tool.name, user_id=tool.user_id) is not None:
-                raise ValueError(f"Tool with name {tool.name} already exists")
-            session.add(ToolModel(**vars(tool)))
-            session.commit()
-
     @enforce_types
     def update_agent(self, agent: AgentState):
         with self.session_maker() as session:
@@ -556,18 +514,6 @@ class MetadataStore:
                 session.add(BlockModel(**vars(block)))
             session.commit()
 
-    @enforce_types
-    def update_tool(self, tool_id: str, tool: Tool):
-        with self.session_maker() as session:
-            session.query(ToolModel).filter(ToolModel.id == tool_id).update(vars(tool))
-            session.commit()
-
-    @enforce_types
-    def delete_tool(self, tool_id: str):
-        with self.session_maker() as session:
-            session.query(ToolModel).filter(ToolModel.id == tool_id).delete()
-            session.commit()
-
     @enforce_types
     def delete_file_from_source(self, source_id: str, file_id: str, user_id: Optional[str]):
         with self.session_maker() as session:
@@ -612,23 +558,6 @@ class MetadataStore:
 
             session.commit()
 
-    @enforce_types
-    def list_tools(self, cursor: Optional[str] = None, limit: Optional[int] = 50, user_id: Optional[str] = None) -> List[ToolModel]:
-        with self.session_maker() as session:
-            # Query for public tools or user-specific tools
-            query = session.query(ToolModel).filter(or_(ToolModel.user_id == None, ToolModel.user_id == user_id))
-
-            # Apply cursor if provided (assuming cursor is an ID)
-            if cursor:
-                query = query.filter(ToolModel.id > cursor)
-
-            # Order by ID and apply limit
-            results = query.order_by(asc(ToolModel.id)).limit(limit).all()
-
-            # Convert to records
-            res = [r.to_record() for r in results]
-            return res
-
     @enforce_types
     def list_agents(self, user_id: str) -> List[AgentState]:
         with self.session_maker() as session:
@@ -672,32 +601,6 @@ class MetadataStore:
             assert len(results) == 1, f"Expected 1 result, got {len(results)}"
             return results[0].to_record()
 
-    @enforce_types
-    def get_tool(
-        self, tool_name: Optional[str] = None, tool_id: Optional[str] = None, user_id: Optional[str] = None
-    ) -> Optional[ToolModel]:
-        with self.session_maker() as session:
-            if tool_id:
-                results = session.query(ToolModel).filter(ToolModel.id == tool_id).all()
-            else:
-                assert tool_name is not None
-                results = session.query(ToolModel).filter(ToolModel.name == tool_name).filter(ToolModel.user_id == None).all()
-                if user_id:
-                    results += session.query(ToolModel).filter(ToolModel.name == tool_name).filter(ToolModel.user_id == user_id).all()
-            if len(results) == 0:
-                return None
-            # assert len(results) == 1, f"Expected 1 result, got {len(results)}"
-            return results[0].to_record()
-
-    @enforce_types
-    def get_tool_with_name_and_user_id(self, tool_name: Optional[str] = None, user_id: Optional[str] = None) -> Optional[ToolModel]:
-        with self.session_maker() as session:
-            results = session.query(ToolModel).filter(ToolModel.name == tool_name).filter(ToolModel.user_id == user_id).all()
-            if len(results) == 0:
-                return None
-            assert len(results) == 1, f"Expected 1 result, got {len(results)}"
-            return results[0].to_record()
-
     @enforce_types
     def get_block(self, block_id: str) -> Optional[Block]:
         with self.session_maker() as session:

letta/o1_agent.py

@@ -10,7 +10,7 @@ from letta.schemas.tool import Tool
 from letta.schemas.usage import LettaUsageStatistics
 
 
-def send_thinking_message(self: Agent, message: str) -> Optional[str]:
+def send_thinking_message(self: "Agent", message: str) -> Optional[str]:
     """
     Sends a thinking message so that the model can reason out loud before responding.
 
@@ -24,7 +24,7 @@ def send_thinking_message(self: Agent, message: str) -> Optional[str]:
     return None
 
 
-def send_final_message(self: Agent, message: str) -> Optional[str]:
+def send_final_message(self: "Agent", message: str) -> Optional[str]:
     """
     Sends a final message to the human user after thinking for a while.
 

letta/orm/__all__.py

@@ -0,0 +1,15 @@
+"""__all__ acts as manual import management to avoid collisions and circular imports."""
+
+# from letta.orm.agent import Agent
+# from letta.orm.users_agents import UsersAgents
+# from letta.orm.blocks_agents import BlocksAgents
+# from letta.orm.token import Token
+# from letta.orm.source import Source
+# from letta.orm.document import Document
+# from letta.orm.passage import Passage
+# from letta.orm.memory_templates import MemoryTemplate, HumanMemoryTemplate, PersonaMemoryTemplate
+# from letta.orm.sources_agents import SourcesAgents
+# from letta.orm.tools_agents import ToolsAgents
+# from letta.orm.job import Job
+# from letta.orm.block import Block
+# from letta.orm.message import Message

letta/orm/mixins.py

@@ -55,7 +55,6 @@ class OrganizationMixin(Base):
 
     __abstract__ = True
 
-    # Changed _organization_id to store string (still a valid UUID4 string)
     _organization_id: Mapped[str] = mapped_column(String, ForeignKey("organization._id"))
 
     @property
@@ -65,3 +64,19 @@ class OrganizationMixin(Base):
     @organization_id.setter
     def organization_id(self, value: str) -> None:
         _relation_setter(self, "organization", value)
+
+
+class UserMixin(Base):
+    """Mixin for models that belong to a user."""
+
+    __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)

letta/orm/organization.py

@@ -7,6 +7,7 @@ from letta.schemas.organization import Organization as PydanticOrganization
 
 if TYPE_CHECKING:
 
+    from letta.orm.tool import Tool
     from letta.orm.user import User
 
 
@@ -19,6 +20,7 @@ class Organization(SqlalchemyBase):
     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")
+    tools: Mapped[List["Tool"]] = relationship("Tool", back_populates="organization", cascade="all, delete-orphan")
 
     # TODO: Map these relationships later when we actually make these models
     # below is just a suggestion

letta/orm/sqlalchemy_base.py

@@ -184,21 +184,20 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         logger.warning("to_record is deprecated, use to_pydantic instead.")
         return self.to_pydantic()
 
-    # TODO: Look into this later and maybe add back?
-    # def _infer_organization(self, db_session: "Session") -> None:
-    #     """🪄 MAGIC ALERT! 🪄
-    #     Because so much of the original API is centered around user scopes,
-    #     this allows us to continue with that scope and then infer the org from the creating user.
-    #
-    #     IF a created_by_id is set, we will use that to infer the organization and magic set it at create time!
-    #     If not do nothing to the object. Mutates in place.
-    #     """
-    #     if self.created_by_id and hasattr(self, "_organization_id"):
-    #         try:
-    #             from letta.orm.user import User  # to avoid circular import
-    #
-    #             created_by = User.read(db_session, self.created_by_id)
-    #         except NoResultFound:
-    #             logger.warning(f"User {self.created_by_id} not found, unable to infer organization.")
-    #             return
-    #         self._organization_id = created_by._organization_id
+    def _infer_organization(self, db_session: "Session") -> None:
+        """🪄 MAGIC ALERT! 🪄
+        Because so much of the original API is centered around user scopes,
+        this allows us to continue with that scope and then infer the org from the creating user.
+
+        IF a created_by_id is set, we will use that to infer the organization and magic set it at create time!
+        If not do nothing to the object. Mutates in place.
+        """
+        if self.created_by_id and hasattr(self, "_organization_id"):
+            try:
+                from letta.orm.user import User  # to avoid circular import
+
+                created_by = User.read(db_session, self.created_by_id)
+            except NoResultFound:
+                logger.warning(f"User {self.created_by_id} not found, unable to infer organization.")
+                return
+            self._organization_id = created_by._organization_id

letta/orm/tool.py

@@ -0,0 +1,54 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from sqlalchemy import JSON, String, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+# TODO everything in functions should live in this model
+from letta.orm.enums import ToolSourceType
+from letta.orm.mixins import OrganizationMixin, UserMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.tool import Tool as PydanticTool
+
+if TYPE_CHECKING:
+    pass
+
+    from letta.orm.organization import Organization
+    from letta.orm.user import User
+
+
+class Tool(SqlalchemyBase, OrganizationMixin, UserMixin):
+    """Represents an available tool that the LLM can invoke.
+
+    NOTE: polymorphic inheritance makes more sense here as a TODO. We want a superset of tools
+    that are always available, and a subset scoped to the organization. Alternatively, we could use the apply_access_predicate to build
+    more granular permissions.
+    """
+
+    __tablename__ = "tool"
+    __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"),
+        UniqueConstraint("name", "_user_id", name="uix_name_user"),
+    )
+
+    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.")
+    source_type: Mapped[ToolSourceType] = mapped_column(String, doc="The type of the source code.", default=ToolSourceType.json)
+    source_code: Mapped[Optional[str]] = mapped_column(String, doc="The source code of the function.")
+    json_schema: Mapped[dict] = mapped_column(JSON, default=lambda: {}, doc="The OAI compatable JSON schema of the function.")
+    module: Mapped[Optional[str]] = mapped_column(
+        String, nullable=True, doc="the module path from which this tool was derived in the codebase."
+    )
+
+    # TODO: add terminal here eventually
+    # This was an intentional decision by Sarah
+
+    # relationships
+    # TODO: Possibly add in user in the future
+    # This will require some more thought and justification to add this in.
+    user: Mapped["User"] = relationship("User", back_populates="tools", lazy="selectin")
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="tools", lazy="selectin")

letta/orm/user.py

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

letta/schemas/block.py

@@ -17,11 +17,14 @@ class BaseBlock(LettaBase, validate_assignment=True):
     value: Optional[str] = Field(None, description="Value of the block.")
     limit: int = Field(2000, description="Character limit of the block.")
 
-    name: Optional[str] = Field(None, description="Name of the block.")
+    # template data (optional)
+    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).")
-    label: Optional[str] = Field(None, description="Label of the block (e.g. 'human', 'persona').")
 
-    # metadat
+    # context window label
+    label: str = Field(None, description="Label of the block (e.g. 'human', 'persona') in the context window.")
+
+    # metadata
     description: Optional[str] = Field(None, description="Description of the block.")
     metadata_: Optional[dict] = Field({}, description="Metadata of the block.")
 
@@ -39,12 +42,6 @@ class BaseBlock(LettaBase, validate_assignment=True):
             raise e
         return self
 
-    @model_validator(mode="after")
-    def ensure_label(self) -> Self:
-        if not self.label:
-            self.label = self.name
-        return self
-
     def __len__(self):
         return len(self.value)
 

letta/schemas/memory.py

@@ -61,7 +61,7 @@ class Memory(BaseModel, validate_assignment=True):
 
     """
 
-    # Memory.memory is a dict mapping from memory block section to memory block.
+    # Memory.memory is a dict mapping from memory block label to memory block.
     memory: Dict[str, Block] = Field(default_factory=dict, description="Mapping from memory block section to memory block.")
 
     # Memory.template is a Jinja2 template for compiling memory module into a prompt string.
@@ -126,44 +126,42 @@ class Memory(BaseModel, validate_assignment=True):
         }
 
     def to_flat_dict(self):
-        """Convert to a dictionary that maps directly from block names to values"""
+        """Convert to a dictionary that maps directly from block label to values"""
         return {k: v.value for k, v in self.memory.items() if v is not None}
 
-    def list_block_names(self) -> List[str]:
+    def list_block_labels(self) -> List[str]:
         """Return a list of the block names held inside the memory object"""
         return list(self.memory.keys())
 
     # TODO: these should actually be label, not name
-    def get_block(self, name: str) -> Block:
+    def get_block(self, label: str) -> Block:
         """Correct way to index into the memory.memory field, returns a Block"""
-        if name not in self.memory:
-            raise KeyError(f"Block field {name} does not exist (available sections = {', '.join(list(self.memory.keys()))})")
+        if label not in self.memory:
+            raise KeyError(f"Block field {label} does not exist (available sections = {', '.join(list(self.memory.keys()))})")
         else:
-            return self.memory[name]
+            return self.memory[label]
 
     def get_blocks(self) -> List[Block]:
         """Return a list of the blocks held inside the memory object"""
         return list(self.memory.values())
 
-    def link_block(self, name: str, block: Block, override: Optional[bool] = False):
+    def link_block(self, block: Block, override: Optional[bool] = False):
         """Link a new block to the memory object"""
         if not isinstance(block, Block):
             raise ValueError(f"Param block must be type Block (not {type(block)})")
-        if not isinstance(name, str):
-            raise ValueError(f"Name must be str (not type {type(name)})")
-        if not override and name in self.memory:
-            raise ValueError(f"Block with name {name} already exists")
+        if not override and block.label in self.memory:
+            raise ValueError(f"Block with label {block.label} already exists")
 
-        self.memory[name] = block
+        self.memory[block.label] = block
 
-    def update_block_value(self, name: str, value: str):
+    def update_block_value(self, label: str, value: str):
         """Update the value of a block"""
-        if name not in self.memory:
-            raise ValueError(f"Block with name {name} does not exist")
+        if label not in self.memory:
+            raise ValueError(f"Block with label {label} does not exist")
         if not isinstance(value, str):
             raise ValueError(f"Provided value must be a string")
 
-        self.memory[name].value = value
+        self.memory[label].value = value
 
 
 # TODO: ideally this is refactored into ChatMemory and the subclasses are given more specific names.
@@ -192,41 +190,41 @@ class BasicBlockMemory(Memory):
             # assert block.name is not None and block.name != "", "each existing chat block must have a name"
             # self.link_block(name=block.name, block=block)
             assert block.label is not None and block.label != "", "each existing chat block must have a name"
-            self.link_block(name=block.label, block=block)
+            self.link_block(block=block)
 
-    def core_memory_append(self: "Agent", name: str, content: str) -> Optional[str]:  # type: ignore
+    def core_memory_append(self: "Agent", label: str, content: str) -> Optional[str]:  # type: ignore
         """
         Append to the contents of core memory.
 
         Args:
-            name (str): Section of the memory to be edited (persona or human).
+            label (str): Section of the memory to be edited (persona or human).
             content (str): Content to write to the memory. All unicode (including emojis) are supported.
 
         Returns:
             Optional[str]: None is always returned as this function does not produce a response.
         """
-        current_value = str(self.memory.get_block(name).value)
+        current_value = str(self.memory.get_block(label).value)
         new_value = current_value + "\n" + str(content)
-        self.memory.update_block_value(name=name, value=new_value)
+        self.memory.update_block_value(label=label, value=new_value)
         return None
 
-    def core_memory_replace(self: "Agent", name: str, old_content: str, new_content: str) -> Optional[str]:  # type: ignore
+    def core_memory_replace(self: "Agent", label: str, old_content: str, new_content: str) -> Optional[str]:  # type: ignore
         """
         Replace the contents of core memory. To delete memories, use an empty string for new_content.
 
         Args:
-            name (str): Section of the memory to be edited (persona or human).
+            label (str): Section of the memory to be edited (persona or human).
             old_content (str): String to replace. Must be an exact match.
             new_content (str): Content to write to the memory. All unicode (including emojis) are supported.
 
         Returns:
             Optional[str]: None is always returned as this function does not produce a response.
         """
-        current_value = str(self.memory.get_block(name).value)
+        current_value = str(self.memory.get_block(label).value)
         if old_content not in current_value:
-            raise ValueError(f"Old content '{old_content}' not found in memory block '{name}'")
+            raise ValueError(f"Old content '{old_content}' not found in memory block '{label}'")
         new_value = current_value.replace(str(old_content), str(new_content))
-        self.memory.update_block_value(name=name, value=new_value)
+        self.memory.update_block_value(label=label, value=new_value)
         return None
 
 
@@ -245,8 +243,8 @@ class ChatMemory(BasicBlockMemory):
             limit (int): The character limit for each block.
         """
         super().__init__()
-        self.link_block(name="persona", block=Block(name="persona", value=persona, limit=limit, label="persona"))
-        self.link_block(name="human", block=Block(name="human", value=human, limit=limit, label="human"))
+        self.link_block(block=Block(value=persona, limit=limit, label="persona"))
+        self.link_block(block=Block(value=human, limit=limit, label="human"))
 
 
 class UpdateMemory(BaseModel):