letta-nightly 0.8.0.dev20250606195656__py3-none-any.whl → 0.8.3.dev20250607000559__py3-none-any.whl

letta/helpers/decorators.py

@@ -0,0 +1,69 @@
+import inspect
+from functools import wraps
+from typing import Callable
+
+from letta.log import get_logger
+from letta.plugins.plugins import get_experimental_checker
+from letta.settings import settings
+
+logger = get_logger(__name__)
+
+
+def experimental(feature_name: str, fallback_function: Callable, **kwargs):
+    """Decorator that runs a fallback function if experimental feature is not enabled.
+
+    - kwargs from the decorator will be combined with function kwargs and overwritten only for experimental evaluation.
+    - if the decorated function, fallback_function, or experimental checker function is async, the whole call will be async
+    """
+
+    def decorator(f):
+        experimental_checker = get_experimental_checker()
+        is_f_async = inspect.iscoroutinefunction(f)
+        is_fallback_async = inspect.iscoroutinefunction(fallback_function)
+        is_experimental_checker_async = inspect.iscoroutinefunction(experimental_checker)
+
+        async def call_function(func, is_async, *args, **_kwargs):
+            if is_async:
+                return await func(*args, **_kwargs)
+            return func(*args, **_kwargs)
+
+        # asynchronous wrapper if any function is async
+        if any((is_f_async, is_fallback_async, is_experimental_checker_async)):
+
+            @wraps(f)
+            async def async_wrapper(*args, **_kwargs):
+                result = await call_function(experimental_checker, is_experimental_checker_async, feature_name, **dict(_kwargs, **kwargs))
+                if result:
+                    return await call_function(f, is_f_async, *args, **_kwargs)
+                else:
+                    return await call_function(fallback_function, is_fallback_async, *args, **_kwargs)
+
+            return async_wrapper
+
+        else:
+
+            @wraps(f)
+            def wrapper(*args, **_kwargs):
+                if experimental_checker(feature_name, **dict(_kwargs, **kwargs)):
+                    return f(*args, **_kwargs)
+                else:
+                    return fallback_function(*args, **kwargs)
+
+            return wrapper
+
+    return decorator
+
+
+def deprecated(message: str):
+    """Simple decorator that marks a method as deprecated."""
+
+    def decorator(f):
+        @wraps(f)
+        def wrapper(*args, **kwargs):
+            if settings.debug:
+                logger.warning(f"Function {f.__name__} is deprecated: {message}.")
+            return f(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

letta/{services/helpers/noop_helper.py → helpers/singleton.py}

@@ -1,7 +1,12 @@
+# TODO (cliandy): consolidate with decorators later
+from functools import wraps
+
+
 def singleton(cls):
     """Decorator to make a class a Singleton class."""
     instances = {}
 
+    @wraps(cls)
     def get_instance(*args, **kwargs):
         if cls not in instances:
             instances[cls] = cls(*args, **kwargs)

letta/interfaces/anthropic_streaming_interface.py

@@ -23,7 +23,7 @@ from anthropic.types.beta import (
 )
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
-from letta.helpers.datetime_helpers import get_utc_timestamp_ns
+from letta.helpers.datetime_helpers import get_utc_timestamp_ns, ns_to_ms
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.log import get_logger
 from letta.schemas.letta_message import (
@@ -62,8 +62,7 @@ class AnthropicStreamingInterface:
         self.use_assistant_message = use_assistant_message
 
         # Premake IDs for database writes
-        self.letta_assistant_message_id = Message.generate_id()
-        self.letta_tool_message_id = Message.generate_id()
+        self.letta_message_id = Message.generate_id()
 
         self.anthropic_mode = None
         self.message_id = None
@@ -132,7 +131,7 @@ class AnthropicStreamingInterface:
                         now = get_utc_timestamp_ns()
                         ttft_ns = now - provider_request_start_timestamp_ns
                         ttft_span.add_event(
-                            name="anthropic_time_to_first_token_ms", attributes={"anthropic_time_to_first_token_ms": ttft_ns // 1_000_000}
+                            name="anthropic_time_to_first_token_ms", attributes={"anthropic_time_to_first_token_ms": ns_to_ms(ttft_ns)}
                         )
                         first_chunk = False
 
@@ -152,7 +151,7 @@ class AnthropicStreamingInterface:
                             if not self.use_assistant_message:
                                 # Buffer the initial tool call message instead of yielding immediately
                                 tool_call_msg = ToolCallMessage(
-                                    id=self.letta_tool_message_id,
+                                    id=self.letta_message_id,
                                     tool_call=ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id),
                                     date=datetime.now(timezone.utc).isoformat(),
                                 )
@@ -165,11 +164,11 @@ class AnthropicStreamingInterface:
                             if prev_message_type and prev_message_type != "hidden_reasoning_message":
                                 message_index += 1
                             hidden_reasoning_message = HiddenReasoningMessage(
-                                id=self.letta_assistant_message_id,
+                                id=self.letta_message_id,
                                 state="redacted",
                                 hidden_reasoning=content.data,
                                 date=datetime.now(timezone.utc).isoformat(),
-                                otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
+                                otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                             )
                             self.reasoning_messages.append(hidden_reasoning_message)
                             prev_message_type = hidden_reasoning_message.message_type
@@ -206,10 +205,10 @@ class AnthropicStreamingInterface:
                             if prev_message_type and prev_message_type != "reasoning_message":
                                 message_index += 1
                             reasoning_message = ReasoningMessage(
-                                id=self.letta_assistant_message_id,
+                                id=self.letta_message_id,
                                 reasoning=self.accumulated_inner_thoughts[-1],
                                 date=datetime.now(timezone.utc).isoformat(),
-                                otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
+                                otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                             )
                             self.reasoning_messages.append(reasoning_message)
                             prev_message_type = reasoning_message.message_type
@@ -233,10 +232,10 @@ class AnthropicStreamingInterface:
                                 if prev_message_type and prev_message_type != "reasoning_message":
                                     message_index += 1
                                 reasoning_message = ReasoningMessage(
-                                    id=self.letta_assistant_message_id,
+                                    id=self.letta_message_id,
                                     reasoning=inner_thoughts_diff,
                                     date=datetime.now(timezone.utc).isoformat(),
-                                    otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
+                                    otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                                 )
                                 self.reasoning_messages.append(reasoning_message)
                                 prev_message_type = reasoning_message.message_type
@@ -249,10 +248,28 @@ class AnthropicStreamingInterface:
                                 if len(self.tool_call_buffer) > 0:
                                     if prev_message_type and prev_message_type != "tool_call_message":
                                         message_index += 1
+
+                                    # Strip out the inner thoughts from the buffered tool call arguments before streaming
+                                    tool_call_args = ""
                                     for buffered_msg in self.tool_call_buffer:
-                                        buffered_msg.otid = Message.generate_otid_from_id(self.letta_tool_message_id, message_index)
-                                        prev_message_type = buffered_msg.message_type
-                                        yield buffered_msg
+                                        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_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,
+                                        name=self.tool_call_buffer[0].name,
+                                        sender_id=self.tool_call_buffer[0].sender_id,
+                                        step_id=self.tool_call_buffer[0].step_id,
+                                        tool_call=ToolCallDelta(
+                                            name=self.tool_call_name,
+                                            tool_call_id=self.tool_call_id,
+                                            arguments=tool_call_args,
+                                        ),
+                                    )
+                                    prev_message_type = tool_call_msg.message_type
+                                    yield tool_call_msg
                                     self.tool_call_buffer = []
 
                             # Start detecting special case of "send_message"
@@ -266,24 +283,26 @@ class AnthropicStreamingInterface:
                                     if prev_message_type and prev_message_type != "assistant_message":
                                         message_index += 1
                                     assistant_msg = AssistantMessage(
-                                        id=self.letta_assistant_message_id,
+                                        id=self.letta_message_id,
                                         content=[TextContent(text=send_message_diff)],
                                         date=datetime.now(timezone.utc).isoformat(),
-                                        otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
+                                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                                     )
                                     prev_message_type = assistant_msg.message_type
                                     yield assistant_msg
                             else:
                                 # Otherwise, it is a normal tool call - buffer or yield based on inner thoughts status
                                 tool_call_msg = ToolCallMessage(
-                                    id=self.letta_tool_message_id,
-                                    tool_call=ToolCallDelta(arguments=delta.partial_json),
+                                    id=self.letta_message_id,
+                                    tool_call=ToolCallDelta(
+                                        name=self.tool_call_name, tool_call_id=self.tool_call_id, arguments=delta.partial_json
+                                    ),
                                     date=datetime.now(timezone.utc).isoformat(),
                                 )
                                 if self.inner_thoughts_complete:
                                     if prev_message_type and prev_message_type != "tool_call_message":
                                         message_index += 1
-                                    tool_call_msg.otid = Message.generate_otid_from_id(self.letta_tool_message_id, message_index)
+                                    tool_call_msg.otid = Message.generate_otid_from_id(self.letta_message_id, message_index)
                                     prev_message_type = tool_call_msg.message_type
                                     yield tool_call_msg
                                 else:
@@ -301,11 +320,11 @@ class AnthropicStreamingInterface:
                             if prev_message_type and prev_message_type != "reasoning_message":
                                 message_index += 1
                             reasoning_message = ReasoningMessage(
-                                id=self.letta_assistant_message_id,
+                                id=self.letta_message_id,
                                 source="reasoner_model",
                                 reasoning=delta.thinking,
                                 date=datetime.now(timezone.utc).isoformat(),
-                                otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
+                                otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                             )
                             self.reasoning_messages.append(reasoning_message)
                             prev_message_type = reasoning_message.message_type
@@ -320,12 +339,12 @@ class AnthropicStreamingInterface:
                             if prev_message_type and prev_message_type != "reasoning_message":
                                 message_index += 1
                             reasoning_message = ReasoningMessage(
-                                id=self.letta_assistant_message_id,
+                                id=self.letta_message_id,
                                 source="reasoner_model",
                                 reasoning="",
                                 date=datetime.now(timezone.utc).isoformat(),
                                 signature=delta.signature,
-                                otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
+                                otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                             )
                             self.reasoning_messages.append(reasoning_message)
                             prev_message_type = reasoning_message.message_type
@@ -360,7 +379,7 @@ class AnthropicStreamingInterface:
             group: List[Union[ReasoningMessage, HiddenReasoningMessage]], group_type: str
         ) -> Union[TextContent, ReasoningContent, RedactedReasoningContent]:
             if group_type == "reasoning":
-                reasoning_text = "".join(chunk.reasoning for chunk in group)
+                reasoning_text = "".join(chunk.reasoning for chunk in group).strip()
                 is_native = any(chunk.source == "reasoner_model" for chunk in group)
                 signature = next((chunk.signature for chunk in group if chunk.signature is not None), None)
                 if is_native:

letta/interfaces/openai_streaming_interface.py

@@ -5,7 +5,7 @@ from openai import AsyncStream
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
-from letta.helpers.datetime_helpers import get_utc_timestamp_ns
+from letta.helpers.datetime_helpers import get_utc_timestamp_ns, ns_to_ms
 from letta.schemas.letta_message import AssistantMessage, LettaMessage, ReasoningMessage, ToolCallDelta, ToolCallMessage
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.message import Message
@@ -32,14 +32,14 @@ class OpenAIStreamingInterface:
         self.function_args_buffer = None
         self.function_id_buffer = None
         self.last_flushed_function_name = None
+        self.last_flushed_function_id = None
 
         # Buffer to hold function arguments until inner thoughts are complete
         self.current_function_arguments = ""
         self.current_json_parse_result = {}
 
         # Premake IDs for database writes
-        self.letta_assistant_message_id = Message.generate_id()
-        self.letta_tool_message_id = Message.generate_id()
+        self.letta_message_id = Message.generate_id()
 
         self.message_id = None
         self.model = None
@@ -54,14 +54,14 @@ class OpenAIStreamingInterface:
         self.reasoning_messages = []
 
     def get_reasoning_content(self) -> List[TextContent]:
-        content = "".join(self.reasoning_messages)
+        content = "".join(self.reasoning_messages).strip()
         return [TextContent(text=content)]
 
     def get_tool_call_object(self) -> ToolCall:
         """Useful for agent loop"""
         function_name = self.last_flushed_function_name if self.last_flushed_function_name else self.function_name_buffer
         return ToolCall(
-            id=self.letta_tool_message_id,
+            id=self.last_flushed_function_id,
             function=FunctionCall(arguments=self.current_function_arguments, name=function_name),
         )
 
@@ -85,7 +85,7 @@ class OpenAIStreamingInterface:
                     now = get_utc_timestamp_ns()
                     ttft_ns = now - provider_request_start_timestamp_ns
                     ttft_span.add_event(
-                        name="openai_time_to_first_token_ms", attributes={"openai_time_to_first_token_ms": ttft_ns // 1_000_000}
+                        name="openai_time_to_first_token_ms", attributes={"openai_time_to_first_token_ms": ns_to_ms(ttft_ns)}
                     )
                     first_chunk = False
 
@@ -133,11 +133,11 @@ class OpenAIStreamingInterface:
                                     message_index += 1
                                 self.reasoning_messages.append(updates_inner_thoughts)
                                 reasoning_message = ReasoningMessage(
-                                    id=self.letta_tool_message_id,
+                                    id=self.letta_message_id,
                                     date=datetime.now(timezone.utc),
                                     reasoning=updates_inner_thoughts,
                                     # name=name,
-                                    otid=Message.generate_otid_from_id(self.letta_tool_message_id, message_index),
+                                    otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                                 )
                                 prev_message_type = reasoning_message.message_type
                                 yield reasoning_message
@@ -171,20 +171,22 @@ class OpenAIStreamingInterface:
                                             message_index += 1
                                         self.tool_call_name = str(self.function_name_buffer)
                                         tool_call_msg = ToolCallMessage(
-                                            id=self.letta_tool_message_id,
+                                            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,
                                             ),
-                                            otid=Message.generate_otid_from_id(self.letta_tool_message_id, message_index),
+                                            otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                                         )
                                         prev_message_type = tool_call_msg.message_type
                                         yield tool_call_msg
 
                                     # Record what the last function name we flushed was
                                     self.last_flushed_function_name = self.function_name_buffer
+                                    if self.last_flushed_function_id is None:
+                                        self.last_flushed_function_id = self.function_id_buffer
                                     # Clear the buffer
                                     self.function_name_buffer = None
                                     self.function_id_buffer = None
@@ -236,10 +238,10 @@ class OpenAIStreamingInterface:
                                             if prev_message_type and prev_message_type != "assistant_message":
                                                 message_index += 1
                                             assistant_message = AssistantMessage(
-                                                id=self.letta_assistant_message_id,
+                                                id=self.letta_message_id,
                                                 date=datetime.now(timezone.utc),
                                                 content=combined_chunk,
-                                                otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
+                                                otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                                             )
                                             prev_message_type = assistant_message.message_type
                                             yield assistant_message
@@ -268,11 +270,11 @@ class OpenAIStreamingInterface:
                                                 if prev_message_type and prev_message_type != "assistant_message":
                                                     message_index += 1
                                                 assistant_message = AssistantMessage(
-                                                    id=self.letta_assistant_message_id,
+                                                    id=self.letta_message_id,
                                                     date=datetime.now(timezone.utc),
                                                     content=diff,
                                                     # name=name,
-                                                    otid=Message.generate_otid_from_id(self.letta_assistant_message_id, message_index),
+                                                    otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                                                 )
                                                 prev_message_type = assistant_message.message_type
                                                 yield assistant_message
@@ -292,15 +294,15 @@ class OpenAIStreamingInterface:
                                             if prev_message_type and prev_message_type != "tool_call_message":
                                                 message_index += 1
                                             tool_call_msg = ToolCallMessage(
-                                                id=self.letta_tool_message_id,
+                                                id=self.letta_message_id,
                                                 date=datetime.now(timezone.utc),
                                                 tool_call=ToolCallDelta(
-                                                    name=None,
+                                                    name=self.function_name_buffer,
                                                     arguments=combined_chunk,
                                                     tool_call_id=self.function_id_buffer,
                                                 ),
                                                 # name=name,
-                                                otid=Message.generate_otid_from_id(self.letta_tool_message_id, message_index),
+                                                otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                                             )
                                             prev_message_type = tool_call_msg.message_type
                                             yield tool_call_msg
@@ -312,7 +314,7 @@ class OpenAIStreamingInterface:
                                             if prev_message_type and prev_message_type != "tool_call_message":
                                                 message_index += 1
                                             tool_call_msg = ToolCallMessage(
-                                                id=self.letta_tool_message_id,
+                                                id=self.letta_message_id,
                                                 date=datetime.now(timezone.utc),
                                                 tool_call=ToolCallDelta(
                                                     name=None,
@@ -320,7 +322,7 @@ class OpenAIStreamingInterface:
                                                     tool_call_id=self.function_id_buffer,
                                                 ),
                                                 # name=name,
-                                                otid=Message.generate_otid_from_id(self.letta_tool_message_id, message_index),
+                                                otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                                             )
                                             prev_message_type = tool_call_msg.message_type
                                             yield tool_call_msg

letta/llm_api/anthropic.py

@@ -26,6 +26,7 @@ from letta.llm_api.helpers import add_inner_thoughts_to_functions
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION
 from letta.local_llm.utils import num_tokens_from_functions, num_tokens_from_messages
 from letta.log import get_logger
+from letta.otel.tracing import log_event
 from letta.schemas.enums import ProviderCategory
 from letta.schemas.message import Message as _Message
 from letta.schemas.message import MessageRole as _MessageRole
@@ -45,7 +46,6 @@ from letta.services.provider_manager import ProviderManager
 from letta.services.user_manager import UserManager
 from letta.settings import model_settings
 from letta.streaming_interface import AgentChunkStreamingInterface, AgentRefreshStreamingInterface
-from letta.tracing import log_event
 
 logger = get_logger(__name__)
 

letta/llm_api/anthropic_client.py

@@ -27,16 +27,16 @@ from letta.llm_api.helpers import add_inner_thoughts_to_functions, unpack_all_in
 from letta.llm_api.llm_client_base import LLMClientBase
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION
 from letta.log import get_logger
+from letta.otel.tracing import trace_method
 from letta.schemas.enums import ProviderCategory
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message as PydanticMessage
-from letta.schemas.openai.chat_completion_request import Tool
+from letta.schemas.openai.chat_completion_request import Tool as OpenAITool
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice, FunctionCall
 from letta.schemas.openai.chat_completion_response import Message as ChoiceMessage
 from letta.schemas.openai.chat_completion_response import ToolCall, UsageStatistics
 from letta.services.provider_manager import ProviderManager
 from letta.settings import model_settings
-from letta.tracing import trace_method
 
 DUMMY_FIRST_USER_MESSAGE = "User initializing bootup sequence."
 
@@ -199,10 +199,10 @@ class AnthropicClient(LLMClientBase):
         elif llm_config.enable_reasoner:
             # NOTE: reasoning models currently do not allow for `any`
             tool_choice = {"type": "auto", "disable_parallel_tool_use": True}
-            tools_for_request = [Tool(function=f) for f in tools]
+            tools_for_request = [OpenAITool(function=f) for f in tools]
         elif force_tool_call is not None:
             tool_choice = {"type": "tool", "name": force_tool_call}
-            tools_for_request = [Tool(function=f) for f in tools if f["name"] == force_tool_call]
+            tools_for_request = [OpenAITool(function=f) for f in tools if f["name"] == force_tool_call]
 
             # need to have this setting to be able to put inner thoughts in kwargs
             if not llm_config.put_inner_thoughts_in_kwargs:
@@ -216,7 +216,7 @@ class AnthropicClient(LLMClientBase):
                 tool_choice = {"type": "any", "disable_parallel_tool_use": True}
             else:
                 tool_choice = {"type": "auto", "disable_parallel_tool_use": True}
-            tools_for_request = [Tool(function=f) for f in tools] if tools is not None else None
+            tools_for_request = [OpenAITool(function=f) for f in tools] if tools is not None else None
 
         # Add tool choice
         if tool_choice:
@@ -230,7 +230,7 @@ class AnthropicClient(LLMClientBase):
                 inner_thoughts_key=INNER_THOUGHTS_KWARG,
                 inner_thoughts_description=INNER_THOUGHTS_KWARG_DESCRIPTION,
             )
-            tools_for_request = [Tool(function=f) for f in tools_with_inner_thoughts]
+            tools_for_request = [OpenAITool(function=f) for f in tools_with_inner_thoughts]
 
         if tools_for_request and len(tools_for_request) > 0:
             # TODO eventually enable parallel tool use
@@ -270,7 +270,7 @@ class AnthropicClient(LLMClientBase):
 
         return data
 
-    async def count_tokens(self, messages: List[dict] = None, model: str = None, tools: List[Tool] = None) -> int:
+    async def count_tokens(self, messages: List[dict] = None, model: str = None, tools: List[OpenAITool] = None) -> int:
         client = anthropic.AsyncAnthropic()
         if messages and len(messages) == 0:
             messages = None
@@ -278,11 +278,19 @@ class AnthropicClient(LLMClientBase):
             anthropic_tools = convert_tools_to_anthropic_format(tools)
         else:
             anthropic_tools = None
-        result = await client.beta.messages.count_tokens(
-            model=model or "claude-3-7-sonnet-20250219",
-            messages=messages or [{"role": "user", "content": "hi"}],
-            tools=anthropic_tools or [],
-        )
+
+        try:
+            result = await client.beta.messages.count_tokens(
+                model=model or "claude-3-7-sonnet-20250219",
+                messages=messages or [{"role": "user", "content": "hi"}],
+                tools=anthropic_tools or [],
+            )
+        except:
+            import ipdb
+
+            ipdb.set_trace()
+            raise
+
         token_count = result.input_tokens
         if messages is None:
             token_count -= 8
@@ -419,10 +427,16 @@ class AnthropicClient(LLMClientBase):
                 if content_part.type == "text":
                     content = strip_xml_tags(string=content_part.text, tag="thinking")
                 if content_part.type == "tool_use":
-                    # hack for tool rules
+                    # hack for incorrect tool format
                     tool_input = json.loads(json.dumps(content_part.input))
                     if "id" in tool_input and tool_input["id"].startswith("toolu_") and "function" in tool_input:
-                        arguments = str(tool_input["function"]["arguments"])
+                        arguments = json.dumps(tool_input["function"]["arguments"], indent=2)
+                        try:
+                            args_json = json.loads(arguments)
+                            if not isinstance(args_json, dict):
+                                raise ValueError("Expected parseable json object for arguments")
+                        except:
+                            arguments = str(tool_input["function"]["arguments"])
                     else:
                         arguments = json.dumps(tool_input, indent=2)
                     tool_calls = [
@@ -477,7 +491,7 @@ class AnthropicClient(LLMClientBase):
         return chat_completion_response
 
 
-def convert_tools_to_anthropic_format(tools: List[Tool]) -> List[dict]:
+def convert_tools_to_anthropic_format(tools: List[OpenAITool]) -> List[dict]:
     """See: https://docs.anthropic.com/claude/docs/tool-use
 
     OpenAI style:
@@ -527,7 +541,7 @@ def convert_tools_to_anthropic_format(tools: List[Tool]) -> List[dict]:
     for tool in tools:
         formatted_tool = {
             "name": tool.function.name,
-            "description": tool.function.description,
+            "description": tool.function.description if tool.function.description else "",
             "input_schema": tool.function.parameters or {"type": "object", "properties": {}, "required": []},
         }
         formatted_tools.append(formatted_tool)

letta/llm_api/google_vertex_client.py

@@ -12,12 +12,12 @@ from letta.llm_api.llm_client_base import LLMClientBase
 from letta.local_llm.json_parser import clean_json_string_extra_backslash
 from letta.local_llm.utils import count_tokens
 from letta.log import get_logger
+from letta.otel.tracing import trace_method
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.openai.chat_completion_request import Tool
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice, FunctionCall, Message, ToolCall, UsageStatistics
 from letta.settings import model_settings, settings
-from letta.tracing import trace_method
 from letta.utils import get_tool_call_id
 
 logger = get_logger(__name__)