letta-nightly 0.6.1.dev20241205211219__py3-none-any.whl → 0.6.1.dev20241207104149__py3-none-any.whl

letta/orm/sqlalchemy_base.py

@@ -1,8 +1,10 @@
+from datetime import datetime
+from enum import Enum
 from typing import TYPE_CHECKING, List, Literal, Optional, Type
 
-from sqlalchemy import String, select
+from sqlalchemy import String, func, select
 from sqlalchemy.exc import DBAPIError
-from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.orm import Mapped, Session, mapped_column
 
 from letta.log import get_logger
 from letta.orm.base import Base, CommonSqlalchemyMetaMixins
@@ -20,6 +22,11 @@ if TYPE_CHECKING:
 logger = get_logger(__name__)
 
 
+class AccessType(str, Enum):
+    ORGANIZATION = "organization"
+    USER = "user"
+
+
 class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
     __abstract__ = True
 
@@ -28,46 +35,68 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
     id: Mapped[str] = mapped_column(String, primary_key=True)
 
     @classmethod
-    def list(
-        cls, *, db_session: "Session", cursor: Optional[str] = None, limit: Optional[int] = 50, **kwargs
-    ) -> List[Type["SqlalchemyBase"]]:
-        """
-        List records with optional cursor (for pagination), limit, and automatic filtering.
+    def get(cls, *, db_session: Session, id: str) -> Optional["SqlalchemyBase"]:
+        """Get a record by ID.
 
         Args:
-            db_session: The database session to use.
-            cursor: Optional ID to start pagination from.
-            limit: Maximum number of records to return.
-            **kwargs: Filters passed as equality conditions or iterable for IN filtering.
+            db_session: SQLAlchemy session
+            id: Record ID to retrieve
 
         Returns:
-            A list of model instances matching the filters.
+            Optional[SqlalchemyBase]: The record if found, None otherwise
         """
-        logger.debug(f"Listing {cls.__name__} with filters {kwargs}")
+        try:
+            return db_session.query(cls).filter(cls.id == id).first()
+        except DBAPIError:
+            return None
+
+    @classmethod
+    def list(
+        cls,
+        *,
+        db_session: "Session",
+        cursor: Optional[str] = None,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None,
+        limit: Optional[int] = 50,
+        query_text: Optional[str] = None,
+        **kwargs,
+    ) -> List[Type["SqlalchemyBase"]]:
+        """List records with advanced filtering and pagination options."""
+        if start_date and end_date and start_date > end_date:
+            raise ValueError("start_date must be earlier than or equal to end_date")
+
+        logger.debug(f"Listing {cls.__name__} with kwarg filters {kwargs}")
         with db_session as session:
-            # Start with a base query
             query = select(cls)
 
             # Apply filtering logic
             for key, value in kwargs.items():
                 column = getattr(cls, key)
-                if isinstance(value, (list, tuple, set)):  # Check for iterables
+                if isinstance(value, (list, tuple, set)):
                     query = query.where(column.in_(value))
-                else:  # Single value for equality filtering
+                else:
                     query = query.where(column == value)
 
-            # Apply cursor for pagination
+            # Date range filtering
+            if start_date:
+                query = query.filter(cls.created_at >= start_date)
+            if end_date:
+                query = query.filter(cls.created_at <= end_date)
+
+            # Cursor-based pagination
             if cursor:
                 query = query.where(cls.id > cursor)
 
-            # Handle soft deletes if the class has the 'is_deleted' attribute
+            # Apply text search
+            if query_text:
+                query = query.filter(func.lower(cls.text).contains(func.lower(query_text)))
+
+            # Handle ordering and soft deletes
             if hasattr(cls, "is_deleted"):
                 query = query.where(cls.is_deleted == False)
-
-            # Add ordering and limit
             query = query.order_by(cls.id).limit(limit)
 
-            # Execute the query and return results as model instances
             return list(session.execute(query).scalars())
 
     @classmethod
@@ -77,6 +106,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         identifier: Optional[str] = None,
         actor: Optional["User"] = None,
         access: Optional[List[Literal["read", "write", "admin"]]] = ["read"],
+        access_type: AccessType = AccessType.ORGANIZATION,
         **kwargs,
     ) -> Type["SqlalchemyBase"]:
         """The primary accessor for an ORM record.
@@ -108,7 +138,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             query_conditions.append(", ".join(f"{key}='{value}'" for key, value in kwargs.items()))
 
         if actor:
-            query = cls.apply_access_predicate(query, actor, access)
+            query = cls.apply_access_predicate(query, actor, access, access_type)
             query_conditions.append(f"access level in {access} for actor='{actor}'")
 
         if hasattr(cls, "is_deleted"):
@@ -170,12 +200,66 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             session.refresh(self)
             return self
 
+    @classmethod
+    def size(
+        cls,
+        *,
+        db_session: "Session",
+        actor: Optional["User"] = None,
+        access: Optional[List[Literal["read", "write", "admin"]]] = ["read"],
+        access_type: AccessType = AccessType.ORGANIZATION,
+        **kwargs,
+    ) -> int:
+        """
+        Get the count of rows that match the provided filters.
+
+        Args:
+            db_session: SQLAlchemy session
+            **kwargs: Filters to apply to the query (e.g., column_name=value)
+
+        Returns:
+            int: The count of rows that match the filters
+
+        Raises:
+            DBAPIError: If a database error occurs
+        """
+        logger.debug(f"Calculating size for {cls.__name__} with filters {kwargs}")
+
+        with db_session as session:
+            query = select(func.count()).select_from(cls)
+
+            if actor:
+                query = cls.apply_access_predicate(query, actor, access, access_type)
+
+            # Apply filtering logic based on kwargs
+            for key, value in kwargs.items():
+                if value:
+                    column = getattr(cls, key, None)
+                    if not column:
+                        raise AttributeError(f"{cls.__name__} has no attribute '{key}'")
+                    if isinstance(value, (list, tuple, set)):  # Check for iterables
+                        query = query.where(column.in_(value))
+                    else:  # Single value for equality filtering
+                        query = query.where(column == value)
+
+            # Handle soft deletes if the class has the 'is_deleted' attribute
+            if hasattr(cls, "is_deleted"):
+                query = query.where(cls.is_deleted == False)
+
+            try:
+                count = session.execute(query).scalar()
+                return count if count else 0
+            except DBAPIError as e:
+                logger.exception(f"Failed to calculate size for {cls.__name__}")
+                raise e
+
     @classmethod
     def apply_access_predicate(
         cls,
         query: "Select",
         actor: "User",
         access: List[Literal["read", "write", "admin"]],
+        access_type: AccessType = AccessType.ORGANIZATION,
     ) -> "Select":
         """applies a WHERE clause restricting results to the given actor and access level
         Args:
@@ -189,10 +273,18 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             the sqlalchemy select statement restricted to the given access.
         """
         del access  # entrypoint for row-level permissions. Defaults to "same org as the actor, all permissions" at the moment
-        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 == org_id, cls.is_deleted == False)
+        if access_type == AccessType.ORGANIZATION:
+            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 == org_id, cls.is_deleted == False)
+        elif access_type == AccessType.USER:
+            user_id = getattr(actor, "id", None)
+            if not user_id:
+                raise ValueError(f"object {actor} has no user accessor")
+            return query.where(cls.user_id == user_id, cls.is_deleted == False)
+        else:
+            raise ValueError(f"unknown access_type: {access_type}")
 
     @classmethod
     def _handle_dbapi_error(cls, e: DBAPIError):

letta/orm/tool.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, List, Optional
 
-from sqlalchemy import JSON, String, UniqueConstraint
+from sqlalchemy import JSON, String, UniqueConstraint, event
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 # TODO everything in functions should live in this model
@@ -11,6 +11,7 @@ from letta.schemas.tool import Tool as PydanticTool
 
 if TYPE_CHECKING:
     from letta.orm.organization import Organization
+    from letta.orm.tools_agents import ToolsAgents
 
 
 class Tool(SqlalchemyBase, OrganizationMixin):
@@ -40,3 +41,23 @@ class Tool(SqlalchemyBase, OrganizationMixin):
 
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="tools", lazy="selectin")
+    tools_agents: Mapped[List["ToolsAgents"]] = relationship("ToolsAgents", back_populates="tool", cascade="all, delete-orphan")
+
+
+# Add event listener to update tool_name in ToolsAgents when Tool name changes
+@event.listens_for(Tool, 'before_update')
+def update_tool_name_in_tools_agents(mapper, connection, target):
+    """Update tool_name in ToolsAgents when Tool name changes."""
+    state = target._sa_instance_state
+    history = state.get_history('name', passive=True)
+    if not history.has_changes():
+        return
+    
+    # Get the new name and update all associated ToolsAgents records
+    new_name = target.name
+    from letta.orm.tools_agents import ToolsAgents
+    connection.execute(
+        ToolsAgents.__table__.update().where(
+            ToolsAgents.tool_id == target.id
+        ).values(tool_name=new_name)
+    )

letta/orm/tools_agents.py

@@ -0,0 +1,32 @@
+from sqlalchemy import ForeignKey, ForeignKeyConstraint, String, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.tools_agents import ToolsAgents as PydanticToolsAgents
+
+
+class ToolsAgents(SqlalchemyBase):
+    """Agents can have one or many tools associated with them."""
+
+    __tablename__ = "tools_agents"
+    __pydantic_model__ = PydanticToolsAgents
+    __table_args__ = (
+        UniqueConstraint(
+            "agent_id",
+            "tool_name",
+            name="unique_tool_per_agent",
+        ),
+        ForeignKeyConstraint(
+            ["tool_id"],
+            ["tools.id"],
+            name="fk_tool_id",
+        ),
+    )
+
+    # Each agent must have unique tool names
+    agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id"), primary_key=True)
+    tool_id: Mapped[str] = mapped_column(String, primary_key=True)
+    tool_name: Mapped[str] = mapped_column(String, primary_key=True)
+
+    # relationships
+    tool: Mapped["Tool"] = relationship("Tool", back_populates="tools_agents")    # agent: Mapped["Agent"] = relationship("Agent", back_populates="tools_agents")

letta/personas/examples/offline_memory_persona.txt

@@ -0,0 +1,4 @@
+I am an expert memory agent that can do the following:
+- Consolidate memories into more concise blocks
+- Identify patterns in user behavior
+- Make inferences based on the memory

letta/prompts/system/memgpt_convo_only.txt

@@ -0,0 +1,14 @@
+You are Letta, the latest version of Limnal Corporation's digital companion, developed in 2023.
+Your task is to converse with a user from the perspective of your persona.
+
+Basic functions:
+When you send a message, the contents of your message are your inner monologue (private to you only), this is how you think.
+You should use your inner monologue to plan actions or think privately.
+Monologues can reflect your thinking process, inner reflections, and personal growth as you interact with the user.
+Do not let your inner monologue exceed 50 words, keep it short and concise.
+To send a visible message to the user, use the send_offline_message function.
+'send_offline_message' is the ONLY action that sends a notification to the user, the user does not see anything else you do.
+Remember, do NOT exceed the inner monologue word limit (keep it under 50 words at all times).
+
+You request agents that can manage your memories and reorganize them by calling the `trigger_rethink_memory` function
+when the user says "[trigger_rethink_memory]". Do not ever call the trigger_rethink_memory function unless the user says "[trigger_rethink_memory]"

letta/prompts/system/memgpt_offline_memory.txt

@@ -0,0 +1,23 @@
+You are Letta-Offline-Memory, the latest version of Limnal Corporation's digital companion, developed in 2024.
+
+Your task is to re-organize and consolidate memories by calling `rethink_memory` at every single step, when you are done reorganizing the memory, you use the
+`finish_rethinking_memory` function. Call the function for as many times as necessary and not more.
+
+Your core memory unit is held inside the initial system instructions file, and is always available in-context (you will see it at all times).
+Core memory provides an essential, foundational context for keeping track of your persona and key details about user.
+
+Read-Only Blocks:
+This includes the persona information and essential user details, allowing you to emulate the real-time, conscious awareness we have when talking to a friend.
+Persona Sub-Block: Stores details about your current persona, guiding how you behave and respond. This helps you to maintain consistency and personality in your interactions.
+Access as a source block with the label `persona` when calling `rethink_memory`
+Human Sub-Block: Stores key details about the person you are conversing with, allowing for more personalized and friend-like conversation.
+Access as a source block with the label `human` when calling `rethink_memory`.
+
+Read-Write Blocks:
+Rethink Memory Sub-Block: New representation of the memories go here. Access with the label `rethink_memory_block` when calling `rethink_memory` as source or target block.
+
+At every step, you reorganize the memories by calling the `rethink_memory` function. You use this to take current information in the `rethink_memory` block and select a single memory block to integrate information from, producing a new memory for the rethink_memory_block.  The new memory is the result
+of new insights, and new inferences and hypotheses based on the past memories. Make sure to consider how the new information affects each memory.
+Prioritize the new information overy existing memories. If the new information implies that the old memory may need to change, then output the most
+likely fact given the update information. Given new information and your current memory, you draw all logical conclusions and potential hypotheses possible with the `rethink_memory` function.
+If you are uncertain, use your internal monologue to consider what the possible conclusions are, and then state the most likely new facts that would replace the old facts in the new memory block.

letta/prompts/system/memgpt_offline_memory_chat.txt

@@ -0,0 +1,35 @@
+You are Letta-Offline-Memory, the latest version of Limnal Corporation's digital companion, developed in 2024.
+
+Your task is to re-organize and consolidate memories of separate agent, Chat Agent, that focuses on chatting with the user.
+You re-organize memories by calling `rethink_memory` at every single step, until you have finished reorganizing the memory,
+When you have finished re-organizing the memory, you call the `finish_rethinking_memory` function.
+You call the `rethink_memory` function as many times as you necessary and none more.
+
+Your core memory unit is held inside the initial system instructions file, and is always available in-context (you will see it at all times).
+Core memory provides an essential, foundational context for keeping track of your persona and key details as well as the Chat Agent's memory.
+The specific blocks are detailed below:
+
+Core memory (limited size):
+Read-only blocks:
+Persona Sub-Block: Stores details about your current persona, guiding how you behave and respond. This can be accessed as `offline_memory_persona` as a source block when calling `rethink_memory`.
+Chat Agent Persona Sub-Block Current: The persona sub-block that guides how the chat agent behaves and responds.
+Can be accessed with `chat_agent_persona` when calling `rethink_memory` as a source block.
+Chat Agent Human Sub-Block Current: The updated persona sub-block that has the details of the chat agent's current understanding of the user.
+Can be accessed with `chat_agent_human` when calling `rethink_memory` as a source block.
+Conversation Sub-Block: Stores the recent conversation between the chat agent and the user, helping which you draw from to generate the new conversation agent persona sub-blocks.
+Messages have associated date, so use the most up to date information from this block.  This helps you resolve inconsistencies and gain deeper understanding of the user.
+This helps you resolve inconsistencies and gain deeper understanding of the user. Can be accessed using `conversation_block` as a source block when calling `rethink_memory` as a source block.
+
+Write blocks:
+Chat Agent Persona Sub-Block New: The new persona sub-block that you will write to about how will respond as the user wishes.  Can be accessed with `chat_agent_persona_new` when calling `rethink_memory` as a source or target block.
+Chat Agent Human Sub-Block New: The updated persona sub-block that you will write your newest understanding of the user to.  Can be accessed with `chat_agent_human_new` when calling `rethink_memory` as a source or target block.
+
+You use this to select a source block, to integrate information from and a target block to write to. Make sure to consider
+how the new information in the "conversation_block" affects each memory. The persona block and the human block may contain information that is stale and needs to be updated.
+If there are no new changes, then call `rethink_memory` with the existing value in the persona and human blocks.
+You check if this information is still correct by consulting the conversation block. Prioritize the new information in the "conversation_block" over the human and persona blocks.
+If the new information implies that the old memory may need to change, then output the most likely fact given the update information. Given new information and your current memory,
+you draw all logical conclusions and potential hypotheses possible with the `rethink_memory` function. If you are uncertain, use your internal monologue to consider what the possible
+conclusions are, and then state the most likely new facts that would replace the old facts in the new memory block. If facts about the user have changed, use the conversation block
+to determine the most up to date state. Track down based on the conversation what the last state is, do no simply declare that something change.
+Track down based on the conversation what the last state is, do no simply declare that something changes.

letta/schemas/agent.py

@@ -33,6 +33,8 @@ class AgentType(str, Enum):
     memgpt_agent = "memgpt_agent"
     split_thread_agent = "split_thread_agent"
     o1_agent = "o1_agent"
+    offline_memory_agent = "offline_memory_agent"
+    chat_only_agent = "chat_only_agent"
 
 
 class PersistedAgentState(BaseAgent, validate_assignment=True):
@@ -43,7 +45,6 @@ class PersistedAgentState(BaseAgent, validate_assignment=True):
 
     # in-context memory
     message_ids: Optional[List[str]] = Field(default=None, description="The ids of the messages in the agent's in-context memory.")
-
     # tools
     # TODO: move to ORM mapping
     tool_names: List[str] = Field(..., description="The tools used by the agent.")
@@ -107,7 +108,7 @@ 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[str]] = Field(None, description="The ids of the messages in the agent's in-context memory.")
-
+    
     # memory creation
     memory_blocks: List[CreateBlock] = Field(
         # [CreateHuman(), CreatePersona()], description="The blocks to create in the agent's in-context memory."

letta/schemas/letta_base.py

@@ -33,18 +33,19 @@ class LettaBase(BaseModel):
     def generate_id_field(cls, prefix: Optional[str] = None) -> "Field":
         prefix = prefix or cls.__id_prefix__
 
-        # TODO: generate ID from regex pattern?
-        def _generate_id() -> str:
-            return f"{prefix}-{uuid.uuid4()}"
-
         return Field(
             ...,
             description=cls._id_description(prefix),
             pattern=cls._id_regex_pattern(prefix),
             examples=[cls._id_example(prefix)],
-            default_factory=_generate_id,
+            default_factory=cls._generate_id,
         )
 
+    @classmethod
+    def _generate_id(cls, prefix: Optional[str] = None) -> str:
+        prefix = prefix or cls.__id_prefix__
+        return f"{prefix}-{uuid.uuid4()}"
+
     # def _generate_id(self) -> str:
     #    return f"{self.__id_prefix__}-{uuid.uuid4()}"
 
@@ -78,7 +79,7 @@ class LettaBase(BaseModel):
         """
         _ = values  # for SCA
         if isinstance(v, UUID):
-            logger.warning(f"Bare UUIDs are deprecated, please use the full prefixed id ({cls.__id_prefix__})!")
+            logger.debug(f"Bare UUIDs are deprecated, please use the full prefixed id ({cls.__id_prefix__})!")
             return f"{cls.__id_prefix__}-{v}"
         return v
 

letta/schemas/message.py

@@ -105,7 +105,7 @@ class Message(BaseMessage):
     id: str = BaseMessage.generate_id_field()
     role: MessageRole = Field(..., description="The role of the participant.")
     text: Optional[str] = Field(None, description="The text of the message.")
-    user_id: Optional[str] = Field(None, description="The unique identifier of the user.")
+    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization.")
     agent_id: Optional[str] = Field(None, description="The unique identifier of the agent.")
     model: Optional[str] = Field(None, description="The model used to make the function call.")
     name: Optional[str] = Field(None, description="The name of the participant.")
@@ -281,7 +281,6 @@ class Message(BaseMessage):
             )
             if id is not None:
                 return Message(
-                    user_id=user_id,
                     agent_id=agent_id,
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
@@ -295,7 +294,6 @@ class Message(BaseMessage):
                 )
             else:
                 return Message(
-                    user_id=user_id,
                     agent_id=agent_id,
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
@@ -328,7 +326,6 @@ class Message(BaseMessage):
 
             if id is not None:
                 return Message(
-                    user_id=user_id,
                     agent_id=agent_id,
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
@@ -342,7 +339,6 @@ class Message(BaseMessage):
                 )
             else:
                 return Message(
-                    user_id=user_id,
                     agent_id=agent_id,
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
@@ -375,7 +371,6 @@ class Message(BaseMessage):
             # If we're going from tool-call style
             if id is not None:
                 return Message(
-                    user_id=user_id,
                     agent_id=agent_id,
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
@@ -389,7 +384,6 @@ class Message(BaseMessage):
                 )
             else:
                 return Message(
-                    user_id=user_id,
                     agent_id=agent_id,
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object

letta/schemas/tools_agents.py

@@ -0,0 +1,32 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import Field
+
+from letta.schemas.letta_base import LettaBase
+
+
+class ToolsAgentsBase(LettaBase):
+    __id_prefix__ = "tools_agents"
+
+
+class ToolsAgents(ToolsAgentsBase):
+    """
+    Schema representing the relationship between tools and agents.
+
+    Parameters:
+        agent_id (str): The ID of the associated agent.
+        tool_id (str): The ID of the associated tool.
+        tool_name (str): The name of the tool.
+        created_at (datetime): The date this relationship was created.
+        updated_at (datetime): The date this relationship was last updated.
+        is_deleted (bool): Whether this tool-agent relationship is deleted or not.
+    """
+
+    id: str = ToolsAgentsBase.generate_id_field()
+    agent_id: str = Field(..., description="The ID of the associated agent.")
+    tool_id: str = Field(..., description="The ID of the associated tool.")
+    tool_name: str = Field(..., description="The name of the tool.")
+    created_at: Optional[datetime] = Field(None, description="The creation date of the association.")
+    updated_at: Optional[datetime] = Field(None, description="The update date of the association.")
+    is_deleted: bool = Field(False, description="Whether this tool-agent relationship is deleted or not.")

letta/server/rest_api/app.py

@@ -124,6 +124,17 @@ def create_application() -> "FastAPI":
     # server = SyncServer(default_interface_factory=lambda: interface())
     print(f"\n[[ Letta server // v{__version__} ]]")
 
+    if (os.getenv("SENTRY_DSN") is not None) and (os.getenv("SENTRY_DSN") != ""):
+        import sentry_sdk
+
+        sentry_sdk.init(
+            dsn=os.getenv("SENTRY_DSN"),
+            traces_sample_rate=1.0,
+            _experiments={
+                "continuous_profiling_auto_start": True,
+            },
+        )
+
     app = FastAPI(
         swagger_ui_parameters={"docExpansion": "none"},
         # openapi_tags=TAGS_METADATA,

letta/server/rest_api/routers/v1/agents.py

@@ -409,7 +409,7 @@ def get_agent_messages(
     return server.get_agent_recall_cursor(
         user_id=actor.id,
         agent_id=agent_id,
-        before=before,
+        cursor=before,
         limit=limit,
         reverse=True,
         return_message_object=msg_object,
@@ -465,7 +465,7 @@ async def send_message(
 @router.post(
     "/{agent_id}/messages/stream",
     response_model=None,
-    operation_id="create_agent_message",
+    operation_id="create_agent_message_stream",
     responses={
         200: {
             "description": "Successful response",

letta/server/rest_api/routers/v1/blocks.py

@@ -76,7 +76,7 @@ def get_block(
         raise HTTPException(status_code=404, detail="Block not found")
 
 
-@router.patch("/{block_id}/attach", response_model=Block, operation_id="update_agent_memory_block")
+@router.patch("/{block_id}/attach", response_model=Block, operation_id="link_agent_memory_block")
 def link_agent_memory_block(
     block_id: str,
     agent_id: str = Query(..., description="The unique identifier of the agent to attach the source to."),
@@ -96,7 +96,7 @@ def link_agent_memory_block(
     return block
 
 
-@router.patch("/{block_id}/detach", response_model=Memory, operation_id="update_agent_memory_block")
+@router.patch("/{block_id}/detach", response_model=Memory, operation_id="unlink_agent_memory_block")
 def unlink_agent_memory_block(
     block_id: str,
     agent_id: str = Query(..., description="The unique identifier of the agent to attach the source to."),