Chat Completions

OpenAI 兼容的聊天补全接口，支持流式输出、函数调用、结构化输出和视觉理解。

POST /v1/chat/completions

请求示例

Curl

curl https://gw.opentoken.io/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPEN_TOKEN_KEY" \
  -d '{
  "model": "gpt-4o",
  "messages": [
    {"role": "system", "content": "你是资深 Python 工程师。"},
    {"role": "user", "content": "解释装饰器的工作原理。"}
  ],
  "temperature": 0.7,
  "max_tokens": 500
}'

Python

import os
import requests

response = requests.post(
    "https://gw.opentoken.io/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {os.environ['OPEN_TOKEN_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "model": "gpt-4o",
        "messages": [
            {"role": "system", "content": "你是资深 Python 工程师。"},
            {"role": "user", "content": "解释装饰器的工作原理。"},
        ],
        "temperature": 0.7,
        "max_tokens": 500,
    },
)

data = response.json()
print(data["choices"][0]["message"]["content"])
print(f"Token: {data['usage']['total_tokens']}")

TypeScript

const response = await fetch(
  "https://gw.opentoken.io/v1/chat/completions",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.OPEN_TOKEN_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "gpt-4o",
      messages: [
        { role: "system", content: "你是资深 Python 工程师。" },
        { role: "user", content: "解释装饰器的工作原理。" },
      ],
      temperature: 0.7,
      max_tokens: 500,
    }),
  }
);
const data = await response.json();
console.log(data.choices[0].message.content);

Java

import java.net.http.*;
import java.net.URI;
import com.google.gson.*;

HttpClient client = HttpClient.newHttpClient();
String apiKey = System.getenv("OPEN_TOKEN_KEY");

JsonObject sys = new JsonObject();
sys.addProperty("role", "system");
sys.addProperty("content", "你是资深 Python 工程师。");

JsonObject usr = new JsonObject();
usr.addProperty("role", "user");
usr.addProperty("content", "解释装饰器的工作原理。");

JsonArray msgs = new JsonArray();
msgs.add(sys); msgs.add(usr);

JsonObject payload = new JsonObject();
payload.addProperty("model", "gpt-4o");
payload.add("messages", msgs);
payload.addProperty("temperature", 0.7);
payload.addProperty("max_tokens", 500);

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://gw.opentoken.io/v1/chat/completions"))
    .header("Authorization", "Bearer " + apiKey)
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(payload.toString()))
    .build();

HttpResponse<String> resp = client.send(request,
    HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

Go

package main

import (
    "bytes"; "encoding/json"; "fmt"
    "net/http"; "os"
)

func main() {
    apiKey := os.Getenv("OPEN_TOKEN_KEY")
    body, _ := json.Marshal(map[string]interface{}{
        "model": "gpt-4o",
        "messages": []map[string]string{
            {"role": "system", "content": "你是资深 Python 工程师。"},
            {"role": "user", "content": "解释装饰器的工作原理。"},
        },
        "temperature": 0.7,
        "max_tokens": 500,
    })
    req, _ := http.NewRequest("POST",
        "https://gw.opentoken.io/v1/chat/completions", bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Println(result)
}

PHP

<?php
$apiKey = getenv('OPEN_TOKEN_KEY');
$ch = curl_init('https://gw.opentoken.io/v1/chat/completions');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'model' => 'gpt-4o',
        'messages' => [
            ['role' => 'system', 'content' => '你是资深 Python 工程师。'],
            ['role' => 'user', 'content' => '解释装饰器的工作原理。'],
        ],
        'temperature' => 0.7,
        'max_tokens' => 500,
    ]),
]);
$data = json_decode(curl_exec($ch), true);
curl_close($ch);
echo $data['choices'][0]['message']['content'];

Ruby

require 'net/http'
require 'json'

api_key = ENV['OPEN_TOKEN_KEY']
uri = URI('https://gw.opentoken.io/v1/chat/completions')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri.path, {
  'Authorization' => "Bearer #{api_key}",
  'Content-Type' => 'application/json',
})
request.body = {
  model: 'gpt-4o',
  messages: [
    { role: 'system', content: '你是资深 Python 工程师。' },
    { role: 'user', content: '解释装饰器的工作原理。' }
  ],
  temperature: 0.7,
  max_tokens: 500,
}.to_json

response = http.request(request)
data = JSON.parse(response.body)
puts data['choices'][0]['message']['content']

C#

using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

var apiKey = Environment.GetEnvironmentVariable("OPEN_TOKEN_KEY");
using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", apiKey);

var payload = new
{
    model = "gpt-4o",
    messages = new[]
    {
        new { role = "system", content = "你是资深 Python 工程师。" },
        new { role = "user", content = "解释装饰器的工作原理。" },
    },
    temperature = 0.7,
    max_tokens = 500,
};
var json = JsonSerializer.Serialize(payload);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PostAsync(
    "https://gw.opentoken.io/v1/chat/completions", content);
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);

流式输出

在请求中添加 "stream": true 启用 SSE 流式输出。

Curl

curl -N https://gw.opentoken.io/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPEN_TOKEN_KEY" \
  -d '{
  "model": "gpt-4o",
  "messages": [{"role": "user", "content": "写一首关于 AI 的诗"}],
  "stream": true
}'

Python

import os, requests, json

response = requests.post(
    "https://gw.opentoken.io/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {os.environ['OPEN_TOKEN_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "model": "gpt-4o",
        "messages": [{"role": "user", "content": "写一首关于 AI 的诗"}],
        "stream": True,
    },
    stream=True,
)

buffer = ""
for chunk in response.iter_content(chunk_size=1024, decode_unicode=True):
    buffer += chunk
    while "\n" in buffer:
        line, buffer = buffer.split("\n", 1)
        line = line.strip()
        if not line.startswith("data: "):
            continue
        data = line[6:]
        if data == "[DONE]":
            break
        try:
            obj = json.loads(data)
        except json.JSONDecodeError:
            continue
        content = obj["choices"][0]["delta"].get("content")
        if content:
            print(content, end="", flush=True)
        if obj.get("usage"):
            print(f"\n用量: {obj['usage']}")

TypeScript

const response = await fetch(
  "https://gw.opentoken.io/v1/chat/completions",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.OPEN_TOKEN_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "gpt-4o",
      messages: [{ role: "user", content: "写一首关于 AI 的诗" }],
      stream: true,
    }),
  }
);

const reader = response.body?.getReader();
const decoder = new TextDecoder();
let buffer = "";

while (true) {
  const { done, value } = await reader!.read();
  if (done) break;
  buffer += decoder.decode(value, { stream: true });
  const lines = buffer.split('\n');
  buffer = lines.pop() ?? "";
  for (const line of lines) {
    const trimmed = line.trim();
    if (!trimmed.startsWith('data: ') || trimmed === 'data: [DONE]') continue;
    const data = JSON.parse(trimmed.slice(6));
    const content = data.choices[0]?.delta?.content;
    if (content) process.stdout.write(content);
  }
}

请求参数

参数	类型	必填	默认值	描述
model	string	是	-	模型 ID，例如 gpt-4o
messages	array	是	-	对话消息数组，每条含 role 和 content
temperature	number	否	1.0	采样温度，用于控制生成过程中的随机性。较低的值通常会使输出更稳定、可预测；较高的值通常会增加输出的多样性。
max_tokens	integer	否	-	限制本次响应可生成的最大 token 数；实际输出长度可能因停止条件、上下文长度或模型限制而更短。
top_p	number	否	1.0	核采样参数，用于将每一步采样限制在累计概率达到 top_p 的候选集合内。
frequency_penalty	number	否	0.0	频率惩罚，用于降低模型重复生成高频内容的倾向。
presence_penalty	number	否	0.0	存在惩罚，用于提高模型引入新主题或新词汇的倾向。
stop	string / array	否	-	停止序列，触发后停止生成
stream	boolean	否	false	启用 SSE 流式输出
response_format	object	否	-	结构化输出格式：json_object 或 json_schema
tools	array	否	-	工具定义数组，用于 Function Calling

Function Calling（函数调用）

通过 tools 参数定义函数，使模型能够结构化地请求调用外部工具。

{
  "model": "gpt-4o",
  "messages": [{"role": "user", "content": "北京今天天气怎么样？"}],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "获取指定城市的天气信息",
        "parameters": {
          "type": "object",
          "properties": {
            "city": { "type": "string", "description": "城市名称" }
          },
          "required": ["city"]
        }
      }
    }
  ]
}

Structured Outputs（结构化输出）

使用 response_format 强制模型返回结构化 JSON：

• JSON 模式：{"type": "json_object"} — 确保输出为有效 JSON
• JSON Schema：{"type": "json_schema", "json_schema": {...}} — 按指定 schema 输出

{
  "model": "gpt-4o",
  "messages": [{"role": "user", "content": "列出 3 种水果及颜色"}],
  "response_format": {
    "type": "json_schema",
    "json_schema": {
      "name": "fruits",
      "schema": {
        "type": "object",
        "properties": {
          "fruits": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "name": { "type": "string" },
                "color": { "type": "string" }
              },
              "required": ["name", "color"]
            }
          }
        }
      }
    }
  }
}

响应结构

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1717800000,
  "model": "gpt-4o",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "装饰器是 Python 中的一种设计模式..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 30,
    "completion_tokens": 120,
    "total_tokens": 150
  }
}

流式响应结构

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion.chunk",
  "created": 1717800000,
  "model": "gpt-4o",
  "choices": [
    {
      "index": 0,
      "delta": {
        "content": "装饰"
      },
      "finish_reason": null
    }
  ]
}