--- type: research title: Chat Submode SSE — Real Delta Protocol with Message Markers description: The captured response stream of /f/conversation — delta v1, infrastructure events (resume token, input echo, message markers) and assistant/tool messages tags: [openai, sse, delta, protocol, markers, real-traces] timestamp: 2026-08-26 --- # Chat Submode SSE — Real Captured Protocol Part of [openai-research](openai-research.md). Source: bezetacil `004-response-sse.js` capturing the raw SSE body of `/f/conversation` (2026-08-26, multiple real messages). ## Stream envelope The response is standard SSE blocks: `event: ` + `data: `. Some events carry a named `event:` line; infrastructure events are **data-only** (no `event:` line) — the parsed `{event: undefined, data: {type: …}}`. ## Named events ### `delta_encoding` — v1 ``` event: delta_encoding data: "v1" ``` First event of every stream. The delta encoding version. ### `delta` — the conversation tree patches ``` event: delta data: {"p":"","o":"add","v":{"message":{"id":"…","author":{"role":"system"},"content":{...}}}} ``` - `p` = JSON path (string, root `""`) - `o` = op (`add`, `replace`, `remove`, `patch`) - `v` = value (a full message object with `id`, `author`, `content`) The stream replays the whole topic tree first: `system → system → system → user → system …` (the prior messages), then appends the new turn. Messages with `create_time` are persisted; ones with `null` are in-flight scaffolding. Tool messages appear as: ```json {"author": {"role": "tool", "name": "web.run", "metadata": {"real_author": "tool:web.run"}}} ``` The `web.run` tool execution (web search) interleaves its result messages into the tree. ## Infrastructure events (data-only) ### `resume_conversation_token` ```json {"type":"resume_conversation_token","kind":"topic","token":"eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.…"} ``` A JWT (ES256) issued at stream start — the resume token for the topic. Used by the resume flow (`fjr`) to continue an interrupted turn. ### `input_message` ```json {"type":"input_message","input_message":{"id":"…","author":{"role":"user"},"create_time":1787769883.78}} ``` Echo of the user's message that triggered the turn (the server echoes the canonical record). ### `message_marker` ```json {"type":"message_marker","conversation_id":"6a8f33f9-aa30-83e9-8d12-2116f4006fbd","message_id":"…","marker":"cot_token","event":"first"} ``` The pipeline stage markers, in order: | marker | meaning | |---|---| | `cot_token` | the chain-of-thought token (the encrypted reasoning segment) is being emitted | | `user_visible_token` | the user-visible text segment is being emitted | | `final_channel_token` | the turn's final channel token (turn close) | Each marker carries `event: "first"` (observed; possibly `last`/`delta_encoding` for subsequent markers of the same message). ## Stream metrics (observed) | message | chunks | bytes | events | |---|---|---|---| | simple reply | 16 | 21048 | 27 | | reply with web search | 33 | 30267 | 40 | | second message | 24 | 21702 | 32 | ## What this closes The static RE had the delta skeleton (channel/path/value, immer apply). The real stream shows: 1. The tree is **replayed then appended** in one stream (no separate history fetch) 2. **Infrastructure events** (resume token, input echo, message markers) ride the same SSE — no separate channel 3. The **encrypted reasoning integration**: the `cot_token` marker precedes the user-visible text — the server tags which segment is the encrypted CoT 4. Tool execution (`web.run`) interleaves result messages into the tree with `role: tool` ## Cross-references - [chat-submode-protocol](chat-submode-protocol.md) — where this stream fits - [attestation-flow](attestation-flow.md) — the integrity that gates the request - [bezetacil](../bezetacil/bezetacil.md) — the 004-response-sse script - [flow-a-manual-step-by-step](flow-a-manual-step-by-step.md) — the validated sequence in which this stream is consumed - [flow-a-tool-protocol](flow-a-tool-protocol.md) — how a local tool call appears in this same stream ## TypeScript types (wire + events) ```ts // ── the wire delta keys (from the decoder YAr, asar) ───────────────────── /** compressed keys: channel='c', path='p', op='o', value='v' */ export interface WireDelta { c?: number // channel — INHERITED from the previous delta when absent o: 'add' | 'replace' | 'remove' | 'patch' | 'append' | string p: string // JSON path ('' root, '/message/content/parts/0', …) v?: unknown // string for append fragments; message object for add/patch } /** The decoder state that provides the inheritance. */ export interface DeltaDecoderState { previousDelta: { channel: number; op: string; path: string; value: unknown } previousValueByChannel: unknown[] } // ── named SSE events ───────────────────────────────────────────────────── export interface SseEvent { event: T data: D } /** delta_encoding: the first event of every stream. */ export type DeltaEncodingEvent = SseEvent<'delta_encoding', 'v1'> export type DeltaEvent = SseEvent<'delta', WireDelta | WireDelta[]> /** message_marker pipeline stages (observed 'first'; the last-marker events of a * message may re-emit with 'last'/'delta_encoding' — see the page). */ export type MessageMarkerKind = 'cot_token' | 'user_visible_token' | 'final_channel_token' export interface MessageMarkerEvent { type: 'message_marker' conversation_id: string message_id: string marker: MessageMarkerKind event: 'first' | 'last' | 'delta_encoding' | string } // ── data-only infrastructure events ────────────────────────────────────── export interface ResumeConversationTokenEvent { type: 'resume_conversation_token' kind: 'topic' token: string // ES256 JWT — resume the interrupted turn } export interface InputMessageEvent { type: 'input_message' input_message: import('./flow-a-tool-protocol').ConversationMessage & { id: string } } export interface TitleGenerationEvent { type: 'title_generation' title: string conversation_id: string } export interface MessageStreamCompleteEvent { type: 'message_stream_complete' conversation_id: string } export interface ConversationDetailMetadataEvent { type: 'conversation_detail_metadata' banner_info: unknown | null blocked_features: unknown[] model_limits: unknown[] limits_progress: unknown[] [key: string]: unknown } export interface ServerSteMetadataEvent { type: 'server_ste_metadata' metadata: { server_ttfvt_ms: number | null conduit_prewarmed: boolean plan_type: string // 'plus' plan_type_bucket: string // 'paid' [key: string]: unknown } } ``` ## Delta field details (from the full dump) ### Field compression Deltas carry fields as `{c, o, p, v}` — the `c` (channel) is **inherited from the previous delta when absent**. Observed: 2 of 6 deltas carried `c`; the rest inherited. This matches the `ujr.previousDelta` semantics from the static RE — now proven with real data (and confirmed directly in the asar decoder `QAr` with `YAr = [['channel','c'],['path','p'],['op','o'],['value','v']]`). ### Ops observed - `add` — a whole message node into the tree root (`p: ""`, channel 0) - `append` — streaming text: `p: "/message/content/parts/0"`, `v: "Oi, Alefita. Boa…"` — fragments accumulate in `parts[0]` of the assistant message - `patch` — state updates at the root (`p: ""`) ### The assistant message metadata (real payload) ```json { "id": ">", "author": {"role": "assistant"}, "content": {"content_type": "code", "language": "unknown", "text": ""}, "status": "finished_successfully", "end_turn": false, "recipient": "web.run", "channel": null, "metadata": { "finish_details": {"type": "stop", "stop_tokens": [200012]}, "cot_version": "v5", "model_slug": "gpt-5-6-thinking", "default_model_slug": "gpt-5-6-thinking", "thinking_effort": "extended", "reasoning_title": "Searching the web", "reasoning_titles": ["Searching the web"], "reasoning_status": "is_reasoning", "reasoning_start_time": 1787770105.62, "parent_id": "c46ff5c8-277f-4e09-8215-93ce4bafc6b3", "request_id": "57af2415-69fa-47cb-a0b0-8b8c12745302", "tool_icons": ["globe"] }, "conversation_id": "6a8f34f1-6b30-83e9-bf16-37e58ef7abbb" } ``` ### Reasoning representation `reasoning` appears in 12 events but **no `encrypted_content` in the SSE** — the chat submode carries reasoning as **titles + markers** (`reasoning_title`, `cot_version: "v5"`, the `cot_token` message_marker). The encrypted CoT body is server-side, referenced by the marker token; it does not travel in the response stream. This differs from the codex backend, where the customer sends `include: ["reasoning.encrypted_content"]` and receives it in the payload.