智脑API平台接入文档

Authorization: Bearer sk-YOUR_API_KEY

curl https://api.zhinaoapi.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-YOUR_GROK_KEY" \
  -d '{
    "model": "grok-4.5",
    "messages": [
      {"role": "user", "content": "只回复：Grok 接入成功"}
    ],
    "max_tokens": 64,
    "stream": false
  }'

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["NINE_M8M_API_KEY"],
    base_url="https://api.zhinaoapi.ai/v1",
)

response = client.responses.create(
    model="grok-4.5",
    input="用三句话说明这个接口已连接成功。",
)

print(response.output_text)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.NINE_M8M_API_KEY,
  baseURL: "https://api.zhinaoapi.ai/v1",
});

const completion = await client.chat.completions.create({
  model: "grok-4.5",
  messages: [{ role: "user", content: "你好，Grok！" }],
});

console.log(completion.choices[0].message.content);

curl https://api.zhinaoapi.ai/v1/images/generations \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-YOUR_GROK_KEY" \
  -d '{
    "model": "grok-imagine-image",
    "prompt": "一座未来城市的夜景，电影级光影，干净的构图",
    "resolution": "2k",
    "aspect_ratio": "16:9",
    "n": 1
  }'

# 把 example.com/source.jpg 换成真实、可公开读取的图片地址
curl https://api.zhinaoapi.ai/v1/images/edits \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-YOUR_GROK_KEY" \
  -d '{
    "model": "grok-imagine-edit",
    "prompt": "保留主体，把背景改成雪山日出",
    "image": {"url": "https://example.com/source.jpg"}
  }'

curl https://api.zhinaoapi.ai/v1/videos/generations \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-YOUR_GROK_KEY" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "海浪拍打礁石，电影镜头，缓慢推进",
    "duration": 8,
    "resolution": "720p",
    "aspect_ratio": "16:9"
  }'

# image 是“固定第一帧”的图片，不是参考图数组
curl https://api.zhinaoapi.ai/v1/videos/generations \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-YOUR_GROK_KEY" \
  -d '{
    "model": "grok-imagine-video-1.5",
    "prompt": "保持人物外观不变，人物轻轻转头微笑，镜头缓慢推近",
    "image": {"url": "https://example.com/first-frame.jpg"},
    "duration": 8,
    "resolution": "720p",
    "aspect_ratio": "9:16"
  }'

curl https://api.zhinaoapi.ai/v1/videos/generations \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-YOUR_GROK_KEY" \
  -d '{
    "model": "grok-imagine-video-1.5",
    "prompt": "让 <IMAGE_0> 中的人物穿着相同服装，在雨后的城市街道缓慢行走；画面采用 <IMAGE_1> 的霓虹电影风格。",
    "reference_images": [
      {"url": "https://example.com/person.jpg"},
      {"url": "https://example.com/style.jpg"}
    ],
    "duration": 10,
    "resolution": "720p",
    "aspect_ratio": "16:9"
  }'

import json
import os
import time
from pathlib import Path
from urllib.request import Request, urlopen

API_ROOT = "https://api.zhinaoapi.ai"
API_BASE = API_ROOT + "/v1"
API_KEY = os.environ["NINE_M8M_API_KEY"]

def api_request(method, path, payload=None):
    data = None if payload is None else json.dumps(payload).encode("utf-8")
    request = Request(
        API_BASE + path,
        data=data,
        method=method,
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json",
        },
    )
    with urlopen(request, timeout=60) as response:
        return json.load(response)

job = api_request("POST", "/videos/generations", {
    "model": "grok-imagine-video-1.5",
    "prompt": "让 <IMAGE_0> 中的人物在阳光下缓慢转身。",
    "reference_images": [{"url": "https://example.com/person.jpg"}],
    "duration": 8,
    "resolution": "720p",
    "aspect_ratio": "9:16",
})
request_id = job["request_id"]
print("任务已创建：", request_id)

deadline = time.monotonic() + 600
while time.monotonic() < deadline:
    state = api_request("GET", f"/videos/{request_id}")
    if state.get("status") == "done":
        video_url = state["video"]["url"]
        if video_url.startswith("/"):
            video_url = API_ROOT + video_url
        download = Request(video_url, headers={"Authorization": f"Bearer {API_KEY}"})
        with urlopen(download, timeout=120) as response:
            Path("grok-video.mp4").write_bytes(response.read())
        print("已下载：grok-video.mp4")
        break
    print("仍在处理，5 秒后再次查询…")
    time.sleep(5)
else:
    raise TimeoutError("10 分钟内未完成；请保留 request_id 后稍后继续查询。")

# 查询任务；完成时状态为 done，结果地址在 video.url
curl https://api.zhinaoapi.ai/v1/videos/REQUEST_ID \
  -H "Authorization: Bearer sk-YOUR_GROK_KEY"

# 任务完成后也可通过本站内容端点下载
curl -L https://api.zhinaoapi.ai/v1/videos/REQUEST_ID/content \
  -H "Authorization: Bearer sk-YOUR_GROK_KEY" \
  -o grok-video.mp4

export SUB2_API_KEY='sk-YOUR_SEEDANCE_GROUP_KEY'

curl --fail-with-body --silent --show-error --max-time 90 \
  'https://zhinaoapi.ai/api/v3/contents/generations/tasks' \
  -H "Authorization: Bearer $SUB2_API_KEY" \
  -H 'Content-Type: application/json' \
  --data '{
    "model": "seedance2.0fast",
    "duration": 5,
    "resolution": "720p",
    "ratio": "16:9",
    "content": [
      {"type": "text", "text": "海浪轻轻拍打沙滩，固定镜头，自然光，画面平稳。"}
    ]
  }'

{
  "id": "video_0123456789abcdef0123456789abcdef",
  "status": "queued"
}

{
  "model": "seedance2.5",
  "duration": 5,
  "resolution": "720p",
  "ratio": "9:16",
  "content": [
    {"type": "text", "text": "参考图片中的人物在花园里缓慢转身，镜头平稳推进，保持人物外观一致。"},
    {"type": "image_url", "image_url": {"url": "https://YOUR_PUBLIC_IMAGE_HOST/reference.jpg"}, "role": "reference_image"}
  ]
}

export SEEDANCE_TASK_ID='创建响应里的实际 id'
curl --fail-with-body --silent --show-error \
  "https://zhinaoapi.ai/api/v3/contents/generations/tasks/$SEEDANCE_TASK_ID" \
  -H "Authorization: Bearer $SUB2_API_KEY"

{
  "id": "video_0123456789abcdef0123456789abcdef",
  "status": "succeeded",
  "duration": 5,
  "resolution": "720p",
  "ratio": "16:9",
  "content": {
    "video_url": "https://dola-pool.zhinaoapi.ai/seedance-media/video_0123456789abcdef0123456789abcdef?expires=EXPIRES&signature=SIGNATURE"
  }
}

#!/usr/bin/env bash
# Bash + curl + jq. POST is executed at most once; GET may be retried manually.
set -euo pipefail
: "${SUB2_API_KEY:?请先设置 SUB2_API_KEY 为 Seedance 分组的 API Key}"
base='https://zhinaoapi.ai/api/v3/contents/generations/tasks'

# To resume, export SEEDANCE_TASK_ID to the saved ID before running this script.
task_id="${SEEDANCE_TASK_ID:-}"
if [[ -z "$task_id" ]]; then
  if ! created=$(curl --fail-with-body --silent --show-error --connect-timeout 10 --max-time 90 \
    "$base" -H "Authorization: Bearer $SUB2_API_KEY" -H 'Content-Type: application/json' \
    --data '{"model":"seedance2.0fast","duration":5,"resolution":"720p","ratio":"16:9","content":[{"type":"text","text":"海浪轻轻拍打沙滩，固定镜头，自然光，画面平稳。"}]}'); then
    printf '%s\n' '创建失败或响应不明确。不要自动再次 POST，请保存错误并核查。' >&2
    exit 1
  fi
  task_id=$(printf '%s' "$created" | jq -er '.id | select(type == "string" and length > 0)')
fi
printf '任务 ID（请保存）：%s\n' "$task_id"

for ((attempt=0; attempt<180; attempt++)); do
  # No --retry-all-errors and no retries on the create request.
  if ! result=$(curl --fail-with-body --silent --show-error --max-time 90 \
    "$base/$task_id" -H "Authorization: Bearer $SUB2_API_KEY"); then
    printf '%s\n' '查询失败，保留 task_id 排查；不要重新创建任务。' >&2
    exit 1
  fi
  status=$(printf '%s' "$result" | jq -r '.status // "unknown"')
  printf '任务状态：%s\n' "$status"
  if [[ "$status" == 'succeeded' ]]; then
    video_url=$(printf '%s' "$result" | jq -er '.content.video_url | select(type == "string" and length > 0)')
    output="seedance-$task_id.mp4"
    if [[ -e "$output" ]]; then
      printf '输出文件已存在，请更换文件名：%s\n' "$output" >&2
      exit 1
    fi
    # Signed URL: do not send the Sub2 API key to the download host.
    curl --fail-with-body --silent --show-error --location --proto '=https' --proto-redir '=https' \
      --max-time 180 "$video_url" --output "$output"
    printf '视频已保存：%s\n' "$output"
    exit 0
  fi
  case "$status" in
    failed|cancelled|canceled|expired)
      printf '%s\n' "$result" | jq '{status,error}'
      exit 1
      ;;
  esac
  sleep 15
done
printf '%s\n' '本地等待到期；任务未必结束。用相同 API Key 和 SEEDANCE_TASK_ID 继续查询。' >&2
exit 1

export SUB2_API_KEY='sk-YOUR_SEEDANCE_GROUP_KEY'
python3 seedance-example.py --output demo.mp4

# 恢复已有任务；不要因等待超时再次创建
python3 seedance-example.py --task-id '保存的任务 id' --output resumed.mp4

# 可选：换 2.5，添加实际公开参考图
python3 seedance-example.py --model seedance2.5 --duration 5 --ratio 9:16 \
  --image-url 'https://YOUR_PUBLIC_IMAGE_HOST/reference.jpg' --output reference.mp4

#!/usr/bin/env python3
"""Python 3.9+; no third-party packages. Never automatically repeat POST."""
import argparse
import json
import os
import shutil
import time
from pathlib import Path
from urllib.error import HTTPError, URLError
from urllib.parse import quote, urlsplit
from urllib.request import Request, urlopen

ORIGIN = "https://zhinaoapi.ai"
ENDPOINT = ORIGIN + "/api/v3/contents/generations/tasks"


class APIError(RuntimeError):
    def __init__(self, status, body):
        super().__init__(f"HTTP {status}: {body[:1000]}")
        self.status = status


def api(method, url, key, body=None):
    encoded = json.dumps(body, ensure_ascii=False).encode("utf-8") if body is not None else None
    headers = {"Authorization": "Bearer " + key, "Accept": "application/json"}
    if encoded is not None:
        headers["Content-Type"] = "application/json"
    request = Request(url, data=encoded, headers=headers, method=method)
    try:
        with urlopen(request, timeout=90) as response:
            return json.load(response)
    except HTTPError as error:
        raise APIError(error.code, error.read(65536).decode("utf-8", errors="replace")) from None


def create_once(key, model, duration, ratio, prompt, image_url):
    content = [{"type": "text", "text": prompt}]
    if image_url:
        content.append({"type": "image_url", "image_url": {"url": image_url}, "role": "reference_image"})
    body = {"model": model, "duration": duration, "resolution": "720p", "ratio": ratio, "content": content}
    try:
        result = api("POST", ENDPOINT, key, body)
    except Exception as error:
        raise RuntimeError(
            "创建任务失败或响应不明确。不要自动再次 POST；上游可能已经接受任务。"
            "请保存错误并向客服核查。 " + str(error)
        ) from None
    task_id = result.get("id")
    if not isinstance(task_id, str) or not task_id:
        raise RuntimeError("创建响应缺少任务 ID；不要重复提交，请核查。")
    return task_id


def wait_for_video(key, task_id, minutes):
    url = ENDPOINT + "/" + quote(task_id, safe="")
    deadline = time.monotonic() + minutes * 60
    while time.monotonic() < deadline:
        try:
            result = api("GET", url, key)
        except APIError as error:
            if error.status not in (408, 429, 500, 502, 503, 504):
                raise
            print("查询暂不可用，20 秒后重试 GET；不会创建新任务。", flush=True)
            time.sleep(20)
            continue
        except (URLError, TimeoutError):
            print("查询网络异常，20 秒后重试 GET。", flush=True)
            time.sleep(20)
            continue
        status = result.get("status", "unknown")
        print("任务状态：", status, flush=True)
        if status == "succeeded":
            video_url = result.get("content", {}).get("video_url")
            if not isinstance(video_url, str) or not video_url:
                raise RuntimeError("成功响应缺少 content.video_url；请联系支持。")
            return video_url
        if status in ("failed", "cancelled", "canceled", "expired"):
            raise RuntimeError("任务未成功：" + json.dumps(result.get("error", status), ensure_ascii=False))
        time.sleep(15)
    raise TimeoutError("本地等待到期，任务未必结束；保存 ID，下次使用 --task-id 继续查询，不要新建。")


def download(video_url, filename):
    # Signed media URLs already authorize access. Never send the Sub2 API key.
    if urlsplit(video_url).scheme != "https":
        raise RuntimeError("拒绝非 HTTPS 视频地址。")
    target = Path(filename)
    if target.exists():
        raise FileExistsError("输出文件已存在；请选择新文件名：" + str(target))
    try:
        with urlopen(Request(video_url), timeout=180) as response, target.open("xb") as output:
            content_type = response.headers.get("Content-Type", "").split(";", 1)[0].strip()
            if content_type not in ("video/mp4", "application/octet-stream"):
                raise RuntimeError("视频下载返回了意外类型：" + content_type)
            shutil.copyfileobj(response, output)
    except HTTPError as error:
        if error.code == 403:
            raise RuntimeError("签名链接可能已过期；用同一个 Key 重新 GET 任务获取新链接，不要 POST。") from None
        raise
    print("视频已保存：", target, flush=True)


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--task-id", help="恢复查询已有任务，不创建新任务")
    parser.add_argument("--model", choices=("seedance2.0fast", "seedance2.5"), default="seedance2.0fast")
    parser.add_argument("--duration", type=int, default=5)
    parser.add_argument("--ratio", choices=("16:9", "9:16", "1:1", "4:3", "3:4", "adaptive"), default="16:9")
    parser.add_argument("--prompt", default="海浪轻轻拍打沙滩，固定镜头，自然光，画面平稳。")
    parser.add_argument("--image-url", help="可选：无需登录的公网 HTTPS 参考图 URL")
    parser.add_argument("--output", default="seedance-output.mp4")
    parser.add_argument("--wait-minutes", type=int, default=45)
    args = parser.parse_args()
    key = os.getenv("SUB2_API_KEY", "").strip()
    if not key:
        parser.error("请先设置 SUB2_API_KEY 环境变量为绑定 Seedance 分组的 Key")
    allowed = (5, 10, 15) if args.model == "seedance2.0fast" else (5, 10, 30)
    if args.duration not in allowed or args.wait_minutes <= 0:
        parser.error("模型时长不支持，或等待时间不是正数")
    task_id = args.task_id or create_once(key, args.model, args.duration, args.ratio, args.prompt, args.image_url)
    print("任务 ID（请立即保存）：", task_id, flush=True)
    video_url = wait_for_video(key, task_id, args.wait_minutes)
    download(video_url, args.output)


if __name__ == "__main__":
    main()

export SUB2_API_KEY='sk-YOUR_SEEDANCE_GROUP_KEY'
node seedance-example.mjs

# 恢复查询已创建任务，不会 POST 新任务
export SEEDANCE_TASK_ID='保存的任务 id'
export SEEDANCE_OUTPUT='resumed.mp4'
node seedance-example.mjs

// Node.js 20+; no npm dependencies. Never automatically repeat POST.
import { createWriteStream, existsSync } from 'node:fs';
import { pipeline } from 'node:stream/promises';
import { Readable } from 'node:stream';

const endpoint = 'https://zhinaoapi.ai/api/v3/contents/generations/tasks';
const key = (process.env.SUB2_API_KEY || '').trim();
const taskToResume = process.env.SEEDANCE_TASK_ID || '';
const model = process.env.SEEDANCE_MODEL || 'seedance2.0fast';
const duration = Number(process.env.SEEDANCE_DURATION || 5);
const imageUrl = process.env.SEEDANCE_IMAGE_URL || '';
const output = process.env.SEEDANCE_OUTPUT || 'seedance-output.mp4';
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));

class APIError extends Error {
  constructor(status, body) {
    super(`HTTP ${status}: ${body.slice(0, 1000)}`);
    this.status = status;
  }
}

async function api(method, url, body) {
  const response = await fetch(url, {
    method,
    headers: {
      Authorization: `Bearer ${key}`,
      Accept: 'application/json',
      ...(body ? { 'Content-Type': 'application/json' } : {}),
    },
    body: body ? JSON.stringify(body) : undefined,
    signal: AbortSignal.timeout(90_000),
  });
  const raw = await response.text();
  if (!response.ok) throw new APIError(response.status, raw);
  return JSON.parse(raw);
}

async function createOnce() {
  const content = [{ type: 'text', text: process.env.SEEDANCE_PROMPT || '海浪轻轻拍打沙滩，固定镜头，自然光，画面平稳。' }];
  if (imageUrl) content.push({ type: 'image_url', image_url: { url: imageUrl }, role: 'reference_image' });
  let result;
  try {
    result = await api('POST', endpoint, {
      model, duration, resolution: '720p', ratio: process.env.SEEDANCE_RATIO || '16:9', content,
    });
  } catch (error) {
    throw new Error(`创建失败或响应不明确，禁止自动再次 POST；请保存错误并核查。 ${error.message}`);
  }
  if (typeof result.id !== 'string' || !result.id) throw new Error('创建响应缺少任务 ID；不要重复提交。');
  return result.id;
}

async function poll(taskId) {
  const statusUrl = `${endpoint}/${encodeURIComponent(taskId)}`;
  const deadline = Date.now() + 45 * 60_000;
  while (Date.now() < deadline) {
    let result;
    try {
      result = await api('GET', statusUrl);
    } catch (error) {
      const retryable = error instanceof APIError
        ? [408, 429, 500, 502, 503, 504].includes(error.status)
        : error instanceof TypeError || ['TimeoutError', 'AbortError'].includes(error.name);
      if (!retryable) throw error;
      console.log('查询暂不可用，20 秒后重试 GET；不会创建新任务。');
      await sleep(20_000);
      continue;
    }
    console.log('任务状态：', result.status || 'unknown');
    if (result.status === 'succeeded') {
      if (!result.content?.video_url) throw new Error('成功响应缺少 content.video_url；请联系支持。');
      return result.content.video_url;
    }
    if (['failed', 'cancelled', 'canceled', 'expired'].includes(result.status)) {
      throw new Error(`任务未成功：${JSON.stringify(result.error || result.status)}`);
    }
    await sleep(15_000);
  }
  throw new Error('本地等待到期，任务未必结束；保留 ID，下次设置 SEEDANCE_TASK_ID 继续查询，不要新建。');
}

async function download(url) {
  if (new URL(url).protocol !== 'https:') throw new Error('拒绝非 HTTPS 视频地址。');
  if (existsSync(output)) throw new Error(`输出文件已存在，请更换 SEEDANCE_OUTPUT：${output}`);
  // Signed URLs already authorize access. Do not send the Sub2 API key.
  const response = await fetch(url, { signal: AbortSignal.timeout(180_000) });
  if (response.status === 403) throw new Error('签名链接可能过期；重新 GET 任务获取新链接，不要 POST。');
  if (!response.ok || !response.body) throw new Error(`下载失败 HTTP ${response.status}`);
  const mime = (response.headers.get('content-type') || '').split(';')[0].trim();
  if (!['video/mp4', 'application/octet-stream'].includes(mime)) throw new Error(`意外下载类型：${mime}`);
  await pipeline(Readable.fromWeb(response.body), createWriteStream(output, { flags: 'wx' }));
  console.log('视频已保存：', output);
}

async function main() {
  if (!key) throw new Error('请先设置 SUB2_API_KEY，为绑定 Seedance 分组的 Key。');
  const durations = { 'seedance2.0fast': [5, 10, 15], 'seedance2.5': [5, 10, 30] };
  if (!durations[model]?.includes(duration)) throw new Error('模型或时长不支持。');
  const taskId = taskToResume || await createOnce();
  console.log('任务 ID（请立即保存）：', taskId);
  await download(await poll(taskId));
}

main().catch(error => { console.error(error.message); process.exitCode = 1; });

{
  "model": "gpt-5.5",
  "messages": [
    {
      "role": "system",
      "content": "你是一位专业的技术文档撰写助手。"
    },
    {
      "role": "user",
      "content": "请帮我写一段 Python 快速排序代码。"
    }
  ],
  "temperature": 0.7,
  "max_tokens": 2048,
  "stream": false
}

curl https://api.zhinaoapi.ai/v1/images/generations \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-YOUR_API_KEY" \
  -d '{
    "model": "gpt-image-2",
    "prompt": "一张未来感城市夜景，霓虹灯，电影感构图",
    "size": "1024x1024",
    "quality": "high",
    "n": 1
  }'

{
  "id": "chatcmpl-abc123def456",
  "object": "chat.completion",
  "created": 1781654400,
  "model": "gpt-5.5",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "以下是 Python 快速排序的实现..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 42,
    "completion_tokens": 256,
    "total_tokens": 298
  }
}

data: {"id":"chatcmpl-abc123","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}

data: {"id":"chatcmpl-abc123","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"以下"},"finish_reason":null}]}

data: {"id":"chatcmpl-abc123","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"是"},"finish_reason":null}]}

data: [DONE]

{
  "error": {
    "message": "具体的错误描述信息",
    "type": "error_type",
    "code": "error_code"
  }
}

pip install openai

from openai import OpenAI

client = OpenAI(
    api_key="sk-YOUR_API_KEY",
    base_url="https://api.zhinaoapi.ai/v1"
)

response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {"role": "system", "content": "你是一个有帮助的AI助手。"},
        {"role": "user", "content": "用Python实现一个二分查找算法。"}
    ],
    temperature=0.7,
    max_tokens=1024
)

print(response.choices[0].message.content)

npm install openai

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'sk-YOUR_API_KEY',
  baseURL: 'https://api.zhinaoapi.ai/v1',
});

async function main() {
  const completion = await client.chat.completions.create({
    model: 'gpt-5.5',
    messages: [
      { role: 'system', content: '你是一个有帮助的AI助手。' },
      { role: 'user', content: '用JavaScript实现一个防抖函数。' }
    ],
    temperature: 0.7,
    max_tokens: 1024,
  });

  console.log(completion.choices[0].message.content);
}

main();

curl -X POST https://api.zhinaoapi.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-YOUR_API_KEY" \
  -d '{
    "model": "gpt-5.4-mini",
    "messages": [
      {"role": "system", "content": "你是一个有帮助的AI助手。"},
      {"role": "user", "content": "什么是量子计算？请用通俗的语言解释。"}
    ],
    "temperature": 0.7,
    "max_tokens": 512
  }'

from openai import OpenAI

client = OpenAI(
    api_key="sk-YOUR_API_KEY",
    base_url="https://api.zhinaoapi.ai/v1"
)

stream = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {"role": "user", "content": "写一首关于春天的七言绝句。"}
    ],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)

print()  # 换行

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'sk-YOUR_API_KEY',
  baseURL: 'https://api.zhinaoapi.ai/v1',
});

async function main() {
  const stream = await client.chat.completions.create({
    model: 'gpt-5.5',
    messages: [
      { role: 'user', content: '写一首关于春天的七言绝句。' }
    ],
    stream: true,
  });

  for await (const chunk of stream) {
    const content = chunk.choices[0]?.delta?.content;
    if (content) {
      process.stdout.write(content);
    }
  }

  console.log();
}

main();

curl -X POST https://api.zhinaoapi.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-YOUR_API_KEY" \
  -N \
  -d '{
    "model": "gpt-5.5",
    "messages": [
      {"role": "user", "content": "你好"}
    ],
    "stream": true
  }'

# 将以下内容添加到 ~/.bashrc 或 ~/.zshrc
export ANTHROPIC_BASE_URL="https://api.zhinaoapi.ai"
export ANTHROPIC_API_KEY="sk-YOUR_API_KEY"

# 使配置生效
source ~/.bashrc  # 或 source ~/.zshrc

# 临时设置（当前会话有效）
$env:ANTHROPIC_BASE_URL = "https://api.zhinaoapi.ai"
$env:ANTHROPIC_API_KEY = "sk-YOUR_API_KEY"

# 永久设置（写入用户环境变量）
[Environment]::SetEnvironmentVariable("ANTHROPIC_BASE_URL", "https://api.zhinaoapi.ai", "User")
[Environment]::SetEnvironmentVariable("ANTHROPIC_API_KEY", "sk-YOUR_API_KEY", "User")

:: 永久设置
setx ANTHROPIC_BASE_URL "https://api.zhinaoapi.ai"
setx ANTHROPIC_API_KEY "sk-YOUR_API_KEY"

# 启动 Claude Code
claude

# 或在项目目录中启动
cd your-project && claude