letta-nightly 0.12.0.dev20251009104148__py3-none-any.whl → 0.12.0.dev20251009203644__py3-none-any.whl

letta/interfaces/anthropic_streaming_interface.py

@@ -279,9 +279,11 @@ class AnthropicStreamingInterface:
                     if prev_message_type and prev_message_type != "tool_call_message":
                         message_index += 1
                     if self.tool_call_name not in self.requires_approval_tools:
+                        tool_call_delta = ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id)
                         tool_call_msg = ToolCallMessage(
                             id=self.letta_message_id,
-                            tool_call=ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id),
+                            tool_call=tool_call_delta,
+                            tool_calls=tool_call_delta,
                             date=datetime.now(timezone.utc).isoformat(),
                             otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                             run_id=self.run_id,
@@ -423,15 +425,17 @@ class AnthropicStreamingInterface:
                             tool_call_args += buffered_msg.tool_call.arguments if buffered_msg.tool_call.arguments else ""
                         tool_call_args = tool_call_args.replace(f'"{INNER_THOUGHTS_KWARG}": "{current_inner_thoughts}"', "")
 
+                        tool_call_delta = ToolCallDelta(
+                            name=self.tool_call_name,
+                            tool_call_id=self.tool_call_id,
+                            arguments=tool_call_args,
+                        )
                         tool_call_msg = ToolCallMessage(
                             id=self.tool_call_buffer[0].id,
                             otid=Message.generate_otid_from_id(self.tool_call_buffer[0].id, message_index),
                             date=self.tool_call_buffer[0].date,
-                            tool_call=ToolCallDelta(
-                                name=self.tool_call_name,
-                                tool_call_id=self.tool_call_id,
-                                arguments=tool_call_args,
-                            ),
+                            tool_call=tool_call_delta,
+                            tool_calls=tool_call_delta,
                             run_id=self.run_id,
                         )
                         prev_message_type = tool_call_msg.message_type
@@ -467,9 +471,13 @@ class AnthropicStreamingInterface:
                             run_id=self.run_id,
                         )
                     else:
+                        tool_call_delta = ToolCallDelta(
+                            name=self.tool_call_name, tool_call_id=self.tool_call_id, arguments=delta.partial_json
+                        )
                         tool_call_msg = ToolCallMessage(
                             id=self.letta_message_id,
-                            tool_call=ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id, arguments=delta.partial_json),
+                            tool_call=tool_call_delta,
+                            tool_calls=tool_call_delta,
                             date=datetime.now(timezone.utc).isoformat(),
                             run_id=self.run_id,
                         )
@@ -778,9 +786,11 @@ class SimpleAnthropicStreamingInterface:
                 else:
                     if prev_message_type and prev_message_type != "tool_call_message":
                         message_index += 1
+                    tool_call_delta = ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id)
                     tool_call_msg = ToolCallMessage(
                         id=self.letta_message_id,
-                        tool_call=ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id),
+                        tool_call=tool_call_delta,
+                        tool_calls=tool_call_delta,
                         date=datetime.now(timezone.utc).isoformat(),
                         otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                         run_id=self.run_id,
@@ -860,9 +870,11 @@ class SimpleAnthropicStreamingInterface:
                 else:
                     if prev_message_type and prev_message_type != "tool_call_message":
                         message_index += 1
+                    tool_call_delta = ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id, arguments=delta.partial_json)
                     tool_call_msg = ToolCallMessage(
                         id=self.letta_message_id,
-                        tool_call=ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id, arguments=delta.partial_json),
+                        tool_call=tool_call_delta,
+                        tool_calls=tool_call_delta,
                         date=datetime.now(timezone.utc).isoformat(),
                         otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                         run_id=self.run_id,

letta/interfaces/gemini_streaming_interface.py

@@ -273,15 +273,17 @@ class SimpleGeminiStreamingInterface:
                 else:
                     if prev_message_type and prev_message_type != "tool_call_message":
                         message_index += 1
+                    tool_call_delta = ToolCallDelta(
+                        name=name,
+                        arguments=arguments_str,
+                        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_str,
-                            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,
                     )

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/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/server/rest_api/interface.py

@@ -562,14 +562,16 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
                 if prev_message_type and prev_message_type != "tool_call_message":
                     message_index += 1
+                tool_call_delta = ToolCallDelta(
+                    name=json_reasoning_content.get("name"),
+                    arguments=json.dumps(json_reasoning_content.get("arguments")),
+                    tool_call_id=None,
+                )
                 processed_chunk = ToolCallMessage(
                     id=message_id,
                     date=message_date,
-                    tool_call=ToolCallDelta(
-                        name=json_reasoning_content.get("name"),
-                        arguments=json.dumps(json_reasoning_content.get("arguments")),
-                        tool_call_id=None,
-                    ),
+                    tool_call=tool_call_delta,
+                    tool_calls=tool_call_delta,
                     name=name,
                     otid=Message.generate_otid_from_id(message_id, message_index),
                 )
@@ -703,14 +705,16 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                     else:
                         if prev_message_type and prev_message_type != "tool_call_message":
                             message_index += 1
+                        tc_delta = ToolCallDelta(
+                            name=tool_call_delta.get("name"),
+                            arguments=tool_call_delta.get("arguments"),
+                            tool_call_id=tool_call_delta.get("id"),
+                        )
                         processed_chunk = ToolCallMessage(
                             id=message_id,
                             date=message_date,
-                            tool_call=ToolCallDelta(
-                                name=tool_call_delta.get("name"),
-                                arguments=tool_call_delta.get("arguments"),
-                                tool_call_id=tool_call_delta.get("id"),
-                            ),
+                            tool_call=tc_delta,
+                            tool_calls=tc_delta,
                             name=name,
                             otid=Message.generate_otid_from_id(message_id, message_index),
                         )
@@ -779,14 +783,16 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                             else:
                                 if prev_message_type and prev_message_type != "tool_call_message":
                                     message_index += 1
+                                tc_delta = ToolCallDelta(
+                                    name=self.function_name_buffer,
+                                    arguments=None,
+                                    tool_call_id=self.function_id_buffer,
+                                )
                                 processed_chunk = ToolCallMessage(
                                     id=message_id,
                                     date=message_date,
-                                    tool_call=ToolCallDelta(
-                                        name=self.function_name_buffer,
-                                        arguments=None,
-                                        tool_call_id=self.function_id_buffer,
-                                    ),
+                                    tool_call=tc_delta,
+                                    tool_calls=tc_delta,
                                     name=name,
                                     otid=Message.generate_otid_from_id(message_id, message_index),
                                 )
@@ -843,14 +849,16 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                     combined_chunk = self.function_args_buffer + updates_main_json
                                     if prev_message_type and prev_message_type != "tool_call_message":
                                         message_index += 1
+                                    tc_delta = ToolCallDelta(
+                                        name=None,
+                                        arguments=combined_chunk,
+                                        tool_call_id=self.function_id_buffer,
+                                    )
                                     processed_chunk = ToolCallMessage(
                                         id=message_id,
                                         date=message_date,
-                                        tool_call=ToolCallDelta(
-                                            name=None,
-                                            arguments=combined_chunk,
-                                            tool_call_id=self.function_id_buffer,
-                                        ),
+                                        tool_call=tc_delta,
+                                        tool_calls=tc_delta,
                                         name=name,
                                         otid=Message.generate_otid_from_id(message_id, message_index),
                                     )
@@ -861,14 +869,16 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                     # If there's no buffer to clear, just output a new chunk with new data
                                     if prev_message_type and prev_message_type != "tool_call_message":
                                         message_index += 1
+                                    tc_delta = ToolCallDelta(
+                                        name=None,
+                                        arguments=updates_main_json,
+                                        tool_call_id=self.function_id_buffer,
+                                    )
                                     processed_chunk = ToolCallMessage(
                                         id=message_id,
                                         date=message_date,
-                                        tool_call=ToolCallDelta(
-                                            name=None,
-                                            arguments=updates_main_json,
-                                            tool_call_id=self.function_id_buffer,
-                                        ),
+                                        tool_call=tc_delta,
+                                        tool_calls=tc_delta,
                                         name=name,
                                         otid=Message.generate_otid_from_id(message_id, message_index),
                                     )
@@ -992,14 +1002,16 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 else:
                     if prev_message_type and prev_message_type != "tool_call_message":
                         message_index += 1
+                    tc_delta = ToolCallDelta(
+                        name=tool_call_delta.get("name"),
+                        arguments=tool_call_delta.get("arguments"),
+                        tool_call_id=tool_call_delta.get("id"),
+                    )
                     processed_chunk = ToolCallMessage(
                         id=message_id,
                         date=message_date,
-                        tool_call=ToolCallDelta(
-                            name=tool_call_delta.get("name"),
-                            arguments=tool_call_delta.get("arguments"),
-                            tool_call_id=tool_call_delta.get("id"),
-                        ),
+                        tool_call=tc_delta,
+                        tool_calls=tc_delta,
                         name=name,
                         otid=Message.generate_otid_from_id(message_id, message_index),
                     )
@@ -1262,14 +1274,16 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                         # Store the ID of the tool call so allow skipping the corresponding response
                         self.prev_assistant_message_id = function_call.id
                     else:
+                        tool_call_obj = ToolCall(
+                            name=function_call.function.name,
+                            arguments=function_call.function.arguments,
+                            tool_call_id=function_call.id,
+                        )
                         processed_chunk = ToolCallMessage(
                             id=msg_obj.id,
                             date=msg_obj.created_at,
-                            tool_call=ToolCall(
-                                name=function_call.function.name,
-                                arguments=function_call.function.arguments,
-                                tool_call_id=function_call.id,
-                            ),
+                            tool_call=tool_call_obj,
+                            tool_calls=tool_call_obj,
                             name=msg_obj.name,
                             otid=Message.generate_otid_from_id(msg_obj.id, chunk_index) if chunk_index is not None else None,
                         )
@@ -1303,14 +1317,29 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 # Skip this tool call receipt
                 return
             else:
+                from letta.schemas.letta_message import ToolReturn as ToolReturnSchema
+
+                status = msg_obj.tool_returns[0].status if msg_obj.tool_returns else "success"
+                stdout = msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else []
+                stderr = msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else []
+
+                tool_return_obj = ToolReturnSchema(
+                    tool_return=msg,
+                    status=status,
+                    tool_call_id=msg_obj.tool_call_id,
+                    stdout=stdout,
+                    stderr=stderr,
+                )
+
                 new_message = ToolReturnMessage(
                     id=msg_obj.id,
                     date=msg_obj.created_at,
                     tool_return=msg,
-                    status=msg_obj.tool_returns[0].status if msg_obj.tool_returns else "success",
+                    status=status,
                     tool_call_id=msg_obj.tool_call_id,
-                    stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else [],
-                    stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else [],
+                    stdout=stdout,
+                    stderr=stderr,
+                    tool_returns=[tool_return_obj],
                     name=msg_obj.name,
                     otid=Message.generate_otid_from_id(msg_obj.id, chunk_index) if chunk_index is not None else None,
                 )
@@ -1319,14 +1348,29 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
             msg = msg.replace("Error: ", "", 1)
             # new_message = {"function_return": msg, "status": "error"}
             assert msg_obj.tool_call_id is not None
+            from letta.schemas.letta_message import ToolReturn as ToolReturnSchema
+
+            status = msg_obj.tool_returns[0].status if msg_obj.tool_returns else "error"
+            stdout = msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else []
+            stderr = msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else []
+
+            tool_return_obj = ToolReturnSchema(
+                tool_return=msg,
+                status=status,
+                tool_call_id=msg_obj.tool_call_id,
+                stdout=stdout,
+                stderr=stderr,
+            )
+
             new_message = ToolReturnMessage(
                 id=msg_obj.id,
                 date=msg_obj.created_at,
                 tool_return=msg,
-                status=msg_obj.tool_returns[0].status if msg_obj.tool_returns else "error",
+                status=status,
                 tool_call_id=msg_obj.tool_call_id,
-                stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else [],
-                stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else [],
+                stdout=stdout,
+                stderr=stderr,
+                tool_returns=[tool_return_obj],
                 name=msg_obj.name,
                 otid=Message.generate_otid_from_id(msg_obj.id, chunk_index) if chunk_index is not None else None,
             )

letta/server/rest_api/routers/v1/providers.py

@@ -120,6 +120,40 @@ async def check_provider(
         raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"{e}")
 
 
+@router.post("/{provider_id}/check", response_model=None, operation_id="check_existing_provider")
+async def check_existing_provider(
+    provider_id: str,
+    headers: HeaderParams = Depends(get_headers),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Verify the API key and additional parameters for an existing provider.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+        provider = await server.provider_manager.get_provider_async(provider_id=provider_id, actor=actor)
+
+        # Create a ProviderCheck from the existing provider
+        provider_check = ProviderCheck(
+            provider_type=provider.provider_type,
+            api_key=provider.api_key,
+            base_url=provider.base_url,
+        )
+
+        await server.provider_manager.check_provider_api_key(provider_check=provider_check)
+        return JSONResponse(
+            status_code=status.HTTP_200_OK, content={"message": f"Valid api key for provider_type={provider.provider_type.value}"}
+        )
+    except LLMAuthenticationError as e:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=f"{e.message}")
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail=f"Provider provider_id={provider_id} not found for user_id={actor.id}.")
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"{e}")
+
+
 @router.delete("/{provider_id}", response_model=None, operation_id="delete_provider")
 async def delete_provider(
     provider_id: str,

letta/server/rest_api/routers/v1/runs.py

@@ -286,7 +286,7 @@ async def delete_run(
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     runs_manager = RunManager()
-    return await runs_manager.delete_run_by_id(run_id=run_id, actor=actor)
+    return await runs_manager.delete_run(run_id=run_id, actor=actor)
 
 
 @router.post(

letta/server/server.py

@@ -1239,6 +1239,16 @@ class SyncServer(object):
                 function_args=tool_args,
                 tool=tool,
             )
+            from letta.schemas.letta_message import ToolReturn as ToolReturnSchema
+
+            tool_return_obj = ToolReturnSchema(
+                tool_return=str(tool_execution_result.func_return),
+                status=tool_execution_result.status,
+                tool_call_id="null",
+                stdout=tool_execution_result.stdout,
+                stderr=tool_execution_result.stderr,
+            )
+
             return ToolReturnMessage(
                 id="null",
                 tool_call_id="null",
@@ -1247,10 +1257,21 @@ class SyncServer(object):
                 tool_return=str(tool_execution_result.func_return),
                 stdout=tool_execution_result.stdout,
                 stderr=tool_execution_result.stderr,
+                tool_returns=[tool_return_obj],
             )
 
         except Exception as e:
             func_return = get_friendly_error_msg(function_name=tool.name, exception_name=type(e).__name__, exception_message=str(e))
+            from letta.schemas.letta_message import ToolReturn as ToolReturnSchema
+
+            tool_return_obj = ToolReturnSchema(
+                tool_return=func_return,
+                status="error",
+                tool_call_id="null",
+                stdout=[],
+                stderr=[traceback.format_exc()],
+            )
+
             return ToolReturnMessage(
                 id="null",
                 tool_call_id="null",
@@ -1259,6 +1280,7 @@ class SyncServer(object):
                 tool_return=func_return,
                 stdout=[],
                 stderr=[traceback.format_exc()],
+                tool_returns=[tool_return_obj],
             )
 
     # MCP wrappers

{letta_nightly-0.12.0.dev20251009104148.dist-info → letta_nightly-0.12.0.dev20251009203644.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: letta-nightly
-Version: 0.12.0.dev20251009104148
+Version: 0.12.0.dev20251009203644
 Summary: Create LLM agents with long-term memory and custom tools
 Author-email: Letta Team <contact@letta.com>
 License: Apache License

{letta_nightly-0.12.0.dev20251009104148.dist-info → letta_nightly-0.12.0.dev20251009203644.dist-info}/RECORD

@@ -88,10 +88,10 @@ letta/humans/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/humans/examples/basic.txt,sha256=Lcp8YESTWvOJgO4Yf_yyQmgo5bKakeB1nIVrwEGG6PA,17
 letta/humans/examples/cs_phd.txt,sha256=9C9ZAV_VuG7GB31ksy3-_NAyk8rjE6YtVOkhp08k1xw,297
 letta/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/interfaces/anthropic_streaming_interface.py,sha256=-zJ4LhS7vIXnfYg-PtEM_SZya1MFT_2hdaxbNyTppFg,44188
-letta/interfaces/gemini_streaming_interface.py,sha256=17a96UeLtTqlyNLJe9f0gi5dnUuE8iIgZneIaZ2AotE,12316
+letta/interfaces/anthropic_streaming_interface.py,sha256=VaqI_aLAOk8EbVmDLe8PMOb5LsKNhVqpgVbLe-WbjMg,44780
+letta/interfaces/gemini_streaming_interface.py,sha256=1nJwGl3nKAL7yfDX0zzpWrrjjpqzRFo82JpsEF6u_cA,12406
 letta/interfaces/openai_chat_completions_streaming_interface.py,sha256=3xHXh8cW79EkiMUTYfvcH_s92nkLjxXfvtVOVC3bfLo,5050
-letta/interfaces/openai_streaming_interface.py,sha256=E-gFVpZDl6rECU3KpmN31CU-CfkjSj4aD_3u2CwtuRw,75950
+letta/interfaces/openai_streaming_interface.py,sha256=ROUbTygmwWyxkfAhjnI9LPR16Wxo-Kf5POsJuWM10rk,76594
 letta/interfaces/utils.py,sha256=c6jvO0dBYHh8DQnlN-B0qeNC64d3CSunhfqlFA4pJTY,278
 letta/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/jobs/helpers.py,sha256=kO4aj954xsQ1RAmkjY6LQQ7JEIGuhaxB1e9pzrYKHAY,914
@@ -99,7 +99,7 @@ letta/jobs/llm_batch_job_polling.py,sha256=HUCTa1lTOiLAB_8m95RUfeNJa4lxlF8paGdCV
 letta/jobs/scheduler.py,sha256=Ub5VTCA8P5C9Y-0mPK2YIPJSEzKbSd2l5Sp0sOWctD8,8697
 letta/jobs/types.py,sha256=K8GKEnqEgAT6Kq4F2hUrBC4ZAFM9OkfOjVMStzxKuXQ,742
 letta/llm_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/llm_api/anthropic_client.py,sha256=xZc2tvqz0_P3oNc0Wd2iWpK8qopQJkOSGnOFyo7v7hU,42204
+letta/llm_api/anthropic_client.py,sha256=nDE3D0aqxI1pQGl2zOdkJNqc74KNp7_6ZXK5AEwgIP4,43320
 letta/llm_api/azure_client.py,sha256=BeChGsH4brrSgZBbCf8UE5RkW-3ZughpKnsBY2VYxwI,3841
 letta/llm_api/bedrock_client.py,sha256=xB01zdk1bzzf0ExkPcWcuxuLb1GXaJglvgRMYP2zai4,3572
 letta/llm_api/deepseek_client.py,sha256=YYja4-LWODE8fAJPSIVGxA7q0hb6-QmWRxWhlboTp64,17144
@@ -261,7 +261,7 @@ letta/schemas/health.py,sha256=zT6mYovvD17iJRuu2rcaQQzbEEYrkwvAE9TB7iU824c,139
 letta/schemas/identity.py,sha256=-6ABqAuz-VfGcAoAX5oVyzpjBiY4jAN-gJUM-PLBQQY,3984
 letta/schemas/job.py,sha256=iIGYuegO9OzWyfA8nTV0sov67KyTb2QAhSHYy4TVte0,5552
 letta/schemas/letta_base.py,sha256=LhVKaSAUr7HzrvuEJE_1ZKJMe-nJKoYR-ZgLe1IUTpY,4020
-letta/schemas/letta_message.py,sha256=RZiWiqan_fxJBjoSi8JpSMjdrvlxEEF4jmq-HGBCMtw,18021
+letta/schemas/letta_message.py,sha256=lsWR5FaUYNmQ5xu0RWk_bjsT0q8x90nWmekuggykQ60,19142
 letta/schemas/letta_message_content.py,sha256=_BTfU6NcxNbc6SPt4ANVGUh0d0QUqVQkfDF0gM8rbdg,13226
 letta/schemas/letta_ping.py,sha256=9JphoKhWZ63JqsakIx4aaj8dYMtYVa7HxSkT5cMh5cI,863
 letta/schemas/letta_request.py,sha256=ll0QTt-tzaJ3zxpPyaifz7mtWcPy6QmvPUDOzngbxfQ,4526
@@ -272,7 +272,7 @@ letta/schemas/llm_config.py,sha256=dzEiIvm1l5xlYF0Q1It-18l9HKdwMd4Yr09A3gWhhNI,1
 letta/schemas/llm_config_overrides.py,sha256=E6qJuVA8TwAAy3VjGitJ5jSQo5PbN-6VPcZOF5qhP9A,1815
 letta/schemas/mcp.py,sha256=Wiu3FL5qupaHFaMqKFp-w1Ev6ShQ5dPfAtKIMGmRiF8,15527
 letta/schemas/memory.py,sha256=g2cPd0CF_3atzVkQA8ioIm52oZbsr6Ng-w31qGgNJ_g,20206
-letta/schemas/message.py,sha256=kXTfYnbFm7uzj2TIy-R3ixrSJGnR6xasdt1wgYJJOvw,74961
+letta/schemas/message.py,sha256=E8d8I2ALa6dAW28yrGEIjUNGvqigPPBmovwA8xopDro,78354
 letta/schemas/npm_requirement.py,sha256=HkvBF7KjHUH-MG-RAEYJHO2MLRS2rxFUcmbpbZVznLk,457
 letta/schemas/organization.py,sha256=TXrHN4IBQnX-mWvRuCOH57XZSLYCVOY0wWm2_UzDQIA,1279
 letta/schemas/passage.py,sha256=_bO19zOIQtQ3F3VqDSgIJqh15V0IIrJ_KdlbCt6-4D0,3940
@@ -333,7 +333,7 @@ letta/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/constants.py,sha256=yAdGbLkzlOU_dLTx0lKDmAnj0ZgRXCEaIcPJWO69eaE,92
 letta/server/db.py,sha256=bh294tLdOQxOrO9jICDrXa_UXTAYFByu_47tPXlKrjs,3006
 letta/server/generate_openapi_schema.sh,sha256=14Q6r0fbNNVVdf4X3Z-H0ZtyrVw5zYLzL5Doom3kM9k,351
-letta/server/server.py,sha256=nEvHxECQJ6I6EC2GQRNzHZpxg5HgFkhCXzqFwB-U9E4,78499
+letta/server/server.py,sha256=JClC6RiH5giUEGr74VzpABAZOASazHiBGmnG7nr-PwQ,79339
 letta/server/startup.sh,sha256=z-Fea-7LiuS_aG1tJqS8JAsDQaamwC_kuDhv9D3PPPY,2698
 letta/server/utils.py,sha256=rRvW6L1lzau4u9boamiyZH54lf5tQ91ypXzUW9cfSPA,1667
 letta/server/rest_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -341,7 +341,7 @@ letta/server/rest_api/app.py,sha256=43HvR0pVs3XHUpmHJvT4wMm_sWc8NcB1ViH5XYCnSBc,
 letta/server/rest_api/auth_token.py,sha256=725EFEIiNj4dh70hrSd94UysmFD8vcJLrTRfNHkzxDo,774
 letta/server/rest_api/chat_completions_interface.py,sha256=-7wO7pNBWXMqblVkJpuZ8JPJ-LjudLTtT6BJu-q_XAM,11138
 letta/server/rest_api/dependencies.py,sha256=4VdkahB_yLpvwmJnwWG1s46apclrR53QfDeE1es9wUc,1722
-letta/server/rest_api/interface.py,sha256=_GQfKYUp9w4Wo2HSE_8Ff7QU16t1blspLaqmukpER9s,67099
+letta/server/rest_api/interface.py,sha256=KbeStLQQ9fLDOYJwA-VrzuppgCr9_b6k2CFVBYNw2A0,68676
 letta/server/rest_api/json_parser.py,sha256=yoakaCkSMdf0Y_pyILoFKZlvzXeqF-E1KNeHzatLMDc,9157
 letta/server/rest_api/redis_stream_manager.py,sha256=cJaveonCmTaCMi_I56u5TaSgGIu7e6TltvRZeLC49DU,11227
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
@@ -369,8 +369,8 @@ letta/server/rest_api/routers/v1/jobs.py,sha256=fZkw3O9ivKYMgXkst-lDEiCPN8eL4-MY
 letta/server/rest_api/routers/v1/llms.py,sha256=sv5VWqB0-iSRi6LyzqsM1fLmOFm9UhM9ofzR9WHvJdE,1808
 letta/server/rest_api/routers/v1/messages.py,sha256=MgfHaTuPGyO1RjtjDuu4fC5dkmXEannUc9XGEK_aFLg,8559
 letta/server/rest_api/routers/v1/organizations.py,sha256=Un7qRo-69m9bC_TYyMnIRNLXf3fHHbNh1aVghnzzips,2932
-letta/server/rest_api/routers/v1/providers.py,sha256=_gKcCbEN2tW7c0BO7_cMFEYdhhsxDlKaopqXlZXMU1s,5996
-letta/server/rest_api/routers/v1/runs.py,sha256=qdCnp90Mdycu_itmPk78U_gYVbboBcadsCCAAdl4Oe8,14957
+letta/server/rest_api/routers/v1/providers.py,sha256=EbUub6JlnGyYvykSqoFQaTWLTcr132VD5Edmh_Vxb1Y,7509
+letta/server/rest_api/routers/v1/runs.py,sha256=f5snwQHkmmWVNuB4nYRL9SE22DWASZu5GuVtHdRwRzs,14951
 letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=1x1QOOv-7jB9qf_AiYXH7ITyYMYicAgA4a5Qc8OHwB0,8702
 letta/server/rest_api/routers/v1/sources.py,sha256=8fkCbprC4PZlcf5HnBYj2-8PjWFIkL0TWZBlp95N7nE,22319
 letta/server/rest_api/routers/v1/steps.py,sha256=OIExfKSwilCmtrVHhF80h8g3yqhf5ww533FIw7N8noI,8251
@@ -476,8 +476,8 @@ letta/templates/sandbox_code_file.py.j2,sha256=eXga5J_04Z8-pGdwfOCDjcRnMceIqcF5i
 letta/templates/sandbox_code_file_async.py.j2,sha256=lb7nh_P2W9VZHzU_9TxSCEMUod7SDziPXgvT75xVds0,2748
 letta/templates/summary_request_text.j2,sha256=ZttQwXonW2lk4pJLYzLK0pmo4EO4EtUUIXjgXKiizuc,842
 letta/types/__init__.py,sha256=hokKjCVFGEfR7SLMrtZsRsBfsC7yTIbgKPLdGg4K1eY,147
-letta_nightly-0.12.0.dev20251009104148.dist-info/METADATA,sha256=-xts5F15qFLK5pjWrucujMu7g3rWG_qDh3uG9DQuzjE,24468
-letta_nightly-0.12.0.dev20251009104148.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-letta_nightly-0.12.0.dev20251009104148.dist-info/entry_points.txt,sha256=m-94Paj-kxiR6Ktu0us0_2qfhn29DzF2oVzqBE6cu8w,41
-letta_nightly-0.12.0.dev20251009104148.dist-info/licenses/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.12.0.dev20251009104148.dist-info/RECORD,,
+letta_nightly-0.12.0.dev20251009203644.dist-info/METADATA,sha256=P1HTklX5YTlDe3BCg-vOF-NsHMseJx7r19qrHXzPft4,24468
+letta_nightly-0.12.0.dev20251009203644.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+letta_nightly-0.12.0.dev20251009203644.dist-info/entry_points.txt,sha256=m-94Paj-kxiR6Ktu0us0_2qfhn29DzF2oVzqBE6cu8w,41
+letta_nightly-0.12.0.dev20251009203644.dist-info/licenses/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.12.0.dev20251009203644.dist-info/RECORD,,