from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://tokenhub-intl.tencentcloudmaas.com/v1",
)

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Obtain weather information for a location by inputting the location.",
        "parameters": {
            "type": "object",
            "properties": {"location": {"type": "string"}},
            "required": ["location"],
        },
    },
}]

messages = [
    {"role": "system", "content": "You are an Agent. You must reason step by step and invoke tools to complete tasks."},
    {"role": "user", "content": "What is the weather like in Shenzhen today?"},
]

# The OpenAI Python SDK has strict type signatures. Non-standard fields, such as reasoning_effort, must be passed through the extra_body parameter.
resp1 = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    tools=tools,
    tool_choice="auto",
    extra_body={"reasoning_effort": "high"},
)
msg1 = resp1.choices[0].message
print("Round 1 assistant.reasoning_content:", getattr(msg1, "reasoning_content", ""))
print("Round 1 tool_calls:", msg1.tool_calls)

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://tokenhub-intl.tencentcloudmaas.com/v1',
});

const tools = [{
  type: 'function',
  function: {
    name: 'get_weather',
    "description": "Obtain weather information for a location by inputting the location.",
    parameters: {
      type: 'object',
      properties: { location: { type: 'string' } },
      required: ['location'],
    },
  },
}];

const messages = [
  { role: 'system', content: 'You are an Agent. You must reason step by step and invoke tools to complete tasks.' },
  { role: 'user', content: 'What is the weather like in Shenzhen today?' },
];

const resp1 = await client.chat.completions.create({
  model: 'deepseek-v4-pro',
  messages,
  tools,
  tool_choice: 'auto',
  reasoning_effort: 'high',
});

const msg1 = resp1.choices[0].message;
console.log('Round 1 reasoning_content:', msg1.reasoning_content);
console.log('Round 1 tool_calls:', msg1.tool_calls);

import okhttp3.*;
import com.google.gson.*;
import java.util.*;

public class InterleavedThinking {
    static final String URL = "https://tokenhub-intl.tencentcloudmaas.com/v1/chat/completions";
    static final String API_KEY = "YOUR_API_KEY";
    static final OkHttpClient HTTP = new OkHttpClient();
    static final Gson GSON = new Gson();

    /** A generic chat call that returns the raw JSON response string. */
    static String chat(List<Map<String, Object>> messages, List<Map<String, Object>> tools) throws Exception {
        Map<String, Object> body = new HashMap<>();
        body.put("model", "deepseek-v4-pro");
        body.put("messages", messages);
        body.put("tools", tools);
        body.put("tool_choice", "auto");
        body.put("reasoning_effort", "high");
        body.put("stream", false);

        Request req = new Request.Builder()
            .url(URL)
            .header("Authorization", "Bearer " + API_KEY)
            .post(RequestBody.create(GSON.toJson(body), MediaType.parse("application/json")))
            .build();
        try (Response resp = HTTP.newCall(req).execute()) {
            return resp.body().string();
        }
    }

    public static void main(String[] args) throws Exception {
        List<Map<String, Object>> tools = List.of(Map.of(
            "type", "function",
            "function", Map.of(
                "name", "get_weather",
                "description", "Obtain weather information for a location by inputting the location.",
                "parameters", Map.of(
                    "type", "object",
                    "properties", Map.of("location", Map.of("type", "string")),
                    "required", List.of("location")
                )
            )
        ));

        List<Map<String, Object>> messages = new ArrayList<>();
        messages.add(Map.of("role", "system", "content", "You are an Agent. You must reason step by step and invoke tools to complete tasks."));
        messages.add(Map.of("role", "user", "content", "What is the weather like in Shenzhen today?"));

        // Round 1: The model decides whether to call the tool.
        String r1 = chat(messages, tools);
        System.out.println("Round 1 response: " + r1);
        // Next, backfill the reasoning_content / tool_calls from the response into messages. Refer to Step 2 for details.
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

const (
    URL    = "https://tokenhub-intl.tencentcloudmaas.com/v1/chat/completions"
    APIKEY = "YOUR_API_KEY"
)

// Generic chat call
func chat(messages []map[string]interface{}, tools []map[string]interface{}) (map[string]interface{}, error) {
    body, _ := json.Marshal(map[string]interface{}{
        "model":            "deepseek-v4-pro",
        "messages":         messages,
        "tools":            tools,
        "tool_choice":      "auto",
        "reasoning_effort": "high",
        "stream":           false,
    })
    req, _ := http.NewRequest("POST", URL, bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer "+APIKEY)
    req.Header.Set("Content-Type", "application/json")
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    data, _ := io.ReadAll(resp.Body)
    var out map[string]interface{}
    json.Unmarshal(data, &out)
    return out, nil
}

func main() {
    tools := []map[string]interface{}{{
        "type": "function",
        "function": map[string]interface{}{
            "name":        "get_weather",
            "description": "Obtain weather information for a location by inputting the location.",
            "parameters": map[string]interface{}{
                "type": "object",
                "properties": map[string]interface{}{
                    "location": map[string]string{"type": "string"},
                },
                "required": []string{"location"},
            },
        },
    }}

    messages := []map[string]interface{}{
        {"role": "system", "content": "You are an Agent. You must reason step by step and invoke tools to complete tasks."},
        {"role": "user", "content": "What is the weather like in Shenzhen today?"},
    }

    // Round 1: The model decides whether to call the tool.
    r1, _ := chat(messages, tools)
    fmt.Printf("Round 1 response: %+v\\n", r1)
    // Next, backfill the reasoning_content / tool_calls from the response into messages. Refer to Step 2 for details.
}

# Continuing from the previous step: Include the assistant message from Round 1 (containing reasoning_content + tool_calls)
# Backfill into messages along with the tool results.
import json

# Backfill of the assistant message from Round 1: reasoning_content must be retained.
assistant_msg = {
    "role": "assistant",
    "content": msg1.content,
    "reasoning_content": getattr(msg1, "reasoning_content", ""),
    "tool_calls": [
        {
            "id": tc.id,
            "type": tc.type,
            "function": {
                "name": tc.function.name,
                "arguments": tc.function.arguments,
            },
        } for tc in (msg1.tool_calls or [])
    ],
}
messages.append(assistant_msg)

# The business side executes the tool and backfills the result with role=tool.
for tc in (msg1.tool_calls or []):
    args = json.loads(tc.function.arguments)
    # Replace with actual business logic here
    tool_result = "Cloudy, temperature 7~13°C"
    messages.append({
        "role": "tool",
        "tool_call_id": tc.id,
        "content": tool_result,
    })

# Round 2: Return the tool result to the model, which then continues reasoning and outputs the final response.
resp2 = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    tools=tools,
    tool_choice="auto",
    extra_body={"reasoning_effort": "high"},
)
print("Final answer:", resp2.choices[0].message.content)

// Continuing from the previous step: Include the assistant message from Round 1 (containing reasoning_content + tool_calls)
// Backfill into messages along with the tool results.

const assistantMsg = {
  role: 'assistant',
  content: msg1.content,
  reasoning_content: msg1.reasoning_content,
  tool_calls: msg1.tool_calls,
};
messages.push(assistantMsg);

for (const tc of msg1.tool_calls || []) {
  const args = JSON.parse(tc.function.arguments);
  // Replace with actual business logic here
  const toolResult = 'Cloudy, temperature 7~13°C';
  messages.push({
    role: 'tool',
    tool_call_id: tc.id,
    content: toolResult,
  });
}

const resp2 = await client.chat.completions.create({
  model: 'deepseek-v4-pro',
  messages,
  tools,
  tool_choice: 'auto',
  reasoning_effort: 'high',
});
console.log('Final answer:', resp2.choices[0].message.content);

// Continuing from main(): Backfill the assistant message and tool results from Round 1, then initiate the Round 2 request.
// Complete workflow illustration (only message construction is shown, the HTTP call reuses the chat() function from the previous step)

// 1. Parse the Round 1 response
JsonObject r1Obj = JsonParser.parseString(r1).getAsJsonObject();
JsonObject msg1 = r1Obj.getAsJsonArray("choices").get(0).getAsJsonObject()
    .getAsJsonObject("message");

// 2. Backfill the assistant message (including reasoning_content) entirely to messages.
Map<String, Object> assistantEntry = new LinkedHashMap<>();
assistantEntry.put("role", "assistant");
assistantEntry.put("content", msg1.has("content") ? msg1.get("content").getAsString() : "");
if (msg1.has("reasoning_content")) {
    assistantEntry.put("reasoning_content", msg1.get("reasoning_content").getAsString());
}
if (msg1.has("tool_calls")) {
    assistantEntry.put("tool_calls", GSON.fromJson(msg1.get("tool_calls"), List.class));
}
messages.add(assistantEntry);

// 3. The business side executes the tool and backfills the result with role=tool.
for (JsonElement el : msg1.getAsJsonArray("tool_calls")) {
    JsonObject call = el.getAsJsonObject();
    String toolResult = "Cloudy, temperature 7~13°C"; // Replace with actual business logic here
    messages.add(Map.of(
        "role", "tool",
        "tool_call_id", call.get("id").getAsString(),
        "content", toolResult
    ));
}

// 4. Round 2: Return the Tool Result to the Model
String r2 = chat(messages, tools);
System.out.println("Round 2 response: " + r2);

// Continuing from main(): Backfill the assistant message and tool results from Round 1, then initiate the Round 2 request.
// Complete workflow illustration (only message construction is shown, the HTTP call reuses the chat() function from the previous step)

// 1. Extract the assistant message from the Round 1 response.
msg1Wrap := r1["choices"].([]interface{})[0].(map[string]interface{})
msg1 := msg1Wrap["message"].(map[string]interface{})

// 2. Backfill the assistant message (including reasoning_content) entirely to messages.
messages = append(messages, msg1)

// 3. The business side executes the tool and backfills the result with role=tool.
toolCalls, _ := msg1["tool_calls"].([]interface{})
for _, c := range toolCalls {
    call := c.(map[string]interface{})
    toolResult := "Cloudy, temperature 7~13°C" // Replace with actual business logic here
    messages = append(messages, map[string]interface{}{
        "role":         "tool",
        "tool_call_id": call["id"],
        "content":      toolResult,
    })
}

// 4. Round 2: Return the Tool Result to the Model
r2, _ := chat(messages, tools)
fmt.Printf("Round 2 response: %+v\\n", r2)