DeepSeek Tool Calls with Thinking: reasoning_content Management

User: "What's the weather in Tokyo and should I bring an umbrella?"

Model (turn 1.1):
  reasoning: "I need to get tomorrow's date first, then call get_weather."
  tool_call: get_date()

Tool result: "2026-06-13"

Model (turn 1.2):
  reasoning: "Tomorrow is June 13. Now I'll call get_weather for Tokyo."
  tool_call: get_weather(location="Tokyo", date="2026-06-13")

Tool result: "Rainy, 15°C"

Model (turn 1.3):
  reasoning: "It's rainy and cool. The user should definitely bring an umbrella."
  content: "Yes, bring an umbrella! Tomorrow will be rainy with temperatures around 15°C."

# CORRECT: Always pass the full message object
response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    tools=tools,
    reasoning_effort="high",
    extra_body={"thinking": {"type": "enabled"}}
)

message = response.choices[0].message

# This single line handles reasoning_content + content + tool_calls correctly:
messages.append(message)

# Execute tool
tool_result = execute_tool(message.tool_calls[0])
messages.append({
    "role": "tool",
    "tool_call_id": message.tool_calls[0].id,
    "content": tool_result
})

# Continue — reasoning_content from the previous message is automatically passed
response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    tools=tools,
    reasoning_effort="high",
    extra_body={"thinking": {"type": "enabled"}}
)

def run_with_tools(messages, tools, tool_handler):
    """Complete tool call loop with reasoning management."""
    while True:
        response = client.chat.completions.create(
            model="deepseek-v4-pro",
            messages=messages,
            tools=tools,
            reasoning_effort="high",
            extra_body={"thinking": {"type": "enabled"}}
        )

        message = response.choices[0].message
        messages.append(message)  # Includes reasoning_content, content, tool_calls

        # No tool calls → final answer reached
        if not message.tool_calls:
            return message.content, message.reasoning_content

        # Execute all tool calls
        for tool_call in message.tool_calls:
            result = tool_handler(tool_call.function.name, tool_call.function.arguments)
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result
            })

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "strict": True,  # Enable strict mode
        "description": "Get weather for a location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "City name"
                }
            },
            "required": ["location"],
            "additionalProperties": False  # Required in strict mode
        }
    }
}]

# Must use beta endpoint for strict mode
client = OpenAI(
    base_url="https://api.deepseek.com/beta",
    api_key="<key>"
)

HTTP 400: "reasoning_content is required for tool call turns"

Fix: Always use messages.append(response.choices[0].message)
     Never manually construct the assistant message dict in tool-call loops.

HTTP 400: "Schema validation failed"

Fix: Ensure all object properties are in 'required' array.
     Set 'additionalProperties: false' on all objects.
     Check that parameter names match between schema and function definition.

Tool calls work in both thinking and non-thinking mode.
If you don't need reasoning, omit the thinking parameter for simpler tool loops.
Non-thinking mode doesn't require reasoning_content management.