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_user_groups",
            "description": "Queries all user groups to which a specified user belongs.",
            "parameters": {
                "type": "object",
                "properties": {
                    "user": {"type": "string"},
                },
                "required": ["user"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "get_group_permissions",
            "description": "Queries the access permissions of a specified user group for various resources.",
            "parameters": {
                "type": "object",
                "properties": {
                    "group": {"type": "string"},
                },
                "required": ["group"],
            },
        },
    },
]

messages = [
    {"role": "system", "content": "You are an enterprise IT permissions assistant Agent that answers questions by invoking tools to query organizational and permission data. Always perform step-by-step reasoning and thinking in Chinese."},
    {"role": "user", "content": "Which user groups does Alice belong to?"},
]

# When tools are carried, hy3 enables Preserved Thinking by default.
# To explicitly control it, you can pass preserved_thinking: True/False in the extra_body.
resp1 = client.chat.completions.create(
    model="hy3",
    messages=messages,
    tools=tools,
    tool_choice="auto",
    extra_body={"reasoning_effort": "high"},
)
msg1 = resp1.choices[0].message
print("Round 1 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_user_groups',
      description: 'Queries all user groups to which a specified user belongs.',
      parameters: {
        type: 'object',
        properties: {
          user: { type: 'string' },
        },
        required: ['user'],
      },
    },
  },
  {
    type: 'function',
    function: {
      name: 'get_group_permissions',
      description: 'Queries the access permissions of a specified user group for various resources.',
      parameters: {
        type: 'object',
        properties: {
          group: { type: 'string' },
        },
        required: ['group'],
      },
    },
  },
];

const messages = [
  { role: 'system', content: 'You are an enterprise IT permissions assistant Agent that answers questions by invoking tools to query organizational and permission data. Always perform step-by-step reasoning and thinking in Chinese.' },
  {"role": "user", "content": "Which user groups does Alice belong to?"},
];

const resp1 = await client.chat.completions.create({
  model: 'hy3',
  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 PreservedThinking {
    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", "hy3");
        body.put("messages", messages);
        body.put("tools", tools);
        body.put("tool_choice", "auto");
        body.put("reasoning_effort", "high");
        body.put("stream", false);
        // For explicit control, you can add: body.put("preserved_thinking", true);

        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_user_groups",
                    "description", "Queries all user groups to which a specified user belongs.",
                    "parameters", Map.of(
                        "type", "object",
                        "properties", Map.of(
                            "user", Map.of("type", "string")
                        ),
                        "required", List.of("user")
                    )
                )
            ),
            Map.of(
                "type", "function",
                "function", Map.of(
                    "name", "get_group_permissions",
                    "description", "Queries the access permissions of a specified user group for various resources.",
                    "parameters", Map.of(
                        "type", "object",
                        "properties", Map.of(
                            "group", Map.of("type", "string")
                        ),
                        "required", List.of("group")
                    )
                )
            )
        );

        List<Map<String, Object>> messages = new ArrayList<>();
        messages.add(Map.of("role", "system", "content", "You are an enterprise IT permissions assistant Agent that answers questions by invoking tools to query organizational and permission data. Always perform step-by-step reasoning and thinking in Chinese."));
        messages.add(Map.of("role", "user", "content", "Which user groups does Alice belong to?"));

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

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":            "hy3",
        "messages":         messages,
        "tools":            tools,
        "tool_choice":      "auto",
        "reasoning_effort": "high",
        "stream":           false,
        // For explicit control, you can add: "preserved_thinking": true,
    })
    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_user_groups",
                "description": "Queries all user groups to which a specified user belongs.",
                "parameters": map[string]interface{}{
                    "type": "object",
                    "properties": map[string]interface{}{
                        "user": map[string]string{"type": "string"},
                    },
                    "required": []string{"user"},
                },
            },
        },
        {
            "type": "function",
            "function": map[string]interface{}{
                "name":        "get_group_permissions",
                "description": "Queries the access permissions of a specified user group for various resources.",
                "parameters": map[string]interface{}{
                    "type": "object",
                    "properties": map[string]interface{}{
                        "group": map[string]string{"type": "string"},
                    },
                    "required": []string{"group"},
                },
            },
        },
    }

    messages := []map[string]interface{}{
        {"role": "system", "content": "You are an enterprise IT permissions assistant Agent that answers questions by invoking tools to query organizational and permission data. Always perform step-by-step reasoning and thinking in Chinese."},
        {"role": "user", "content": "Which user groups does Alice belong to?"},
    }

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

# Continuing from step1: Add the assistant message from Round 1 (containing reasoning_content + tool_calls)
# Backfill into the messages along with the tool result
import json

# Backfill of the assistant message from Round 1: reasoning_content must be retained
assistant_msg = {
    "role": "assistant",
    "content": msg1.content or "",
    "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)

# Execute get_user_groups on the business side and backfill the result with role=tool.
for tc in (msg1.tool_calls or []):
    # Replace with actual business logic here
    tool_result = json.dumps({"user": "Alice", "groups": ["Engineering", "OnCall"]}, ensure_ascii=False)
    messages.append({
        "role": "tool",
        "tool_call_id": tc.id,
        "content": tool_result,
    })

# Round 2: Send the tool result back to the model, which then continues to think
resp2 = client.chat.completions.create(
    model="hy3",
    messages=messages,
    tools=tools,
    tool_choice="auto",
    extra_body={"reasoning_effort": "high"},
)
msg2 = resp2.choices[0].message
print("Round 2 reasoning_content:", getattr(msg2, "reasoning_content", ""))
print("Round 2 content:", msg2.content)