letta-nightly 0.6.27.dev20250219104103__py3-none-any.whl → 0.6.28.dev20250220163833__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.27"
+__version__ = "0.6.28"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

letta/agent.py

@@ -60,6 +60,7 @@ from letta.services.tool_manager import ToolManager
 from letta.settings import summarizer_settings
 from letta.streaming_interface import StreamingRefreshCLIInterface
 from letta.system import get_heartbeat, get_token_limit_warning, package_function_response, package_summarize_message, package_user_message
+from letta.tracing import trace_method
 from letta.utils import (
     count_tokens,
     get_friendly_error_msg,
@@ -309,6 +310,7 @@ class Agent(BaseAgent):
         # Return updated messages
         return messages
 
+    @trace_method("Get AI Reply")
     def _get_ai_reply(
         self,
         message_sequence: List[Message],
@@ -399,6 +401,7 @@ class Agent(BaseAgent):
         log_telemetry(self.logger, "_handle_ai_response finish catch-all exception")
         raise Exception("Retries exhausted and no valid response received.")
 
+    @trace_method("Handle AI Response")
     def _handle_ai_response(
         self,
         response_message: ChatCompletionMessage,  # TODO should we eventually move the Message creation outside of this function?
@@ -492,7 +495,10 @@ class Agent(BaseAgent):
             try:
                 raw_function_args = function_call.arguments
                 function_args = parse_json(raw_function_args)
-            except Exception:
+                if not isinstance(function_args, dict):
+                    raise ValueError(f"Function arguments are not a dictionary: {function_args} (raw={raw_function_args})")
+            except Exception as e:
+                print(e)
                 error_msg = f"Error parsing JSON for function '{function_name}' arguments: {function_call.arguments}"
                 function_response = "None"  # more like "never ran?"
                 messages = self._handle_function_error_response(
@@ -627,9 +633,15 @@ class Agent(BaseAgent):
         elif self.tool_rules_solver.is_terminal_tool(function_name):
             heartbeat_request = False
 
+        # if continue tool rule, then  must request a heartbeat
+        # TODO: dont even include heartbeats in the args
+        if self.tool_rules_solver.is_continue_tool(function_name):
+            heartbeat_request = True
+
         log_telemetry(self.logger, "_handle_ai_response finish")
         return messages, heartbeat_request, function_failed
 
+    @trace_method("Agent Step")
     def step(
         self,
         messages: Union[Message, List[Message]],

letta/client/client.py

@@ -2351,6 +2351,7 @@ class LocalClient(AbstractClient):
         tool_rules: Optional[List[BaseToolRule]] = None,
         include_base_tools: Optional[bool] = True,
         include_multi_agent_tools: bool = False,
+        include_base_tool_rules: bool = True,
         # metadata
         metadata: Optional[Dict] = {"human:": DEFAULT_HUMAN, "persona": DEFAULT_PERSONA},
         description: Optional[str] = None,
@@ -2402,6 +2403,7 @@ class LocalClient(AbstractClient):
             "tool_rules": tool_rules,
             "include_base_tools": include_base_tools,
             "include_multi_agent_tools": include_multi_agent_tools,
+            "include_base_tool_rules": include_base_tool_rules,
             "system": system,
             "agent_type": agent_type,
             "llm_config": llm_config if llm_config else self._default_llm_config,

letta/constants.py

@@ -86,6 +86,8 @@ NON_USER_MSG_PREFIX = "[This is an automated system message hidden from the user
 # The max amount of tokens supported by the underlying model (eg 8k for gpt-4 and Mistral 7B)
 LLM_MAX_TOKENS = {
     "DEFAULT": 8192,
+    "deepseek-chat": 64000,
+    "deepseek-reasoner": 64000,
     ## OpenAI models: https://platform.openai.com/docs/models/overview
     # "o1-preview
     "chatgpt-4o-latest": 128000,

letta/functions/schema_generator.py

@@ -394,12 +394,12 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[
     # append the heartbeat
     # TODO: don't hard-code
     # TODO: if terminal, don't include this
-    if function.__name__ not in ["send_message"]:
-        schema["parameters"]["properties"]["request_heartbeat"] = {
-            "type": "boolean",
-            "description": "Request an immediate heartbeat after function execution. Set to `True` if you want to send a follow-up message or run a follow-up function.",
-        }
-        schema["parameters"]["required"].append("request_heartbeat")
+    # if function.__name__ not in ["send_message"]:
+    schema["parameters"]["properties"]["request_heartbeat"] = {
+        "type": "boolean",
+        "description": "Request an immediate heartbeat after function execution. Set to `True` if you want to send a follow-up message or run a follow-up function.",
+    }
+    schema["parameters"]["required"].append("request_heartbeat")
 
     return schema
 

letta/helpers/converters.py

@@ -0,0 +1,153 @@
+import base64
+from typing import Any, Dict, List, Optional, Union
+
+import numpy as np
+from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall
+from openai.types.chat.chat_completion_message_tool_call import Function as OpenAIFunction
+from sqlalchemy import Dialect
+
+from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.enums import ToolRuleType
+from letta.schemas.llm_config import LLMConfig
+from letta.schemas.tool_rule import ChildToolRule, ConditionalToolRule, ContinueToolRule, InitToolRule, TerminalToolRule, ToolRule
+
+# --------------------------
+# LLMConfig Serialization
+# --------------------------
+
+
+def serialize_llm_config(config: Union[Optional[LLMConfig], Dict]) -> Optional[Dict]:
+    """Convert an LLMConfig object into a JSON-serializable dictionary."""
+    if config and isinstance(config, LLMConfig):
+        return config.model_dump()
+    return config
+
+
+def deserialize_llm_config(data: Optional[Dict]) -> Optional[LLMConfig]:
+    """Convert a dictionary back into an LLMConfig object."""
+    return LLMConfig(**data) if data else None
+
+
+# --------------------------
+# EmbeddingConfig Serialization
+# --------------------------
+
+
+def serialize_embedding_config(config: Union[Optional[EmbeddingConfig], Dict]) -> Optional[Dict]:
+    """Convert an EmbeddingConfig object into a JSON-serializable dictionary."""
+    if config and isinstance(config, EmbeddingConfig):
+        return config.model_dump()
+    return config
+
+
+def deserialize_embedding_config(data: Optional[Dict]) -> Optional[EmbeddingConfig]:
+    """Convert a dictionary back into an EmbeddingConfig object."""
+    return EmbeddingConfig(**data) if data else None
+
+
+# --------------------------
+# ToolRule Serialization
+# --------------------------
+
+
+def serialize_tool_rules(tool_rules: Optional[List[ToolRule]]) -> List[Dict[str, Any]]:
+    """Convert a list of ToolRules into a JSON-serializable format."""
+
+    if not tool_rules:
+        return []
+
+    data = [{**rule.model_dump(), "type": rule.type.value} for rule in tool_rules]  # Convert Enum to string for JSON compatibility
+
+    # Validate ToolRule structure
+    for rule_data in data:
+        if rule_data["type"] == ToolRuleType.constrain_child_tools.value and "children" not in rule_data:
+            raise ValueError(f"Invalid ToolRule serialization: 'children' field missing for rule {rule_data}")
+
+    return data
+
+
+def deserialize_tool_rules(data: Optional[List[Dict]]) -> List[Union[ChildToolRule, InitToolRule, TerminalToolRule, ConditionalToolRule]]:
+    """Convert a list of dictionaries back into ToolRule objects."""
+    if not data:
+        return []
+
+    return [deserialize_tool_rule(rule_data) for rule_data in data]
+
+
+def deserialize_tool_rule(data: Dict) -> Union[ChildToolRule, InitToolRule, TerminalToolRule, ConditionalToolRule, ContinueToolRule]:
+    """Deserialize a dictionary to the appropriate ToolRule subclass based on 'type'."""
+    rule_type = ToolRuleType(data.get("type"))
+
+    if rule_type == ToolRuleType.run_first:
+        return InitToolRule(**data)
+    elif rule_type == ToolRuleType.exit_loop:
+        return TerminalToolRule(**data)
+    elif rule_type == ToolRuleType.constrain_child_tools:
+        return ChildToolRule(**data)
+    elif rule_type == ToolRuleType.conditional:
+        return ConditionalToolRule(**data)
+    elif rule_type == ToolRuleType.continue_loop:
+        return ContinueToolRule(**data)
+    raise ValueError(f"Unknown ToolRule type: {rule_type}")
+
+
+# --------------------------
+# ToolCall Serialization
+# --------------------------
+
+
+def serialize_tool_calls(tool_calls: Optional[List[Union[OpenAIToolCall, dict]]]) -> List[Dict]:
+    """Convert a list of OpenAI ToolCall objects into JSON-serializable format."""
+    if not tool_calls:
+        return []
+
+    serialized_calls = []
+    for call in tool_calls:
+        if isinstance(call, OpenAIToolCall):
+            serialized_calls.append(call.model_dump())
+        elif isinstance(call, dict):
+            serialized_calls.append(call)  # Already a dictionary, leave it as-is
+        else:
+            raise TypeError(f"Unexpected tool call type: {type(call)}")
+
+    return serialized_calls
+
+
+def deserialize_tool_calls(data: Optional[List[Dict]]) -> List[OpenAIToolCall]:
+    """Convert a JSON list back into OpenAIToolCall objects."""
+    if not data:
+        return []
+
+    calls = []
+    for item in data:
+        func_data = item.pop("function", None)
+        tool_call_function = OpenAIFunction(**func_data) if func_data else None
+        calls.append(OpenAIToolCall(function=tool_call_function, **item))
+
+    return calls
+
+
+# --------------------------
+# Vector Serialization
+# --------------------------
+
+
+def serialize_vector(vector: Optional[Union[List[float], np.ndarray]]) -> Optional[bytes]:
+    """Convert a NumPy array or list into a base64-encoded byte string."""
+    if vector is None:
+        return None
+    if isinstance(vector, list):
+        vector = np.array(vector, dtype=np.float32)
+
+    return base64.b64encode(vector.tobytes())
+
+
+def deserialize_vector(data: Optional[bytes], dialect: Dialect) -> Optional[np.ndarray]:
+    """Convert a base64-encoded byte string back into a NumPy array."""
+    if not data:
+        return None
+
+    if dialect.name == "sqlite":
+        data = base64.b64decode(data)
+
+    return np.frombuffer(data, dtype=np.float32)

letta/helpers/tool_rule_solver.py

@@ -4,7 +4,7 @@ from typing import List, Optional, Union
 from pydantic import BaseModel, Field
 
 from letta.schemas.enums import ToolRuleType
-from letta.schemas.tool_rule import BaseToolRule, ChildToolRule, ConditionalToolRule, InitToolRule, TerminalToolRule
+from letta.schemas.tool_rule import BaseToolRule, ChildToolRule, ConditionalToolRule, ContinueToolRule, InitToolRule, TerminalToolRule
 
 
 class ToolRuleValidationError(Exception):
@@ -18,6 +18,9 @@ class ToolRulesSolver(BaseModel):
     init_tool_rules: List[InitToolRule] = Field(
         default_factory=list, description="Initial tool rules to be used at the start of tool execution."
     )
+    continue_tool_rules: List[ContinueToolRule] = Field(
+        default_factory=list, description="Continue tool rules to be used to continue tool execution."
+    )
     tool_rules: List[Union[ChildToolRule, ConditionalToolRule]] = Field(
         default_factory=list, description="Standard tool rules for controlling execution sequence and allowed transitions."
     )
@@ -43,6 +46,9 @@ class ToolRulesSolver(BaseModel):
             elif rule.type == ToolRuleType.exit_loop:
                 assert isinstance(rule, TerminalToolRule)
                 self.terminal_tool_rules.append(rule)
+            elif rule.type == ToolRuleType.continue_loop:
+                assert isinstance(rule, ContinueToolRule)
+                self.continue_tool_rules.append(rule)
 
     def update_tool_usage(self, tool_name: str):
         """Update the internal state to track the last tool called."""
@@ -80,6 +86,10 @@ class ToolRulesSolver(BaseModel):
         """Check if the tool has children tools"""
         return any(rule.tool_name == tool_name for rule in self.tool_rules)
 
+    def is_continue_tool(self, tool_name):
+        """Check if the tool is defined as a continue tool in the tool rules."""
+        return any(rule.tool_name == tool_name for rule in self.continue_tool_rules)
+
     def validate_conditional_tool(self, rule: ConditionalToolRule):
         """
         Validate a conditional tool rule

letta/llm_api/anthropic.py

@@ -519,6 +519,7 @@ def _prepare_anthropic_request(
     prefix_fill: bool = True,
     # if true, put COT inside the tool calls instead of inside the content
     put_inner_thoughts_in_kwargs: bool = False,
+    bedrock: bool = False,
 ) -> dict:
     """Prepare the request data for Anthropic API format."""
 
@@ -606,10 +607,11 @@ def _prepare_anthropic_request(
     # NOTE: cannot prefill with tools for opus:
     # Your API request included an `assistant` message in the final position, which would pre-fill the `assistant` response. When using tools with "claude-3-opus-20240229"
     if prefix_fill and not put_inner_thoughts_in_kwargs and "opus" not in data["model"]:
-        data["messages"].append(
-            # Start the thinking process for the assistant
-            {"role": "assistant", "content": f"<{inner_thoughts_xml_tag}>"},
-        )
+        if not bedrock:  # not support for bedrock
+            data["messages"].append(
+                # Start the thinking process for the assistant
+                {"role": "assistant", "content": f"<{inner_thoughts_xml_tag}>"},
+            )
 
     # Validate max_tokens
     assert "max_tokens" in data, data
@@ -651,13 +653,16 @@ def anthropic_bedrock_chat_completions_request(
     inner_thoughts_xml_tag: Optional[str] = "thinking",
 ) -> ChatCompletionResponse:
     """Make a chat completion request to Anthropic via AWS Bedrock."""
-    data = _prepare_anthropic_request(data, inner_thoughts_xml_tag)
+    data = _prepare_anthropic_request(data, inner_thoughts_xml_tag, bedrock=True)
 
     # Get the client
     client = get_bedrock_client()
 
     # Make the request
     try:
+        # bedrock does not support certain args
+        data["tool_choice"] = {"type": "any"}
+
         response = client.messages.create(**data)
         return convert_anthropic_response_to_chatcompletion(response=response, inner_thoughts_xml_tag=inner_thoughts_xml_tag)
     except PermissionDeniedError:

letta/llm_api/aws_bedrock.py

@@ -10,7 +10,7 @@ def has_valid_aws_credentials() -> bool:
     """
     Check if AWS credentials are properly configured.
     """
-    valid_aws_credentials = os.getenv("AWS_ACCESS_KEY_ID") and os.getenv("AWS_SECRET_ACCESS_KEY") and os.getenv("AWS_REGION")
+    valid_aws_credentials = os.getenv("AWS_ACCESS_KEY") and os.getenv("AWS_SECRET_ACCESS_KEY") and os.getenv("AWS_REGION")
     return valid_aws_credentials
 
 

letta/llm_api/azure_openai_constants.py

@@ -6,5 +6,6 @@ AZURE_MODEL_TO_CONTEXT_LENGTH = {
     "gpt-35-turbo-0125": 16385,
     "gpt-4-0613": 8192,
     "gpt-4o-mini-2024-07-18": 128000,
+    "gpt-4o-mini": 128000,
     "gpt-4o": 128000,
 }

letta/llm_api/deepseek.py

@@ -0,0 +1,303 @@
+import json
+import re
+import warnings
+from typing import List, Optional
+
+from letta.schemas.llm_config import LLMConfig
+from letta.schemas.message import Message as _Message
+from letta.schemas.openai.chat_completion_request import AssistantMessage, ChatCompletionRequest, ChatMessage
+from letta.schemas.openai.chat_completion_request import FunctionCall as ToolFunctionChoiceFunctionCall
+from letta.schemas.openai.chat_completion_request import Tool, ToolFunctionChoice, ToolMessage, UserMessage, cast_message_to_subtype
+from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
+from letta.schemas.openai.openai import Function, ToolCall
+from letta.utils import get_tool_call_id
+
+
+def merge_tool_message(previous_message: ChatMessage, tool_message: ToolMessage) -> ChatMessage:
+    """
+    Merge `ToolMessage` objects into the previous message.
+    """
+    previous_message.content += (
+        f"<ToolMessage> content: {tool_message.content}, role: {tool_message.role}, tool_call_id: {tool_message.tool_call_id}</ToolMessage>"
+    )
+    return previous_message
+
+
+def handle_assistant_message(assistant_message: AssistantMessage) -> AssistantMessage:
+    """
+    For `AssistantMessage` objects, remove the `tool_calls` field and add them to the `content` field.
+    """
+
+    if "tool_calls" in assistant_message.dict().keys():
+        assistant_message.content = "".join(
+            [
+                # f"<ToolCall> name: {tool_call.function.name}, function: {tool_call.function}</ToolCall>"
+                f"<ToolCall> {json.dumps(tool_call.function.dict())} </ToolCall>"
+                for tool_call in assistant_message.tool_calls
+            ]
+        )
+        del assistant_message.tool_calls
+    return assistant_message
+
+
+def map_messages_to_deepseek_format(messages: List[ChatMessage]) -> List[_Message]:
+    """
+    Deepeek API has the following constraints: messages must be interleaved between user and assistant messages, ending on a user message.
+    Tools are currently unstable for V3 and not supported for R1 in the API: https://api-docs.deepseek.com/guides/function_calling.
+
+    This function merges ToolMessages into AssistantMessages and removes ToolCalls from AssistantMessages, and adds a dummy user message
+    at the end.
+
+    """
+    deepseek_messages = []
+    for idx, message in enumerate(messages):
+        # First message is the system prompt, add it
+        if idx == 0 and message.role == "system":
+            deepseek_messages.append(message)
+            continue
+        if message.role == "user":
+            if deepseek_messages[-1].role == "assistant" or deepseek_messages[-1].role == "system":
+                # User message, add it
+                deepseek_messages.append(UserMessage(content=message.content))
+            else:
+                # add to the content of the previous message
+                deepseek_messages[-1].content += message.content
+        elif message.role == "assistant":
+            if deepseek_messages[-1].role == "user":
+                # Assistant message, remove tool calls and add them to the content
+                deepseek_messages.append(handle_assistant_message(message))
+            else:
+                # add to the content of the previous message
+                deepseek_messages[-1].content += message.content
+        elif message.role == "tool" and deepseek_messages[-1].role == "assistant":
+            # Tool message, add it to the last assistant message
+            merged_message = merge_tool_message(deepseek_messages[-1], message)
+            deepseek_messages[-1] = merged_message
+        else:
+            print(f"Skipping message: {message}")
+
+    # This needs to end on a user message, add a dummy message if the last was assistant
+    if deepseek_messages[-1].role == "assistant":
+        deepseek_messages.append(UserMessage(content=""))
+    return deepseek_messages
+
+
+def build_deepseek_chat_completions_request(
+    llm_config: LLMConfig,
+    messages: List[_Message],
+    user_id: Optional[str],
+    functions: Optional[list],
+    function_call: Optional[str],
+    use_tool_naming: bool,
+    max_tokens: Optional[int],
+) -> ChatCompletionRequest:
+    # if functions and llm_config.put_inner_thoughts_in_kwargs:
+    #     # Special case for LM Studio backend since it needs extra guidance to force out the thoughts first
+    #     # TODO(fix)
+    #     inner_thoughts_desc = (
+    #         INNER_THOUGHTS_KWARG_DESCRIPTION_GO_FIRST if ":1234" in llm_config.model_endpoint else INNER_THOUGHTS_KWARG_DESCRIPTION
+    #     )
+    #     functions = add_inner_thoughts_to_functions(
+    #         functions=functions,
+    #         inner_thoughts_key=INNER_THOUGHTS_KWARG,
+    #         inner_thoughts_description=inner_thoughts_desc,
+    #     )
+
+    openai_message_list = [cast_message_to_subtype(m.to_openai_dict(put_inner_thoughts_in_kwargs=False)) for m in messages]
+
+    if llm_config.model:
+        model = llm_config.model
+    else:
+        warnings.warn(f"Model type not set in llm_config: {llm_config.model_dump_json(indent=4)}")
+        model = None
+    if use_tool_naming:
+        if function_call is None:
+            tool_choice = None
+        elif function_call not in ["none", "auto", "required"]:
+            tool_choice = ToolFunctionChoice(type="function", function=ToolFunctionChoiceFunctionCall(name=function_call))
+        else:
+            tool_choice = function_call
+
+        def add_functions_to_system_message(system_message: ChatMessage):
+            system_message.content += f"<available functions> {''.join(json.dumps(f) for f in functions)} </available functions>"
+            system_message.content += f'Select best function to call simply respond with a single json block with the fields "name" and "arguments". Use double quotes around the arguments.'
+
+        if llm_config.model == "deepseek-reasoner":  # R1 currently doesn't support function calling natively
+            add_functions_to_system_message(
+                openai_message_list[0]
+            )  # Inject additional instructions to the system prompt with the available functions
+
+            openai_message_list = map_messages_to_deepseek_format(openai_message_list)
+
+            data = ChatCompletionRequest(
+                model=model,
+                messages=openai_message_list,
+                user=str(user_id),
+                max_completion_tokens=max_tokens,
+                temperature=llm_config.temperature,
+            )
+        else:
+            data = ChatCompletionRequest(
+                model=model,
+                messages=openai_message_list,
+                tools=[Tool(type="function", function=f) for f in functions] if functions else None,
+                tool_choice=tool_choice,
+                user=str(user_id),
+                max_completion_tokens=max_tokens,
+                temperature=llm_config.temperature,
+            )
+    else:
+        data = ChatCompletionRequest(
+            model=model,
+            messages=openai_message_list,
+            functions=functions,
+            function_call=function_call,
+            user=str(user_id),
+            max_completion_tokens=max_tokens,
+            temperature=llm_config.temperature,
+        )
+
+    return data
+
+
+def convert_deepseek_response_to_chatcompletion(
+    response: ChatCompletionResponse,
+) -> ChatCompletionResponse:
+    """
+        Example response from DeepSeek:
+
+        ChatCompletion(
+        id='bc7f7d25-82e4-443a-b217-dfad2b66da8e',
+        choices=[
+            Choice(
+                finish_reason='stop',
+                index=0,
+                logprobs=None,
+                message=ChatCompletionMessage(
+                    content='{"function": "send_message", "arguments": {"message": "Hey! Whales are such majestic creatures, aren\'t they? How\'s your day going? 🌊 "}}',
+                    refusal=None,
+                    role='assistant',
+                    audio=None,
+                    function_call=None,
+                    tool_calls=None,
+                    reasoning_content='Okay, the user said "hello whales". Hmm, that\'s an interesting greeting. Maybe they meant "hello there" or are they actually talking about whales? Let me check if I misheard. Whales are fascinating creatures. I should respond in a friendly way. Let me ask them how they\'re doing and mention whales to keep the conversation going.'
+                )
+            )
+        ],
+        created=1738266449,
+        model='deepseek-reasoner',
+        object='chat.completion',
+        service_tier=None,
+        system_fingerprint='fp_7e73fd9a08',
+        usage=CompletionUsage(
+            completion_tokens=111,
+            prompt_tokens=1270,
+            total_tokens=1381,
+            completion_tokens_details=CompletionTokensDetails(
+                accepted_prediction_tokens=None,
+                audio_tokens=None,
+                reasoning_tokens=72,
+                rejected_prediction_tokens=None
+            ),
+            prompt_tokens_details=PromptTokensDetails(
+                audio_tokens=None,
+                cached_tokens=1088
+            ),
+            prompt_cache_hit_tokens=1088,
+            prompt_cache_miss_tokens=182
+        )
+    )
+    """
+
+    def convert_dict_quotes(input_dict: dict):
+        """
+        Convert a dictionary with single-quoted keys to double-quoted keys,
+        properly handling boolean values and nested structures.
+
+        Args:
+            input_dict (dict): Input dictionary with single-quoted keys
+
+        Returns:
+            str: JSON string with double-quoted keys
+        """
+        # First convert the dictionary to a JSON string to handle booleans properly
+        json_str = json.dumps(input_dict)
+
+        # Function to handle complex string replacements
+        def replace_quotes(match):
+            key = match.group(1)
+            # Escape any existing double quotes in the key
+            key = key.replace('"', '\\"')
+            return f'"{key}":'
+
+        # Replace single-quoted keys with double-quoted keys
+        # This regex looks for single-quoted keys followed by a colon
+        def strip_json_block(text):
+            # Check if text starts with ```json or similar
+            if text.strip().startswith("```"):
+                # Split by \n to remove the first and last lines
+                lines = text.split("\n")[1:-1]
+                return "\n".join(lines)
+            return text
+
+        pattern = r"'([^']*)':"
+        converted_str = re.sub(pattern, replace_quotes, strip_json_block(json_str))
+
+        # Parse the string back to ensure valid JSON format
+        try:
+            json.loads(converted_str)
+            return converted_str
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Failed to create valid JSON with double quotes: {str(e)}")
+
+    def extract_json_block(text):
+        # Find the first {
+        start = text.find("{")
+        if start == -1:
+            return text
+
+        # Track nested braces to find the matching closing brace
+        brace_count = 0
+        end = start
+
+        for i in range(start, len(text)):
+            if text[i] == "{":
+                brace_count += 1
+            elif text[i] == "}":
+                brace_count -= 1
+                if brace_count == 0:
+                    end = i + 1
+                    break
+
+        return text[start:end]
+
+    content = response.choices[0].message.content
+    try:
+        content_dict = json.loads(extract_json_block(content))
+
+        if type(content_dict["arguments"]) == str:
+            content_dict["arguments"] = json.loads(content_dict["arguments"])
+
+        tool_calls = [
+            ToolCall(
+                id=get_tool_call_id(),
+                type="function",
+                function=Function(
+                    name=content_dict["name"],
+                    arguments=convert_dict_quotes(content_dict["arguments"]),
+                ),
+            )
+        ]
+    except (json.JSONDecodeError, TypeError, KeyError) as e:
+        print(e)
+        tool_calls = response.choices[0].message.tool_calls
+        raise ValueError(f"Failed to create valid JSON {content}")
+
+    # Move the "reasoning_content" into the "content" field
+    response.choices[0].message.content = response.choices[0].message.reasoning_content
+    response.choices[0].message.tool_calls = tool_calls
+
+    # Remove the "reasoning_content" field
+    response.choices[0].message.reasoning_content = None
+
+    return response