letta-nightly 0.6.14.dev20250123041709__py3-none-any.whl → 0.6.15.dev20250124054224__py3-none-any.whl

letta/orm/sqlalchemy_base.py

@@ -3,7 +3,7 @@ from enum import Enum
 from functools import wraps
 from typing import TYPE_CHECKING, List, Literal, Optional, Tuple, Union
 
-from sqlalchemy import String, and_, desc, func, or_, select
+from sqlalchemy import String, and_, func, or_, select
 from sqlalchemy.exc import DBAPIError, IntegrityError, TimeoutError
 from sqlalchemy.orm import Mapped, Session, mapped_column
 
@@ -52,7 +52,8 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         cls,
         *,
         db_session: "Session",
-        cursor: Optional[str] = None,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
         start_date: Optional[datetime] = None,
         end_date: Optional[datetime] = None,
         limit: Optional[int] = 50,
@@ -69,12 +70,13 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         **kwargs,
     ) -> List["SqlalchemyBase"]:
         """
-        List records with cursor-based pagination, ordering by created_at.
-        Cursor is an ID, but pagination is based on the cursor object's created_at value.
+        List records with before/after pagination, ordering by created_at.
+        Can use both before and after to fetch a window of records.
 
         Args:
             db_session: SQLAlchemy session
-            cursor: ID of the last item seen (for pagination)
+            before: ID of item to paginate before (upper bound)
+            after: ID of item to paginate after (lower bound)
             start_date: Filter items after this date
             end_date: Filter items before this date
             limit: Maximum number of items to return
@@ -89,13 +91,25 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             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:
-            # If cursor provided, get the reference object
-            cursor_obj = None
-            if cursor:
-                cursor_obj = session.get(cls, cursor)
-                if not cursor_obj:
-                    raise NoResultFound(f"No {cls.__name__} found with id {cursor}")
+            # Get the reference objects for pagination
+            before_obj = None
+            after_obj = None
+
+            if before:
+                before_obj = session.get(cls, before)
+                if not before_obj:
+                    raise NoResultFound(f"No {cls.__name__} found with id {before}")
+
+            if after:
+                after_obj = session.get(cls, after)
+                if not after_obj:
+                    raise NoResultFound(f"No {cls.__name__} found with id {after}")
+
+            # Validate that before comes after the after object if both are provided
+            if before_obj and after_obj and before_obj.created_at < after_obj.created_at:
+                raise ValueError("'before' reference must be later than 'after' reference")
 
             query = select(cls)
 
@@ -122,8 +136,8 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
                 else:
                     # Match ANY tag - use join and filter
                     query = (
-                        query.join(cls.tags).filter(cls.tags.property.mapper.class_.tag.in_(tags)).group_by(cls.id)  # Deduplicate results
-                    )
+                        query.join(cls.tags).filter(cls.tags.property.mapper.class_.tag.in_(tags)).group_by(cls.id)
+                    )  # Deduplicate results
 
                 # Group by primary key and all necessary columns to avoid JSON comparison
                 query = query.group_by(cls.id)
@@ -150,16 +164,35 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             if end_date:
                 query = query.filter(cls.created_at < end_date)
 
-            # Cursor-based pagination
-            if cursor_obj:
-                if ascending:
-                    query = query.where(cls.created_at >= cursor_obj.created_at).where(
-                        or_(cls.created_at > cursor_obj.created_at, cls.id > cursor_obj.id)
-                    )
+            # Handle pagination based on before/after
+            if before or after:
+                conditions = []
+
+                if before and after:
+                    # Window-based query - get records between before and after
+                    conditions = [
+                        or_(cls.created_at < before_obj.created_at, and_(cls.created_at == before_obj.created_at, cls.id < before_obj.id)),
+                        or_(cls.created_at > after_obj.created_at, and_(cls.created_at == after_obj.created_at, cls.id > after_obj.id)),
+                    ]
                 else:
-                    query = query.where(cls.created_at <= cursor_obj.created_at).where(
-                        or_(cls.created_at < cursor_obj.created_at, cls.id < cursor_obj.id)
-                    )
+                    # Pure pagination query
+                    if before:
+                        conditions.append(
+                            or_(
+                                cls.created_at < before_obj.created_at,
+                                and_(cls.created_at == before_obj.created_at, cls.id < before_obj.id),
+                            )
+                        )
+                    if after:
+                        conditions.append(
+                            or_(
+                                cls.created_at > after_obj.created_at,
+                                and_(cls.created_at == after_obj.created_at, cls.id > after_obj.id),
+                            )
+                        )
+
+                if conditions:
+                    query = query.where(and_(*conditions))
 
             # Text search
             if query_text:
@@ -184,7 +217,9 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
                     # SQLite with custom vector type
                     query_embedding_binary = adapt_array(query_embedding)
                     query = query.order_by(
-                        func.cosine_distance(cls.embedding, query_embedding_binary).asc(), cls.created_at.asc(), cls.id.asc()
+                        func.cosine_distance(cls.embedding, query_embedding_binary).asc(),
+                        cls.created_at.asc() if ascending else cls.created_at.desc(),
+                        cls.id.asc(),
                     )
                     is_ordered = True
 
@@ -195,13 +230,28 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             # Apply ordering
             if not is_ordered:
                 if ascending:
-                    query = query.order_by(cls.created_at, cls.id)
+                    query = query.order_by(cls.created_at.asc(), cls.id.asc())
                 else:
-                    query = query.order_by(desc(cls.created_at), desc(cls.id))
+                    query = query.order_by(cls.created_at.desc(), cls.id.desc())
+
+            # Apply limit, adjusting for both bounds if necessary
+            if before and after:
+                # When both bounds are provided, we need to fetch enough records to satisfy
+                # the limit while respecting both bounds. We'll fetch more and then trim.
+                query = query.limit(limit * 2)
+            else:
+                query = query.limit(limit)
+
+            results = list(session.execute(query).scalars())
 
-            query = query.limit(limit)
+            # If we have both bounds, take the middle portion
+            if before and after and len(results) > limit:
+                middle = len(results) // 2
+                start = max(0, middle - limit // 2)
+                end = min(len(results), start + limit)
+                results = results[start:end]
 
-            return list(session.execute(query).scalars())
+            return results
 
     @classmethod
     @handle_db_timeout
@@ -449,12 +499,10 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
     def to_pydantic(self) -> "BaseModel":
         """converts to the basic pydantic model counterpart"""
+        model = self.__pydantic_model__.model_validate(self)
         if hasattr(self, "metadata_"):
-            model_dict = {k: v for k, v in self.__dict__.items() if k in self.__pydantic_model__.model_fields}
-            model_dict["metadata"] = self.metadata_
-            return self.__pydantic_model__.model_validate(model_dict)
-
-        return self.__pydantic_model__.model_validate(self)
+            model.metadata = self.metadata_
+        return model
 
     def to_record(self) -> "BaseModel":
         """Deprecated accessor for to_pydantic"""

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, Index, String, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 # TODO everything in functions should live in this model
@@ -26,7 +26,10 @@ class Tool(SqlalchemyBase, OrganizationMixin):
 
     # Add unique constraint on (name, _organization_id)
     # An organization should not have multiple tools with the same name
-    __table_args__ = (UniqueConstraint("name", "organization_id", name="uix_name_organization"),)
+    __table_args__ = (
+        UniqueConstraint("name", "organization_id", name="uix_name_organization"),
+        Index("ix_tools_created_at_name", "created_at", "name"),
+    )
 
     name: Mapped[str] = mapped_column(doc="The display name of the tool.")
     tool_type: Mapped[ToolType] = mapped_column(

letta/schemas/embedding_config_overrides.py

@@ -0,0 +1,3 @@
+from typing import Dict
+
+EMBEDDING_HANDLE_OVERRIDES: Dict[str, Dict[str, str]] = {}

letta/schemas/enums.py

@@ -9,6 +9,10 @@ class MessageRole(str, Enum):
     system = "system"
 
 
+class MessageContentType(str, Enum):
+    text = "text"
+
+
 class OptionState(str, Enum):
     """Useful for kwargs that are bool + default option"""
 

letta/schemas/job.py

@@ -12,7 +12,7 @@ class JobBase(OrmMetadataBase):
     __id_prefix__ = "job"
     status: JobStatus = Field(default=JobStatus.created, description="The status of the job.")
     completed_at: Optional[datetime] = Field(None, description="The unix timestamp of when the job was completed.")
-    metadata: Optional[dict] = Field(None, description="The metadata of the job.")
+    metadata: Optional[dict] = Field(None, validation_alias="metadata_", description="The metadata of the job.")
     job_type: JobType = Field(default=JobType.JOB, description="The type of the job.")
 
 

letta/schemas/letta_message.py

@@ -4,6 +4,8 @@ from typing import Annotated, List, Literal, Optional, Union
 
 from pydantic import BaseModel, Field, field_serializer, field_validator
 
+from letta.schemas.enums import MessageContentType
+
 # Letta API style responses (intended to be easier to use vs getting true Message types)
 
 
@@ -32,18 +34,33 @@ class LettaMessage(BaseModel):
         return dt.isoformat(timespec="seconds")
 
 
+class MessageContent(BaseModel):
+    type: MessageContentType = Field(..., description="The type of the message.")
+
+
+class TextContent(MessageContent):
+    type: Literal[MessageContentType.text] = Field(MessageContentType.text, description="The type of the message.")
+    text: str = Field(..., description="The text content of the message.")
+
+
+MessageContentUnion = Annotated[
+    Union[TextContent],
+    Field(discriminator="type"),
+]
+
+
 class SystemMessage(LettaMessage):
     """
     A message generated by the system. Never streamed back on a response, only used for cursor pagination.
 
     Attributes:
-        message (str): The message sent by the system
+        content (Union[str, List[MessageContentUnion]]): The message content sent by the user (can be a string or an array of content parts)
         id (str): The ID of the message
         date (datetime): The date the message was created in ISO format
     """
 
     message_type: Literal["system_message"] = "system_message"
-    message: str
+    content: Union[str, List[MessageContentUnion]]
 
 
 class UserMessage(LettaMessage):
@@ -51,13 +68,13 @@ class UserMessage(LettaMessage):
     A message sent by the user. Never streamed back on a response, only used for cursor pagination.
 
     Attributes:
-        message (str): The message sent by the user
+        content (Union[str, List[MessageContentUnion]]): The message content sent by the user (can be a string or an array of content parts)
         id (str): The ID of the message
         date (datetime): The date the message was created in ISO format
     """
 
     message_type: Literal["user_message"] = "user_message"
-    message: str
+    content: Union[str, List[MessageContentUnion]]
 
 
 class ReasoningMessage(LettaMessage):
@@ -167,7 +184,7 @@ class ToolReturnMessage(LettaMessage):
 
 class AssistantMessage(LettaMessage):
     message_type: Literal["assistant_message"] = "assistant_message"
-    assistant_message: str
+    content: Union[str, List[MessageContentUnion]]
 
 
 class LegacyFunctionCallMessage(LettaMessage):

letta/schemas/llm_config.py

@@ -14,6 +14,7 @@ class LLMConfig(BaseModel):
         model_wrapper (str): The wrapper for the model. This is used to wrap additional text around the input/output of the model. This is useful for text-to-text completions, such as the Completions API in OpenAI.
         context_window (int): The context window size for the model.
         put_inner_thoughts_in_kwargs (bool): Puts `inner_thoughts` as a kwarg in the function call if this is set to True. This helps with function calling performance and also the generation of inner thoughts.
+        temperature (float): The temperature to use when generating text with the model. A higher temperature will result in more random text.
     """
 
     # TODO: 🤮 don't default to a vendor! bug city!
@@ -46,6 +47,10 @@ class LLMConfig(BaseModel):
         description="Puts 'inner_thoughts' as a kwarg in the function call if this is set to True. This helps with function calling performance and also the generation of inner thoughts.",
     )
     handle: Optional[str] = Field(None, description="The handle for this config, in the format provider/model-name.")
+    temperature: float = Field(
+        0.7,
+        description="The temperature to use when generating text with the model. A higher temperature will result in more random text.",
+    )
 
     # FIXME hack to silence pydantic protected namespace warning
     model_config = ConfigDict(protected_namespaces=())

letta/schemas/llm_config_overrides.py

@@ -0,0 +1,38 @@
+from typing import Dict
+
+LLM_HANDLE_OVERRIDES: Dict[str, Dict[str, str]] = {
+    "anthropic": {
+        "claude-3-5-haiku-20241022": "claude-3.5-haiku",
+        "claude-3-5-sonnet-20241022": "claude-3.5-sonnet",
+        "claude-3-opus-20240229": "claude-3-opus",
+    },
+    "openai": {
+        "chatgpt-4o-latest": "chatgpt-4o",
+        "gpt-3.5-turbo": "gpt-3.5-turbo",
+        "gpt-3.5-turbo-0125": "gpt-3.5-turbo-jan",
+        "gpt-3.5-turbo-1106": "gpt-3.5-turbo-nov",
+        "gpt-3.5-turbo-16k": "gpt-3.5-turbo-16k",
+        "gpt-3.5-turbo-instruct": "gpt-3.5-turbo-instruct",
+        "gpt-4-0125-preview": "gpt-4-preview-jan",
+        "gpt-4-0613": "gpt-4-june",
+        "gpt-4-1106-preview": "gpt-4-preview-nov",
+        "gpt-4-turbo-2024-04-09": "gpt-4-turbo-apr",
+        "gpt-4o-2024-05-13": "gpt-4o-may",
+        "gpt-4o-2024-08-06": "gpt-4o-aug",
+        "gpt-4o-mini-2024-07-18": "gpt-4o-mini-jul",
+    },
+    "together": {
+        "Qwen/Qwen2.5-72B-Instruct-Turbo": "qwen-2.5-72b-instruct",
+        "meta-llama/Llama-3-70b-chat-hf": "llama-3-70b",
+        "meta-llama/Meta-Llama-3-70B-Instruct-Turbo": "llama-3-70b-instruct",
+        "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo": "llama-3.1-405b-instruct",
+        "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo": "llama-3.1-70b-instruct",
+        "meta-llama/Llama-3.3-70B-Instruct-Turbo": "llama-3.3-70b-instruct",
+        "mistralai/Mistral-7B-Instruct-v0.2": "mistral-7b-instruct-v2",
+        "mistralai/Mistral-7B-Instruct-v0.3": "mistral-7b-instruct-v3",
+        "mistralai/Mixtral-8x22B-Instruct-v0.1": "mixtral-8x22b-instruct",
+        "mistralai/Mixtral-8x7B-Instruct-v0.1": "mixtral-8x7b-instruct",
+        "mistralai/Mixtral-8x7B-v0.1": "mixtral-8x7b",
+        "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO": "hermes-2-mixtral",
+    },
+}

letta/schemas/message.py

@@ -2,21 +2,23 @@ import copy
 import json
 import warnings
 from datetime import datetime, timezone
-from typing import List, Literal, Optional
+from typing import Any, Dict, List, Literal, Optional, Union
 
 from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall
 from openai.types.chat.chat_completion_message_tool_call import Function as OpenAIFunction
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field, field_validator, model_validator
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, TOOL_CALL_ID_MAX_LEN
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG
-from letta.schemas.enums import MessageRole
+from letta.schemas.enums import MessageContentType, MessageRole
 from letta.schemas.letta_base import OrmMetadataBase
 from letta.schemas.letta_message import (
     AssistantMessage,
     LettaMessage,
+    MessageContentUnion,
     ReasoningMessage,
     SystemMessage,
+    TextContent,
     ToolCall,
     ToolCallMessage,
     ToolReturnMessage,
@@ -59,7 +61,7 @@ class MessageCreate(BaseModel):
         MessageRole.user,
         MessageRole.system,
     ] = Field(..., description="The role of the participant.")
-    text: str = Field(..., description="The text of the message.")
+    content: Union[str, List[MessageContentUnion]] = Field(..., description="The content of the message.")
     name: Optional[str] = Field(None, description="The name of the participant.")
 
 
@@ -67,7 +69,7 @@ class MessageUpdate(BaseModel):
     """Request to update a message"""
 
     role: Optional[MessageRole] = Field(None, description="The role of the participant.")
-    text: Optional[str] = Field(None, description="The text of the message.")
+    content: Optional[Union[str, List[MessageContentUnion]]] = Field(..., description="The content of the message.")
     # NOTE: probably doesn't make sense to allow remapping user_id or agent_id (vs creating a new message)
     # user_id: Optional[str] = Field(None, description="The unique identifier of the user.")
     # agent_id: Optional[str] = Field(None, description="The unique identifier of the agent.")
@@ -79,6 +81,18 @@ class MessageUpdate(BaseModel):
     tool_calls: Optional[List[OpenAIToolCall,]] = Field(None, description="The list of tool calls requested.")
     tool_call_id: Optional[str] = Field(None, description="The id of the tool call.")
 
+    def model_dump(self, to_orm: bool = False, **kwargs) -> Dict[str, Any]:
+        data = super().model_dump(**kwargs)
+        if to_orm and "content" in data:
+            if isinstance(data["content"], str):
+                data["text"] = data["content"]
+            else:
+                for content in data["content"]:
+                    if content["type"] == "text":
+                        data["text"] = content["text"]
+            del data["content"]
+        return data
+
 
 class Message(BaseMessage):
     """
@@ -100,7 +114,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.")
+    content: Optional[List[MessageContentUnion]] = Field(None, description="The content of the message.")
     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.")
@@ -108,6 +122,7 @@ class Message(BaseMessage):
     tool_calls: Optional[List[OpenAIToolCall,]] = Field(None, description="The list of tool calls requested.")
     tool_call_id: Optional[str] = Field(None, description="The id of the tool call.")
     step_id: Optional[str] = Field(None, description="The id of the step that this message was created in.")
+
     # This overrides the optional base orm schema, created_at MUST exist on all messages objects
     created_at: datetime = Field(default_factory=get_utc_time, description="The timestamp when the object was created.")
 
@@ -118,6 +133,37 @@ class Message(BaseMessage):
         assert v in roles, f"Role must be one of {roles}"
         return v
 
+    @model_validator(mode="before")
+    @classmethod
+    def convert_from_orm(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+        if isinstance(data, dict):
+            if "text" in data and "content" not in data:
+                data["content"] = [TextContent(text=data["text"])]
+                del data["text"]
+        return data
+
+    def model_dump(self, to_orm: bool = False, **kwargs) -> Dict[str, Any]:
+        data = super().model_dump(**kwargs)
+        if to_orm:
+            for content in data["content"]:
+                if content["type"] == "text":
+                    data["text"] = content["text"]
+            del data["content"]
+        return data
+
+    @property
+    def text(self) -> Optional[str]:
+        """
+        Retrieve the first text content's text.
+
+        Returns:
+            str: The text content, or None if no text content exists
+        """
+        if not self.content:
+            return None
+        text_content = [content.text for content in self.content if content.type == MessageContentType.text]
+        return text_content[0] if text_content else None
+
     def to_json(self):
         json_message = vars(self)
         if json_message["tool_calls"] is not None:
@@ -165,7 +211,7 @@ class Message(BaseMessage):
                             AssistantMessage(
                                 id=self.id,
                                 date=self.created_at,
-                                assistant_message=message_string,
+                                content=message_string,
                             )
                         )
                     else:
@@ -221,7 +267,7 @@ class Message(BaseMessage):
                 UserMessage(
                     id=self.id,
                     date=self.created_at,
-                    message=self.text,
+                    content=self.text,
                 )
             )
         elif self.role == MessageRole.system:
@@ -231,7 +277,7 @@ class Message(BaseMessage):
                 SystemMessage(
                     id=self.id,
                     date=self.created_at,
-                    message=self.text,
+                    content=self.text,
                 )
             )
         else:
@@ -283,7 +329,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole.tool,  # NOTE
-                    text=openai_message_dict["content"],
+                    content=[TextContent(text=openai_message_dict["content"])],
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=openai_message_dict["tool_calls"] if "tool_calls" in openai_message_dict else None,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
@@ -296,7 +342,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole.tool,  # NOTE
-                    text=openai_message_dict["content"],
+                    content=[TextContent(text=openai_message_dict["content"])],
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=openai_message_dict["tool_calls"] if "tool_calls" in openai_message_dict else None,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
@@ -328,7 +374,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
-                    text=openai_message_dict["content"],
+                    content=[TextContent(text=openai_message_dict["content"])],
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=tool_calls,
                     tool_call_id=None,  # NOTE: None, since this field is only non-null for role=='tool'
@@ -341,7 +387,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
-                    text=openai_message_dict["content"],
+                    content=[TextContent(text=openai_message_dict["content"])],
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=tool_calls,
                     tool_call_id=None,  # NOTE: None, since this field is only non-null for role=='tool'
@@ -373,7 +419,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
-                    text=openai_message_dict["content"],
+                    content=[TextContent(text=openai_message_dict["content"])],
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=tool_calls,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
@@ -386,7 +432,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
-                    text=openai_message_dict["content"],
+                    content=[TextContent(text=openai_message_dict["content"] or "")],
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=tool_calls,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,

letta/schemas/openai/chat_completions.py

@@ -104,7 +104,7 @@ class ChatCompletionRequest(BaseModel):
     logit_bias: Optional[Dict[str, int]] = None
     logprobs: Optional[bool] = False
     top_logprobs: Optional[int] = None
-    max_tokens: Optional[int] = None
+    max_completion_tokens: Optional[int] = None
     n: Optional[int] = 1
     presence_penalty: Optional[float] = 0
     response_format: Optional[ResponseFormat] = None

letta/schemas/passage.py

@@ -23,7 +23,7 @@ class PassageBase(OrmMetadataBase):
 
     # file association
     file_id: Optional[str] = Field(None, description="The unique identifier of the file associated with the passage.")
-    metadata: Optional[Dict] = Field({}, description="The metadata of the passage.")
+    metadata: Optional[Dict] = Field({}, validation_alias="metadata_", description="The metadata of the passage.")
 
 
 class Passage(PassageBase):