letta-nightly 0.5.2.dev20241119104253__py3-none-any.whl → 0.5.3.dev20241120010849__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.5.2"
+__version__ = "0.5.3"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

letta/agent.py

@@ -27,6 +27,7 @@ from letta.llm_api.llm_api_tools import create
 from letta.local_llm.utils import num_tokens_from_functions, num_tokens_from_messages
 from letta.memory import ArchivalMemory, RecallMemory, summarize_messages
 from letta.metadata import MetadataStore
+from letta.orm import User
 from letta.persistence_manager import LocalStateManager
 from letta.schemas.agent import AgentState, AgentStepResponse
 from letta.schemas.block import Block
@@ -46,6 +47,7 @@ from letta.schemas.passage import Passage
 from letta.schemas.tool import Tool
 from letta.schemas.tool_rule import TerminalToolRule
 from letta.schemas.usage import LettaUsageStatistics
+from letta.services.block_manager import BlockManager
 from letta.services.source_manager import SourceManager
 from letta.services.user_manager import UserManager
 from letta.streaming_interface import StreamingRefreshCLIInterface
@@ -234,6 +236,7 @@ class Agent(BaseAgent):
         # agents can be created from providing agent_state
         agent_state: AgentState,
         tools: List[Tool],
+        user: User,
         # memory: Memory,
         # extras
         messages_total: Optional[int] = None,  # TODO remove?
@@ -245,6 +248,8 @@ class Agent(BaseAgent):
         self.agent_state = agent_state
         assert isinstance(self.agent_state.memory, Memory), f"Memory object is not of type Memory: {type(self.agent_state.memory)}"
 
+        self.user = user
+
         # link tools
         self.link_tools(tools)
 
@@ -1221,7 +1226,9 @@ class Agent(BaseAgent):
                     # future if we expect templates to change often.
                     continue
                 block_id = block.get("id")
-                db_block = ms.get_block(block_id=block_id)
+
+                # TODO: This is really hacky and we should probably figure out how to
+                db_block = BlockManager().get_block_by_id(block_id=block_id, actor=self.user)
                 if db_block is None:
                     # this case covers if someone has deleted a shared block by interacting
                     # with some other agent.
@@ -1598,7 +1605,7 @@ def save_agent(agent: Agent, ms: MetadataStore):
 
     # NOTE: we're saving agent memory before persisting the agent to ensure
     # that allocated block_ids for each memory block are present in the agent model
-    save_agent_memory(agent=agent, ms=ms)
+    save_agent_memory(agent=agent)
 
     if ms.get_agent(agent_id=agent.agent_state.id):
         ms.update_agent(agent_state)
@@ -1609,7 +1616,7 @@ def save_agent(agent: Agent, ms: MetadataStore):
     assert isinstance(agent.agent_state.memory, Memory), f"Memory is not a Memory object: {type(agent_state.memory)}"
 
 
-def save_agent_memory(agent: Agent, ms: MetadataStore):
+def save_agent_memory(agent: Agent):
     """
     Save agent memory to metadata store. Memory is a collection of blocks and each block is persisted to the block table.
 
@@ -1618,14 +1625,12 @@ def save_agent_memory(agent: Agent, ms: MetadataStore):
 
     for block_dict in agent.memory.to_dict()["memory"].values():
         # TODO: block creation should happen in one place to enforce these sort of constraints consistently.
-        if block_dict.get("user_id", None) is None:
-            block_dict["user_id"] = agent.agent_state.user_id
         block = Block(**block_dict)
         # FIXME: should we expect for block values to be None? If not, we need to figure out why that is
         # the case in some tests, if so we should relax the DB constraint.
         if block.value is None:
             block.value = ""
-        ms.update_or_create_block(block)
+        BlockManager().create_or_update_block(block, actor=agent.user)
 
 
 def strip_name_field_from_user_message(user_message_text: str) -> Tuple[str, Optional[str]]:

letta/agent_store/db.py

@@ -380,9 +380,10 @@ class PostgresStorageConnector(SQLStorageConnector):
         else:
             raise ValueError(f"Table type {table_type} not implemented")
 
-        for c in self.db_model.__table__.columns:
-            if c.name == "embedding":
-                assert isinstance(c.type, Vector), f"Embedding column must be of type Vector, got {c.type}"
+        if settings.pg_uri:
+            for c in self.db_model.__table__.columns:
+                if c.name == "embedding":
+                    assert isinstance(c.type, Vector), f"Embedding column must be of type Vector, got {c.type}"
 
         from letta.server.server import db_context
 

letta/cli/cli.py

@@ -220,7 +220,7 @@ def run(
 
         # create agent
         tools = [server.tool_manager.get_tool_by_name(tool_name=tool_name, actor=client.user) for tool_name in agent_state.tools]
-        letta_agent = Agent(agent_state=agent_state, interface=interface(), tools=tools)
+        letta_agent = Agent(agent_state=agent_state, interface=interface(), tools=tools, user=client.user)
 
     else:  # create new agent
         # create new agent config: override defaults with args if provided
@@ -320,6 +320,7 @@ def run(
             tools=tools,
             # gpt-3.5-turbo tends to omit inner monologue, relax this requirement for now
             first_message_verify_mono=True if (model is not None and "gpt-4" in model) else False,
+            user=client.user,
         )
         save_agent(agent=letta_agent, ms=ms)
         typer.secho(f"🎉 Created new agent '{letta_agent.agent_state.name}' (id={letta_agent.agent_state.id})", fg=typer.colors.GREEN)

letta/client/client.py

@@ -12,12 +12,10 @@ from letta.memory import get_memory_functions
 from letta.schemas.agent import AgentState, AgentType, CreateAgent, UpdateAgentState
 from letta.schemas.block import (
     Block,
-    CreateBlock,
-    CreateHuman,
-    CreatePersona,
+    BlockCreate,
+    BlockUpdate,
     Human,
     Persona,
-    UpdateBlock,
     UpdateHuman,
     UpdatePersona,
 )
@@ -883,8 +881,8 @@ class RESTClient(AbstractClient):
         else:
             return [Block(**block) for block in response.json()]
 
-    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)
+    def create_block(self, label: str, value: str, template_name: Optional[str] = None, is_template: bool = False) -> Block:  #
+        request = BlockCreate(label=label, value=value, template=is_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}")
@@ -896,7 +894,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, template_name=name, value=text)
+        request = BlockUpdate(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}")
@@ -950,7 +948,7 @@ class RESTClient(AbstractClient):
         Returns:
             human (Human): Human block
         """
-        return self.create_block(label="human", template_name=name, text=text, template=True)
+        return self.create_block(label="human", template_name=name, value=text, is_template=True)
 
     def update_human(self, human_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Human:
         """
@@ -990,7 +988,7 @@ class RESTClient(AbstractClient):
         Returns:
             persona (Persona): Persona block
         """
-        return self.create_block(label="persona", template_name=name, text=text, template=True)
+        return self.create_block(label="persona", template_name=name, value=text, is_template=True)
 
     def update_persona(self, persona_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Persona:
         """
@@ -2125,8 +2123,7 @@ class LocalClient(AbstractClient):
     # humans / personas
 
     def get_block_id(self, name: str, label: str) -> str:
-
-        block = self.server.get_blocks(name=name, label=label, user_id=self.user_id, template=True)
+        block = self.server.block_manager.get_blocks(actor=self.user, template_name=name, label=label, is_template=True)
         if not block:
             return None
         return block[0].id
@@ -2142,7 +2139,7 @@ class LocalClient(AbstractClient):
         Returns:
             human (Human): Human block
         """
-        return self.server.create_block(CreateHuman(template_name=name, value=text, user_id=self.user_id), user_id=self.user_id)
+        return self.server.block_manager.create_or_update_block(Human(template_name=name, value=text), actor=self.user)
 
     def create_persona(self, name: str, text: str):
         """
@@ -2155,7 +2152,7 @@ class LocalClient(AbstractClient):
         Returns:
             persona (Persona): Persona block
         """
-        return self.server.create_block(CreatePersona(template_name=name, value=text, user_id=self.user_id), user_id=self.user_id)
+        return self.server.block_manager.create_or_update_block(Persona(template_name=name, value=text), actor=self.user)
 
     def list_humans(self):
         """
@@ -2164,7 +2161,7 @@ class LocalClient(AbstractClient):
         Returns:
             humans (List[Human]): List of human blocks
         """
-        return self.server.get_blocks(label="human", user_id=self.user_id, template=True)
+        return self.server.block_manager.get_blocks(actor=self.user, label="human", is_template=True)
 
     def list_personas(self) -> List[Persona]:
         """
@@ -2173,7 +2170,7 @@ class LocalClient(AbstractClient):
         Returns:
             personas (List[Persona]): List of persona blocks
         """
-        return self.server.get_blocks(label="persona", user_id=self.user_id, template=True)
+        return self.server.block_manager.get_blocks(actor=self.user, label="persona", is_template=True)
 
     def update_human(self, human_id: str, text: str):
         """
@@ -2186,7 +2183,9 @@ class LocalClient(AbstractClient):
         Returns:
             human (Human): Updated human block
         """
-        return self.server.update_block(UpdateHuman(id=human_id, value=text, user_id=self.user_id, template=True))
+        return self.server.block_manager.update_block(
+            block_id=human_id, block_update=UpdateHuman(value=text, is_template=True), actor=self.user
+        )
 
     def update_persona(self, persona_id: str, text: str):
         """
@@ -2199,7 +2198,9 @@ class LocalClient(AbstractClient):
         Returns:
             persona (Persona): Updated persona block
         """
-        return self.server.update_block(UpdatePersona(id=persona_id, value=text, user_id=self.user_id, template=True))
+        return self.server.block_manager.update_block(
+            block_id=persona_id, block_update=UpdatePersona(value=text, is_template=True), actor=self.user
+        )
 
     def get_persona(self, id: str) -> Persona:
         """
@@ -2212,7 +2213,7 @@ class LocalClient(AbstractClient):
             persona (Persona): Persona block
         """
         assert id, f"Persona ID must be provided"
-        return Persona(**self.server.get_block(id).model_dump())
+        return Persona(**self.server.block_manager.get_block_by_id(id, actor=self.user).model_dump())
 
     def get_human(self, id: str) -> Human:
         """
@@ -2225,7 +2226,7 @@ class LocalClient(AbstractClient):
             human (Human): Human block
         """
         assert id, f"Human ID must be provided"
-        return Human(**self.server.get_block(id).model_dump())
+        return Human(**self.server.block_manager.get_block_by_id(id, actor=self.user).model_dump())
 
     def get_persona_id(self, name: str) -> str:
         """
@@ -2237,7 +2238,7 @@ class LocalClient(AbstractClient):
         Returns:
             id (str): ID of the persona block
         """
-        persona = self.server.get_blocks(name=name, label="persona", user_id=self.user_id, template=True)
+        persona = self.server.block_manager.get_blocks(actor=self.user, template_name=name, label="persona", is_template=True)
         if not persona:
             return None
         return persona[0].id
@@ -2252,7 +2253,7 @@ class LocalClient(AbstractClient):
         Returns:
             id (str): ID of the human block
         """
-        human = self.server.get_blocks(name=name, label="human", user_id=self.user_id, template=True)
+        human = self.server.block_manager.get_blocks(actor=self.user, template_name=name, label="human", is_template=True)
         if not human:
             return None
         return human[0].id
@@ -2264,7 +2265,7 @@ class LocalClient(AbstractClient):
         Args:
             id (str): ID of the persona block
         """
-        self.server.delete_block(id)
+        self.delete_block(id)
 
     def delete_human(self, id: str):
         """
@@ -2273,7 +2274,7 @@ class LocalClient(AbstractClient):
         Args:
             id (str): ID of the human block
         """
-        self.server.delete_block(id)
+        self.delete_block(id)
 
     # tools
     def load_langchain_tool(self, langchain_tool: "LangChainBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> Tool:
@@ -2661,9 +2662,9 @@ class LocalClient(AbstractClient):
         Returns:
             blocks (List[Block]): List of blocks
         """
-        return self.server.get_blocks(label=label, template=templates_only)
+        return self.server.block_manager.get_blocks(actor=self.user, label=label, is_template=templates_only)
 
-    def create_block(self, label: str, text: str, template_name: Optional[str] = None, template: bool = False) -> Block:  #
+    def create_block(self, label: str, value: str, template_name: Optional[str] = None, is_template: bool = False) -> Block:  #
         """
         Create a block
 
@@ -2675,8 +2676,8 @@ class LocalClient(AbstractClient):
         Returns:
             block (Block): Created block
         """
-        return self.server.create_block(
-            CreateBlock(label=label, template_name=template_name, value=text, user_id=self.user_id, template=template), user_id=self.user_id
+        return self.server.block_manager.create_or_update_block(
+            Block(label=label, template_name=template_name, value=value, is_template=is_template), actor=self.user
         )
 
     def update_block(self, block_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Block:
@@ -2691,7 +2692,9 @@ class LocalClient(AbstractClient):
         Returns:
             block (Block): Updated block
         """
-        return self.server.update_block(UpdateBlock(id=block_id, template_name=name, value=text))
+        return self.server.block_manager.update_block(
+            block_id=block_id, block_update=BlockUpdate(template_name=name, value=text), actor=self.user
+        )
 
     def get_block(self, block_id: str) -> Block:
         """
@@ -2703,7 +2706,7 @@ class LocalClient(AbstractClient):
         Returns:
             block (Block): Block
         """
-        return self.server.get_block(block_id)
+        return self.server.block_manager.get_block_by_id(block_id, actor=self.user)
 
     def delete_block(self, id: str) -> Block:
         """
@@ -2715,7 +2718,7 @@ class LocalClient(AbstractClient):
         Returns:
             block (Block): Deleted block
         """
-        return self.server.delete_block(id)
+        return self.server.block_manager.delete_block(id, actor=self.user)
 
     def set_default_llm_config(self, llm_config: LLMConfig):
         """

letta/constants.py

@@ -158,3 +158,6 @@ RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE = 5
 # TODO Is this config or constant?
 CORE_MEMORY_PERSONA_CHAR_LIMIT: int = 2000
 CORE_MEMORY_HUMAN_CHAR_LIMIT: int = 2000
+
+MAX_FILENAME_LENGTH = 255
+RESERVED_FILENAMES = {"CON", "PRN", "AUX", "NUL", "COM1", "COM2", "LPT1", "LPT2"}

letta/metadata.py

@@ -4,23 +4,13 @@ import os
 import secrets
 from typing import List, Optional
 
-from sqlalchemy import (
-    BIGINT,
-    JSON,
-    Boolean,
-    Column,
-    DateTime,
-    Index,
-    String,
-    TypeDecorator,
-)
+from sqlalchemy import JSON, Column, DateTime, Index, String, TypeDecorator
 from sqlalchemy.sql import func
 
 from letta.config import LettaConfig
 from letta.orm.base import Base
 from letta.schemas.agent import AgentState
 from letta.schemas.api_key import APIKey
-from letta.schemas.block import Block, Human, Persona
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import JobStatus
 from letta.schemas.job import Job
@@ -269,63 +259,6 @@ class AgentSourceMappingModel(Base):
         return f"<AgentSourceMapping(user_id='{self.user_id}', agent_id='{self.agent_id}', source_id='{self.source_id}')>"
 
 
-class BlockModel(Base):
-    __tablename__ = "block"
-    __table_args__ = {"extend_existing": True}
-
-    id = Column(String, primary_key=True, nullable=False)
-    value = Column(String, nullable=False)
-    limit = Column(BIGINT)
-    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)
-    description = Column(String)
-    user_id = Column(String)
-    Index(__tablename__ + "_idx_user", user_id),
-
-    def __repr__(self) -> str:
-        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":
-            return Persona(
-                id=self.id,
-                value=self.value,
-                limit=self.limit,
-                template_name=self.template_name,
-                template=self.template,
-                label=self.label,
-                metadata_=self.metadata_,
-                description=self.description,
-                user_id=self.user_id,
-            )
-        elif self.label == "human":
-            return Human(
-                id=self.id,
-                value=self.value,
-                limit=self.limit,
-                template_name=self.template_name,
-                template=self.template,
-                label=self.label,
-                metadata_=self.metadata_,
-                description=self.description,
-                user_id=self.user_id,
-            )
-        else:
-            return Block(
-                id=self.id,
-                value=self.value,
-                limit=self.limit,
-                template_name=self.template_name,
-                template=self.template,
-                label=self.label,
-                metadata_=self.metadata_,
-                description=self.description,
-                user_id=self.user_id,
-            )
-
-
 class JobModel(Base):
     __tablename__ = "jobs"
     __table_args__ = {"extend_existing": True}
@@ -425,27 +358,6 @@ class MetadataStore:
             session.add(AgentModel(**fields))
             session.commit()
 
-    @enforce_types
-    def create_block(self, block: Block):
-        with self.session_maker() as session:
-            # TODO: fix?
-            # we are only validating that more than one template block
-            # with a given name doesn't exist.
-            if (
-                session.query(BlockModel)
-                .filter(BlockModel.template_name == block.template_name)
-                .filter(BlockModel.user_id == block.user_id)
-                .filter(BlockModel.template == True)
-                .filter(BlockModel.label == block.label)
-                .count()
-                > 0
-            ):
-
-                raise ValueError(f"Block with name {block.template_name} already exists")
-
-            session.add(BlockModel(**vars(block)))
-            session.commit()
-
     @enforce_types
     def update_agent(self, agent: AgentState):
         with self.session_maker() as session:
@@ -457,28 +369,6 @@ class MetadataStore:
             session.query(AgentModel).filter(AgentModel.id == agent.id).update(fields)
             session.commit()
 
-    @enforce_types
-    def update_block(self, block: Block):
-        with self.session_maker() as session:
-            session.query(BlockModel).filter(BlockModel.id == block.id).update(vars(block))
-            session.commit()
-
-    @enforce_types
-    def update_or_create_block(self, block: Block):
-        with self.session_maker() as session:
-            existing_block = session.query(BlockModel).filter(BlockModel.id == block.id).first()
-            if existing_block:
-                session.query(BlockModel).filter(BlockModel.id == block.id).update(vars(block))
-            else:
-                session.add(BlockModel(**vars(block)))
-            session.commit()
-
-    @enforce_types
-    def delete_block(self, block_id: str):
-        with self.session_maker() as session:
-            session.query(BlockModel).filter(BlockModel.id == block_id).delete()
-            session.commit()
-
     @enforce_types
     def delete_agent(self, agent_id: str):
         with self.session_maker() as session:
@@ -513,50 +403,6 @@ class MetadataStore:
             assert len(results) == 1, f"Expected 1 result, got {len(results)}"  # should only be one result
             return results[0].to_record()
 
-    @enforce_types
-    def get_block(self, block_id: str) -> Optional[Block]:
-        with self.session_maker() as session:
-            results = session.query(BlockModel).filter(BlockModel.id == block_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_blocks(
-        self,
-        user_id: Optional[str],
-        label: Optional[str] = None,
-        template: Optional[bool] = None,
-        template_name: Optional[str] = None,
-        id: Optional[str] = None,
-    ) -> Optional[List[Block]]:
-        """List available blocks"""
-        with self.session_maker() as session:
-            query = session.query(BlockModel)
-
-            if user_id:
-                query = query.filter(BlockModel.user_id == user_id)
-
-            if label:
-                query = query.filter(BlockModel.label == label)
-
-            if template_name:
-                query = query.filter(BlockModel.template_name == template_name)
-
-            if id:
-                query = query.filter(BlockModel.id == id)
-
-            if template:
-                query = query.filter(BlockModel.template == template)
-
-            results = query.all()
-
-            if len(results) == 0:
-                return None
-
-            return [r.to_record() for r in results]
-
     # agent source metadata
     @enforce_types
     def attach_source(self, user_id: str, agent_id: str, source_id: str):

letta/o1_agent.py

@@ -8,6 +8,7 @@ from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.tool import Tool
 from letta.schemas.usage import LettaUsageStatistics
+from letta.schemas.user import User
 
 
 def send_thinking_message(self: "Agent", message: str) -> Optional[str]:
@@ -43,11 +44,12 @@ class O1Agent(Agent):
         self,
         interface: AgentInterface,
         agent_state: AgentState,
+        user: User,
         tools: List[Tool] = [],
         max_thinking_steps: int = 10,
         first_message_verify_mono: bool = False,
     ):
-        super().__init__(interface, agent_state, tools)
+        super().__init__(interface, agent_state, tools, user)
         self.max_thinking_steps = max_thinking_steps
         self.tools = tools
         self.first_message_verify_mono = first_message_verify_mono

letta/orm/__init__.py

@@ -1,4 +1,5 @@
 from letta.orm.base import Base
+from letta.orm.block import Block
 from letta.orm.file import FileMetadata
 from letta.orm.organization import Organization
 from letta.orm.source import Source

letta/orm/block.py

@@ -0,0 +1,44 @@
+from typing import TYPE_CHECKING, Optional, Type
+
+from sqlalchemy import JSON, BigInteger, Integer
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.mixins import OrganizationMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.block import Block as PydanticBlock
+from letta.schemas.block import Human, Persona
+
+if TYPE_CHECKING:
+    from letta.orm.organization import Organization
+
+
+class Block(OrganizationMixin, SqlalchemyBase):
+    """Blocks are sections of the LLM context, representing a specific part of the total Memory"""
+
+    __tablename__ = "block"
+    __pydantic_model__ = PydanticBlock
+
+    template_name: Mapped[Optional[str]] = mapped_column(
+        nullable=True, doc="the unique name that identifies a block in a human-readable way"
+    )
+    description: Mapped[Optional[str]] = mapped_column(nullable=True, doc="a description of the block for context")
+    label: Mapped[str] = mapped_column(doc="the type of memory block in use, ie 'human', 'persona', 'system'")
+    is_template: Mapped[bool] = mapped_column(
+        doc="whether the block is a template (e.g. saved human/persona options as baselines for other templates)", default=False
+    )
+    value: Mapped[str] = mapped_column(doc="Text content of the block for the respective section of core memory.")
+    limit: Mapped[BigInteger] = mapped_column(Integer, default=2000, doc="Character limit of the block.")
+    metadata_: Mapped[Optional[dict]] = mapped_column(JSON, default={}, doc="arbitrary information related to the block.")
+
+    # relationships
+    organization: Mapped[Optional["Organization"]] = relationship("Organization")
+
+    def to_pydantic(self) -> Type:
+        match self.label:
+            case "human":
+                Schema = Human
+            case "persona":
+                Schema = Persona
+            case _:
+                Schema = PydanticBlock
+        return Schema.model_validate(self)

letta/orm/organization.py

@@ -23,6 +23,7 @@ class Organization(SqlalchemyBase):
     # relationships
     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")
+    blocks: Mapped[List["Block"]] = relationship("Block", back_populates="organization", cascade="all, delete-orphan")
     sources: Mapped[List["Source"]] = relationship("Source", back_populates="organization", cascade="all, delete-orphan")
     agents_tags: Mapped[List["AgentsTags"]] = relationship("AgentsTags", back_populates="organization", cascade="all, delete-orphan")
     files: Mapped[List["FileMetadata"]] = relationship("FileMetadata", back_populates="organization", cascade="all, delete-orphan")