原生协议调用POST

curl -N https://api.tokentosea.com/v1/invoke \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "model": "qwen-deep-research",
    "input": {"messages": [{"role": "user", "content": "比较太阳能和风能发电的主要特点。"}]},
    "parameters": {},
    "stream": true
  }'

import json
import os
import uuid

import requests

response = requests.post(
    "https://api.tokentosea.com/v1/invoke",
    headers={
        "Authorization": "Bearer " + os.environ["TOKENTOSEA_API_KEY"],
        "Idempotency-Key": str(uuid.uuid4()),
    },
    json={
        "model": "qwen-deep-research",
        "input": {"messages": [{"role": "user", "content": "比较太阳能和风能发电的主要特点。"}]},
        "parameters": {},
        "stream": True,
    },
    stream=True,
    timeout=1300,
)
response.raise_for_status()
for line in response.iter_lines(decode_unicode=True):
    if not line or not line.startswith("data:"):
        continue
    event = json.loads(line[5:].strip())
    if "error" in event:  # 结算失败等：用同一个键查询 /v1/results/{key}
        raise RuntimeError(event["error"])
    print(json.dumps(event, ensure_ascii=False)[:200])

import { randomUUID } from 'node:crypto';

const response = await fetch('https://api.tokentosea.com/v1/invoke', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.TOKENTOSEA_API_KEY}`,
    'Content-Type': 'application/json',
    'Idempotency-Key': randomUUID(),
  },
  body: JSON.stringify({
    model: 'qwen-deep-research',
    input: { messages: [{ role: 'user', content: '比较太阳能和风能发电的主要特点。' }] },
    parameters: {},
    stream: true,
  }),
});
if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);

const decoder = new TextDecoder();
let buffer = '';
for await (const chunk of response.body) {
  buffer += decoder.decode(chunk, { stream: true });
  let index;
  while ((index = buffer.indexOf('\n\n')) >= 0) {
    const frame = buffer.slice(0, index);
    buffer = buffer.slice(index + 2);
    const data = frame.split('\n').filter((line) => line.startsWith('data:')).map((line) => line.slice(5).trim()).join('\n');
    if (!data) continue;
    const event = JSON.parse(data);
    if (event.error) throw new Error(JSON.stringify(event.error)); // 用同一个键查询 /v1/results/{key}
    console.log(JSON.stringify(event).slice(0, 200));
  }
}

REQUEST_KEY="$(uuidgen)"
curl https://api.tokentosea.com/v1/invoke \
  -H "Authorization: Bearer $TOKENTOSEA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $REQUEST_KEY" \
  -d '{
    "model": "speech-2.8-hd",
    "text_file_id": "file_tts_…",
    "voice_setting": {"voice_id": "male-qn-qingse"},
    "audio_setting": {"format": "mp3"}
  }'

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

import os
import time
import uuid

import requests

API = "https://api.tokentosea.com/v1"
HEADERS = {"Authorization": "Bearer " + os.environ["TOKENTOSEA_API_KEY"]}

with open("chapter.txt", "rb") as text:
    uploaded = requests.post(
        API + "/files",
        headers={**HEADERS, "Idempotency-Key": str(uuid.uuid4())},
        data={"model": "speech-2.8-hd", "purpose": "t2a_async_input"},
        files={"file": ("chapter.txt", text, "text/plain")},
        timeout=120,
    )
uploaded.raise_for_status()

request_key = str(uuid.uuid4())
submitted = requests.post(
    API + "/invoke",
    headers={**HEADERS, "Idempotency-Key": request_key},
    json={
        "model": "speech-2.8-hd",
        "text_file_id": uploaded.json()["id"],
        "voice_setting": {"voice_id": "male-qn-qingse"},
        "audio_setting": {"format": "mp3"},
    },
    timeout=120,
)
if submitted.status_code != 202:
    raise RuntimeError(f"{submitted.status_code}: {submitted.text}")

while True:
    time.sleep(10)
    result = requests.get(API + "/results/" + request_key, headers=HEADERS, timeout=30).json()
    if result["status"] in ("succeeded", "failed"):
        break
print(result["status"], result.get("output", {}).get("data"))

import { randomUUID } from 'node:crypto';
import { readFile } from 'node:fs/promises';

const API = 'https://api.tokentosea.com/v1';
const headers = { Authorization: `Bearer ${process.env.TOKENTOSEA_API_KEY}` };
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const form = new FormData();
form.set('model', 'speech-2.8-hd');
form.set('purpose', 't2a_async_input');
form.set('file', new Blob([await readFile('chapter.txt')], { type: 'text/plain' }), 'chapter.txt');
const uploaded = await fetch(`${API}/files`, { method: 'POST', headers: { ...headers, 'Idempotency-Key': randomUUID() }, body: form });
if (!uploaded.ok) throw new Error(await uploaded.text());

const requestKey = randomUUID();
const submitted = await fetch(`${API}/invoke`, {
  method: 'POST',
  headers: { ...headers, 'Content-Type': 'application/json', 'Idempotency-Key': requestKey },
  body: JSON.stringify({
    model: 'speech-2.8-hd',
    text_file_id: (await uploaded.json()).id,
    voice_setting: { voice_id: 'male-qn-qingse' },
    audio_setting: { format: 'mp3' },
  }),
});
if (submitted.status !== 202) throw new Error(`HTTP ${submitted.status}: ${await submitted.text()}`);

let result;
do {
  await sleep(10_000);
  result = await (await fetch(`${API}/results/${requestKey}`, { headers })).json();
} while (!['succeeded', 'failed'].includes(result.status));
console.log(result.status, result.output?.data);