letta-nightly 0.6.37.dev20250311104150__py3-none-any.whl → 0.6.39.dev20250313104142__py3-none-any.whl

letta/llm_api/llm_client_base.py

@@ -0,0 +1,129 @@
+from abc import abstractmethod
+from typing import List, Optional, Union
+
+from openai import AsyncStream, Stream
+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
+
+from letta.schemas.llm_config import LLMConfig
+from letta.schemas.message import Message
+from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
+from letta.tracing import log_event
+
+
+class LLMClientBase:
+    """
+    Abstract base class for LLM clients, formatting the request objects,
+    handling the downstream request and parsing into chat completions response format
+    """
+
+    def __init__(
+        self,
+        agent_id: str,
+        llm_config: LLMConfig,
+        put_inner_thoughts_first: Optional[bool] = True,
+        use_structured_output: Optional[bool] = True,
+        use_tool_naming: bool = True,
+        actor_id: Optional[str] = None,
+    ):
+        self.agent_id = agent_id
+        self.llm_config = llm_config
+        self.put_inner_thoughts_first = put_inner_thoughts_first
+        self.actor_id = actor_id
+
+    def send_llm_request(
+        self,
+        messages: List[Message],
+        tools: Optional[List[dict]] = None,  # TODO: change to Tool object
+        tool_call: Optional[str] = None,
+        stream: bool = False,
+        first_message: bool = False,
+        force_tool_call: Optional[str] = None,
+    ) -> Union[ChatCompletionResponse, Stream[ChatCompletionChunk]]:
+        """
+        Issues a request to the downstream model endpoint and parses response.
+        If stream=True, returns a Stream[ChatCompletionChunk] that can be iterated over.
+        Otherwise returns a ChatCompletionResponse.
+        """
+        request_data = self.build_request_data(messages, tools, tool_call)
+        log_event(name="llm_request_sent", attributes=request_data)
+        if stream:
+            return self.stream(request_data)
+        else:
+            response_data = self.request(request_data)
+            log_event(name="llm_response_received", attributes=response_data)
+            return self.convert_response_to_chat_completion(response_data, messages)
+
+    async def send_llm_request_async(
+        self,
+        messages: List[Message],
+        tools: Optional[List[dict]] = None,  # TODO: change to Tool object
+        tool_call: Optional[str] = None,
+        stream: bool = False,
+        first_message: bool = False,
+        force_tool_call: Optional[str] = None,
+    ) -> Union[ChatCompletionResponse, AsyncStream[ChatCompletionChunk]]:
+        """
+        Issues a request to the downstream model endpoint.
+        If stream=True, returns an AsyncStream[ChatCompletionChunk] that can be async iterated over.
+        Otherwise returns a ChatCompletionResponse.
+        """
+        request_data = self.build_request_data(messages, tools, tool_call)
+        log_event(name="llm_request_sent", attributes=request_data)
+        if stream:
+            return await self.stream_async(request_data)
+        else:
+            response_data = await self.request_async(request_data)
+            log_event(name="llm_response_received", attributes=response_data)
+            return self.convert_response_to_chat_completion(response_data, messages)
+
+    @abstractmethod
+    def build_request_data(
+        self,
+        messages: List[Message],
+        tools: List[dict],
+        tool_call: Optional[str],
+    ) -> dict:
+        """
+        Constructs a request object in the expected data format for this client.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def request(self, request_data: dict) -> dict:
+        """
+        Performs underlying request to llm and returns raw response.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def request_async(self, request_data: dict) -> dict:
+        """
+        Performs underlying request to llm and returns raw response.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def convert_response_to_chat_completion(
+        self,
+        response_data: dict,
+        input_messages: List[Message],
+    ) -> ChatCompletionResponse:
+        """
+        Converts custom response format from llm client into an OpenAI
+        ChatCompletionsResponse object.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def stream(self, request_data: dict) -> Stream[ChatCompletionChunk]:
+        """
+        Performs underlying streaming request to llm and returns raw response.
+        """
+        raise NotImplementedError(f"Streaming is not supported for {self.llm_config.model_endpoint_type}")
+
+    @abstractmethod
+    async def stream_async(self, request_data: dict) -> AsyncStream[ChatCompletionChunk]:
+        """
+        Performs underlying streaming request to llm and returns raw response.
+        """
+        raise NotImplementedError(f"Streaming is not supported for {self.llm_config.model_endpoint_type}")

letta/local_llm/utils.py

@@ -114,26 +114,36 @@ def num_tokens_from_functions(functions: List[dict], model: str = "gpt-4"):
                     function_tokens += len(encoding.encode(propertiesKey))
                     v = parameters["properties"][propertiesKey]
                     for field in v:
-                        if field == "type":
-                            function_tokens += 2
-                            function_tokens += len(encoding.encode(v["type"]))
-                        elif field == "description":
-                            function_tokens += 2
-                            function_tokens += len(encoding.encode(v["description"]))
-                        elif field == "enum":
-                            function_tokens -= 3
-                            for o in v["enum"]:
-                                function_tokens += 3
-                                function_tokens += len(encoding.encode(o))
-                        elif field == "items":
-                            function_tokens += 2
-                            if isinstance(v["items"], dict) and "type" in v["items"]:
-                                function_tokens += len(encoding.encode(v["items"]["type"]))
-                        elif field == "default":
-                            function_tokens += 2
-                            function_tokens += len(encoding.encode(str(v["default"])))
-                        else:
-                            logger.warning(f"num_tokens_from_functions: Unsupported field {field} in function {function}")
+                        try:
+                            if field == "type":
+                                function_tokens += 2
+                                function_tokens += len(encoding.encode(v["type"]))
+                            elif field == "description":
+                                function_tokens += 2
+                                function_tokens += len(encoding.encode(v["description"]))
+                            elif field == "enum":
+                                function_tokens -= 3
+                                for o in v["enum"]:
+                                    function_tokens += 3
+                                    function_tokens += len(encoding.encode(o))
+                            elif field == "items":
+                                function_tokens += 2
+                                if isinstance(v["items"], dict) and "type" in v["items"]:
+                                    function_tokens += len(encoding.encode(v["items"]["type"]))
+                            elif field == "default":
+                                function_tokens += 2
+                                function_tokens += len(encoding.encode(str(v["default"])))
+                            elif field == "title":
+                                # TODO: Is this right? For MCP
+                                continue
+                            else:
+                                # TODO: Handle nesting here properly
+                                # Disable this for now for MCP
+                                continue
+                                # logger.warning(f"num_tokens_from_functions: Unsupported field {field} in function {function}")
+                        except:
+                            logger.error(f"Failed to encode field {field} with value {v}")
+                            raise
                 function_tokens += 11
 
         num_tokens += function_tokens

letta/log.py

@@ -54,7 +54,7 @@ DEVELOPMENT_LOGGING = {
             "propagate": True,  # Let logs bubble up to root
         },
         "uvicorn": {
-            "level": "INFO",
+            "level": "CRITICAL",
             "handlers": ["console"],
             "propagate": True,
         },

letta/memory.py

@@ -36,7 +36,7 @@ def get_memory_functions(cls: Memory) -> Dict[str, Callable]:
 
 def _format_summary_history(message_history: List[Message]):
     # TODO use existing prompt formatters for this (eg ChatML)
-    return "\n".join([f"{m.role}: {m.text}" for m in message_history])
+    return "\n".join([f"{m.role}: {m.content[0].text}" for m in message_history])
 
 
 def summarize_messages(

letta/orm/__init__.py

@@ -5,6 +5,7 @@ from letta.orm.block import Block
 from letta.orm.blocks_agents import BlocksAgents
 from letta.orm.file import FileMetadata
 from letta.orm.identities_agents import IdentitiesAgents
+from letta.orm.identities_blocks import IdentitiesBlocks
 from letta.orm.identity import Identity
 from letta.orm.job import Job
 from letta.orm.job_messages import JobMessage

letta/orm/block.py

@@ -12,6 +12,7 @@ from letta.schemas.block import Human, Persona
 
 if TYPE_CHECKING:
     from letta.orm import Organization
+    from letta.orm.identity import Identity
 
 
 class Block(OrganizationMixin, SqlalchemyBase):
@@ -47,6 +48,13 @@ class Block(OrganizationMixin, SqlalchemyBase):
         back_populates="core_memory",
         doc="Agents associated with this block.",
     )
+    identities: Mapped[List["Identity"]] = relationship(
+        "Identity",
+        secondary="identities_blocks",
+        lazy="selectin",
+        back_populates="blocks",
+        passive_deletes=True,
+    )
 
     def to_pydantic(self) -> Type:
         match self.label:

letta/orm/enums.py

@@ -8,6 +8,8 @@ class ToolType(str, Enum):
     LETTA_MULTI_AGENT_CORE = "letta_multi_agent_core"
     EXTERNAL_COMPOSIO = "external_composio"
     EXTERNAL_LANGCHAIN = "external_langchain"
+    # TODO is "external" the right name here? Since as of now, MCP is local / doesn't support remote?
+    EXTERNAL_MCP = "external_mcp"
 
 
 class JobType(str, Enum):

letta/orm/identities_blocks.py

@@ -0,0 +1,13 @@
+from sqlalchemy import ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from letta.orm.base import Base
+
+
+class IdentitiesBlocks(Base):
+    """Identities may have one or many blocks associated with them."""
+
+    __tablename__ = "identities_blocks"
+
+    identity_id: Mapped[str] = mapped_column(String, ForeignKey("identities.id", ondelete="CASCADE"), primary_key=True)
+    block_id: Mapped[str] = mapped_column(String, ForeignKey("block.id", ondelete="CASCADE"), primary_key=True)

letta/orm/identity.py

@@ -40,12 +40,20 @@ class Identity(SqlalchemyBase, OrganizationMixin):
     agents: Mapped[List["Agent"]] = relationship(
         "Agent", secondary="identities_agents", lazy="selectin", passive_deletes=True, back_populates="identities"
     )
+    blocks: Mapped[List["Block"]] = relationship(
+        "Block", secondary="identities_blocks", lazy="selectin", passive_deletes=True, back_populates="identities"
+    )
 
     @property
     def agent_ids(self) -> List[str]:
         """Get just the agent IDs without loading the full agent objects"""
         return [agent.id for agent in self.agents]
 
+    @property
+    def block_ids(self) -> List[str]:
+        """Get just the block IDs without loading the full agent objects"""
+        return [block.id for block in self.blocks]
+
     def to_pydantic(self) -> PydanticIdentity:
         state = {
             "id": self.id,
@@ -54,6 +62,7 @@ class Identity(SqlalchemyBase, OrganizationMixin):
             "identity_type": self.identity_type,
             "project_id": self.project_id,
             "agent_ids": self.agent_ids,
+            "block_ids": self.block_ids,
             "organization_id": self.organization_id,
             "properties": self.properties,
         }

letta/orm/sqlalchemy_base.py

@@ -69,7 +69,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         join_model: Optional[Base] = None,
         join_conditions: Optional[Union[Tuple, List]] = None,
         identifier_keys: Optional[List[str]] = None,
-        identifier_id: Optional[str] = None,
+        identity_id: Optional[str] = None,
         **kwargs,
     ) -> List["SqlalchemyBase"]:
         """
@@ -148,9 +148,9 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             if identifier_keys and hasattr(cls, "identities"):
                 query = query.join(cls.identities).filter(cls.identities.property.mapper.class_.identifier_key.in_(identifier_keys))
 
-            # given the identifier_id, we can find within the agents table any agents that have the identifier_id in their identity_ids
-            if identifier_id and hasattr(cls, "identities"):
-                query = query.join(cls.identities).filter(cls.identities.property.mapper.class_.id == identifier_id)
+            # given the identity_id, we can find within the agents table any agents that have the identity_id in their identity_ids
+            if identity_id and hasattr(cls, "identities"):
+                query = query.join(cls.identities).filter(cls.identities.property.mapper.class_.id == identity_id)
 
             # Apply filtering logic from kwargs
             for key, value in kwargs.items():

letta/orm/step.py

@@ -33,6 +33,7 @@ class Step(SqlalchemyBase):
     job_id: Mapped[Optional[str]] = mapped_column(
         ForeignKey("jobs.id", ondelete="SET NULL"), nullable=True, doc="The unique identified of the job run that triggered this step"
     )
+    agent_id: Mapped[Optional[str]] = mapped_column(None, nullable=True, doc="The name of the model used for this step.")
     provider_name: Mapped[Optional[str]] = mapped_column(None, nullable=True, doc="The name of the provider used for this step.")
     model: Mapped[Optional[str]] = mapped_column(None, nullable=True, doc="The name of the model used for this step.")
     model_endpoint: Mapped[Optional[str]] = mapped_column(None, nullable=True, doc="The model endpoint url used for this step.")

letta/schemas/block.py

@@ -1,6 +1,6 @@
 from typing import Optional
 
-from pydantic import BaseModel, Field, model_validator
+from pydantic import Field, model_validator
 from typing_extensions import Self
 
 from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT
@@ -37,7 +37,8 @@ class BaseBlock(LettaBase, validate_assignment=True):
 
     @model_validator(mode="after")
     def verify_char_limit(self) -> Self:
-        if self.value and len(self.value) > self.limit:
+        # self.limit can be None from
+        if self.limit is not None and self.value and len(self.value) > self.limit:
             error_msg = f"Edit failed: Exceeds {self.limit} character limit (requested {len(self.value)}) - {str(self)}."
             raise ValueError(error_msg)
 
@@ -89,61 +90,16 @@ class Persona(Block):
     label: str = "persona"
 
 
-# class CreateBlock(BaseBlock):
-#    """Create a block"""
-#
-#    is_template: bool = True
-#    label: str = Field(..., description="Label of the block.")
-
-
-class BlockLabelUpdate(BaseModel):
-    """Update the label of a block"""
-
-    current_label: str = Field(..., description="Current label of the block.")
-    new_label: str = Field(..., description="New label of the block.")
-
-
-# class CreatePersona(CreateBlock):
-#    """Create a persona block"""
-#
-#    label: str = "persona"
-#
-#
-# class CreateHuman(CreateBlock):
-#    """Create a human block"""
-#
-#    label: str = "human"
-
-
 class BlockUpdate(BaseBlock):
     """Update a block"""
 
-    limit: Optional[int] = Field(CORE_MEMORY_BLOCK_CHAR_LIMIT, description="Character limit of the block.")
+    limit: Optional[int] = Field(None, description="Character limit of the block.")
     value: Optional[str] = Field(None, description="Value of the block.")
 
     class Config:
         extra = "ignore"  # Ignores extra fields
 
 
-class BlockLimitUpdate(BaseModel):
-    """Update the limit of a block"""
-
-    label: str = Field(..., description="Label of the block.")
-    limit: int = Field(..., description="New limit of the block.")
-
-
-# class UpdatePersona(BlockUpdate):
-#    """Update a persona block"""
-#
-#    label: str = "persona"
-#
-#
-# class UpdateHuman(BlockUpdate):
-#    """Update a human block"""
-#
-#    label: str = "human"
-
-
 class CreateBlock(BaseBlock):
     """Create a block"""
 

letta/schemas/identity.py

@@ -46,6 +46,7 @@ class Identity(IdentityBase):
     identity_type: IdentityType = Field(..., description="The type of the identity.")
     project_id: Optional[str] = Field(None, description="The project id of the identity, if applicable.")
     agent_ids: List[str] = Field(..., description="The IDs of the agents associated with the identity.")
+    block_ids: List[str] = Field(..., description="The IDs of the blocks associated with the identity.")
     organization_id: Optional[str] = Field(None, description="The organization id of the user")
     properties: List[IdentityProperty] = Field(default_factory=list, description="List of properties associated with the identity")
 
@@ -56,6 +57,7 @@ class IdentityCreate(LettaBase):
     identity_type: IdentityType = Field(..., description="The type of the identity.")
     project_id: Optional[str] = Field(None, description="The project id of the identity, if applicable.")
     agent_ids: Optional[List[str]] = Field(None, description="The agent ids that are associated with the identity.")
+    block_ids: Optional[List[str]] = Field(None, description="The IDs of the blocks associated with the identity.")
     properties: Optional[List[IdentityProperty]] = Field(None, description="List of properties associated with the identity.")
 
 
@@ -64,4 +66,5 @@ class IdentityUpdate(LettaBase):
     name: Optional[str] = Field(None, description="The name of the identity.")
     identity_type: Optional[IdentityType] = Field(None, description="The type of the identity.")
     agent_ids: Optional[List[str]] = Field(None, description="The agent ids that are associated with the identity.")
+    block_ids: Optional[List[str]] = Field(None, description="The IDs of the blocks associated with the identity.")
     properties: Optional[List[IdentityProperty]] = Field(None, description="List of properties associated with the identity.")

letta/schemas/letta_message.py

@@ -236,6 +236,32 @@ LettaMessageUnion = Annotated[
 ]
 
 
+class UpdateSystemMessage(BaseModel):
+    content: Union[str, List[MessageContentUnion]]
+    message_type: Literal["system_message"] = "system_message"
+
+
+class UpdateUserMessage(BaseModel):
+    content: Union[str, List[MessageContentUnion]]
+    message_type: Literal["user_message"] = "user_message"
+
+
+class UpdateReasoningMessage(BaseModel):
+    reasoning: Union[str, List[MessageContentUnion]]
+    message_type: Literal["reasoning_message"] = "reasoning_message"
+
+
+class UpdateAssistantMessage(BaseModel):
+    content: Union[str, List[MessageContentUnion]]
+    message_type: Literal["assistant_message"] = "assistant_message"
+
+
+LettaMessageUpdateUnion = Annotated[
+    Union[UpdateSystemMessage, UpdateUserMessage, UpdateReasoningMessage, UpdateAssistantMessage],
+    Field(discriminator="message_type"),
+]
+
+
 def create_letta_message_union_schema():
     return {
         "oneOf": [