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

letta/memory.py

@@ -67,14 +67,12 @@ def summarize_messages(
             + message_sequence_to_summarize[cutoff:]
         )
 
-    dummy_user_id = agent_state.user_id
+    agent_state.user_id
     dummy_agent_id = agent_state.id
     message_sequence = []
-    message_sequence.append(Message(user_id=dummy_user_id, agent_id=dummy_agent_id, role=MessageRole.system, text=summary_prompt))
-    message_sequence.append(
-        Message(user_id=dummy_user_id, agent_id=dummy_agent_id, role=MessageRole.assistant, text=MESSAGE_SUMMARY_REQUEST_ACK)
-    )
-    message_sequence.append(Message(user_id=dummy_user_id, agent_id=dummy_agent_id, role=MessageRole.user, text=summary_input))
+    message_sequence.append(Message(agent_id=dummy_agent_id, role=MessageRole.system, text=summary_prompt))
+    message_sequence.append(Message(agent_id=dummy_agent_id, role=MessageRole.assistant, text=MESSAGE_SUMMARY_REQUEST_ACK))
+    message_sequence.append(Message(agent_id=dummy_agent_id, role=MessageRole.user, text=summary_input))
 
     # TODO: We need to eventually have a separate LLM config for the summarizer LLM
     llm_config_no_inner_thoughts = agent_state.llm_config.model_copy(deep=True)
@@ -252,82 +250,6 @@ class DummyRecallMemory(RecallMemory):
             return matches, len(matches)
 
 
-class BaseRecallMemory(RecallMemory):
-    """Recall memory based on base functions implemented by storage connectors"""
-
-    def __init__(self, agent_state, restrict_search_to_summaries=False):
-        # If true, the pool of messages that can be queried are the automated summaries only
-        # (generated when the conversation window needs to be shortened)
-        self.restrict_search_to_summaries = restrict_search_to_summaries
-        from letta.agent_store.storage import StorageConnector
-
-        self.agent_state = agent_state
-
-        # create embedding model
-        self.embed_model = embedding_model(agent_state.embedding_config)
-        self.embedding_chunk_size = agent_state.embedding_config.embedding_chunk_size
-
-        # create storage backend
-        self.storage = StorageConnector.get_recall_storage_connector(user_id=agent_state.user_id, agent_id=agent_state.id)
-        # TODO: have some mechanism for cleanup otherwise will lead to OOM
-        self.cache = {}
-
-    def get_all(self, start=0, count=None):
-        start = 0 if start is None else int(start)
-        count = 0 if count is None else int(count)
-        results = self.storage.get_all(start, count)
-        results_json = [message.to_openai_dict() for message in results]
-        return results_json, len(results)
-
-    def text_search(self, query_string, count=None, start=None):
-        start = 0 if start is None else int(start)
-        count = 0 if count is None else int(count)
-        results = self.storage.query_text(query_string, count, start)
-        results_json = [message.to_openai_dict_search_results() for message in results]
-        return results_json, len(results)
-
-    def date_search(self, start_date, end_date, count=None, start=None):
-        start = 0 if start is None else int(start)
-        count = 0 if count is None else int(count)
-        results = self.storage.query_date(start_date, end_date, count, start)
-        results_json = [message.to_openai_dict_search_results() for message in results]
-        return results_json, len(results)
-
-    def compile(self) -> str:
-        total = self.storage.size()
-        system_count = self.storage.size(filters={"role": "system"})
-        user_count = self.storage.size(filters={"role": "user"})
-        assistant_count = self.storage.size(filters={"role": "assistant"})
-        function_count = self.storage.size(filters={"role": "function"})
-        other_count = total - (system_count + user_count + assistant_count + function_count)
-
-        memory_str = (
-            f"Statistics:"
-            + f"\n{total} total messages"
-            + f"\n{system_count} system"
-            + f"\n{user_count} user"
-            + f"\n{assistant_count} assistant"
-            + f"\n{function_count} function"
-            + f"\n{other_count} other"
-        )
-        return f"\n### RECALL MEMORY ###" + f"\n{memory_str}"
-
-    def insert(self, message: Message):
-        self.storage.insert(message)
-
-    def insert_many(self, messages: List[Message]):
-        self.storage.insert_many(messages)
-
-    def save(self):
-        self.storage.save()
-
-    def __len__(self):
-        return self.storage.size()
-
-    def count(self) -> int:
-        return len(self)
-
-
 class EmbeddingArchivalMemory(ArchivalMemory):
     """Archival memory with embedding based search"""
 

letta/metadata.py

@@ -14,7 +14,6 @@ from letta.schemas.api_key import APIKey
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import ToolRuleType
 from letta.schemas.llm_config import LLMConfig
-from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
 from letta.schemas.tool_rule import ChildToolRule, InitToolRule, TerminalToolRule
 from letta.schemas.user import User
 from letta.services.per_agent_lock_manager import PerAgentLockManager
@@ -66,40 +65,6 @@ class EmbeddingConfigColumn(TypeDecorator):
         return value
 
 
-class ToolCallColumn(TypeDecorator):
-
-    impl = JSON
-    cache_ok = True
-
-    def load_dialect_impl(self, dialect):
-        return dialect.type_descriptor(JSON())
-
-    def process_bind_param(self, value, dialect):
-        if value:
-            values = []
-            for v in value:
-                if isinstance(v, ToolCall):
-                    values.append(v.model_dump())
-                else:
-                    values.append(v)
-            return values
-
-        return value
-
-    def process_result_value(self, value, dialect):
-        if value:
-            tools = []
-            for tool_value in value:
-                if "function" in tool_value:
-                    tool_call_function = ToolCallFunction(**tool_value["function"])
-                    del tool_value["function"]
-                else:
-                    tool_call_function = None
-                tools.append(ToolCall(function=tool_call_function, **tool_value))
-            return tools
-        return value
-
-
 # TODO: eventually store providers?
 # class Provider(Base):
 #    __tablename__ = "providers"

letta/o1_agent.py

@@ -20,7 +20,7 @@ def send_thinking_message(self: "Agent", message: str) -> Optional[str]:
     Returns:
         Optional[str]: None is always returned as this function does not produce a response.
     """
-    self.interface.internal_monologue(message, msg_obj=self._messages[-1])
+    self.interface.internal_monologue(message)
     return None
 
 
@@ -34,7 +34,7 @@ def send_final_message(self: "Agent", message: str) -> Optional[str]:
     Returns:
         Optional[str]: None is always returned as this function does not produce a response.
     """
-    self.interface.internal_monologue(message, msg_obj=self._messages[-1])
+    self.interface.internal_monologue(message)
     return None
 
 
@@ -62,10 +62,15 @@ class O1Agent(Agent):
         """Run Agent.inner_step in a loop, terminate when final thinking message is sent or max_thinking_steps is reached"""
         # assert ms is not None, "MetadataStore is required"
         next_input_message = messages if isinstance(messages, list) else [messages]
+
         counter = 0
         total_usage = UsageStatistics()
         step_count = 0
         while step_count < self.max_thinking_steps:
+            # This is hacky but we need to do this for now
+            for m in next_input_message:
+                m.id = m._generate_id()
+
             kwargs["ms"] = ms
             kwargs["first_message"] = False
             step_response = self.inner_step(

letta/offline_memory_agent.py

@@ -18,6 +18,7 @@ def trigger_rethink_memory(agent_state: "AgentState", message: Optional[str]) ->
 
     """
     from letta import create_client
+
     client = create_client()
     agents = client.list_agents()
     for agent in agents:
@@ -149,6 +150,11 @@ class OfflineMemoryAgent(Agent):
         step_count = 0
 
         while counter < self.max_memory_rethinks:
+            # This is hacky but we need to do this for now
+            # TODO: REMOVE THIS
+            for m in next_input_message:
+                m.id = m._generate_id()
+
             kwargs["ms"] = ms
             kwargs["first_message"] = False
             step_response = self.inner_step(

letta/orm/__init__.py

@@ -1,8 +1,10 @@
+from letta.orm.agents_tags import AgentsTags
 from letta.orm.base import Base
 from letta.orm.block import Block
 from letta.orm.blocks_agents import BlocksAgents
 from letta.orm.file import FileMetadata
 from letta.orm.job import Job
+from letta.orm.message import Message
 from letta.orm.organization import Organization
 from letta.orm.sandbox_config import SandboxConfig, SandboxEnvironmentVariable
 from letta.orm.source import Source

letta/orm/file.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, List
 
 from sqlalchemy import Integer, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship

letta/orm/message.py

@@ -0,0 +1,66 @@
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import JSON, DateTime, TypeDecorator
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.mixins import AgentMixin, OrganizationMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.message import Message as PydanticMessage
+from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
+
+
+class ToolCallColumn(TypeDecorator):
+
+    impl = JSON
+    cache_ok = True
+
+    def load_dialect_impl(self, dialect):
+        return dialect.type_descriptor(JSON())
+
+    def process_bind_param(self, value, dialect):
+        if value:
+            values = []
+            for v in value:
+                if isinstance(v, ToolCall):
+                    values.append(v.model_dump())
+                else:
+                    values.append(v)
+            return values
+
+        return value
+
+    def process_result_value(self, value, dialect):
+        if value:
+            tools = []
+            for tool_value in value:
+                if "function" in tool_value:
+                    tool_call_function = ToolCallFunction(**tool_value["function"])
+                    del tool_value["function"]
+                else:
+                    tool_call_function = None
+                tools.append(ToolCall(function=tool_call_function, **tool_value))
+            return tools
+        return value
+
+
+class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
+    """Defines data model for storing Message objects"""
+
+    __tablename__ = "messages"
+    __table_args__ = {"extend_existing": True}
+    __pydantic_model__ = PydanticMessage
+
+    id: Mapped[str] = mapped_column(primary_key=True, doc="Unique message identifier")
+    role: Mapped[str] = mapped_column(doc="Message role (user/assistant/system/tool)")
+    text: Mapped[Optional[str]] = mapped_column(nullable=True, doc="Message content")
+    model: Mapped[Optional[str]] = mapped_column(nullable=True, doc="LLM model used")
+    name: Mapped[Optional[str]] = mapped_column(nullable=True, doc="Name for multi-agent scenarios")
+    tool_calls: Mapped[ToolCall] = mapped_column(ToolCallColumn, doc="Tool call information")
+    tool_call_id: Mapped[Optional[str]] = mapped_column(nullable=True, doc="ID of the tool call")
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=datetime.utcnow)
+
+    # Relationships
+    # TODO: Add in after Agent ORM is created
+    # agent: Mapped["Agent"] = relationship("Agent", back_populates="messages", lazy="selectin")
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="messages", lazy="selectin")

letta/orm/mixins.py

@@ -31,6 +31,22 @@ class UserMixin(Base):
     user_id: Mapped[str] = mapped_column(String, ForeignKey("users.id"))
 
 
+class AgentMixin(Base):
+    """Mixin for models that belong to an agent."""
+
+    __abstract__ = True
+
+    agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id"))
+
+
+class FileMixin(Base):
+    """Mixin for models that belong to a file."""
+
+    __abstract__ = True
+
+    file_id: Mapped[str] = mapped_column(String, ForeignKey("files.id"))
+
+
 class SourceMixin(Base):
     """Mixin for models (e.g. file) that belong to a source."""
 

letta/orm/organization.py

@@ -33,6 +33,7 @@ class Organization(SqlalchemyBase):
     sandbox_environment_variables: Mapped[List["SandboxEnvironmentVariable"]] = relationship(
         "SandboxEnvironmentVariable", back_populates="organization", cascade="all, delete-orphan"
     )
+    messages: Mapped[List["Message"]] = relationship("Message", 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

@@ -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/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/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."),