letta-nightly 0.6.12.dev20250122104013__py3-none-any.whl → 0.6.14.dev20250123041709__py3-none-any.whl

letta/constants.py

@@ -125,8 +125,6 @@ LLM_MAX_TOKENS = {
     "gpt-3.5-turbo-16k-0613": 16385,  # legacy
     "gpt-3.5-turbo-0301": 4096,  # legacy
 }
-# The amount of tokens before a sytem warning about upcoming truncation is sent to Letta
-MESSAGE_SUMMARY_WARNING_FRAC = 0.75
 # The error message that Letta will receive
 # MESSAGE_SUMMARY_WARNING_STR = f"Warning: the conversation history will soon reach its maximum length and be trimmed. Make sure to save any important information from the conversation to your memory before it is removed."
 # Much longer and more specific variant of the prompt
@@ -138,15 +136,10 @@ MESSAGE_SUMMARY_WARNING_STR = " ".join(
         # "Remember to pass request_heartbeat = true if you would like to send a message immediately after.",
     ]
 )
-# The fraction of tokens we truncate down to
-MESSAGE_SUMMARY_TRUNC_TOKEN_FRAC = 0.75
+
 # The ackknowledgement message used in the summarize sequence
 MESSAGE_SUMMARY_REQUEST_ACK = "Understood, I will respond with a summary of the message (and only the summary, nothing else) once I receive the conversation history. I'm ready."
 
-# Even when summarizing, we want to keep a handful of recent messages
-# These serve as in-context examples of how to use functions / what user messages look like
-MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST = 3
-
 # Maximum length of an error message
 MAX_ERROR_MESSAGE_CHAR_LIMIT = 500
 

letta/data_sources/connectors.py

@@ -77,7 +77,7 @@ def load_data(connector: DataConnector, source: Source, passage_manager: Passage
                 text=passage_text,
                 file_id=file_metadata.id,
                 source_id=source.id,
-                metadata_=passage_metadata,
+                metadata=passage_metadata,
                 organization_id=source.organization_id,
                 embedding_config=source.embedding_config,
                 embedding=embedding,

letta/functions/helpers.py

@@ -12,12 +12,37 @@ from letta.schemas.letta_response import LettaResponse
 from letta.schemas.message import MessageCreate
 
 
-def generate_composio_tool_wrapper(action_name: str) -> tuple[str, str]:
-    # Instantiate the object
-    tool_instantiation_str = f"composio_toolset.get_tools(actions=['{action_name}'])[0]"
+# TODO: This is kind of hacky, as this is used to search up the action later on composio's side
+# TODO: So be very careful changing/removing these pair of functions
+def generate_func_name_from_composio_action(action_name: str) -> str:
+    """
+    Generates the composio function name from the composio action.
 
+    Args:
+        action_name: The composio action name
+
+    Returns:
+        function name
+    """
+    return action_name.lower()
+
+
+def generate_composio_action_from_func_name(func_name: str) -> str:
+    """
+    Generates the composio action from the composio function name.
+
+    Args:
+        func_name: The composio function name
+
+    Returns:
+        composio action name
+    """
+    return func_name.upper()
+
+
+def generate_composio_tool_wrapper(action_name: str) -> tuple[str, str]:
     # Generate func name
-    func_name = action_name.lower()
+    func_name = generate_func_name_from_composio_action(action_name)
 
     wrapper_function_str = f"""
 def {func_name}(**kwargs):

letta/functions/schema_generator.py

@@ -2,6 +2,7 @@ import inspect
 import warnings
 from typing import Any, Dict, List, Optional, Type, Union, get_args, get_origin
 
+from composio.client.collections import ActionParametersModel
 from docstring_parser import parse
 from pydantic import BaseModel
 
@@ -429,3 +430,57 @@ def generate_schema_from_args_schema_v2(
         function_call_json["parameters"]["required"].append("request_heartbeat")
 
     return function_call_json
+
+
+def generate_tool_schema_for_composio(
+    parameters_model: ActionParametersModel,
+    name: str,
+    description: str,
+    append_heartbeat: bool = True,
+) -> Dict[str, Any]:
+    properties_json = {}
+    required_fields = parameters_model.required or []
+
+    # Extract properties from the ActionParametersModel
+    for field_name, field_props in parameters_model.properties.items():
+        # Initialize the property structure
+        property_schema = {
+            "type": field_props["type"],
+            "description": field_props.get("description", ""),
+        }
+
+        # Handle optional default values
+        if "default" in field_props:
+            property_schema["default"] = field_props["default"]
+
+        # Handle enumerations
+        if "enum" in field_props:
+            property_schema["enum"] = field_props["enum"]
+
+        # Handle array item types
+        if field_props["type"] == "array" and "items" in field_props:
+            property_schema["items"] = field_props["items"]
+
+        # Add the property to the schema
+        properties_json[field_name] = property_schema
+
+    # Add the optional heartbeat parameter
+    if append_heartbeat:
+        properties_json["request_heartbeat"] = {
+            "type": "boolean",
+            "description": "Request an immediate heartbeat after function execution. Set to `True` if you want to send a follow-up message or run a follow-up function.",
+        }
+        required_fields.append("request_heartbeat")
+
+    # Return the final schema
+    return {
+        "name": name,
+        "description": description,
+        "strict": True,
+        "parameters": {
+            "type": "object",
+            "properties": properties_json,
+            "additionalProperties": False,
+            "required": required_fields,
+        },
+    }

letta/llm_api/helpers.py

@@ -7,8 +7,10 @@ from typing import Any, List, Union
 import requests
 
 from letta.constants import OPENAI_CONTEXT_WINDOW_ERROR_SUBSTRING
+from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice
-from letta.utils import json_dumps, printd
+from letta.settings import summarizer_settings
+from letta.utils import count_tokens, json_dumps, printd
 
 
 def _convert_to_structured_output_helper(property: dict) -> dict:
@@ -287,6 +289,54 @@ def unpack_inner_thoughts_from_kwargs(choice: Choice, inner_thoughts_key: str) -
     return rewritten_choice
 
 
+def calculate_summarizer_cutoff(in_context_messages: List[Message], token_counts: List[int], logger: "logging.Logger") -> int:
+    if len(in_context_messages) != len(token_counts):
+        raise ValueError(
+            f"Given in_context_messages has different length from given token_counts: {len(in_context_messages)} != {len(token_counts)}"
+        )
+
+    in_context_messages_openai = [m.to_openai_dict() for m in in_context_messages]
+
+    if summarizer_settings.evict_all_messages:
+        logger.info("Evicting all messages...")
+        return len(in_context_messages)
+    else:
+        # Start at index 1 (past the system message),
+        # and collect messages for summarization until we reach the desired truncation token fraction (eg 50%)
+        # We do the inverse of `desired_memory_token_pressure` to get what we need to remove
+        desired_token_count_to_summarize = int(sum(token_counts) * (1 - summarizer_settings.desired_memory_token_pressure))
+        logger.info(f"desired_token_count_to_summarize={desired_token_count_to_summarize}")
+
+        tokens_so_far = 0
+        cutoff = 0
+        for i, msg in enumerate(in_context_messages_openai):
+            # Skip system
+            if i == 0:
+                continue
+            cutoff = i
+            tokens_so_far += token_counts[i]
+
+            if msg["role"] not in ["user", "tool", "function"] and tokens_so_far >= desired_token_count_to_summarize:
+                # Break if the role is NOT a user or tool/function and tokens_so_far is enough
+                break
+            elif len(in_context_messages) - cutoff - 1 <= summarizer_settings.keep_last_n_messages:
+                # Also break if we reached the `keep_last_n_messages` threshold
+                # NOTE: This may be on a user, tool, or function in theory
+                logger.warning(
+                    f"Breaking summary cutoff early on role={msg['role']} because we hit the `keep_last_n_messages`={summarizer_settings.keep_last_n_messages}"
+                )
+                break
+
+        logger.info(f"Evicting {cutoff}/{len(in_context_messages)} messages...")
+        return cutoff + 1
+
+
+def get_token_counts_for_messages(in_context_messages: List[Message]) -> List[int]:
+    in_context_messages_openai = [m.to_openai_dict() for m in in_context_messages]
+    token_counts = [count_tokens(str(msg)) for msg in in_context_messages_openai]
+    return token_counts
+
+
 def is_context_overflow_error(exception: Union[requests.exceptions.RequestException, Exception]) -> bool:
     """Checks if an exception is due to context overflow (based on common OpenAI response messages)"""
     from letta.utils import printd

letta/memory.py

@@ -1,12 +1,13 @@
 from typing import Callable, Dict, List
 
-from letta.constants import MESSAGE_SUMMARY_REQUEST_ACK, MESSAGE_SUMMARY_WARNING_FRAC
+from letta.constants import MESSAGE_SUMMARY_REQUEST_ACK
 from letta.llm_api.llm_api_tools import create
 from letta.prompts.gpt_summarize import SYSTEM as SUMMARY_PROMPT_SYSTEM
 from letta.schemas.agent import AgentState
 from letta.schemas.enums import MessageRole
 from letta.schemas.memory import Memory
 from letta.schemas.message import Message
+from letta.settings import summarizer_settings
 from letta.utils import count_tokens, printd
 
 
@@ -49,8 +50,8 @@ def summarize_messages(
     summary_prompt = SUMMARY_PROMPT_SYSTEM
     summary_input = _format_summary_history(message_sequence_to_summarize)
     summary_input_tkns = count_tokens(summary_input)
-    if summary_input_tkns > MESSAGE_SUMMARY_WARNING_FRAC * context_window:
-        trunc_ratio = (MESSAGE_SUMMARY_WARNING_FRAC * context_window / summary_input_tkns) * 0.8  # For good measure...
+    if summary_input_tkns > summarizer_settings.memory_warning_threshold * context_window:
+        trunc_ratio = (summarizer_settings.memory_warning_threshold * context_window / summary_input_tkns) * 0.8  # For good measure...
         cutoff = int(len(message_sequence_to_summarize) * trunc_ratio)
         summary_input = str(
             [summarize_messages(agent_state, message_sequence_to_summarize=message_sequence_to_summarize[:cutoff])]
@@ -58,10 +59,11 @@ def summarize_messages(
         )
 
     dummy_agent_id = agent_state.id
-    message_sequence = []
-    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))
+    message_sequence = [
+        Message(agent_id=dummy_agent_id, role=MessageRole.system, text=summary_prompt),
+        Message(agent_id=dummy_agent_id, role=MessageRole.assistant, text=MESSAGE_SUMMARY_REQUEST_ACK),
+        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)

letta/orm/agent.py

@@ -113,14 +113,14 @@ class Agent(SqlalchemyBase, OrganizationMixin):
             "description": self.description,
             "message_ids": self.message_ids,
             "tools": self.tools,
-            "sources": self.sources,
+            "sources": [source.to_pydantic() for source in self.sources],
             "tags": [t.tag for t in self.tags],
             "tool_rules": self.tool_rules,
             "system": self.system,
             "agent_type": self.agent_type,
             "llm_config": self.llm_config,
             "embedding_config": self.embedding_config,
-            "metadata_": self.metadata_,
+            "metadata": self.metadata_,
             "memory": Memory(blocks=[b.to_pydantic() for b in self.core_memory]),
             "created_by_id": self.created_by_id,
             "last_updated_by_id": self.last_updated_by_id,

letta/orm/block.py

@@ -45,7 +45,9 @@ class Block(OrganizationMixin, SqlalchemyBase):
                 Schema = Persona
             case _:
                 Schema = PydanticBlock
-        return Schema.model_validate(self)
+        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 Schema.model_validate(model_dict)
 
 
 @event.listens_for(Block, "after_update")  # Changed from 'before_update'

letta/orm/custom_columns.py

@@ -2,13 +2,14 @@ import base64
 from typing import List, Union
 
 import numpy as np
+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 sqlalchemy import JSON
 from sqlalchemy.types import BINARY, TypeDecorator
 
 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, ConditionalToolRule, InitToolRule, TerminalToolRule
 
 
@@ -109,7 +110,7 @@ class ToolCallColumn(TypeDecorator):
         if value:
             values = []
             for v in value:
-                if isinstance(v, ToolCall):
+                if isinstance(v, OpenAIToolCall):
                     values.append(v.model_dump())
                 else:
                     values.append(v)
@@ -122,11 +123,11 @@ class ToolCallColumn(TypeDecorator):
             tools = []
             for tool_value in value:
                 if "function" in tool_value:
-                    tool_call_function = ToolCallFunction(**tool_value["function"])
+                    tool_call_function = OpenAIFunction(**tool_value["function"])
                     del tool_value["function"]
                 else:
                     tool_call_function = None
-                tools.append(ToolCall(function=tool_call_function, **tool_value))
+                tools.append(OpenAIToolCall(function=tool_call_function, **tool_value))
             return tools
         return value
 

letta/orm/enums.py

@@ -6,6 +6,7 @@ class ToolType(str, Enum):
     LETTA_CORE = "letta_core"
     LETTA_MEMORY_CORE = "letta_memory_core"
     LETTA_MULTI_AGENT_CORE = "letta_multi_agent_core"
+    EXTERNAL_COMPOSIO = "external_composio"
 
 
 class JobType(str, Enum):

letta/orm/message.py

@@ -1,5 +1,6 @@
 from typing import Optional
 
+from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall
 from sqlalchemy import ForeignKey, Index
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
@@ -7,7 +8,6 @@ from letta.orm.custom_columns import ToolCallColumn
 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
 
 
 class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
@@ -22,7 +22,7 @@ class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
     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_calls: Mapped[OpenAIToolCall] = mapped_column(ToolCallColumn, doc="Tool call information")
     tool_call_id: Mapped[Optional[str]] = mapped_column(nullable=True, doc="ID of the tool call")
     step_id: Mapped[Optional[str]] = mapped_column(
         ForeignKey("steps.id", ondelete="SET NULL"), nullable=True, doc="ID of the step that this message belongs to"

letta/orm/sqlalchemy_base.py

@@ -449,6 +449,11 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
     def to_pydantic(self) -> "BaseModel":
         """converts to the basic pydantic model counterpart"""
+        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)
 
     def to_record(self) -> "BaseModel":

letta/schemas/agent.py

@@ -72,7 +72,7 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
     organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the agent.")
 
     description: Optional[str] = Field(None, description="The description of the agent.")
-    metadata_: Optional[Dict] = Field(None, description="The metadata of the agent.", alias="metadata_")
+    metadata: Optional[Dict] = Field(None, description="The metadata of the agent.")
 
     memory: Memory = Field(..., description="The in-context memory of the agent.")
     tools: List[Tool] = Field(..., description="The tools used by the agent.")
@@ -122,8 +122,8 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
         False, description="If true, attaches the Letta multi-agent tools (e.g. sending a message to another agent)."
     )
     description: Optional[str] = Field(None, description="The description of the agent.")
-    metadata_: Optional[Dict] = Field(None, description="The metadata of the agent.", alias="metadata_")
-    llm: Optional[str] = Field(
+    metadata: Optional[Dict] = Field(None, description="The metadata of the agent.")
+    model: Optional[str] = Field(
         None,
         description="The LLM configuration handle used by the agent, specified in the format "
         "provider/model-name, as an alternative to specifying llm_config.",
@@ -139,7 +139,7 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     tool_exec_environment_variables: Optional[Dict[str, str]] = Field(
         None, description="The environment variables for tool execution specific to this agent."
     )
-    variables: Optional[Dict[str, str]] = Field(None, description="The variables that should be set for the agent.")
+    memory_variables: Optional[Dict[str, str]] = Field(None, description="The variables that should be set for the agent.")
 
     @field_validator("name")
     @classmethod
@@ -166,17 +166,17 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
 
         return name
 
-    @field_validator("llm")
+    @field_validator("model")
     @classmethod
-    def validate_llm(cls, llm: Optional[str]) -> Optional[str]:
-        if not llm:
-            return llm
+    def validate_model(cls, model: Optional[str]) -> Optional[str]:
+        if not model:
+            return model
 
-        provider_name, model_name = llm.split("/", 1)
+        provider_name, model_name = model.split("/", 1)
         if not provider_name or not model_name:
             raise ValueError("The llm config handle should be in the format provider/model-name")
 
-        return llm
+        return model
 
     @field_validator("embedding")
     @classmethod
@@ -184,8 +184,8 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
         if not embedding:
             return embedding
 
-        provider_name, model_name = embedding.split("/", 1)
-        if not provider_name or not model_name:
+        provider_name, embedding_name = embedding.split("/", 1)
+        if not provider_name or not embedding_name:
             raise ValueError("The embedding config handle should be in the format provider/model-name")
 
         return embedding
@@ -203,7 +203,7 @@ class UpdateAgent(BaseModel):
     embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the agent.")
     message_ids: Optional[List[str]] = Field(None, description="The ids of the messages in the agent's in-context memory.")
     description: Optional[str] = Field(None, description="The description of the agent.")
-    metadata_: Optional[Dict] = Field(None, description="The metadata of the agent.", alias="metadata_")
+    metadata: Optional[Dict] = Field(None, description="The metadata of the agent.")
     tool_exec_environment_variables: Optional[Dict[str, str]] = Field(
         None, description="The environment variables for tool execution specific to this agent."
     )

letta/schemas/block.py

@@ -27,7 +27,7 @@ class BaseBlock(LettaBase, validate_assignment=True):
 
     # metadata
     description: Optional[str] = Field(None, description="Description of the block.")
-    metadata_: Optional[dict] = Field({}, description="Metadata of the block.")
+    metadata: Optional[dict] = Field({}, description="Metadata of the block.")
 
     # def __len__(self):
     #     return len(self.value)
@@ -63,7 +63,7 @@ class Block(BaseBlock):
         label (str): The label of the block (e.g. 'human', 'persona'). This defines a category for the block.
         template_name (str): The name of the block template (if it is a template).
         description (str): Description of the block.
-        metadata_ (Dict): Metadata of the block.
+        metadata (Dict): Metadata of the block.
         user_id (str): The unique identifier of the user associated with the block.
     """
 

letta/schemas/environment_variables.py

@@ -26,7 +26,7 @@ class EnvironmentVariableUpdateBase(LettaBase):
     description: Optional[str] = Field(None, description="An optional description of the environment variable.")
 
 
-# Sandbox-Specific Environment Variable
+# Environment Variable
 class SandboxEnvironmentVariableBase(EnvironmentVariableBase):
     __id_prefix__ = "sandbox-env"
     sandbox_config_id: str = Field(..., description="The ID of the sandbox config this environment variable belongs to.")

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, description="The metadata of the job.")
     job_type: JobType = Field(default=JobType.JOB, description="The type of the job.")
 
 

letta/schemas/letta_base.py

@@ -88,6 +88,12 @@ class LettaBase(BaseModel):
             return f"{cls.__id_prefix__}-{v}"
         return v
 
+    def model_dump(self, to_orm: bool = False, **kwargs):
+        data = super().model_dump(**kwargs)
+        if to_orm and "metadata" in data:
+            data["metadata_"] = data.pop("metadata")
+        return data
+
 
 class OrmMetadataBase(LettaBase):
     # metadata fields

letta/schemas/letta_message.py

@@ -222,22 +222,22 @@ LettaMessageUnion = Annotated[
 def create_letta_message_union_schema():
     return {
         "oneOf": [
-            {"$ref": "#/components/schemas/SystemMessage-Output"},
-            {"$ref": "#/components/schemas/UserMessage-Output"},
+            {"$ref": "#/components/schemas/SystemMessage"},
+            {"$ref": "#/components/schemas/UserMessage"},
             {"$ref": "#/components/schemas/ReasoningMessage"},
             {"$ref": "#/components/schemas/ToolCallMessage"},
             {"$ref": "#/components/schemas/ToolReturnMessage"},
-            {"$ref": "#/components/schemas/AssistantMessage-Output"},
+            {"$ref": "#/components/schemas/AssistantMessage"},
         ],
         "discriminator": {
             "propertyName": "message_type",
             "mapping": {
-                "system_message": "#/components/schemas/SystemMessage-Output",
-                "user_message": "#/components/schemas/UserMessage-Output",
+                "system_message": "#/components/schemas/SystemMessage",
+                "user_message": "#/components/schemas/UserMessage",
                 "reasoning_message": "#/components/schemas/ReasoningMessage",
                 "tool_call_message": "#/components/schemas/ToolCallMessage",
                 "tool_return_message": "#/components/schemas/ToolReturnMessage",
-                "assistant_message": "#/components/schemas/AssistantMessage-Output",
+                "assistant_message": "#/components/schemas/AssistantMessage",
             },
         },
     }

letta/schemas/memory.py

@@ -7,10 +7,11 @@ from pydantic import BaseModel, Field
 if TYPE_CHECKING:
     pass
 
+from openai.types.beta.function_tool import FunctionTool as OpenAITool
+
 from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT
 from letta.schemas.block import Block
 from letta.schemas.message import Message
-from letta.schemas.openai.chat_completion_request import Tool
 
 
 class ContextWindowOverview(BaseModel):
@@ -47,7 +48,7 @@ class ContextWindowOverview(BaseModel):
     summary_memory: Optional[str] = Field(None, description="The content of the summary memory.")
 
     num_tokens_functions_definitions: int = Field(..., description="The number of tokens in the functions definitions.")
-    functions_definitions: Optional[List[Tool]] = Field(..., description="The content of the functions definitions.")
+    functions_definitions: Optional[List[OpenAITool]] = Field(..., description="The content of the functions definitions.")
 
     num_tokens_messages: int = Field(..., description="The number of tokens in the messages list.")
     # TODO make list of messages?

letta/schemas/message.py

@@ -4,24 +4,32 @@ import warnings
 from datetime import datetime, timezone
 from typing import List, Literal, Optional
 
+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 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.letta_base import OrmMetadataBase
-from letta.schemas.letta_message import AssistantMessage, LettaMessage, ReasoningMessage, SystemMessage
-from letta.schemas.letta_message import ToolCall as LettaToolCall
-from letta.schemas.letta_message import ToolCallMessage, ToolReturnMessage, UserMessage
-from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
+from letta.schemas.letta_message import (
+    AssistantMessage,
+    LettaMessage,
+    ReasoningMessage,
+    SystemMessage,
+    ToolCall,
+    ToolCallMessage,
+    ToolReturnMessage,
+    UserMessage,
+)
 from letta.utils import get_utc_time, is_utc_datetime, json_dumps
 
 
 def add_inner_thoughts_to_tool_call(
-    tool_call: ToolCall,
+    tool_call: OpenAIToolCall,
     inner_thoughts: str,
     inner_thoughts_key: str,
-) -> ToolCall:
+) -> OpenAIToolCall:
     """Add inner thoughts (arg + value) to a tool call"""
     # because the kwargs are stored as strings, we need to load then write the JSON dicts
     try:
@@ -68,7 +76,7 @@ class MessageUpdate(BaseModel):
     name: Optional[str] = Field(None, description="The name of the participant.")
     # NOTE: we probably shouldn't allow updating the created_at field, right?
     # created_at: Optional[datetime] = Field(None, description="The time the message was created.")
-    tool_calls: Optional[List[ToolCall]] = Field(None, description="The list of tool calls requested.")
+    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.")
 
 
@@ -85,7 +93,7 @@ class Message(BaseMessage):
         model (str): The model used to make the function call.
         name (str): The name of the participant.
         created_at (datetime): The time the message was created.
-        tool_calls (List[ToolCall]): The list of tool calls requested.
+        tool_calls (List[OpenAIToolCall,]): The list of tool calls requested.
         tool_call_id (str): The id of the tool call.
 
     """
@@ -97,7 +105,7 @@ class Message(BaseMessage):
     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.")
-    tool_calls: Optional[List[ToolCall]] = Field(None, description="The list of tool calls requested.")
+    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
@@ -165,7 +173,7 @@ class Message(BaseMessage):
                             ToolCallMessage(
                                 id=self.id,
                                 date=self.created_at,
-                                tool_call=LettaToolCall(
+                                tool_call=ToolCall(
                                     name=tool_call.function.name,
                                     arguments=tool_call.function.arguments,
                                     tool_call_id=tool_call.id,
@@ -304,10 +312,10 @@ class Message(BaseMessage):
             # Convert a function_call (from an assistant message) into a tool_call
             # NOTE: this does not conventionally include a tool_call_id (ToolCall.id), it's on the caster to provide it
             tool_calls = [
-                ToolCall(
+                OpenAIToolCall(
                     id=openai_message_dict["tool_call_id"],  # NOTE: unconventional source, not to spec
                     type="function",
-                    function=ToolCallFunction(
+                    function=OpenAIFunction(
                         name=openai_message_dict["function_call"]["name"],
                         arguments=openai_message_dict["function_call"]["arguments"],
                     ),
@@ -352,7 +360,7 @@ class Message(BaseMessage):
                 assert openai_message_dict["role"] == "assistant", openai_message_dict
 
                 tool_calls = [
-                    ToolCall(id=tool_call["id"], type=tool_call["type"], function=tool_call["function"])
+                    OpenAIToolCall(id=tool_call["id"], type=tool_call["type"], function=tool_call["function"])
                     for tool_call in openai_message_dict["tool_calls"]
                 ]
             else: