OpenAI Compatible モード: レスポンスの処理

resp = client.chat.completions.create(
    model="gpt-4.1-mini",
    messages=[{"role": "user", "content": "What is 1+1?"}]
)
print(resp.choices[0].message.content)
print(resp.usage.total_tokens)

const resp = await openai.chat.completions.create({
  model: 'gpt-4.1-mini',
  messages: [{ role: 'user', content: 'What is 1+1?' }]
});
console.log(resp.choices[0].message.content);
console.log(resp.usage.total_tokens);

curl https://api.apiyi.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"model":"gpt-4.1-mini","messages":[{"role":"user","content":"What is 1+1?"}]}'

stream = client.chat.completions.create(
    model="gpt-4.1-mini",
    messages=[{"role": "user", "content": "Write a short poem"}],
    stream=True
)

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

const stream = await openai.chat.completions.create({
  model: 'gpt-4.1-mini',
  messages: [{ role: 'user', content: 'Write a short poem' }],
  stream: true
});

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

import json, requests

def stream_chat(model, messages, api_key):
    resp = requests.post(
        "https://api.apiyi.com/v1/chat/completions",
        headers={"Authorization": f"Bearer {api_key}",
                 "Content-Type": "application/json"},
        json={"model": model, "messages": messages, "stream": True},
        stream=True, timeout=300,
    )
    text, usage = "", None
    for line in resp.iter_lines(decode_unicode=True):
        if not line or not line.startswith("data: "):
            continue
        data = line[6:]
        if data == "[DONE]":
            break
        chunk = json.loads(data)
        if chunk.get("usage"):          # usage may appear in any chunk
            usage = chunk["usage"]
        choices = chunk.get("choices")
        if not choices:                 # final chunk may be empty; guard it
            continue
        delta = choices[0].get("delta", {})
        piece = delta.get("content")
        if piece:                       # skip role-only / empty-content chunks
            text += piece
            print(piece, end="", flush=True)
        # finish_reason == "stop" is just a marker; don't break (usage often follows)
    return text, usage

async function streamChat(model, messages, apiKey) {
  const resp = await fetch("https://api.apiyi.com/v1/chat/completions", {
    method: "POST",
    headers: { "Authorization": `Bearer ${apiKey}`, "Content-Type": "application/json" },
    body: JSON.stringify({ model, messages, stream: true }),
  });

  const reader = resp.body.getReader();
  const decoder = new TextDecoder();
  let buffer = "", text = "", usage = null;

  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();             // keep the possibly-incomplete last line

    for (const line of lines) {
      if (!line.startsWith("data: ")) continue;
      const data = line.slice(6).trim();
      if (data === "[DONE]") return { text, usage };
      const chunk = JSON.parse(data);
      if (chunk.usage) usage = chunk.usage;        // usage may appear in any chunk
      const choices = chunk.choices;
      if (!choices || choices.length === 0) continue;  // final chunk may be empty
      const piece = choices[0].delta?.content;
      if (piece) { text += piece; process.stdout.write(piece); }
    }
  }
  return { text, usage };
}