letta-nightly 0.12.0.dev20251009104148__py3-none-any.whl → 0.12.1.dev20251009224219__py3-none-any.whl

letta/interfaces/openai_streaming_interface.py

@@ -336,14 +336,16 @@ class OpenAIStreamingInterface:
                                         step_id=self.step_id,
                                     )
                                 else:
+                                    tool_call_delta = ToolCallDelta(
+                                        name=self.function_name_buffer,
+                                        arguments=None,
+                                        tool_call_id=self.function_id_buffer,
+                                    )
                                     tool_call_msg = ToolCallMessage(
                                         id=self.letta_message_id,
                                         date=datetime.now(timezone.utc),
-                                        tool_call=ToolCallDelta(
-                                            name=self.function_name_buffer,
-                                            arguments=None,
-                                            tool_call_id=self.function_id_buffer,
-                                        ),
+                                        tool_call=tool_call_delta,
+                                        tool_calls=tool_call_delta,
                                         otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                                         run_id=self.run_id,
                                         step_id=self.step_id,
@@ -423,14 +425,16 @@ class OpenAIStreamingInterface:
                                             step_id=self.step_id,
                                         )
                                     else:
+                                        tool_call_delta = ToolCallDelta(
+                                            name=self.function_name_buffer,
+                                            arguments=combined_chunk,
+                                            tool_call_id=self.function_id_buffer,
+                                        )
                                         tool_call_msg = ToolCallMessage(
                                             id=self.letta_message_id,
                                             date=datetime.now(timezone.utc),
-                                            tool_call=ToolCallDelta(
-                                                name=self.function_name_buffer,
-                                                arguments=combined_chunk,
-                                                tool_call_id=self.function_id_buffer,
-                                            ),
+                                            tool_call=tool_call_delta,
+                                            tool_calls=tool_call_delta,
                                             # name=name,
                                             otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                                             run_id=self.run_id,
@@ -460,14 +464,16 @@ class OpenAIStreamingInterface:
                                             step_id=self.step_id,
                                         )
                                     else:
+                                        tool_call_delta = ToolCallDelta(
+                                            name=None,
+                                            arguments=updates_main_json,
+                                            tool_call_id=self.function_id_buffer,
+                                        )
                                         tool_call_msg = ToolCallMessage(
                                             id=self.letta_message_id,
                                             date=datetime.now(timezone.utc),
-                                            tool_call=ToolCallDelta(
-                                                name=None,
-                                                arguments=updates_main_json,
-                                                tool_call_id=self.function_id_buffer,
-                                            ),
+                                            tool_call=tool_call_delta,
+                                            tool_calls=tool_call_delta,
                                             # name=name,
                                             otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                                             run_id=self.run_id,
@@ -717,14 +723,16 @@ class SimpleOpenAIStreamingInterface:
                         step_id=self.step_id,
                     )
                 else:
+                    tool_call_delta = ToolCallDelta(
+                        name=tool_call.function.name,
+                        arguments=tool_call.function.arguments,
+                        tool_call_id=tool_call.id,
+                    )
                     tool_call_msg = ToolCallMessage(
                         id=self.letta_message_id,
                         date=datetime.now(timezone.utc),
-                        tool_call=ToolCallDelta(
-                            name=tool_call.function.name,
-                            arguments=tool_call.function.arguments,
-                            tool_call_id=tool_call.id,
-                        ),
+                        tool_call=tool_call_delta,
+                        tool_calls=tool_call_delta,
                         # name=name,
                         otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                         run_id=self.run_id,
@@ -945,15 +953,17 @@ class SimpleOpenAIResponsesStreamingInterface:
                 else:
                     if prev_message_type and prev_message_type != "tool_call_message":
                         message_index += 1
+                    tool_call_delta = ToolCallDelta(
+                        name=name,
+                        arguments=arguments if arguments != "" else None,
+                        tool_call_id=call_id,
+                    )
                     yield ToolCallMessage(
                         id=self.letta_message_id,
                         otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                         date=datetime.now(timezone.utc),
-                        tool_call=ToolCallDelta(
-                            name=name,
-                            arguments=arguments if arguments != "" else None,
-                            tool_call_id=call_id,
-                        ),
+                        tool_call=tool_call_delta,
+                        tool_calls=tool_call_delta,
                         run_id=self.run_id,
                         step_id=self.step_id,
                     )
@@ -1113,15 +1123,17 @@ class SimpleOpenAIResponsesStreamingInterface:
             else:
                 if prev_message_type and prev_message_type != "tool_call_message":
                     message_index += 1
+                tool_call_delta = ToolCallDelta(
+                    name=None,
+                    arguments=delta,
+                    tool_call_id=None,
+                )
                 yield ToolCallMessage(
                     id=self.letta_message_id,
                     otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                     date=datetime.now(timezone.utc),
-                    tool_call=ToolCallDelta(
-                        name=None,
-                        arguments=delta,
-                        tool_call_id=None,
-                    ),
+                    tool_call=tool_call_delta,
+                    tool_calls=tool_call_delta,
                     run_id=self.run_id,
                     step_id=self.step_id,
                 )

letta/llm_api/anthropic_client.py

@@ -56,6 +56,9 @@ class AnthropicClient(LLMClientBase):
     def request(self, request_data: dict, llm_config: LLMConfig) -> dict:
         client = self._get_anthropic_client(llm_config, async_client=False)
         betas: list[str] = []
+        # Interleaved thinking for reasoner (sync path parity)
+        if llm_config.enable_reasoner:
+            betas.append("interleaved-thinking-2025-05-14")
         # 1M context beta for Sonnet 4/4.5 when enabled
         try:
             from letta.settings import model_settings
@@ -371,6 +374,7 @@ class AnthropicClient(LLMClientBase):
     async def count_tokens(self, messages: List[dict] = None, model: str = None, tools: List[OpenAITool] = None) -> int:
         logging.getLogger("httpx").setLevel(logging.WARNING)
 
+        # Use the default client; token counting is lightweight and does not require BYOK overrides
         client = anthropic.AsyncAnthropic()
         if messages and len(messages) == 0:
             messages = None
@@ -379,23 +383,20 @@ class AnthropicClient(LLMClientBase):
         else:
             anthropic_tools = None
 
+        # Detect presence of reasoning blocks anywhere in the final assistant message.
+        # Interleaved thinking is not guaranteed to be the first content part.
         thinking_enabled = False
         if messages and len(messages) > 0:
-            # Check if the last assistant message starts with a thinking block
-            # Find the last assistant message
-            last_assistant_message = None
-            for message in reversed(messages):
-                if message.get("role") == "assistant":
-                    last_assistant_message = message
-                    break
-
-            if (
-                last_assistant_message
-                and isinstance(last_assistant_message.get("content"), list)
-                and len(last_assistant_message["content"]) > 0
-                and last_assistant_message["content"][0].get("type") == "thinking"
-            ):
-                thinking_enabled = True
+            last_assistant_message = next((m for m in reversed(messages) if m.get("role") == "assistant"), None)
+            if last_assistant_message:
+                content = last_assistant_message.get("content")
+                if isinstance(content, list):
+                    for part in content:
+                        if isinstance(part, dict) and part.get("type") in {"thinking", "redacted_thinking"}:
+                            thinking_enabled = True
+                            break
+                elif isinstance(content, str) and "<thinking>" in content:
+                    thinking_enabled = True
 
         try:
             count_params = {
@@ -404,9 +405,27 @@ class AnthropicClient(LLMClientBase):
                 "tools": anthropic_tools or [],
             }
 
+            betas: list[str] = []
             if thinking_enabled:
+                # Match interleaved thinking behavior so token accounting is consistent
                 count_params["thinking"] = {"type": "enabled", "budget_tokens": 16000}
-            result = await client.beta.messages.count_tokens(**count_params)
+                betas.append("interleaved-thinking-2025-05-14")
+
+            # Opt-in to 1M context if enabled for this model in settings
+            try:
+                if (
+                    model
+                    and model_settings.anthropic_sonnet_1m
+                    and (model.startswith("claude-sonnet-4") or model.startswith("claude-sonnet-4-5"))
+                ):
+                    betas.append("context-1m-2025-08-07")
+            except Exception:
+                pass
+
+            if betas:
+                result = await client.beta.messages.count_tokens(**count_params, betas=betas)
+            else:
+                result = await client.beta.messages.count_tokens(**count_params)
         except:
             raise
 

letta/llm_api/openai_client.py

@@ -420,6 +420,17 @@ class OpenAIClient(LLMClientBase):
             logger.warning(f"Model type not set in llm_config: {llm_config.model_dump_json(indent=4)}")
             model = None
 
+        # TODO: we may need to extend this to more models using proxy?
+        is_openrouter = (llm_config.model_endpoint and "openrouter.ai" in llm_config.model_endpoint) or (
+            llm_config.provider_name == "openrouter"
+        )
+        if is_openrouter:
+            try:
+                model = llm_config.handle.split("/", 1)[-1]
+            except:
+                # don't raise error since this isn't robust against edge cases
+                pass
+
         # force function calling for reliability, see https://platform.openai.com/docs/api-reference/chat/create#chat-create-tool_choice
         # TODO(matt) move into LLMConfig
         # TODO: This vllm checking is very brittle and is a patch at most

letta/schemas/environment_variables.py

@@ -3,6 +3,8 @@ from typing import Optional
 from pydantic import Field
 
 from letta.schemas.letta_base import LettaBase, OrmMetadataBase
+from letta.schemas.secret import Secret
+from letta.settings import settings
 
 
 # Base Environment Variable
@@ -13,6 +15,28 @@ class EnvironmentVariableBase(OrmMetadataBase):
     description: Optional[str] = Field(None, description="An optional description of the environment variable.")
     organization_id: Optional[str] = Field(None, description="The ID of the organization this environment variable belongs to.")
 
+    # Encrypted field (stored as Secret object, serialized to string for DB)
+    # Secret class handles validation and serialization automatically via __get_pydantic_core_schema__
+    value_enc: Secret | None = Field(None, description="Encrypted value as Secret object")
+
+    def get_value_secret(self) -> Secret:
+        """Get the value as a Secret object, preferring encrypted over plaintext."""
+        # If value_enc is already a Secret, return it
+        if self.value_enc is not None:
+            return self.value_enc
+        # Otherwise, create from plaintext value
+        return Secret.from_db(None, self.value)
+
+    def set_value_secret(self, secret: Secret) -> None:
+        """Set value from a Secret object, directly storing the Secret."""
+        self.value_enc = secret
+        # Also update plaintext field for dual-write during migration
+        secret_dict = secret.to_dict()
+        if not secret.was_encrypted:
+            self.value = secret_dict["plaintext"]
+        else:
+            self.value = None
+
 
 class EnvironmentVariableCreateBase(LettaBase):
     key: str = Field(..., description="The name of the environment variable.")

letta/schemas/letta_message.py

@@ -190,7 +190,8 @@ class ToolCallMessage(LettaMessage):
     message_type: Literal[MessageType.tool_call_message] = Field(
         default=MessageType.tool_call_message, description="The type of the message."
     )
-    tool_call: Union[ToolCall, ToolCallDelta]
+    tool_call: Union[ToolCall, ToolCallDelta] = Field(..., deprecated=True)
+    tool_calls: Optional[Union[List[ToolCall], ToolCallDelta]] = None
 
     def model_dump(self, *args, **kwargs):
         """
@@ -198,8 +199,14 @@ class ToolCallMessage(LettaMessage):
         """
         kwargs["exclude_none"] = True
         data = super().model_dump(*args, **kwargs)
-        if isinstance(data["tool_call"], dict):
+        if isinstance(data.get("tool_call"), dict):
             data["tool_call"] = {k: v for k, v in data["tool_call"].items() if v is not None}
+        if isinstance(data.get("tool_calls"), dict):
+            data["tool_calls"] = {k: v for k, v in data["tool_calls"].items() if v is not None}
+        elif isinstance(data.get("tool_calls"), list):
+            data["tool_calls"] = [
+                {k: v for k, v in item.items() if v is not None} if isinstance(item, dict) else item for item in data["tool_calls"]
+            ]
         return data
 
     class Config:
@@ -226,6 +233,14 @@ class ToolCallMessage(LettaMessage):
         return v
 
 
+class ToolReturn(BaseModel):
+    tool_return: str
+    status: Literal["success", "error"]
+    tool_call_id: str
+    stdout: Optional[List[str]] = None
+    stderr: Optional[List[str]] = None
+
+
 class ToolReturnMessage(LettaMessage):
     """
     A message representing the return value of a tool call (generated by Letta executing the requested tool).
@@ -234,21 +249,23 @@ class ToolReturnMessage(LettaMessage):
         id (str): The ID of the message
         date (datetime): The date the message was created in ISO format
         name (Optional[str]): The name of the sender of the message
-        tool_return (str): The return value of the tool
-        status (Literal["success", "error"]): The status of the tool call
-        tool_call_id (str): A unique identifier for the tool call that generated this message
-        stdout (Optional[List(str)]): Captured stdout (e.g. prints, logs) from the tool invocation
-        stderr (Optional[List(str)]): Captured stderr from the tool invocation
+        tool_return (str): The return value of the tool (deprecated, use tool_returns)
+        status (Literal["success", "error"]): The status of the tool call (deprecated, use tool_returns)
+        tool_call_id (str): A unique identifier for the tool call that generated this message (deprecated, use tool_returns)
+        stdout (Optional[List(str)]): Captured stdout (e.g. prints, logs) from the tool invocation (deprecated, use tool_returns)
+        stderr (Optional[List(str)]): Captured stderr from the tool invocation (deprecated, use tool_returns)
+        tool_returns (Optional[List[ToolReturn]]): List of tool returns for multi-tool support
     """
 
     message_type: Literal[MessageType.tool_return_message] = Field(
         default=MessageType.tool_return_message, description="The type of the message."
     )
-    tool_return: str
-    status: Literal["success", "error"]
-    tool_call_id: str
-    stdout: Optional[List[str]] = None
-    stderr: Optional[List[str]] = None
+    tool_return: str = Field(..., deprecated=True)
+    status: Literal["success", "error"] = Field(..., deprecated=True)
+    tool_call_id: str = Field(..., deprecated=True)
+    stdout: Optional[List[str]] = Field(None, deprecated=True)
+    stderr: Optional[List[str]] = Field(None, deprecated=True)
+    tool_returns: Optional[List[ToolReturn]] = None
 
 
 class ApprovalRequestMessage(LettaMessage):

letta/schemas/message.py

@@ -492,23 +492,27 @@ class Message(BaseMessage):
         assistant_message_tool_kwarg: str = DEFAULT_MESSAGE_TOOL_KWARG,
     ) -> List[LettaMessage]:
         messages = []
-        # This is type FunctionCall
-        for tool_call in self.tool_calls:
-            otid = Message.generate_otid_from_id(self.id, current_message_count + len(messages))
-            # If we're supporting using assistant message,
-            # then we want to treat certain function calls as a special case
-            if use_assistant_message and tool_call.function.name == assistant_message_tool_name:
-                # We need to unpack the actual message contents from the function call
-                try:
-                    func_args = parse_json(tool_call.function.arguments)
-                    message_string = validate_function_response(func_args[assistant_message_tool_kwarg], 0, truncate=False)
-                except KeyError:
-                    raise ValueError(f"Function call {tool_call.function.name} missing {assistant_message_tool_kwarg} argument")
+
+        # If assistant mode is off, just create one ToolCallMessage with all tool calls
+        if not use_assistant_message:
+            all_tool_call_objs = [
+                ToolCall(
+                    name=tool_call.function.name,
+                    arguments=tool_call.function.arguments,
+                    tool_call_id=tool_call.id,
+                )
+                for tool_call in self.tool_calls
+            ]
+
+            if all_tool_call_objs:
+                otid = Message.generate_otid_from_id(self.id, current_message_count)
                 messages.append(
-                    AssistantMessage(
+                    ToolCallMessage(
                         id=self.id,
                         date=self.created_at,
-                        content=message_string,
+                        # use first tool call for the deprecated field
+                        tool_call=all_tool_call_objs[0],
+                        tool_calls=all_tool_call_objs,
                         name=self.name,
                         otid=otid,
                         sender_id=self.sender_id,
@@ -517,16 +521,41 @@ class Message(BaseMessage):
                         run_id=self.run_id,
                     )
                 )
-            else:
+            return messages
+
+        collected_tool_calls = []
+
+        for tool_call in self.tool_calls:
+            otid = Message.generate_otid_from_id(self.id, current_message_count + len(messages))
+
+            if tool_call.function.name == assistant_message_tool_name:
+                if collected_tool_calls:
+                    tool_call_message = ToolCallMessage(
+                        id=self.id,
+                        date=self.created_at,
+                        # use first tool call for the deprecated field
+                        tool_call=collected_tool_calls[0],
+                        tool_calls=collected_tool_calls.copy(),
+                        name=self.name,
+                        otid=Message.generate_otid_from_id(self.id, current_message_count + len(messages)),
+                        sender_id=self.sender_id,
+                        step_id=self.step_id,
+                        is_err=self.is_err,
+                        run_id=self.run_id,
+                    )
+                    messages.append(tool_call_message)
+                    collected_tool_calls = []  # reset the collection
+
+                try:
+                    func_args = parse_json(tool_call.function.arguments)
+                    message_string = validate_function_response(func_args[assistant_message_tool_kwarg], 0, truncate=False)
+                except KeyError:
+                    raise ValueError(f"Function call {tool_call.function.name} missing {assistant_message_tool_kwarg} argument")
                 messages.append(
-                    ToolCallMessage(
+                    AssistantMessage(
                         id=self.id,
                         date=self.created_at,
-                        tool_call=ToolCall(
-                            name=tool_call.function.name,
-                            arguments=tool_call.function.arguments,
-                            tool_call_id=tool_call.id,
-                        ),
+                        content=message_string,
                         name=self.name,
                         otid=otid,
                         sender_id=self.sender_id,
@@ -535,6 +564,32 @@ class Message(BaseMessage):
                         run_id=self.run_id,
                     )
                 )
+            else:
+                # non-assistant tool call, collect it
+                tool_call_obj = ToolCall(
+                    name=tool_call.function.name,
+                    arguments=tool_call.function.arguments,
+                    tool_call_id=tool_call.id,
+                )
+                collected_tool_calls.append(tool_call_obj)
+
+        # flush any remaining collected tool calls
+        if collected_tool_calls:
+            tool_call_message = ToolCallMessage(
+                id=self.id,
+                date=self.created_at,
+                # use first tool call for the deprecated field
+                tool_call=collected_tool_calls[0],
+                tool_calls=collected_tool_calls,
+                name=self.name,
+                otid=Message.generate_otid_from_id(self.id, current_message_count + len(messages)),
+                sender_id=self.sender_id,
+                step_id=self.step_id,
+                is_err=self.is_err,
+                run_id=self.run_id,
+            )
+            messages.append(tool_call_message)
+
         return messages
 
     def _convert_tool_return_message(self) -> List[ToolReturnMessage]:
@@ -556,6 +611,13 @@ class Message(BaseMessage):
         if self.role != MessageRole.tool:
             raise ValueError(f"Cannot convert message of type {self.role} to ToolReturnMessage")
 
+        # This is a very special buggy case during the double writing period
+        # where there is no tool call id on the tool return object, but it exists top level
+        # This is meant to be a short term patch - this can happen when people are using old agent files that were exported
+        # during a specific migration state
+        if len(self.tool_returns) == 1 and self.tool_call_id and not self.tool_returns[0].tool_call_id:
+            self.tool_returns[0].tool_call_id = self.tool_call_id
+
         if self.tool_returns:
             return self._convert_explicit_tool_returns()
 
@@ -647,6 +709,16 @@ class Message(BaseMessage):
         Returns:
             Configured ToolReturnMessage instance
         """
+        from letta.schemas.letta_message import ToolReturn as ToolReturnSchema
+
+        tool_return_obj = ToolReturnSchema(
+            tool_return=message_text,
+            status=status,
+            tool_call_id=tool_call_id,
+            stdout=stdout,
+            stderr=stderr,
+        )
+
         return ToolReturnMessage(
             id=self.id,
             date=self.created_at,
@@ -655,6 +727,7 @@ class Message(BaseMessage):
             tool_call_id=tool_call_id,
             stdout=stdout,
             stderr=stderr,
+            tool_returns=[tool_return_obj],
             name=self.name,
             otid=Message.generate_otid_from_id(self.id, otid_index),
             sender_id=self.sender_id,
@@ -1625,6 +1698,14 @@ class Message(BaseMessage):
         if messages[-1].role == "approval" and messages[-1].tool_calls is not None and len(messages[-1].tool_calls) > 0:
             messages.remove(messages[-1])
 
+        # Filter last message if it is a lone reasoning message without assistant message or tool call
+        if (
+            messages[-1].role == "assistant"
+            and messages[-1].tool_calls is None
+            and (not messages[-1].content or all(not isinstance(content_part, TextContent) for content_part in messages[-1].content))
+        ):
+            messages.remove(messages[-1])
+
         return messages
 
     @staticmethod

letta/schemas/providers/base.py

@@ -8,6 +8,7 @@ from letta.schemas.enums import ProviderCategory, ProviderType
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.llm_config_overrides import LLM_HANDLE_OVERRIDES
+from letta.schemas.secret import Secret
 from letta.settings import model_settings
 
 
@@ -28,8 +29,14 @@ class Provider(ProviderBase):
     organization_id: str | None = Field(None, description="The organization id of the user")
     updated_at: datetime | None = Field(None, description="The last update timestamp of the provider.")
 
+    # Encrypted fields (stored as Secret objects, serialized to strings for DB)
+    # Secret class handles validation and serialization automatically via __get_pydantic_core_schema__
+    api_key_enc: Secret | None = Field(None, description="Encrypted API key as Secret object")
+    access_key_enc: Secret | None = Field(None, description="Encrypted access key as Secret object")
+
     @model_validator(mode="after")
     def default_base_url(self):
+        # Set default base URL
         if self.provider_type == ProviderType.openai and self.base_url is None:
             self.base_url = model_settings.openai_api_base
         return self
@@ -38,6 +45,42 @@ class Provider(ProviderBase):
         if not self.id:
             self.id = ProviderBase.generate_id(prefix=ProviderBase.__id_prefix__)
 
+    def get_api_key_secret(self) -> Secret:
+        """Get the API key as a Secret object, preferring encrypted over plaintext."""
+        # If api_key_enc is already a Secret, return it
+        if self.api_key_enc is not None:
+            return self.api_key_enc
+        # Otherwise, create from plaintext api_key
+        return Secret.from_db(None, self.api_key)
+
+    def get_access_key_secret(self) -> Secret:
+        """Get the access key as a Secret object, preferring encrypted over plaintext."""
+        # If access_key_enc is already a Secret, return it
+        if self.access_key_enc is not None:
+            return self.access_key_enc
+        # Otherwise, create from plaintext access_key
+        return Secret.from_db(None, self.access_key)
+
+    def set_api_key_secret(self, secret: Secret) -> None:
+        """Set API key from a Secret object, directly storing the Secret."""
+        self.api_key_enc = secret
+        # Also update plaintext field for dual-write during migration
+        secret_dict = secret.to_dict()
+        if not secret.was_encrypted:
+            self.api_key = secret_dict["plaintext"]
+        else:
+            self.api_key = None
+
+    def set_access_key_secret(self, secret: Secret) -> None:
+        """Set access key from a Secret object, directly storing the Secret."""
+        self.access_key_enc = secret
+        # Also update plaintext field for dual-write during migration
+        secret_dict = secret.to_dict()
+        if not secret.was_encrypted:
+            self.access_key = secret_dict["plaintext"]
+        else:
+            self.access_key = None
+
     async def check_api_key(self):
         """Check if the API key is valid for the provider"""
         raise NotImplementedError