Chat CompletionsPOST

curl https://api.tokentosea.com/v1/chat/completions \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "model": "glm-5.3",
    "messages": [
      {"role": "system", "content": "你是一名简洁的助手。"},
      {"role": "user", "content": "请简短介绍一下你能帮助我完成什么。"}
    ],
    "max_tokens": 1024
  }'

import os
import uuid

from openai import OpenAI

client = OpenAI(
    api_key=os.environ["TOKENTOSEA_API_KEY"],
    base_url="https://api.tokentosea.com/v1",
    max_retries=0,
)

request_key = str(uuid.uuid4())  # 保存它：超时或断线后用它查询结果
completion = client.chat.completions.create(
    model="glm-5.3",
    messages=[
        {"role": "system", "content": "你是一名简洁的助手。"},
        {"role": "user", "content": "请简短介绍一下你能帮助我完成什么。"},
    ],
    max_tokens=1024,
    extra_headers={"Idempotency-Key": request_key},
)
print(completion.choices[0].message.content)
print(completion.usage)

import OpenAI from 'openai';
import { randomUUID } from 'node:crypto';

const client = new OpenAI({
  apiKey: process.env.TOKENTOSEA_API_KEY,
  baseURL: 'https://api.tokentosea.com/v1',
  maxRetries: 0,
});

const requestKey = randomUUID(); // 保存它：超时或断线后用它查询结果
const completion = await client.chat.completions.create(
  {
    model: 'glm-5.3',
    messages: [
      { role: 'system', content: '你是一名简洁的助手。' },
      { role: 'user', content: '请简短介绍一下你能帮助我完成什么。' },
    ],
    max_tokens: 1024,
  },
  { headers: { 'Idempotency-Key': requestKey } },
);
console.log(completion.choices[0].message.content);
console.log(completion.usage);

curl -N https://api.tokentosea.com/v1/chat/completions \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "model": "glm-5.3",
    "messages": [{"role": "user", "content": "用三句话解释什么是向量检索。"}],
    "max_tokens": 1024,
    "stream": true
  }'

import os
import uuid

import openai
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["TOKENTOSEA_API_KEY"],
    base_url="https://api.tokentosea.com/v1",
    max_retries=0,
)

request_key = str(uuid.uuid4())
usage = None
try:
    stream = client.chat.completions.create(
        model="glm-5.3",
        messages=[{"role": "user", "content": "用三句话解释什么是向量检索。"}],
        max_tokens=1024,
        stream=True,
        extra_headers={"Idempotency-Key": request_key},
    )
    for chunk in stream:
        if chunk.usage:  # 用量块的 choices 为空，且可能早于结束块到达
            usage = chunk.usage
        for choice in chunk.choices:
            if choice.delta.content:
                print(choice.delta.content, end="", flush=True)
    print("\n", usage)
except openai.APIError as error:
    # 流中途的 execution_result_pending 等错误：用同一个键查询结果，不要换新键重发
    print("调用未正常结束，请查询 /v1/results/" + request_key, error)

import OpenAI from 'openai';
import { randomUUID } from 'node:crypto';

const client = new OpenAI({
  apiKey: process.env.TOKENTOSEA_API_KEY,
  baseURL: 'https://api.tokentosea.com/v1',
  maxRetries: 0,
});

const requestKey = randomUUID();
let usage = null;
try {
  const stream = await client.chat.completions.create(
    {
      model: 'glm-5.3',
      messages: [{ role: 'user', content: '用三句话解释什么是向量检索。' }],
      max_tokens: 1024,
      stream: true,
    },
    { headers: { 'Idempotency-Key': requestKey } },
  );
  for await (const chunk of stream) {
    if (chunk.usage) usage = chunk.usage; // choices 为空的用量块
    for (const choice of chunk.choices) process.stdout.write(choice.delta?.content ?? '');
  }
  console.log('\n', usage);
} catch (error) {
  console.error(`调用未正常结束，请查询 /v1/results/${requestKey}`, error.message);
}

curl https://api.tokentosea.com/v1/chat/completions \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "model": "qwen3.8-max",
    "messages": [{
      "role": "user",
      "content": [
        {"type": "text", "text": "这张图片里有什么？"},
        {"type": "image_url", "image_url": {"url": "https://example.com/photo.jpg"}}
      ]
    }],
    "max_tokens": 1024,
    "enable_thinking": false
  }'

import os
import uuid

from openai import OpenAI

client = OpenAI(
    api_key=os.environ["TOKENTOSEA_API_KEY"],
    base_url="https://api.tokentosea.com/v1",
    max_retries=0,
)
IMAGE_URL = "https://example.com/photo.jpg"  # 厂商需能公网访问

completion = client.chat.completions.create(
    model="qwen3.8-max",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "这张图片里有什么？"},
            {"type": "image_url", "image_url": {"url": IMAGE_URL}},
        ],
    }],
    max_tokens=1024,
    extra_body={"enable_thinking": False},  # 厂商扩展参数放在 extra_body
    extra_headers={"Idempotency-Key": str(uuid.uuid4())},
)
print(completion.choices[0].message.content)

import OpenAI from 'openai';
import { randomUUID } from 'node:crypto';

const client = new OpenAI({
  apiKey: process.env.TOKENTOSEA_API_KEY,
  baseURL: 'https://api.tokentosea.com/v1',
  maxRetries: 0,
});
const IMAGE_URL = 'https://example.com/photo.jpg'; // 厂商需能公网访问

const completion = await client.chat.completions.create(
  {
    model: 'qwen3.8-max',
    messages: [{
      role: 'user',
      content: [
        { type: 'text', text: '这张图片里有什么？' },
        { type: 'image_url', image_url: { url: IMAGE_URL } },
      ],
    }],
    max_tokens: 1024,
    enable_thinking: false, // 厂商扩展参数直接写在请求对象中
  },
  { headers: { 'Idempotency-Key': randomUUID() } },
);
console.log(completion.choices[0].message.content);

curl https://api.tokentosea.com/v1/chat/completions \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "model": "glm-5.3",
    "messages": [{"role": "user", "content": "上海今天天气怎么样？"}],
    "max_tokens": 1024,
    "tools": [{
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "查询城市的实时天气",
        "parameters": {
          "type": "object",
          "properties": {"city": {"type": "string", "description": "城市名"}},
          "required": ["city"]
        }
      }
    }]
  }'

import json
import os
import uuid

from openai import OpenAI

client = OpenAI(
    api_key=os.environ["TOKENTOSEA_API_KEY"],
    base_url="https://api.tokentosea.com/v1",
    max_retries=0,
)
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "查询城市的实时天气",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string", "description": "城市名"}},
            "required": ["city"],
        },
    },
}]
messages = [{"role": "user", "content": "上海今天天气怎么样？"}]

first = client.chat.completions.create(
    model="glm-5.3", messages=messages, tools=tools, max_tokens=1024,
    extra_headers={"Idempotency-Key": str(uuid.uuid4())},
)
message = first.choices[0].message
if message.tool_calls:
    messages.append(message.model_dump(exclude_none=True))
    for call in message.tool_calls:
        args = json.loads(call.function.arguments)
        result = {"city": args["city"], "weather": "晴", "temperature_c": 22}  # 调用你自己的服务
        messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result, ensure_ascii=False)})
    final = client.chat.completions.create(
        model="glm-5.3", messages=messages, tools=tools, max_tokens=1024,
        extra_headers={"Idempotency-Key": str(uuid.uuid4())},  # 新的一轮使用新键
    )
    print(final.choices[0].message.content)

import OpenAI from 'openai';
import { randomUUID } from 'node:crypto';

const client = new OpenAI({
  apiKey: process.env.TOKENTOSEA_API_KEY,
  baseURL: 'https://api.tokentosea.com/v1',
  maxRetries: 0,
});
const tools = [{
  type: 'function',
  function: {
    name: 'get_weather',
    description: '查询城市的实时天气',
    parameters: {
      type: 'object',
      properties: { city: { type: 'string', description: '城市名' } },
      required: ['city'],
    },
  },
}];
const messages = [{ role: 'user', content: '上海今天天气怎么样？' }];

const first = await client.chat.completions.create(
  { model: 'glm-5.3', messages, tools, max_tokens: 1024 },
  { headers: { 'Idempotency-Key': randomUUID() } },
);
const message = first.choices[0].message;
if (message.tool_calls?.length) {
  messages.push(message);
  for (const call of message.tool_calls) {
    const args = JSON.parse(call.function.arguments);
    const result = { city: args.city, weather: '晴', temperature_c: 22 }; // 调用你自己的服务
    messages.push({ role: 'tool', tool_call_id: call.id, content: JSON.stringify(result) });
  }
  const final = await client.chat.completions.create(
    { model: 'glm-5.3', messages, tools, max_tokens: 1024 },
    { headers: { 'Idempotency-Key': randomUUID() } }, // 新的一轮使用新键
  );
  console.log(final.choices[0].message.content);
}

curl "https://api.tokentosea.com/v1/results/$REQUEST_KEY" \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY"

import os
import time

import requests

def wait_for_result(request_key: str, timeout_s: int = 300) -> dict:
    url = "https://api.tokentosea.com/v1/results/" + request_key
    headers = {"Authorization": "Bearer " + os.environ["TOKENTOSEA_API_KEY"]}
    deadline = time.time() + timeout_s
    while time.time() < deadline:
        response = requests.get(url, headers=headers, timeout=30)
        if response.status_code == 404:
            raise LookupError("该键没有已受理的调用，可用同一个键与请求体重发")
        response.raise_for_status()
        result = response.json()
        if result["status"] in ("succeeded", "failed"):
            return result
        time.sleep(5)
    raise TimeoutError("结果仍在处理，稍后用同一个键继续查询")

async function waitForResult(requestKey, timeoutMs = 300_000) {
  const url = `https://api.tokentosea.com/v1/results/${requestKey}`;
  const headers = { Authorization: `Bearer ${process.env.TOKENTOSEA_API_KEY}` };
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const response = await fetch(url, { headers });
    if (response.status === 404) throw new Error('该键没有已受理的调用，可用同一个键与请求体重发');
    if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
    const result = await response.json();
    if (['succeeded', 'failed'].includes(result.status)) return result;
    await new Promise((resolve) => setTimeout(resolve, 5000));
  }
  throw new Error('结果仍在处理，稍后用同一个键继续查询');
}