Qwen3-Coder-Flash

export TOKENTOSEA_API_KEY="你的主站通用 API Key"
REQUEST_KEY="$(uuidgen)"
curl https://api.tokentosea.com/v1/chat/completions \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY" \
  -H "Idempotency-Key: $REQUEST_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "qwen3-coder-flash",
  "messages": [
    {
      "role": "user",
      "content": "请简短介绍一下你能帮助我完成什么。"
    }
  ],
  "max_tokens": 1024,
  "enable_thinking": false
}'

# 查询原请求；异步任务未结束时稍后继续查询，不要重复提交。
curl "https://api.tokentosea.com/v1/results/$REQUEST_KEY" \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY"

# 返回 asset_id 后，获取短期有效的 COS 下载链接。
# curl "https://api.tokentosea.com/v1/assets/ASSET_ID/download-url" \
#   -H "Authorization: Bearer $TOKENTOSEA_API_KEY"

# pip install requests
# export TOKENTOSEA_API_KEY="你的主站通用 API Key"
import json
import os
import time
import uuid

import requests

API_BASE = "https://api.tokentosea.com"
API_KEY = os.environ["TOKENTOSEA_API_KEY"]  # 控制台「我的 Key」创建的通用 API Key
REQUEST_KEY = str(uuid.uuid4())  # Idempotency-Key：重试或查询结果时复用同一个值
AUTH = {"Authorization": f"Bearer {API_KEY}"}
PENDING = {"planned", "sending", "streaming", "upstream_pending", "billing", "archiving"}

payload = {
    "model": "qwen3-coder-flash",
    "messages": [{"role": "user", "content": "请简短介绍一下你能帮助我完成什么。"}],
    "max_tokens": 1024,
    "enable_thinking": False,
}


def show(data):
    print(json.dumps(data, ensure_ascii=False, indent=2))


def wait_for_result():
    """查询原请求；异步任务未结束时稍后继续查询，不要重复提交。"""
    while True:
        result = requests.get(f"{API_BASE}/v1/results/{REQUEST_KEY}", headers=AUTH, timeout=30).json()
        if result.get("status") not in PENDING:
            return result
        time.sleep(5)


try:
    response = requests.post(
        f"{API_BASE}/v1/chat/completions",
        headers={**AUTH, "Idempotency-Key": REQUEST_KEY},
        json=payload,
        timeout=1300,
    )
    print(response.status_code, response.headers.get("X-Request-Id"))
    show(response.json())
except requests.RequestException as error:
    # 连接中断时请求可能已被受理：用同一个 REQUEST_KEY 查询结果，不要重新提交。
    print("\n请求中断：", error)

result = wait_for_result()
print("结果：", result.get("status"), "结算：", result.get("billing_status"), result.get("error") or "")

// Node.js 18+，无需额外依赖。保存为 example.mjs 后运行：node example.mjs
// export TOKENTOSEA_API_KEY="你的主站通用 API Key"
import { randomUUID } from 'node:crypto';

const API_BASE = 'https://api.tokentosea.com';
const API_KEY = process.env.TOKENTOSEA_API_KEY; // 控制台「我的 Key」创建的通用 API Key
const REQUEST_KEY = randomUUID(); // Idempotency-Key：重试或查询结果时复用同一个值
const auth = { Authorization: `Bearer ${API_KEY}` };
const PENDING = new Set(['planned', 'sending', 'streaming', 'upstream_pending', 'billing', 'archiving']);

const payload = {
  model: 'qwen3-coder-flash',
  messages: [{ role: 'user', content: '请简短介绍一下你能帮助我完成什么。' }],
  max_tokens: 1024,
  enable_thinking: false,
};

const show = data => console.log(JSON.stringify(data, null, 2));

// 查询原请求；异步任务未结束时稍后继续查询，不要重复提交。
async function waitForResult() {
  for (;;) {
    const result = await fetch(`${API_BASE}/v1/results/${REQUEST_KEY}`, { headers: auth }).then(r => r.json());
    if (!PENDING.has(result.status)) return result;
    await new Promise(resolve => setTimeout(resolve, 5000));
  }
}

try {
  const response = await fetch(`${API_BASE}/v1/chat/completions`, {
    method: 'POST',
    headers: { ...auth, 'Idempotency-Key': REQUEST_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify(payload),
  });
  console.log(response.status, response.headers.get('x-request-id'));
  show(await response.json());
} catch (error) {
  // 连接中断时请求可能已被受理：用同一个 REQUEST_KEY 查询结果，不要重新提交。
  console.error('\n请求中断：', error.message);
}

const result = await waitForResult();
console.log('结果：', result.status, '结算：', result.billing_status, result.error ?? '');

export TOKENTOSEA_API_KEY="你的主站通用 API Key"
REQUEST_KEY="$(uuidgen)"
curl https://api.tokentosea.com/v1/chat/completions \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY" \
  -H "Idempotency-Key: $REQUEST_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "qwen3-coder-flash",
  "messages": [
    {
      "role": "user",
      "content": "请简短介绍一下你能帮助我完成什么。"
    }
  ],
  "max_tokens": 1024,
  "enable_thinking": false
}'

# 查询原请求；异步任务未结束时稍后继续查询，不要重复提交。
curl "https://api.tokentosea.com/v1/results/$REQUEST_KEY" \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY"

# 返回 asset_id 后，获取短期有效的 COS 下载链接。
# curl "https://api.tokentosea.com/v1/assets/ASSET_ID/download-url" \
#   -H "Authorization: Bearer $TOKENTOSEA_API_KEY"

# pip install requests
# export TOKENTOSEA_API_KEY="你的主站通用 API Key"
import json
import os
import time
import uuid

import requests

API_BASE = "https://api.tokentosea.com"
API_KEY = os.environ["TOKENTOSEA_API_KEY"]  # 控制台「我的 Key」创建的通用 API Key
REQUEST_KEY = str(uuid.uuid4())  # Idempotency-Key：重试或查询结果时复用同一个值
AUTH = {"Authorization": f"Bearer {API_KEY}"}
PENDING = {"planned", "sending", "streaming", "upstream_pending", "billing", "archiving"}

payload = {
    "model": "qwen3-coder-flash",
    "messages": [{"role": "user", "content": "请简短介绍一下你能帮助我完成什么。"}],
    "max_tokens": 1024,
    "enable_thinking": False,
}


def show(data):
    print(json.dumps(data, ensure_ascii=False, indent=2))


def wait_for_result():
    """查询原请求；异步任务未结束时稍后继续查询，不要重复提交。"""
    while True:
        result = requests.get(f"{API_BASE}/v1/results/{REQUEST_KEY}", headers=AUTH, timeout=30).json()
        if result.get("status") not in PENDING:
            return result
        time.sleep(5)


try:
    response = requests.post(
        f"{API_BASE}/v1/chat/completions",
        headers={**AUTH, "Idempotency-Key": REQUEST_KEY},
        json=payload,
        timeout=1300,
    )
    print(response.status_code, response.headers.get("X-Request-Id"))
    show(response.json())
except requests.RequestException as error:
    # 连接中断时请求可能已被受理：用同一个 REQUEST_KEY 查询结果，不要重新提交。
    print("\n请求中断：", error)

result = wait_for_result()
print("结果：", result.get("status"), "结算：", result.get("billing_status"), result.get("error") or "")

// Node.js 18+，无需额外依赖。保存为 example.mjs 后运行：node example.mjs
// export TOKENTOSEA_API_KEY="你的主站通用 API Key"
import { randomUUID } from 'node:crypto';

const API_BASE = 'https://api.tokentosea.com';
const API_KEY = process.env.TOKENTOSEA_API_KEY; // 控制台「我的 Key」创建的通用 API Key
const REQUEST_KEY = randomUUID(); // Idempotency-Key：重试或查询结果时复用同一个值
const auth = { Authorization: `Bearer ${API_KEY}` };
const PENDING = new Set(['planned', 'sending', 'streaming', 'upstream_pending', 'billing', 'archiving']);

const payload = {
  model: 'qwen3-coder-flash',
  messages: [{ role: 'user', content: '请简短介绍一下你能帮助我完成什么。' }],
  max_tokens: 1024,
  enable_thinking: false,
};

const show = data => console.log(JSON.stringify(data, null, 2));

// 查询原请求；异步任务未结束时稍后继续查询，不要重复提交。
async function waitForResult() {
  for (;;) {
    const result = await fetch(`${API_BASE}/v1/results/${REQUEST_KEY}`, { headers: auth }).then(r => r.json());
    if (!PENDING.has(result.status)) return result;
    await new Promise(resolve => setTimeout(resolve, 5000));
  }
}

try {
  const response = await fetch(`${API_BASE}/v1/chat/completions`, {
    method: 'POST',
    headers: { ...auth, 'Idempotency-Key': REQUEST_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify(payload),
  });
  console.log(response.status, response.headers.get('x-request-id'));
  show(await response.json());
} catch (error) {
  // 连接中断时请求可能已被受理：用同一个 REQUEST_KEY 查询结果，不要重新提交。
  console.error('\n请求中断：', error.message);
}

const result = await waitForResult();
console.log('结果：', result.status, '结算：', result.billing_status, result.error ?? '');

export TOKENTOSEA_API_KEY="你的主站通用 API Key"
REQUEST_KEY="$(uuidgen)"
curl -N https://api.tokentosea.com/v1/chat/completions \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY" \
  -H "Idempotency-Key: $REQUEST_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "qwen3-coder-flash",
  "messages": [
    {
      "role": "user",
      "content": "请简短介绍一下你能帮助我完成什么。"
    }
  ],
  "max_tokens": 1024,
  "enable_thinking": false,
  "stream": true
}'

# 查询原请求；异步任务未结束时稍后继续查询，不要重复提交。
curl "https://api.tokentosea.com/v1/results/$REQUEST_KEY" \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY"

# 返回 asset_id 后，获取短期有效的 COS 下载链接。
# curl "https://api.tokentosea.com/v1/assets/ASSET_ID/download-url" \
#   -H "Authorization: Bearer $TOKENTOSEA_API_KEY"

# pip install requests
# export TOKENTOSEA_API_KEY="你的主站通用 API Key"
import json
import os
import time
import uuid

import requests

API_BASE = "https://api.tokentosea.com"
API_KEY = os.environ["TOKENTOSEA_API_KEY"]  # 控制台「我的 Key」创建的通用 API Key
REQUEST_KEY = str(uuid.uuid4())  # Idempotency-Key：重试或查询结果时复用同一个值
AUTH = {"Authorization": f"Bearer {API_KEY}"}
PENDING = {"planned", "sending", "streaming", "upstream_pending", "billing", "archiving"}

payload = {
    "model": "qwen3-coder-flash",
    "messages": [{"role": "user", "content": "请简短介绍一下你能帮助我完成什么。"}],
    "max_tokens": 1024,
    "enable_thinking": False,
    "stream": True,
}


def show(data):
    print(json.dumps(data, ensure_ascii=False, indent=2))


def wait_for_result():
    """查询原请求；异步任务未结束时稍后继续查询，不要重复提交。"""
    while True:
        result = requests.get(f"{API_BASE}/v1/results/{REQUEST_KEY}", headers=AUTH, timeout=30).json()
        if result.get("status") not in PENDING:
            return result
        time.sleep(5)


def events(response):
    """逐行读取 SSE，返回每个 data 帧解析后的 JSON。"""
    for raw in response.iter_lines():
        line = raw.decode("utf-8")
        if line.startswith("data:") and line[5:].strip() not in ("", "[DONE]"):
            yield json.loads(line[5:])


try:
    with requests.post(
        f"{API_BASE}/v1/chat/completions",
        headers={**AUTH, "Idempotency-Key": REQUEST_KEY},
        json=payload,
        stream=True,
        timeout=1300,
    ) as response:
        print(response.status_code, response.headers.get("X-Request-Id"))
        if not response.headers.get("Content-Type", "").startswith("text/event-stream"):
            show(response.json())  # 错误信息或异步受理信封
        else:
            for event in events(response):
                # 思考模型的推理过程在 delta.reasoning_content 中
                for choice in event.get("choices") or []:
                    print((choice.get("delta") or {}).get("content") or "", end="", flush=True)
                if event.get("usage"):
                    print("\nusage:", event["usage"])
                if event.get("error"):
                    print("\n错误：", event["error"])
except requests.RequestException as error:
    # 连接中断时请求可能已被受理：用同一个 REQUEST_KEY 查询结果，不要重新提交。
    print("\n请求中断：", error)

result = wait_for_result()
print("结果：", result.get("status"), "结算：", result.get("billing_status"), result.get("error") or "")

// Node.js 18+，无需额外依赖。保存为 example.mjs 后运行：node example.mjs
// export TOKENTOSEA_API_KEY="你的主站通用 API Key"
import { randomUUID } from 'node:crypto';

const API_BASE = 'https://api.tokentosea.com';
const API_KEY = process.env.TOKENTOSEA_API_KEY; // 控制台「我的 Key」创建的通用 API Key
const REQUEST_KEY = randomUUID(); // Idempotency-Key：重试或查询结果时复用同一个值
const auth = { Authorization: `Bearer ${API_KEY}` };
const PENDING = new Set(['planned', 'sending', 'streaming', 'upstream_pending', 'billing', 'archiving']);

const payload = {
  model: 'qwen3-coder-flash',
  messages: [{ role: 'user', content: '请简短介绍一下你能帮助我完成什么。' }],
  max_tokens: 1024,
  enable_thinking: false,
  stream: true,
};

const show = data => console.log(JSON.stringify(data, null, 2));

// 查询原请求；异步任务未结束时稍后继续查询，不要重复提交。
async function waitForResult() {
  for (;;) {
    const result = await fetch(`${API_BASE}/v1/results/${REQUEST_KEY}`, { headers: auth }).then(r => r.json());
    if (!PENDING.has(result.status)) return result;
    await new Promise(resolve => setTimeout(resolve, 5000));
  }
}

// 逐行读取 SSE，返回每个 data 帧解析后的 JSON。
async function* events(response) {
  const decoder = new TextDecoder();
  let buffer = '';
  for await (const chunk of response.body) {
    buffer += decoder.decode(chunk, { stream: true });
    const lines = buffer.split('\n');
    buffer = lines.pop();
    for (const line of lines) {
      const data = line.startsWith('data:') ? line.slice(5).trim() : '';
      if (data && data !== '[DONE]') yield JSON.parse(data);
    }
  }
}

try {
  const response = await fetch(`${API_BASE}/v1/chat/completions`, {
    method: 'POST',
    headers: { ...auth, 'Idempotency-Key': REQUEST_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify(payload),
  });
  console.log(response.status, response.headers.get('x-request-id'));
  if (!(response.headers.get('content-type') ?? '').startsWith('text/event-stream')) {
    show(await response.json()); // 错误信息或异步受理信封
  } else {
    for await (const event of events(response)) {
      // 思考模型的推理过程在 delta.reasoning_content 中
      for (const choice of event.choices ?? []) process.stdout.write(choice.delta?.content ?? '');
      if (event.usage) console.log('\nusage:', event.usage);
      if (event.error) console.error('\n错误：', event.error);
    }
  }
} catch (error) {
  // 连接中断时请求可能已被受理：用同一个 REQUEST_KEY 查询结果，不要重新提交。
  console.error('\n请求中断：', error.message);
}

const result = await waitForResult();
console.log('结果：', result.status, '结算：', result.billing_status, result.error ?? '');

export TOKENTOSEA_API_KEY="你的主站通用 API Key"
REQUEST_KEY="$(uuidgen)"
curl https://api.tokentosea.com/v1/messages \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY" \
  -H "Idempotency-Key: $REQUEST_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "qwen3-coder-flash",
  "messages": [
    {
      "role": "user",
      "content": "请简短介绍一下你能帮助我完成什么。"
    }
  ],
  "max_tokens": 1024
}'

# 查询原请求；异步任务未结束时稍后继续查询，不要重复提交。
curl "https://api.tokentosea.com/v1/results/$REQUEST_KEY" \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY"

# 返回 asset_id 后，获取短期有效的 COS 下载链接。
# curl "https://api.tokentosea.com/v1/assets/ASSET_ID/download-url" \
#   -H "Authorization: Bearer $TOKENTOSEA_API_KEY"

# pip install requests
# export TOKENTOSEA_API_KEY="你的主站通用 API Key"
import json
import os
import time
import uuid

import requests

API_BASE = "https://api.tokentosea.com"
API_KEY = os.environ["TOKENTOSEA_API_KEY"]  # 控制台「我的 Key」创建的通用 API Key
REQUEST_KEY = str(uuid.uuid4())  # Idempotency-Key：重试或查询结果时复用同一个值
AUTH = {"Authorization": f"Bearer {API_KEY}"}
PENDING = {"planned", "sending", "streaming", "upstream_pending", "billing", "archiving"}

payload = {
    "model": "qwen3-coder-flash",
    "messages": [{"role": "user", "content": "请简短介绍一下你能帮助我完成什么。"}],
    "max_tokens": 1024,
}


def show(data):
    print(json.dumps(data, ensure_ascii=False, indent=2))


def wait_for_result():
    """查询原请求；异步任务未结束时稍后继续查询，不要重复提交。"""
    while True:
        result = requests.get(f"{API_BASE}/v1/results/{REQUEST_KEY}", headers=AUTH, timeout=30).json()
        if result.get("status") not in PENDING:
            return result
        time.sleep(5)


try:
    response = requests.post(
        f"{API_BASE}/v1/messages",
        headers={**AUTH, "Idempotency-Key": REQUEST_KEY},
        json=payload,
        timeout=1300,
    )
    print(response.status_code, response.headers.get("X-Request-Id"))
    show(response.json())
except requests.RequestException as error:
    # 连接中断时请求可能已被受理：用同一个 REQUEST_KEY 查询结果，不要重新提交。
    print("\n请求中断：", error)

result = wait_for_result()
print("结果：", result.get("status"), "结算：", result.get("billing_status"), result.get("error") or "")

// Node.js 18+，无需额外依赖。保存为 example.mjs 后运行：node example.mjs
// export TOKENTOSEA_API_KEY="你的主站通用 API Key"
import { randomUUID } from 'node:crypto';

const API_BASE = 'https://api.tokentosea.com';
const API_KEY = process.env.TOKENTOSEA_API_KEY; // 控制台「我的 Key」创建的通用 API Key
const REQUEST_KEY = randomUUID(); // Idempotency-Key：重试或查询结果时复用同一个值
const auth = { Authorization: `Bearer ${API_KEY}` };
const PENDING = new Set(['planned', 'sending', 'streaming', 'upstream_pending', 'billing', 'archiving']);

const payload = {
  model: 'qwen3-coder-flash',
  messages: [{ role: 'user', content: '请简短介绍一下你能帮助我完成什么。' }],
  max_tokens: 1024,
};

const show = data => console.log(JSON.stringify(data, null, 2));

// 查询原请求；异步任务未结束时稍后继续查询，不要重复提交。
async function waitForResult() {
  for (;;) {
    const result = await fetch(`${API_BASE}/v1/results/${REQUEST_KEY}`, { headers: auth }).then(r => r.json());
    if (!PENDING.has(result.status)) return result;
    await new Promise(resolve => setTimeout(resolve, 5000));
  }
}

try {
  const response = await fetch(`${API_BASE}/v1/messages`, {
    method: 'POST',
    headers: { ...auth, 'Idempotency-Key': REQUEST_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify(payload),
  });
  console.log(response.status, response.headers.get('x-request-id'));
  show(await response.json());
} catch (error) {
  // 连接中断时请求可能已被受理：用同一个 REQUEST_KEY 查询结果，不要重新提交。
  console.error('\n请求中断：', error.message);
}

const result = await waitForResult();
console.log('结果：', result.status, '结算：', result.billing_status, result.error ?? '');

export TOKENTOSEA_API_KEY="你的主站通用 API Key"
REQUEST_KEY="$(uuidgen)"
curl -N https://api.tokentosea.com/v1/messages \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY" \
  -H "Idempotency-Key: $REQUEST_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "qwen3-coder-flash",
  "messages": [
    {
      "role": "user",
      "content": "请简短介绍一下你能帮助我完成什么。"
    }
  ],
  "max_tokens": 1024,
  "stream": true
}'

# 查询原请求；异步任务未结束时稍后继续查询，不要重复提交。
curl "https://api.tokentosea.com/v1/results/$REQUEST_KEY" \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY"

# 返回 asset_id 后，获取短期有效的 COS 下载链接。
# curl "https://api.tokentosea.com/v1/assets/ASSET_ID/download-url" \
#   -H "Authorization: Bearer $TOKENTOSEA_API_KEY"

# pip install requests
# export TOKENTOSEA_API_KEY="你的主站通用 API Key"
import json
import os
import time
import uuid

import requests

API_BASE = "https://api.tokentosea.com"
API_KEY = os.environ["TOKENTOSEA_API_KEY"]  # 控制台「我的 Key」创建的通用 API Key
REQUEST_KEY = str(uuid.uuid4())  # Idempotency-Key：重试或查询结果时复用同一个值
AUTH = {"Authorization": f"Bearer {API_KEY}"}
PENDING = {"planned", "sending", "streaming", "upstream_pending", "billing", "archiving"}

payload = {
    "model": "qwen3-coder-flash",
    "messages": [{"role": "user", "content": "请简短介绍一下你能帮助我完成什么。"}],
    "max_tokens": 1024,
    "stream": True,
}


def show(data):
    print(json.dumps(data, ensure_ascii=False, indent=2))


def wait_for_result():
    """查询原请求；异步任务未结束时稍后继续查询，不要重复提交。"""
    while True:
        result = requests.get(f"{API_BASE}/v1/results/{REQUEST_KEY}", headers=AUTH, timeout=30).json()
        if result.get("status") not in PENDING:
            return result
        time.sleep(5)


def events(response):
    """逐行读取 SSE，返回每个 data 帧解析后的 JSON。"""
    for raw in response.iter_lines():
        line = raw.decode("utf-8")
        if line.startswith("data:") and line[5:].strip() not in ("", "[DONE]"):
            yield json.loads(line[5:])


try:
    with requests.post(
        f"{API_BASE}/v1/messages",
        headers={**AUTH, "Idempotency-Key": REQUEST_KEY},
        json=payload,
        stream=True,
        timeout=1300,
    ) as response:
        print(response.status_code, response.headers.get("X-Request-Id"))
        if not response.headers.get("Content-Type", "").startswith("text/event-stream"):
            show(response.json())  # 错误信息或异步受理信封
        else:
            for event in events(response):
                if event.get("type") == "content_block_delta":
                    print(event["delta"].get("text", ""), end="", flush=True)
                elif event.get("type") == "message_delta":
                    print("\nusage:", event.get("usage"))
                elif event.get("error"):
                    print("\n错误：", event["error"])
except requests.RequestException as error:
    # 连接中断时请求可能已被受理：用同一个 REQUEST_KEY 查询结果，不要重新提交。
    print("\n请求中断：", error)

result = wait_for_result()
print("结果：", result.get("status"), "结算：", result.get("billing_status"), result.get("error") or "")

// Node.js 18+，无需额外依赖。保存为 example.mjs 后运行：node example.mjs
// export TOKENTOSEA_API_KEY="你的主站通用 API Key"
import { randomUUID } from 'node:crypto';

const API_BASE = 'https://api.tokentosea.com';
const API_KEY = process.env.TOKENTOSEA_API_KEY; // 控制台「我的 Key」创建的通用 API Key
const REQUEST_KEY = randomUUID(); // Idempotency-Key：重试或查询结果时复用同一个值
const auth = { Authorization: `Bearer ${API_KEY}` };
const PENDING = new Set(['planned', 'sending', 'streaming', 'upstream_pending', 'billing', 'archiving']);

const payload = {
  model: 'qwen3-coder-flash',
  messages: [{ role: 'user', content: '请简短介绍一下你能帮助我完成什么。' }],
  max_tokens: 1024,
  stream: true,
};

const show = data => console.log(JSON.stringify(data, null, 2));

// 查询原请求；异步任务未结束时稍后继续查询，不要重复提交。
async function waitForResult() {
  for (;;) {
    const result = await fetch(`${API_BASE}/v1/results/${REQUEST_KEY}`, { headers: auth }).then(r => r.json());
    if (!PENDING.has(result.status)) return result;
    await new Promise(resolve => setTimeout(resolve, 5000));
  }
}

// 逐行读取 SSE，返回每个 data 帧解析后的 JSON。
async function* events(response) {
  const decoder = new TextDecoder();
  let buffer = '';
  for await (const chunk of response.body) {
    buffer += decoder.decode(chunk, { stream: true });
    const lines = buffer.split('\n');
    buffer = lines.pop();
    for (const line of lines) {
      const data = line.startsWith('data:') ? line.slice(5).trim() : '';
      if (data && data !== '[DONE]') yield JSON.parse(data);
    }
  }
}

try {
  const response = await fetch(`${API_BASE}/v1/messages`, {
    method: 'POST',
    headers: { ...auth, 'Idempotency-Key': REQUEST_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify(payload),
  });
  console.log(response.status, response.headers.get('x-request-id'));
  if (!(response.headers.get('content-type') ?? '').startsWith('text/event-stream')) {
    show(await response.json()); // 错误信息或异步受理信封
  } else {
    for await (const event of events(response)) {
      if (event.type === 'content_block_delta') process.stdout.write(event.delta?.text ?? '');
      else if (event.type === 'message_delta') console.log('\nusage:', event.usage);
      else if (event.error) console.error('\n错误：', event.error);
    }
  }
} catch (error) {
  // 连接中断时请求可能已被受理：用同一个 REQUEST_KEY 查询结果，不要重新提交。
  console.error('\n请求中断：', error.message);
}

const result = await waitForResult();
console.log('结果：', result.status, '结算：', result.billing_status, result.error ?? '');

export TOKENTOSEA_API_KEY="你的主站通用 API Key"
REQUEST_KEY="$(uuidgen)"
curl https://api.tokentosea.com/v1/responses \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY" \
  -H "Idempotency-Key: $REQUEST_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "qwen3-coder-flash",
  "input": [
    {
      "role": "user",
      "content": "请简短介绍一下你能帮助我完成什么。"
    }
  ],
  "max_output_tokens": 1024,
  "store": false
}'

# 查询原请求；异步任务未结束时稍后继续查询，不要重复提交。
curl "https://api.tokentosea.com/v1/results/$REQUEST_KEY" \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY"

# 返回 asset_id 后，获取短期有效的 COS 下载链接。
# curl "https://api.tokentosea.com/v1/assets/ASSET_ID/download-url" \
#   -H "Authorization: Bearer $TOKENTOSEA_API_KEY"

# pip install requests
# export TOKENTOSEA_API_KEY="你的主站通用 API Key"
import json
import os
import time
import uuid

import requests

API_BASE = "https://api.tokentosea.com"
API_KEY = os.environ["TOKENTOSEA_API_KEY"]  # 控制台「我的 Key」创建的通用 API Key
REQUEST_KEY = str(uuid.uuid4())  # Idempotency-Key：重试或查询结果时复用同一个值
AUTH = {"Authorization": f"Bearer {API_KEY}"}
PENDING = {"planned", "sending", "streaming", "upstream_pending", "billing", "archiving"}

payload = {
    "model": "qwen3-coder-flash",
    "input": [{"role": "user", "content": "请简短介绍一下你能帮助我完成什么。"}],
    "max_output_tokens": 1024,
    "store": False,
}


def show(data):
    print(json.dumps(data, ensure_ascii=False, indent=2))


def wait_for_result():
    """查询原请求；异步任务未结束时稍后继续查询，不要重复提交。"""
    while True:
        result = requests.get(f"{API_BASE}/v1/results/{REQUEST_KEY}", headers=AUTH, timeout=30).json()
        if result.get("status") not in PENDING:
            return result
        time.sleep(5)


try:
    response = requests.post(
        f"{API_BASE}/v1/responses",
        headers={**AUTH, "Idempotency-Key": REQUEST_KEY},
        json=payload,
        timeout=1300,
    )
    print(response.status_code, response.headers.get("X-Request-Id"))
    show(response.json())
except requests.RequestException as error:
    # 连接中断时请求可能已被受理：用同一个 REQUEST_KEY 查询结果，不要重新提交。
    print("\n请求中断：", error)

result = wait_for_result()
print("结果：", result.get("status"), "结算：", result.get("billing_status"), result.get("error") or "")

// Node.js 18+，无需额外依赖。保存为 example.mjs 后运行：node example.mjs
// export TOKENTOSEA_API_KEY="你的主站通用 API Key"
import { randomUUID } from 'node:crypto';

const API_BASE = 'https://api.tokentosea.com';
const API_KEY = process.env.TOKENTOSEA_API_KEY; // 控制台「我的 Key」创建的通用 API Key
const REQUEST_KEY = randomUUID(); // Idempotency-Key：重试或查询结果时复用同一个值
const auth = { Authorization: `Bearer ${API_KEY}` };
const PENDING = new Set(['planned', 'sending', 'streaming', 'upstream_pending', 'billing', 'archiving']);

const payload = {
  model: 'qwen3-coder-flash',
  input: [{ role: 'user', content: '请简短介绍一下你能帮助我完成什么。' }],
  max_output_tokens: 1024,
  store: false,
};

const show = data => console.log(JSON.stringify(data, null, 2));

// 查询原请求；异步任务未结束时稍后继续查询，不要重复提交。
async function waitForResult() {
  for (;;) {
    const result = await fetch(`${API_BASE}/v1/results/${REQUEST_KEY}`, { headers: auth }).then(r => r.json());
    if (!PENDING.has(result.status)) return result;
    await new Promise(resolve => setTimeout(resolve, 5000));
  }
}

try {
  const response = await fetch(`${API_BASE}/v1/responses`, {
    method: 'POST',
    headers: { ...auth, 'Idempotency-Key': REQUEST_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify(payload),
  });
  console.log(response.status, response.headers.get('x-request-id'));
  show(await response.json());
} catch (error) {
  // 连接中断时请求可能已被受理：用同一个 REQUEST_KEY 查询结果，不要重新提交。
  console.error('\n请求中断：', error.message);
}

const result = await waitForResult();
console.log('结果：', result.status, '结算：', result.billing_status, result.error ?? '');

export TOKENTOSEA_API_KEY="你的主站通用 API Key"
REQUEST_KEY="$(uuidgen)"
curl -N https://api.tokentosea.com/v1/responses \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY" \
  -H "Idempotency-Key: $REQUEST_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "qwen3-coder-flash",
  "input": [
    {
      "role": "user",
      "content": "请简短介绍一下你能帮助我完成什么。"
    }
  ],
  "max_output_tokens": 1024,
  "store": false,
  "stream": true
}'

# 查询原请求；异步任务未结束时稍后继续查询，不要重复提交。
curl "https://api.tokentosea.com/v1/results/$REQUEST_KEY" \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY"

# 返回 asset_id 后，获取短期有效的 COS 下载链接。
# curl "https://api.tokentosea.com/v1/assets/ASSET_ID/download-url" \
#   -H "Authorization: Bearer $TOKENTOSEA_API_KEY"

# pip install requests
# export TOKENTOSEA_API_KEY="你的主站通用 API Key"
import json
import os
import time
import uuid

import requests

API_BASE = "https://api.tokentosea.com"
API_KEY = os.environ["TOKENTOSEA_API_KEY"]  # 控制台「我的 Key」创建的通用 API Key
REQUEST_KEY = str(uuid.uuid4())  # Idempotency-Key：重试或查询结果时复用同一个值
AUTH = {"Authorization": f"Bearer {API_KEY}"}
PENDING = {"planned", "sending", "streaming", "upstream_pending", "billing", "archiving"}

payload = {
    "model": "qwen3-coder-flash",
    "input": [{"role": "user", "content": "请简短介绍一下你能帮助我完成什么。"}],
    "max_output_tokens": 1024,
    "store": False,
    "stream": True,
}


def show(data):
    print(json.dumps(data, ensure_ascii=False, indent=2))


def wait_for_result():
    """查询原请求；异步任务未结束时稍后继续查询，不要重复提交。"""
    while True:
        result = requests.get(f"{API_BASE}/v1/results/{REQUEST_KEY}", headers=AUTH, timeout=30).json()
        if result.get("status") not in PENDING:
            return result
        time.sleep(5)


def events(response):
    """逐行读取 SSE，返回每个 data 帧解析后的 JSON。"""
    for raw in response.iter_lines():
        line = raw.decode("utf-8")
        if line.startswith("data:") and line[5:].strip() not in ("", "[DONE]"):
            yield json.loads(line[5:])


try:
    with requests.post(
        f"{API_BASE}/v1/responses",
        headers={**AUTH, "Idempotency-Key": REQUEST_KEY},
        json=payload,
        stream=True,
        timeout=1300,
    ) as response:
        print(response.status_code, response.headers.get("X-Request-Id"))
        if not response.headers.get("Content-Type", "").startswith("text/event-stream"):
            show(response.json())  # 错误信息或异步受理信封
        else:
            for event in events(response):
                if event.get("type") == "response.output_text.delta":
                    print(event.get("delta", ""), end="", flush=True)
                elif event.get("type") == "response.completed":
                    print("\nusage:", event["response"].get("usage"))
                elif event.get("error"):
                    print("\n错误：", event["error"])
except requests.RequestException as error:
    # 连接中断时请求可能已被受理：用同一个 REQUEST_KEY 查询结果，不要重新提交。
    print("\n请求中断：", error)

result = wait_for_result()
print("结果：", result.get("status"), "结算：", result.get("billing_status"), result.get("error") or "")

// Node.js 18+，无需额外依赖。保存为 example.mjs 后运行：node example.mjs
// export TOKENTOSEA_API_KEY="你的主站通用 API Key"
import { randomUUID } from 'node:crypto';

const API_BASE = 'https://api.tokentosea.com';
const API_KEY = process.env.TOKENTOSEA_API_KEY; // 控制台「我的 Key」创建的通用 API Key
const REQUEST_KEY = randomUUID(); // Idempotency-Key：重试或查询结果时复用同一个值
const auth = { Authorization: `Bearer ${API_KEY}` };
const PENDING = new Set(['planned', 'sending', 'streaming', 'upstream_pending', 'billing', 'archiving']);

const payload = {
  model: 'qwen3-coder-flash',
  input: [{ role: 'user', content: '请简短介绍一下你能帮助我完成什么。' }],
  max_output_tokens: 1024,
  store: false,
  stream: true,
};

const show = data => console.log(JSON.stringify(data, null, 2));

// 查询原请求；异步任务未结束时稍后继续查询，不要重复提交。
async function waitForResult() {
  for (;;) {
    const result = await fetch(`${API_BASE}/v1/results/${REQUEST_KEY}`, { headers: auth }).then(r => r.json());
    if (!PENDING.has(result.status)) return result;
    await new Promise(resolve => setTimeout(resolve, 5000));
  }
}

// 逐行读取 SSE，返回每个 data 帧解析后的 JSON。
async function* events(response) {
  const decoder = new TextDecoder();
  let buffer = '';
  for await (const chunk of response.body) {
    buffer += decoder.decode(chunk, { stream: true });
    const lines = buffer.split('\n');
    buffer = lines.pop();
    for (const line of lines) {
      const data = line.startsWith('data:') ? line.slice(5).trim() : '';
      if (data && data !== '[DONE]') yield JSON.parse(data);
    }
  }
}

try {
  const response = await fetch(`${API_BASE}/v1/responses`, {
    method: 'POST',
    headers: { ...auth, 'Idempotency-Key': REQUEST_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify(payload),
  });
  console.log(response.status, response.headers.get('x-request-id'));
  if (!(response.headers.get('content-type') ?? '').startsWith('text/event-stream')) {
    show(await response.json()); // 错误信息或异步受理信封
  } else {
    for await (const event of events(response)) {
      if (event.type === 'response.output_text.delta') process.stdout.write(event.delta ?? '');
      else if (event.type === 'response.completed') console.log('\nusage:', event.response?.usage);
      else if (event.error) console.error('\n错误：', event.error);
    }
  }
} catch (error) {
  // 连接中断时请求可能已被受理：用同一个 REQUEST_KEY 查询结果，不要重新提交。
  console.error('\n请求中断：', error.message);
}

const result = await waitForResult();
console.log('结果：', result.status, '结算：', result.billing_status, result.error ?? '');