Streaming - Auriko

Each streaming event carries a type field like response.output_text.delta or response.completed. The stream ends with a terminal event (response.completed, response.incomplete, or response.failed) instead of a data: [DONE] sentinel.

Prerequisites

An Auriko API key
Python 3.10+ with the OpenAI SDK (pip install openai) or the Auriko SDK (pip install auriko)
- OR Node.js 18+ with the OpenAI SDK (npm install openai) or @auriko/sdk (npm install @auriko/sdk)

Stream text

Stream a response and print each text token:

import os
from openai import OpenAI

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

stream = client.responses.create(
    model="gpt-4o",
    input="Count from 1 to 10",
    stream=True
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

import OpenAI from "openai";

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

const stream = await client.responses.create({
    model: "gpt-4o",
    input: "Count from 1 to 10",
    stream: true,
});

for await (const event of stream) {
    if (event.type === "response.output_text.delta") {
        process.stdout.write(event.delta);
    }
}

import os
from auriko import Client

client = Client(
    api_key=os.environ["AURIKO_API_KEY"],
    base_url="https://api.auriko.ai/v1"
)

stream = client.responses.create(
    model="gpt-4o",
    input="Count from 1 to 10",
    stream=True
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

import { Client } from "@auriko/sdk";

const client = new Client({
    apiKey: process.env.AURIKO_API_KEY,
    baseUrl: "https://api.auriko.ai/v1",
});

const stream = await client.responses.create({
    model: "gpt-4o",
    input: "Count from 1 to 10",
    stream: true,
});

for await (const event of stream) {
    if (event.type === "response.output_text.delta") {
        process.stdout.write(event.delta);
    }
}

curl --no-buffer https://api.auriko.ai/v1/responses \
  -H "Authorization: Bearer $AURIKO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "input": "Count from 1 to 10",
    "stream": true
  }'

Handle event types

A basic text response emits events in this order: response.created → response.in_progress → response.output_item.added → response.content_part.added → response.output_text.delta (repeated) → response.output_text.done → response.content_part.done → response.output_item.done → response.completed

Lifecycle events

Event	Description
`response.created`	Response object created, status is `in_progress`
`response.in_progress`	Processing has started
`response.completed`	Response finished, includes final `response` object
`response.incomplete`	Response stopped early (token limit, content filter)
`response.failed`	Response failed, includes error details

Content events

Event	Description
`response.output_item.added`	New output item started (text, function call, or reasoning)
`response.output_item.done`	Output item finished
`response.content_part.added`	New content part within an output item
`response.content_part.done`	Content part finished
`response.output_text.delta`	Text chunk, access via `event.delta`
`response.output_text.done`	Text output complete, access full text via `event.text`

Reasoning events

Event	Description
`response.reasoning_summary_part.added`	Reasoning summary part started
`response.reasoning_summary_part.done`	Reasoning summary part finished
`response.reasoning_summary_text.delta`	Reasoning summary text chunk
`response.reasoning_summary_text.done`	Reasoning summary text complete

Tool call events

Event	Description
`response.function_call_arguments.delta`	Function call arguments chunk
`response.function_call_arguments.done`	Function call arguments complete

Error event

Event	Description
`error`	Stream-level error

Terminal events (response.completed, response.incomplete, response.failed) carry the final response object with usage and routing_metadata.

Access completed response

You can read response_headers before iterating. After iteration, the stream exposes the terminal event’s full response object.

import os
from openai import OpenAI

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

stream = client.responses.create(
    model="gpt-4o",
    input="What is 2 + 2?",
    stream=True
)

completed = None
for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)
    elif event.type == "response.completed":
        completed = event.response

print(f"\nModel: {completed.model}")
print(f"Usage: {completed.usage.input_tokens} in, {completed.usage.output_tokens} out")

import OpenAI from "openai";

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

const stream = await client.responses.create({
    model: "gpt-4o",
    input: "What is 2 + 2?",
    stream: true,
});

let completed: any = null;
for await (const event of stream) {
    if (event.type === "response.output_text.delta") {
        process.stdout.write(event.delta);
    } else if (event.type === "response.completed") {
        completed = event.response;
    }
}

console.log(`\nModel: ${completed?.model}`);
console.log(`Usage: ${completed?.usage?.input_tokens} in, ${completed?.usage?.output_tokens} out`);

import os
from auriko import Client

client = Client(
    api_key=os.environ["AURIKO_API_KEY"],
    base_url="https://api.auriko.ai/v1"
)

stream = client.responses.create(
    model="gpt-4o",
    input="What is 2 + 2?",
    stream=True
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

final = stream.completed_response
print(f"\nModel: {final.model}")
print(f"Tokens: {final.usage.total_tokens}")
print(f"Provider: {final.routing_metadata.provider}")

import { Client } from "@auriko/sdk";

const client = new Client({
    apiKey: process.env.AURIKO_API_KEY,
    baseUrl: "https://api.auriko.ai/v1",
});

const stream = await client.responses.create({
    model: "gpt-4o",
    input: "What is 2 + 2?",
    stream: true,
});

for await (const event of stream) {
    if (event.type === "response.output_text.delta") {
        process.stdout.write(event.delta);
    }
}

const final = stream.completedResponse;
console.log(`\nModel: ${final?.model}`);
console.log(`Tokens: ${final?.usage?.total_tokens}`);
console.log(`Provider: ${final?.routing_metadata?.provider}`);

cURL streams raw SSE events. See Read raw SSE for parsing terminal events. For routing metadata with the OpenAI SDK, see OpenAI Compatibility.

Stream asynchronously

Stream with the async client:

import os
import asyncio
from openai import AsyncOpenAI

async def stream_response():
    client = AsyncOpenAI(
        api_key=os.environ["AURIKO_API_KEY"],
        base_url="https://api.auriko.ai/v1"
    )

    stream = await client.responses.create(
        model="gpt-4o",
        input="Write a haiku about code",
        stream=True
    )

    async for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)

asyncio.run(stream_response())

import os
import asyncio
from auriko import AsyncClient

async def stream_response():
    client = AsyncClient(
        api_key=os.environ["AURIKO_API_KEY"],
        base_url="https://api.auriko.ai/v1"
    )

    stream = await client.responses.create(
        model="gpt-4o",
        input="Write a haiku about code",
        stream=True
    )

    async for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)

asyncio.run(stream_response())

TypeScript’s SDK is inherently async. See the Stream text example above.

Read raw SSE

The raw wire format uses event: and data: lines. A basic text response looks like this:

event: response.created
data: {"type":"response.created","response":{"id":"resp_abc123","object":"response","status":"in_progress",...}}

event: response.in_progress
data: {"type":"response.in_progress","response":{"id":"resp_abc123","object":"response","status":"in_progress",...}}

event: response.output_item.added
data: {"type":"response.output_item.added","output_index":0,"item":{"type":"message","role":"assistant","content":[]}}

event: response.output_text.delta
data: {"type":"response.output_text.delta","output_index":0,"content_index":0,"delta":"The"}

event: response.output_text.delta
data: {"type":"response.output_text.delta","output_index":0,"content_index":0,"delta":" capital"}

event: response.completed
data: {"type":"response.completed","response":{"id":"resp_abc123","object":"response","status":"completed","output":[...],"usage":{...},"routing_metadata":{...}}}

See Chat Completions streaming for the data: [DONE] format used by the other endpoint. See Error Handling for error recovery patterns.

​Prerequisites

​Stream text

​Handle event types

​Lifecycle events

​Content events

​Reasoning events

​Tool call events

​Error event

​Access completed response

​Stream asynchronously

​Read raw SSE