Streaming

Five endpoints answer with text/event-stream. Four stay open and watch something; the fifth streams one chat reply and closes.

Stream	Endpoint	Frames
Conversation	`GET /v1/conversations/{conversation_id}/events`	`conversation.snapshot`, `item.created`, `item.delivery_updated`, `turn`, `turn.failed`, `assistant.started`, `assistant.delta`, `assistant.completed`
AgentCoPilot	`GET /v1/copilot/agents/{agent_id}/stream`	`snapshot`, `message`, `turn`
ToolCoPilot	`GET /v1/copilot/tools/{tool_id}/stream`	`snapshot`, `message`, `turn`
TaskCoPilot	`GET /v1/copilot/tasks/{task_id}/stream`	`snapshot`, `message`, `turn`
One chat reply	`POST /v1/chats/{chat_id}/messages` with `"stream": true`	`assistant.started`, `assistant.delta`, `assistant.completed`, `item.created`, then `turn.result` and close

The streamed chat reply is documented with the rest of the chat API in text conversations. The GET streams take no query parameters and return 404 before opening if the resource is not in your workspace.

Wire format

event: assistant.delta
data: {"event":"assistant.delta","trigger_item_id":"9c2f1a44-3d0b-4a6e-8f21-5b7c0e93a4d1","text":"Sure"}

: keep-alive

The JSON repeats the frame name in its event field. Narrow on that.
A line starting : is a keep-alive, sent after 15 seconds of silence.
The body is never one JSON document. Read it with an SSE client.

Delivery rules

Snapshot first, and on every reconnect. The first frame of each GET stream is the whole current state, taken after the subscription opens so nothing falls in the gap. To resync, reconnect and replace your local state with the snapshot.
Best effort. Frames are relayed live, never queued or replayed. A frame sent while you were disconnected is gone; every fact it carried is readable from the REST endpoints. item.created frames carry an SSE id: (the item id) for de-duplication, but Last-Event-ID is ignored.
assistant.delta is append-only. Concatenate the chunks. assistant.completed.text is all deltas joined: replace what you accumulated with it.

Conversation frames

GET /v1/conversations/{conversation_id}/events watches one conversation on any channel.

Frame	Fields
`conversation.snapshot`	`conversation` (the `GET /v1/conversations/{conversation_id}` body), `items` (every item, oldest first), `activity.state` (`running` or `idle`)
`item.created`	One conversation item, in the same shape `GET /v1/conversations/{conversation_id}/items` returns, plus `event`
`item.delivery_updated`	`item_ids`, `delivery_status` (see delivery), `provider_message_id`, `error`
`turn`	`turn_id`, `status` (`running`, `done`, `error`, `canceled`), `session_id`, `superseded_by_item_id` (set with `canceled`: a newer message replaced this turn), `error`, `item_ids`
`turn.failed`	`trigger_item_id`, `message`. The turn could not be queued at all, so no `turn` frame follows
`assistant.started`	`trigger_item_id`
`assistant.delta`	`trigger_item_id`, `text` (the next chunk)
`assistant.completed`	`trigger_item_id`, `session_id`, `text` (all deltas joined), `item_ids` (the persisted items)

Item fields (type, direction, role, visibility, delivery_status, attachments) are described on conversations.

CoPilot frames

All three CoPilot rails send the same frames.

Frame	Fields
`snapshot`	`messages` (the whole timeline), `busy` (a turn is running), `error` (why the newest turn stopped, if it stopped badly)
`message`	`id`, `item`, `role`, `content` (flattened text), `tool_calls`, `tool_call_id`, `name`, `created_at`. `item` is discriminated on `type`: `message` (`role`, `content`), `function_call` (`call_id`, `name`, `arguments` as a JSON string) or `function_call_output` (`call_id`, `output`)
`turn`	Same as the conversation `turn` frame

Reading a stream

curl -N https://api.talqing.com/v1/conversations/9c2f1a44-3d0b-4a6e-8f21-5b7c0e93a4d1/events \
  -H "Authorization: Bearer $TALQING_API_KEY"

const controller = new AbortController();
const { stream } = await talqing.conversations.events(
  { conversation_id: conversationId },
  { signal: controller.signal },
);

let reply = "";
for await (const frame of stream) {
  if (frame.event === "assistant.delta") reply += frame.text;
  if (frame.event === "assistant.completed") reply = frame.text ?? reply;
  if (frame.event === "turn" && frame.status !== "running") controller.abort();
}

reply = ""
with talqing.conversations.events(conversation_id) as events:
    for frame in events:
        if frame["event"] == "assistant.delta":
            reply += frame["text"]
        elif frame["event"] == "assistant.completed":
            reply = frame["text"] or reply
        elif frame["event"] == "turn" and frame["status"] != "running":
            break

CoPilot rails are talqing.copilot.agents.stream(...), copilot.tools.stream(...) and copilot.tasks.stream(...).

	TypeScript	Python
Opening	`await` returns `{ stream }`, an async iterable	Not awaited, on `Talqing` or `AsyncTalqing`; use it as a context manager so an early exit closes the connection
Reconnect	Automatic after a transport failure, backoff from 3 s; bound it with `sseMaxRetryAttempts`, stop it with `signal`	None. A finished `Stream` cannot be reopened; open a new one
Open fails (`401`, `403`, `404`)	Surfaces on the first iteration	Raises `TalqingAPIError`

Neither SDK reads a stream: true chat reply as frames; read it with a raw SSE client, or omit stream to get the JSON turn.

What is not streamed

None of these endpoints is an MCP tool. Use GET /v1/conversations/{conversation_id}/items instead of the conversation stream. A live voice or video call is a LiveKit room observed through the browser SDK (web calls); a finished call’s push notification is a webhook.

Using the API

Endpoints

Wire format

Delivery rules

Conversation frames

CoPilot frames

Reading a stream

What is not streamed

​Wire format

​Delivery rules

​Conversation frames

​CoPilot frames

​Reading a stream

​What is not streamed

Wire format

Delivery rules

Conversation frames

CoPilot frames

Reading a stream

What is not streamed