GLM 调用指南

from openai import OpenAI

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

response = client.chat.completions.create(
    model="glm-5.1",
    messages=[{"role": "user", "content": "你好"}],
    max_tokens=1024,
)
print(response.choices[0].message.content)

import OpenAI from 'openai';

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

const response = await client.chat.completions.create({
  model: 'glm-5.1',
  messages: [{ role: 'user', content: '你好' }],
  max_tokens: 1024,
});
console.log(response.choices[0].message.content);

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

public class GlmQuickStart {
    public static void main(String[] args) throws Exception {
        Map<String, Object> body = new HashMap<>();
        body.put("model", "glm-5.1");
        body.put("messages", List.of(Map.of("role", "user", "content", "你好")));
        body.put("max_tokens", 1024);

        Request request = new Request.Builder()
            .url("https://tokenhub.tencentmaas.com/v1/chat/completions")
            .header("Authorization", "Bearer YOUR_API_KEY")
            .post(RequestBody.create(new Gson().toJson(body), MediaType.parse("application/json")))
            .build();

        try (Response response = new OkHttpClient().newCall(request).execute()) {
            System.out.println(response.body().string());
        }
    }
}

package main

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

func main() {
    body, _ := json.Marshal(map[string]interface{}{
        "model":      "glm-5.1",
        "messages":   []map[string]string{{"role": "user", "content": "你好"}},
        "max_tokens": 1024,
    })

    req, _ := http.NewRequest("POST",
        "https://tokenhub.tencentmaas.com/v1/chat/completions",
        bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    data, _ := io.ReadAll(resp.Body)
    fmt.Println(string(data))
}

response = client.chat.completions.create(
    model="glm-5.1",
    messages=[{"role": "user", "content": "你好"}],
    extra_body={"thinking": {"type": "disabled"}},
)

const response = await client.chat.completions.create({
  model: 'glm-5.1',
  messages: [{ role: 'user', content: '你好' }],
  // @ts-ignore - thinking 为 GLM 扩展字段
  thinking: { type: 'disabled' },
});

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

public class GlmThinkingDisabled {
    public static void main(String[] args) throws Exception {
        Map<String, Object> body = new HashMap<>();
        body.put("model", "glm-5.1");
        body.put("messages", List.of(Map.of("role", "user", "content", "你好")));
        body.put("thinking", Map.of("type", "disabled"));

        Request request = new Request.Builder()
            .url("https://tokenhub.tencentmaas.com/v1/chat/completions")
            .header("Authorization", "Bearer YOUR_API_KEY")
            .post(RequestBody.create(new Gson().toJson(body), MediaType.parse("application/json")))
            .build();

        try (Response response = new OkHttpClient().newCall(request).execute()) {
            System.out.println(response.body().string());
        }
    }
}

package main

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

func main() {
    body, _ := json.Marshal(map[string]interface{}{
        "model":    "glm-5.1",
        "messages": []map[string]string{{"role": "user", "content": "你好"}},
        "thinking": map[string]string{"type": "disabled"},
    })

    req, _ := http.NewRequest("POST",
        "https://tokenhub.tencentmaas.com/v1/chat/completions",
        bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    data, _ := io.ReadAll(resp.Body)
    fmt.Println(string(data))
}

const message = response.choices[0].message;
// @ts-ignore - reasoning_content 为 GLM 扩展字段
if (message.reasoning_content) {
  console.log('思考过程：', message.reasoning_content);
}
console.log('回答：', message.content);

// HTTP 调用拿到响应字符串后，用 Gson 解析 reasoning_content 和 content 字段
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

String respBody = response.body().string();
JsonObject json = JsonParser.parseString(respBody).getAsJsonObject();
JsonObject message = json.getAsJsonArray("choices")
    .get(0).getAsJsonObject()
    .getAsJsonObject("message");

if (message.has("reasoning_content") && !message.get("reasoning_content").isJsonNull()) {
    System.out.println("思考过程：" + message.get("reasoning_content").getAsString());
}
System.out.println("回答：" + message.get("content").getAsString());

type Message struct {
    Role             string `json:"role"`
    Content          string `json:"content"`
    ReasoningContent string `json:"reasoning_content,omitempty"`
}

type Choice struct {
    Index   int     `json:"index"`
    Message Message `json:"message"`
}

type ChatResponse struct {
    Choices []Choice `json:"choices"`
}

var result ChatResponse
json.Unmarshal(data, &result)

if result.Choices[0].Message.ReasoningContent != "" {
    fmt.Println("思考过程：", result.Choices[0].Message.ReasoningContent)
}
fmt.Println("回答：", result.Choices[0].Message.Content)

stream = client.chat.completions.create(
    model="glm-5.1",
    messages=[{"role": "user", "content": "解释量子纠缠"}],
    stream=True,
    stream_options={"include_usage": True},
    extra_body={"thinking": {"type": "enabled"}},
)

is_answering = False
for chunk in stream:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    if hasattr(delta, "reasoning_content") and delta.reasoning_content:
        print(delta.reasoning_content, end="", flush=True)
    if hasattr(delta, "content") and delta.content:
        if not is_answering:
            print("\\n--- 回答 ---\\n")
            is_answering = True
        print(delta.content, end="", flush=True)

const stream = await client.chat.completions.create({
  model: 'glm-5.1',
  messages: [{ role: 'user', content: '解释量子纠缠' }],
  stream: true,
  stream_options: { include_usage: true },
  // @ts-ignore - thinking 为 GLM 扩展字段
  thinking: { type: 'enabled' },
});

let isAnswering = false;
for await (const chunk of stream) {
  if (!chunk.choices?.length) continue;
  const delta = chunk.choices[0].delta;
  // @ts-ignore - reasoning_content 为 GLM 扩展字段
  if (delta.reasoning_content) {
    process.stdout.write(delta.reasoning_content);
  }
  if (delta.content) {
    if (!isAnswering) {
      process.stdout.write('\\n--- 回答 ---\\n');
      isAnswering = true;
    }
    process.stdout.write(delta.content);
  }
}

import okhttp3.*;
import com.google.gson.*;
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class GlmStream {
    public static void main(String[] args) throws Exception {
        Map<String, Object> body = new HashMap<>();
        body.put("model", "glm-5.1");
        body.put("messages", List.of(Map.of("role", "user", "content", "解释量子纠缠")));
        body.put("stream", true);
        body.put("stream_options", Map.of("include_usage", true));
        body.put("thinking", Map.of("type", "enabled"));

        Request request = new Request.Builder()
            .url("https://tokenhub.tencentmaas.com/v1/chat/completions")
            .header("Authorization", "Bearer YOUR_API_KEY")
            .post(RequestBody.create(new Gson().toJson(body), MediaType.parse("application/json")))
            .build();

        try (Response response = new OkHttpClient().newCall(request).execute();
             BufferedReader reader = new BufferedReader(
                 new InputStreamReader(response.body().byteStream()))) {
            String line;
            boolean isAnswering = false;
            while ((line = reader.readLine()) != null) {
                if (!line.startsWith("data: ")) continue;
                String data = line.substring(6);
                if (data.equals("[DONE]")) break;

                JsonObject chunk = JsonParser.parseString(data).getAsJsonObject();
                JsonArray choices = chunk.getAsJsonArray("choices");
                if (choices == null || choices.size() == 0) continue;
                JsonObject delta = choices.get(0).getAsJsonObject().getAsJsonObject("delta");

                if (delta.has("reasoning_content") && !delta.get("reasoning_content").isJsonNull()) {
                    System.out.print(delta.get("reasoning_content").getAsString());
                }
                if (delta.has("content") && !delta.get("content").isJsonNull()) {
                    if (!isAnswering) {
                        System.out.println("\\n--- 回答 ---");
                        isAnswering = true;
                    }
                    System.out.print(delta.get("content").getAsString());
                }
            }
        }
    }
}