保留式思考模式（Preserved Thinking）

from openai import OpenAI

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

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_user_groups",
            "description": "查询某个用户所属的所有用户组。",
            "parameters": {
                "type": "object",
                "properties": {
                    "user": {"type": "string"},
                },
                "required": ["user"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "get_group_permissions",
            "description": "查询某个用户组对各资源的访问权限。",
            "parameters": {
                "type": "object",
                "properties": {
                    "group": {"type": "string"},
                },
                "required": ["group"],
            },
        },
    },
]

messages = [
    {"role": "system", "content": "你是一个企业 IT 权限助理 Agent，通过调用工具查询组织与权限数据来回答问题。请始终用中文进行逐步推理与思考。"},
    {"role": "user", "content": "Alice 属于哪些用户组？"},
]

# 携带 tools 时，hy3 默认开启保留式思考。
# 如需显式控制，可在 extra_body 中传 preserved_thinking: True/False
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("第 1 轮 reasoning_content:", getattr(msg1, "reasoning_content", ""))
print("第 1 轮 tool_calls:", msg1.tool_calls)

import OpenAI from 'openai';

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

const tools = [
  {
    type: 'function',
    function: {
      name: 'get_user_groups',
      description: '查询某个用户所属的所有用户组。',
      parameters: {
        type: 'object',
        properties: {
          user: { type: 'string' },
        },
        required: ['user'],
      },
    },
  },
  {
    type: 'function',
    function: {
      name: 'get_group_permissions',
      description: '查询某个用户组对各资源的访问权限。',
      parameters: {
        type: 'object',
        properties: {
          group: { type: 'string' },
        },
        required: ['group'],
      },
    },
  },
];

const messages = [
  { role: 'system', content: '你是一个企业 IT 权限助理 Agent，通过调用工具查询组织与权限数据来回答问题。请始终用中文进行逐步推理与思考。' },
  { role: 'user', content: 'Alice 属于哪些用户组？' },
];

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('第 1 轮 reasoning_content:', msg1.reasoning_content);
console.log('第 1 轮 tool_calls:', msg1.tool_calls);

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

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

    /** 通用 chat 调用，返回原始 JSON 响应字符串。 */
    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);
        // 显式控制可加：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", "查询某个用户所属的所有用户组。",
                    "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", "查询某个用户组对各资源的访问权限。",
                    "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", "你是一个企业 IT 权限助理 Agent，通过调用工具查询组织与权限数据来回答问题。请始终用中文进行逐步推理与思考。"));
        messages.add(Map.of("role", "user",   "content", "Alice 属于哪些用户组？"));

        // 第 1 轮：模型决定是否调用工具
        String r1 = chat(messages, tools);
        System.out.println("第 1 轮响应：" + r1);
        // 后续按响应里的 reasoning_content / tool_calls 回填到 messages，见第 2 步
    }
}

package main

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

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

// 通用 chat 调用
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,
        // 显式控制可加："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": "查询某个用户所属的所有用户组。",
                "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": "查询某个用户组对各资源的访问权限。",
                "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": "你是一个企业 IT 权限助理 Agent，通过调用工具查询组织与权限数据来回答问题。请始终用中文进行逐步推理与思考。"},
        {"role": "user", "content": "Alice 属于哪些用户组？"},
    }

    // 第 1 轮：模型决定是否调用工具
    r1, _ := chat(messages, tools)
    fmt.Printf("第 1 轮响应: %+v\\n", r1)
    // 后续按响应里的 reasoning_content / tool_calls 回填到 messages，见第 2 步
}

# 接续 step1：把第 1 轮的 assistant 消息（含 reasoning_content + tool_calls）
# 与工具结果一起回填到 messages
import json

# 第 1 轮 assistant 消息的回写：reasoning_content 必须保留
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)

# 业务侧执行 get_user_groups，把结果以 role=tool 回填
for tc in (msg1.tool_calls or []):
    # 这里替换为真实业务逻辑
    tool_result = json.dumps({"user": "Alice", "groups": ["Engineering", "OnCall"]}, ensure_ascii=False)
    messages.append({
        "role": "tool",
        "tool_call_id": tc.id,
        "content": tool_result,
    })

# 第 2 轮：把工具结果送回模型，模型继续思考
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("第 2 轮 reasoning_content:", getattr(msg2, "reasoning_content", ""))
print("第 2 轮 content:", msg2.content)

// 接续 step1：把第 1 轮 assistant 消息与工具结果回填
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 toolResult = JSON.stringify({ user: 'Alice', groups: ['Engineering', 'OnCall'] });
  messages.push({
    role: 'tool',
    tool_call_id: tc.id,
    content: toolResult,
  });
}

const resp2 = await client.chat.completions.create({
  model: 'hy3',
  messages,
  tools,
  tool_choice: 'auto',
  reasoning_effort: 'high',
});
const msg2 = resp2.choices[0].message;
console.log('第 2 轮 reasoning_content:', msg2.reasoning_content);
console.log('第 2 轮 content:', msg2.content);