@pipedog/openai 0.0.0-stage → 0.3.0

package/dist/realtime/events.js

@@ -0,0 +1,1639 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/services/openai/realtime/events.py
+/**
+ * Event models and data structures for OpenAI Realtime API communication.
+ *
+ * Porting notes:
+ * - Upstream models are pydantic `BaseModel`s. Here each model extends the
+ *   small `BaseModel` below: fields are camelCase and the constructor takes
+ *   one options object, while `modelValidate()` reads and `modelDump()` /
+ *   `toJSON()` write the upstream snake_case wire keys, so the wire format is
+ *   unchanged. Plain-dict fields (`tracing`, `prompt`, `rate_limits`,
+ *   `status_details`, `tools` as provider dicts) are passed through untouched.
+ * - Validation is reduced to what the services rely on: required fields and
+ *   the `type` literal of server events raise `ValidationError`; value types
+ *   are not checked.
+ * - `model_copy(update=...)` is `modelCopy({ update })`, with camelCase field
+ *   names; `SessionProperties.model_fields` is `SessionProperties.modelFields`
+ *   (camelCase field name to wire key).
+ */
+import { rethrowIfCancelled } from "@pipedog/asyncio";
+import { ToolsSchema } from "@pipedog/core/adapters/schemas/tools_schema";
+import { LLMContext } from "@pipedog/core/processors/aggregators/llm_context";
+import { pyJsonLoads } from "@pipedog/core/utils/py_json";
+import { OPENAI_REALTIME_WHISPER_MODEL, OPENAI_SAMPLE_RATE } from "../_constants.js";
+//
+// Model machinery (pydantic's BaseModel, reduced to what these events need).
+//
+/** Raised when data does not match a model, like pydantic's `ValidationError`. */
+export class ValidationError extends Error {
+    name = "ValidationError";
+}
+function camelToSnake(name) {
+    return name.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+}
+function snakeToCamel(name) {
+    return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function dumpValue(value, options) {
+    if (value instanceof BaseModel)
+        return value.modelDump(options);
+    if (Array.isArray(value))
+        return value.map((v) => dumpValue(v, options));
+    return value;
+}
+function required(options, name, model) {
+    const value = options[name];
+    if (value === undefined) {
+        throw new ValidationError(`1 validation error for ${model}\n${camelToSnake(name)}\n  Field required`);
+    }
+    return value;
+}
+function literal(value, expected, model) {
+    if (value === undefined)
+        required({}, "type", model);
+    if (value !== expected) {
+        throw new ValidationError(`1 validation error for ${model}\ntype\n  Input should be '${expected}'`);
+    }
+    return expected;
+}
+/** A resolver building a model from wire data (or keeping an instance). */
+function model(cls) {
+    return (value) => (value === null ? null : cls.modelValidate(value));
+}
+/** A resolver building a list of models from wire data. */
+function listOf(resolve) {
+    return (value) => (Array.isArray(value) ? value.map(resolve) : value);
+}
+// Extra fields of models that allow them, kept off the instance so they are
+// not taken for declared fields.
+const modelExtras = new WeakMap();
+/**
+ * Base of the models in this module (pydantic's `BaseModel`).
+ *
+ * Fields are the instance's own properties, in declaration order (base class
+ * fields first, as pydantic orders them).
+ */
+export class BaseModel {
+    /** Fields holding nested models, by field name: how to build each from wire data. */
+    static _nested = {};
+    /** Whether keys that match no field are kept (pydantic's `extra="allow"`). */
+    static _extraAllowed = false;
+    /** Extra fields kept from wire data (pydantic's `model_extra`), by wire key. */
+    get modelExtra() {
+        return modelExtras.get(this) ?? null;
+    }
+    /**
+     * Validate wire data (snake_case keys) into a model (pydantic's
+     * `model_validate`). An instance of the model is returned as is.
+     */
+    static modelValidate(data) {
+        // biome-ignore lint/complexity/noThisInStatic: polymorphic static, like pydantic's classmethod.
+        if (data instanceof this)
+            return data;
+        // biome-ignore lint/complexity/noThisInStatic: polymorphic static.
+        const cls = this;
+        if (!isPlainObject(data)) {
+            throw new ValidationError(`1 validation error for ${cls.name}\n  Input should be a valid dictionary or instance of ${cls.name}`);
+        }
+        const nested = cls._nested;
+        const options = {};
+        for (const [key, value] of Object.entries(data)) {
+            const name = snakeToCamel(key);
+            const resolve = Object.hasOwn(nested, name) ? nested[name] : undefined;
+            options[name] = resolve && value !== undefined ? resolve(value) : value;
+        }
+        const instance = new this(options);
+        if (cls._extraAllowed) {
+            const extra = {};
+            for (const [key, value] of Object.entries(data)) {
+                if (!Object.hasOwn(instance, snakeToCamel(key)))
+                    extra[key] = value;
+            }
+            if (Object.keys(extra).length > 0)
+                modelExtras.set(instance, extra);
+        }
+        return instance;
+    }
+    /**
+     * Serialize the model to a plain object with the wire (snake_case) keys
+     * (pydantic's `model_dump`).
+     */
+    modelDump(options = {}) {
+        const out = {};
+        for (const [name, value] of Object.entries(this)) {
+            if (value === undefined)
+                continue;
+            if (options.excludeNone && value === null)
+                continue;
+            out[camelToSnake(name)] = dumpValue(value, options);
+        }
+        const extra = modelExtras.get(this);
+        if (extra) {
+            for (const [key, value] of Object.entries(extra)) {
+                if (options.excludeNone && value === null)
+                    continue;
+                out[key] = value;
+            }
+        }
+        return out;
+    }
+    /** JSON form: the wire dump. */
+    toJSON() {
+        return this.modelDump();
+    }
+    /**
+     * Shallow copy of the model, with `update` (camelCase field names) applied
+     * (pydantic's `model_copy`).
+     */
+    modelCopy(options = {}) {
+        const copy = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+        const extra = modelExtras.get(this);
+        if (extra)
+            modelExtras.set(copy, { ...extra });
+        if (options.update)
+            Object.assign(copy, options.update);
+        return copy;
+    }
+}
+/** Base class for audio format configuration. */
+export class AudioFormat extends BaseModel {
+    type;
+    constructor(options) {
+        super();
+        this.type = required(options, "type", new.target.name);
+    }
+}
+/**
+ * PCM audio format configuration.
+ *
+ * - `type`: audio format type, always "audio/pcm".
+ * - `rate`: sample rate, always 24000 for PCM.
+ */
+export class PCMAudioFormat extends AudioFormat {
+    rate;
+    constructor(options = {}) {
+        super({ type: options.type ?? "audio/pcm" });
+        this.rate = options.rate ?? OPENAI_SAMPLE_RATE;
+    }
+}
+/**
+ * PCMU (G.711 μ-law) audio format configuration.
+ *
+ * - `type`: audio format type, always "audio/pcmu".
+ */
+export class PCMUAudioFormat extends AudioFormat {
+    constructor(options = {}) {
+        super({ type: options.type ?? "audio/pcmu" });
+    }
+}
+/**
+ * PCMA (G.711 A-law) audio format configuration.
+ *
+ * - `type`: audio format type, always "audio/pcma".
+ */
+export class PCMAAudioFormat extends AudioFormat {
+    constructor(options = {}) {
+        super({ type: options.type ?? "audio/pcma" });
+    }
+}
+/** Builds the audio format a wire dict describes, by its `type`. */
+const audioFormat = (value) => {
+    if (value === null || value instanceof AudioFormat || !isPlainObject(value))
+        return value;
+    if (value.type === "audio/pcmu")
+        return PCMUAudioFormat.modelValidate(value);
+    if (value.type === "audio/pcma")
+        return PCMAAudioFormat.modelValidate(value);
+    return PCMAudioFormat.modelValidate(value);
+};
+/** Configuration for audio transcription settings. */
+export class InputAudioTranscription extends BaseModel {
+    model;
+    language;
+    prompt;
+    /**
+     * Initialize InputAudioTranscription.
+     *
+     * @param options.model Transcription model to use (e.g.
+     *   "gpt-realtime-whisper", "gpt-4o-transcribe", "whisper-1").
+     * @param options.language Optional language code for transcription.
+     * @param options.prompt Optional transcription hint text.
+     */
+    constructor(options = {}) {
+        super();
+        this.model = options.model ?? OPENAI_REALTIME_WHISPER_MODEL;
+        this.language = options.language ?? null;
+        this.prompt = options.prompt ?? null;
+    }
+}
+/**
+ * Server-side voice activity detection configuration.
+ *
+ * - `type`: detection type, must be "server_vad".
+ * - `threshold`: voice activity detection threshold (0.0-1.0). Defaults to 0.5.
+ * - `prefixPaddingMs`: padding before speech starts in milliseconds. Defaults to 300.
+ * - `silenceDurationMs`: silence duration to detect speech end in milliseconds.
+ *   Defaults to 500.
+ */
+export class TurnDetection extends BaseModel {
+    type;
+    threshold;
+    prefixPaddingMs;
+    silenceDurationMs;
+    constructor(options = {}) {
+        super();
+        this.type = options.type === undefined ? "server_vad" : options.type;
+        this.threshold = options.threshold === undefined ? 0.5 : options.threshold;
+        this.prefixPaddingMs = options.prefixPaddingMs === undefined ? 300 : options.prefixPaddingMs;
+        this.silenceDurationMs =
+            options.silenceDurationMs === undefined ? 500 : options.silenceDurationMs;
+    }
+}
+/**
+ * Semantic-based turn detection configuration.
+ *
+ * - `type`: detection type, must be "semantic_vad".
+ * - `eagerness`: turn detection eagerness level. Can be "low", "medium",
+ *   "high", or "auto".
+ * - `createResponse`: whether to automatically create responses on turn detection.
+ * - `interruptResponse`: whether to interrupt ongoing responses on turn detection.
+ */
+export class SemanticTurnDetection extends BaseModel {
+    type;
+    eagerness;
+    createResponse;
+    interruptResponse;
+    constructor(options = {}) {
+        super();
+        this.type = options.type === undefined ? "semantic_vad" : options.type;
+        this.eagerness = options.eagerness ?? null;
+        this.createResponse = options.createResponse ?? null;
+        this.interruptResponse = options.interruptResponse ?? null;
+    }
+}
+/** Builds the turn detection a wire value describes: a bool, or a config by its `type`. */
+const turnDetection = (value) => {
+    if (typeof value === "boolean" || value === null || !isPlainObject(value))
+        return value;
+    if (value.type === "semantic_vad")
+        return SemanticTurnDetection.modelValidate(value);
+    return TurnDetection.modelValidate(value);
+};
+/**
+ * Input audio noise reduction configuration.
+ *
+ * - `type`: noise reduction type for different microphone scenarios.
+ */
+export class InputAudioNoiseReduction extends BaseModel {
+    type;
+    constructor(options) {
+        super();
+        this.type = required(options, "type", "InputAudioNoiseReduction");
+    }
+}
+/**
+ * Audio input configuration.
+ *
+ * - `format`: the format of the input audio.
+ * - `transcription`: configuration for input audio transcription.
+ * - `noiseReduction`: configuration for input audio noise reduction.
+ * - `turnDetection`: configuration for turn detection, or false to disable.
+ */
+export class AudioInput extends BaseModel {
+    static _nested = {
+        format: audioFormat,
+        transcription: model(InputAudioTranscription),
+        noiseReduction: model(InputAudioNoiseReduction),
+        turnDetection,
+    };
+    format;
+    transcription;
+    noiseReduction;
+    turnDetection;
+    constructor(options = {}) {
+        super();
+        this.format = options.format ?? null;
+        this.transcription = options.transcription ?? null;
+        this.noiseReduction = options.noiseReduction ?? null;
+        this.turnDetection = options.turnDetection ?? null;
+    }
+}
+/**
+ * Audio output configuration.
+ *
+ * - `format`: the format of the output audio.
+ * - `voice`: the voice the model uses to respond.
+ * - `speed`: the speed of the model's spoken response.
+ */
+export class AudioOutput extends BaseModel {
+    static _nested = { format: audioFormat };
+    format;
+    voice;
+    speed;
+    constructor(options = {}) {
+        super();
+        this.format = options.format ?? null;
+        this.voice = options.voice ?? null;
+        this.speed = options.speed ?? null;
+    }
+}
+/**
+ * Audio configuration for input and output.
+ *
+ * - `input`: configuration for input audio.
+ * - `output`: configuration for output audio.
+ */
+export class AudioConfiguration extends BaseModel {
+    static _nested = {
+        input: model(AudioInput),
+        output: model(AudioOutput),
+    };
+    input;
+    output;
+    constructor(options = {}) {
+        super();
+        this.input = options.input ?? null;
+        this.output = options.output ?? null;
+    }
+}
+/**
+ * Reasoning configuration for reasoning-capable Realtime models (e.g. `gpt-realtime-2`).
+ *
+ * - `effort`: how much reasoning effort the model should apply. `null` (the
+ *   default) leaves the field unset and lets the server pick.
+ */
+export class Reasoning extends BaseModel {
+    // `| string` for forward compatibility: if OpenAI adds new effort levels,
+    // users can pass the new string without waiting for a Pipecat release.
+    effort;
+    constructor(options = {}) {
+        super();
+        this.effort = options.effort ?? null;
+    }
+}
+/**
+ * Configuration properties for an OpenAI Realtime session.
+ *
+ * - `type`: the type of session, always "realtime".
+ * - `object`: object type identifier, always "realtime.session".
+ * - `id`: unique identifier for the session.
+ * - `model`: the Realtime model used for this session. Note: the model is set
+ *   at connection time via the service settings and cannot be changed during
+ *   the session.
+ * - `outputModalities`: the set of modalities the model can respond with.
+ * - `instructions`: system instructions for the assistant.
+ * - `audio`: configuration for input and output audio.
+ * - `tools`: available function tools for the assistant.
+ * - `toolChoice`: tool usage strategy ("auto", "none", or "required").
+ * - `maxOutputTokens`: maximum tokens in response or "inf" for unlimited.
+ * - `tracing`: configuration options for tracing.
+ * - `prompt`: reference to a prompt template and its variables.
+ * - `expiresAt`: session expiration timestamp.
+ * - `include`: additional fields to include in server outputs.
+ * - `reasoning`: reasoning configuration. Only supported by reasoning-capable
+ *   Realtime models such as `gpt-realtime-2`.
+ */
+export class SessionProperties extends BaseModel {
+    static _nested = {
+        audio: model(AudioConfiguration),
+        reasoning: model(Reasoning),
+    };
+    /** The model's fields (pydantic's `model_fields`): camelCase field name to wire key. */
+    static modelFields = {
+        type: "type",
+        object: "object",
+        id: "id",
+        model: "model",
+        outputModalities: "output_modalities",
+        instructions: "instructions",
+        audio: "audio",
+        tools: "tools",
+        toolChoice: "tool_choice",
+        maxOutputTokens: "max_output_tokens",
+        tracing: "tracing",
+        prompt: "prompt",
+        expiresAt: "expires_at",
+        include: "include",
+        reasoning: "reasoning",
+    };
+    type;
+    object;
+    id;
+    model;
+    outputModalities;
+    instructions;
+    audio;
+    // Tools provided by the user (via the service constructor or
+    // LLMUpdateSettingsFrame) may be a ToolsSchema or a plain list of standard
+    // tools (normalized to a ToolsSchema on construction); a list of
+    // provider-native tool dicts passes through. ToolsSchema is never
+    // serialized/deserialized when talking to the server.
+    tools;
+    toolChoice;
+    maxOutputTokens;
+    tracing;
+    prompt;
+    expiresAt;
+    include;
+    reasoning;
+    constructor(options = {}) {
+        super();
+        this.type = options.type === undefined ? "realtime" : options.type;
+        this.object = options.object ?? null;
+        this.id = options.id ?? null;
+        this.model = options.model ?? null;
+        this.outputModalities = options.outputModalities ?? null;
+        this.instructions = options.instructions ?? null;
+        this.audio = options.audio ?? null;
+        this.tools = SessionProperties._normalizeTools(options.tools ?? null);
+        this.toolChoice = options.toolChoice ?? null;
+        this.maxOutputTokens = options.maxOutputTokens ?? null;
+        this.tracing = options.tracing ?? null;
+        this.prompt = options.prompt ?? null;
+        this.expiresAt = options.expiresAt ?? null;
+        this.include = options.include ?? null;
+        this.reasoning = options.reasoning ?? null;
+    }
+    /**
+     * Wrap a plain list of standard tools in a `ToolsSchema`.
+     *
+     * Provider-native tool lists (dicts) pass through unchanged.
+     */
+    static _normalizeTools(v) {
+        if (Array.isArray(v)) {
+            const normalized = LLMContext._normalizeAndValidateTools(v, { allowProviderTools: true });
+            return normalized instanceof ToolsSchema || Array.isArray(normalized)
+                ? normalized
+                : null;
+        }
+        return v;
+    }
+}
+/**
+ * Content within a conversation item.
+ *
+ * - `type`: content type (text, audio, input_text, input_audio, input_image,
+ *   output_text, or output_audio).
+ * - `text`: text content for text-based items.
+ * - `audio`: base64-encoded audio data for audio items.
+ * - `transcript`: transcribed text for audio items.
+ * - `imageUrl`: base64-encoded image data as a data URI for input_image items.
+ * - `detail`: detail level for image processing ("auto", "low", or "high").
+ */
+export class ItemContent extends BaseModel {
+    type;
+    text;
+    audio; // base64-encoded audio
+    transcript;
+    imageUrl; // base64-encoded image as data URI
+    detail;
+    constructor(options) {
+        super();
+        this.type = required(options, "type", "ItemContent");
+        this.text = options.text ?? null;
+        this.audio = options.audio ?? null;
+        this.transcript = options.transcript ?? null;
+        this.imageUrl = options.imageUrl ?? null;
+        this.detail = options.detail ?? null;
+    }
+}
+/**
+ * A conversation item in the realtime session.
+ *
+ * - `id`: unique identifier for the item, auto-generated if not provided.
+ * - `object`: object type identifier for the realtime API.
+ * - `type`: item type (message, function_call, or function_call_output).
+ * - `status`: current status of the item.
+ * - `role`: speaker role for message items (user, assistant, or system).
+ * - `content`: content list for message items.
+ * - `callId`: function call identifier for function_call items.
+ * - `name`: function name for function_call items.
+ * - `arguments`: function arguments as JSON string for function_call items.
+ * - `output`: function output as JSON string for function_call_output items.
+ */
+export class ConversationItem extends BaseModel {
+    static _nested = {
+        content: listOf(model(ItemContent)),
+    };
+    id;
+    object;
+    type;
+    status;
+    // role and content are present for message items
+    role;
+    content;
+    // these four fields are present for function_call items
+    callId;
+    name;
+    arguments;
+    output;
+    constructor(options) {
+        super();
+        this.id = options.id ?? crypto.randomUUID().replaceAll("-", "");
+        this.object = options.object ?? null;
+        this.type = required(options, "type", "ConversationItem");
+        this.status = options.status ?? null;
+        this.role = options.role ?? null;
+        this.content = options.content ?? null;
+        this.callId = options.callId ?? null;
+        this.name = options.name ?? null;
+        this.arguments = options.arguments ?? null;
+        this.output = options.output ?? null;
+    }
+}
+/**
+ * A realtime conversation session.
+ *
+ * - `id`: unique identifier for the conversation.
+ * - `object`: object type identifier, always "realtime.conversation".
+ */
+export class RealtimeConversation extends BaseModel {
+    id;
+    object;
+    constructor(options) {
+        super();
+        this.id = required(options, "id", "RealtimeConversation");
+        this.object = required(options, "object", "RealtimeConversation");
+    }
+}
+/**
+ * Properties for configuring assistant responses.
+ *
+ * - `outputModalities`: output modalities for the response. Must be either
+ *   ["text"] or ["audio"]. Defaults to ["audio"].
+ * - `instructions`: specific instructions for this response.
+ * - `audio`: audio configuration for this response.
+ * - `tools`: available tools for this response.
+ * - `toolChoice`: tool usage strategy for this response.
+ * - `temperature`: sampling temperature for this response.
+ * - `maxOutputTokens`: maximum tokens for this response.
+ */
+export class ResponseProperties extends BaseModel {
+    static _nested = { audio: model(AudioConfiguration) };
+    outputModalities;
+    instructions;
+    audio;
+    tools;
+    toolChoice;
+    temperature;
+    maxOutputTokens;
+    constructor(options = {}) {
+        super();
+        this.outputModalities =
+            options.outputModalities === undefined ? ["audio"] : options.outputModalities;
+        this.instructions = options.instructions ?? null;
+        this.audio = options.audio ?? null;
+        this.tools = options.tools ?? null;
+        this.toolChoice = options.toolChoice ?? null;
+        this.temperature = options.temperature ?? null;
+        this.maxOutputTokens = options.maxOutputTokens ?? null;
+    }
+}
+/**
+ * Error information from the realtime API.
+ *
+ * - `type`: error type identifier.
+ * - `code`: specific error code.
+ * - `message`: human-readable error message.
+ * - `param`: parameter name that caused the error, if applicable.
+ * - `eventId`: event ID associated with the error, if applicable.
+ */
+export class RealtimeError extends BaseModel {
+    type;
+    code;
+    message;
+    param;
+    eventId;
+    constructor(options) {
+        super();
+        this.type = required(options, "type", "RealtimeError");
+        this.code = options.code === undefined ? "" : options.code;
+        this.message = required(options, "message", "RealtimeError");
+        this.param = options.param ?? null;
+        this.eventId = options.eventId ?? null;
+    }
+}
+/**
+ * Base class for client events sent to the realtime API.
+ *
+ * - `eventId`: unique identifier for the event, auto-generated if not provided.
+ */
+export class ClientEvent extends BaseModel {
+    eventId;
+    constructor(options = {}) {
+        super();
+        this.eventId = options.eventId ?? crypto.randomUUID();
+    }
+}
+/**
+ * Event to update session properties.
+ *
+ * - `type`: event type, always "session.update".
+ * - `session`: updated session properties.
+ */
+export class SessionUpdateEvent extends ClientEvent {
+    static _nested = { session: model(SessionProperties) };
+    type = "session.update";
+    session;
+    constructor(options) {
+        super(options);
+        this.session = required(options, "session", "SessionUpdateEvent");
+    }
+    /**
+     * Serialize the event to a plain object.
+     *
+     * Handles special serialization for turn_detection where false becomes null.
+     *
+     * @param options Options passed to the parent `modelDump`.
+     * @returns Object representation of the event.
+     */
+    modelDump(options = {}) {
+        const dump = super.modelDump(options);
+        // Handle turn_detection in audio.input so that false becomes null
+        if ("audio" in dump.session && dump.session.audio) {
+            if ("input" in dump.session.audio && dump.session.audio.input) {
+                if ("turn_detection" in dump.session.audio.input) {
+                    if (dump.session.audio.input.turn_detection === false) {
+                        dump.session.audio.input.turn_detection = null;
+                    }
+                }
+            }
+        }
+        return dump;
+    }
+}
+/**
+ * Event to append audio data to the input buffer.
+ *
+ * - `type`: event type, always "input_audio_buffer.append".
+ * - `audio`: base64-encoded audio data to append.
+ */
+export class InputAudioBufferAppendEvent extends ClientEvent {
+    type = "input_audio_buffer.append";
+    audio; // base64-encoded audio
+    constructor(options) {
+        super(options);
+        this.audio = required(options, "audio", "InputAudioBufferAppendEvent");
+    }
+}
+/**
+ * Event to commit the current input audio buffer.
+ *
+ * - `type`: event type, always "input_audio_buffer.commit".
+ */
+export class InputAudioBufferCommitEvent extends ClientEvent {
+    type = "input_audio_buffer.commit";
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/**
+ * Event to clear the input audio buffer.
+ *
+ * - `type`: event type, always "input_audio_buffer.clear".
+ */
+export class InputAudioBufferClearEvent extends ClientEvent {
+    type = "input_audio_buffer.clear";
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/**
+ * Event to create a new conversation item.
+ *
+ * - `type`: event type, always "conversation.item.create".
+ * - `previousItemId`: ID of the item to insert after, if any.
+ * - `item`: the conversation item to create.
+ */
+export class ConversationItemCreateEvent extends ClientEvent {
+    static _nested = { item: model(ConversationItem) };
+    type = "conversation.item.create";
+    previousItemId;
+    item;
+    constructor(options) {
+        super(options);
+        this.previousItemId = options.previousItemId ?? null;
+        this.item = required(options, "item", "ConversationItemCreateEvent");
+    }
+}
+/**
+ * Event to truncate a conversation item's audio content.
+ *
+ * - `type`: event type, always "conversation.item.truncate".
+ * - `itemId`: ID of the item to truncate.
+ * - `contentIndex`: index of the content to truncate within the item.
+ * - `audioEndMs`: end time in milliseconds for the truncated audio.
+ */
+export class ConversationItemTruncateEvent extends ClientEvent {
+    type = "conversation.item.truncate";
+    itemId;
+    contentIndex;
+    audioEndMs;
+    constructor(options) {
+        super(options);
+        this.itemId = required(options, "itemId", "ConversationItemTruncateEvent");
+        this.contentIndex = required(options, "contentIndex", "ConversationItemTruncateEvent");
+        this.audioEndMs = required(options, "audioEndMs", "ConversationItemTruncateEvent");
+    }
+}
+/**
+ * Event to delete a conversation item.
+ *
+ * - `type`: event type, always "conversation.item.delete".
+ * - `itemId`: ID of the item to delete.
+ */
+export class ConversationItemDeleteEvent extends ClientEvent {
+    type = "conversation.item.delete";
+    itemId;
+    constructor(options) {
+        super(options);
+        this.itemId = required(options, "itemId", "ConversationItemDeleteEvent");
+    }
+}
+/**
+ * Event to retrieve a conversation item by ID.
+ *
+ * - `type`: event type, always "conversation.item.retrieve".
+ * - `itemId`: ID of the item to retrieve.
+ */
+export class ConversationItemRetrieveEvent extends ClientEvent {
+    type = "conversation.item.retrieve";
+    itemId;
+    constructor(options) {
+        super(options);
+        this.itemId = required(options, "itemId", "ConversationItemRetrieveEvent");
+    }
+}
+/**
+ * Event to create a new assistant response.
+ *
+ * - `type`: event type, always "response.create".
+ * - `response`: optional response configuration properties.
+ */
+export class ResponseCreateEvent extends ClientEvent {
+    static _nested = { response: model(ResponseProperties) };
+    type = "response.create";
+    response;
+    constructor(options = {}) {
+        super(options);
+        this.response = options.response ?? null;
+    }
+}
+/**
+ * Event to cancel the current assistant response.
+ *
+ * - `type`: event type, always "response.cancel".
+ */
+export class ResponseCancelEvent extends ClientEvent {
+    type = "response.cancel";
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/**
+ * Base class for server events received from the realtime API.
+ *
+ * - `eventId`: unique identifier for the event.
+ * - `type`: type of the server event.
+ */
+export class ServerEvent extends BaseModel {
+    eventId;
+    type;
+    constructor(options) {
+        super();
+        this.eventId = required(options, "eventId", new.target.name);
+        this.type = required(options, "type", new.target.name);
+    }
+}
+/**
+ * Event indicating a session has been created.
+ *
+ * - `type`: event type, always "session.created".
+ * - `session`: the created session properties.
+ */
+export class SessionCreatedEvent extends ServerEvent {
+    static _nested = { session: model(SessionProperties) };
+    session;
+    constructor(options) {
+        super(options);
+        this.type = literal(options.type, "session.created", "SessionCreatedEvent");
+        this.session = required(options, "session", "SessionCreatedEvent");
+    }
+}
+/**
+ * Event indicating a session has been updated.
+ *
+ * - `type`: event type, always "session.updated".
+ * - `session`: the updated session properties.
+ */
+export class SessionUpdatedEvent extends ServerEvent {
+    static _nested = { session: model(SessionProperties) };
+    session;
+    constructor(options) {
+        super(options);
+        this.type = literal(options.type, "session.updated", "SessionUpdatedEvent");
+        this.session = required(options, "session", "SessionUpdatedEvent");
+    }
+}
+/**
+ * Event indicating a conversation has been created.
+ *
+ * - `type`: event type, always "conversation.created".
+ * - `conversation`: the created conversation.
+ */
+export class ConversationCreated extends ServerEvent {
+    static _nested = {
+        conversation: model(RealtimeConversation),
+    };
+    conversation;
+    constructor(options) {
+        super(options);
+        this.type = literal(options.type, "conversation.created", "ConversationCreated");
+        this.conversation = required(options, "conversation", "ConversationCreated");
+    }
+}
+/**
+ * Event indicating a conversation item has been added.
+ *
+ * - `type`: event type, always "conversation.item.added".
+ * - `previousItemId`: ID of the previous item, if any.
+ * - `item`: the added conversation item.
+ */
+export class ConversationItemAdded extends ServerEvent {
+    static _nested = { item: model(ConversationItem) };
+    previousItemId;
+    item;
+    constructor(options) {
+        super(options);
+        this.type = literal(options.type, "conversation.item.added", "ConversationItemAdded");
+        this.previousItemId = options.previousItemId ?? null;
+        this.item = required(options, "item", "ConversationItemAdded");
+    }
+}
+/**
+ * Event indicating a conversation item is done processing.
+ *
+ * - `type`: event type, always "conversation.item.done".
+ * - `previousItemId`: ID of the previous item, if any.
+ * - `item`: the completed conversation item.
+ */
+export class ConversationItemDone extends ServerEvent {
+    static _nested = { item: model(ConversationItem) };
+    previousItemId;
+    item;
+    constructor(options) {
+        super(options);
+        this.type = literal(options.type, "conversation.item.done", "ConversationItemDone");
+        this.previousItemId = options.previousItemId ?? null;
+        this.item = required(options, "item", "ConversationItemDone");
+    }
+}
+/**
+ * Event containing incremental input audio transcription.
+ *
+ * - `type`: event type, always "conversation.item.input_audio_transcription.delta".
+ * - `itemId`: ID of the conversation item being transcribed.
+ * - `contentIndex`: index of the content within the item.
+ * - `delta`: incremental transcription text.
+ */
+export class ConversationItemInputAudioTranscriptionDelta extends ServerEvent {
+    itemId;
+    contentIndex;
+    delta;
+    constructor(options) {
+        super(options);
+        const name = "ConversationItemInputAudioTranscriptionDelta";
+        this.type = literal(options.type, "conversation.item.input_audio_transcription.delta", name);
+        this.itemId = required(options, "itemId", name);
+        this.contentIndex = required(options, "contentIndex", name);
+        this.delta = required(options, "delta", name);
+    }
+}
+/**
+ * Event indicating input audio transcription is complete.
+ *
+ * - `type`: event type, always "conversation.item.input_audio_transcription.completed".
+ * - `itemId`: ID of the conversation item that was transcribed.
+ * - `contentIndex`: index of the content within the item.
+ * - `transcript`: complete transcription text.
+ */
+export class ConversationItemInputAudioTranscriptionCompleted extends ServerEvent {
+    itemId;
+    contentIndex;
+    transcript;
+    constructor(options) {
+        super(options);
+        const name = "ConversationItemInputAudioTranscriptionCompleted";
+        this.type = literal(options.type, "conversation.item.input_audio_transcription.completed", name);
+        this.itemId = required(options, "itemId", name);
+        this.contentIndex = required(options, "contentIndex", name);
+        this.transcript = required(options, "transcript", name);
+    }
+}
+/**
+ * Event indicating input audio transcription failed.
+ *
+ * - `type`: event type, always "conversation.item.input_audio_transcription.failed".
+ * - `itemId`: ID of the conversation item that failed transcription.
+ * - `contentIndex`: index of the content within the item.
+ * - `error`: error details for the transcription failure.
+ */
+export class ConversationItemInputAudioTranscriptionFailed extends ServerEvent {
+    static _nested = { error: model(RealtimeError) };
+    itemId;
+    contentIndex;
+    error;
+    constructor(options) {
+        super(options);
+        const name = "ConversationItemInputAudioTranscriptionFailed";
+        this.type = literal(options.type, "conversation.item.input_audio_transcription.failed", name);
+        this.itemId = required(options, "itemId", name);
+        this.contentIndex = required(options, "contentIndex", name);
+        this.error = required(options, "error", name);
+    }
+}
+/**
+ * Event indicating a conversation item has been truncated.
+ *
+ * - `type`: event type, always "conversation.item.truncated".
+ * - `itemId`: ID of the truncated conversation item.
+ * - `contentIndex`: index of the content within the item.
+ * - `audioEndMs`: end time in milliseconds for the truncated audio.
+ */
+export class ConversationItemTruncated extends ServerEvent {
+    itemId;
+    contentIndex;
+    audioEndMs;
+    constructor(options) {
+        super(options);
+        const name = "ConversationItemTruncated";
+        this.type = literal(options.type, "conversation.item.truncated", name);
+        this.itemId = required(options, "itemId", name);
+        this.contentIndex = required(options, "contentIndex", name);
+        this.audioEndMs = required(options, "audioEndMs", name);
+    }
+}
+/**
+ * Event indicating a conversation item has been deleted.
+ *
+ * - `type`: event type, always "conversation.item.deleted".
+ * - `itemId`: ID of the deleted conversation item.
+ */
+export class ConversationItemDeleted extends ServerEvent {
+    itemId;
+    constructor(options) {
+        super(options);
+        this.type = literal(options.type, "conversation.item.deleted", "ConversationItemDeleted");
+        this.itemId = required(options, "itemId", "ConversationItemDeleted");
+    }
+}
+/**
+ * Event containing a retrieved conversation item.
+ *
+ * - `type`: event type, always "conversation.item.retrieved".
+ * - `item`: the retrieved conversation item.
+ */
+export class ConversationItemRetrieved extends ServerEvent {
+    static _nested = { item: model(ConversationItem) };
+    item;
+    constructor(options) {
+        super(options);
+        this.type = literal(options.type, "conversation.item.retrieved", "ConversationItemRetrieved");
+        this.item = required(options, "item", "ConversationItemRetrieved");
+    }
+}
+/**
+ * Event indicating an assistant response has been created.
+ *
+ * - `type`: event type, always "response.created".
+ * - `response`: the created response object.
+ */
+export class ResponseCreated extends ServerEvent {
+    // `Response` is declared below; resolved lazily, like upstream's forward reference.
+    static _nested = {
+        response: (value) => (value === null ? null : Response.modelValidate(value)),
+    };
+    response;
+    constructor(options) {
+        super(options);
+        this.type = literal(options.type, "response.created", "ResponseCreated");
+        this.response = required(options, "response", "ResponseCreated");
+    }
+}
+/**
+ * Event indicating an assistant response is complete.
+ *
+ * - `type`: event type, always "response.done".
+ * - `response`: the completed response object.
+ */
+export class ResponseDone extends ServerEvent {
+    static _nested = {
+        response: (value) => (value === null ? null : Response.modelValidate(value)),
+    };
+    response;
+    constructor(options) {
+        super(options);
+        this.type = literal(options.type, "response.done", "ResponseDone");
+        this.response = required(options, "response", "ResponseDone");
+    }
+}
+/**
+ * Event indicating an output item has been added to a response.
+ *
+ * - `type`: event type, always "response.output_item.added".
+ * - `responseId`: ID of the response.
+ * - `outputIndex`: index of the output item.
+ * - `item`: the added conversation item.
+ */
+export class ResponseOutputItemAdded extends ServerEvent {
+    static _nested = { item: model(ConversationItem) };
+    responseId;
+    outputIndex;
+    item;
+    constructor(options) {
+        super(options);
+        const name = "ResponseOutputItemAdded";
+        this.type = literal(options.type, "response.output_item.added", name);
+        this.responseId = required(options, "responseId", name);
+        this.outputIndex = required(options, "outputIndex", name);
+        this.item = required(options, "item", name);
+    }
+}
+/**
+ * Event indicating an output item is complete.
+ *
+ * - `type`: event type, always "response.output_item.done".
+ * - `responseId`: ID of the response.
+ * - `outputIndex`: index of the output item.
+ * - `item`: the completed conversation item.
+ */
+export class ResponseOutputItemDone extends ServerEvent {
+    static _nested = { item: model(ConversationItem) };
+    responseId;
+    outputIndex;
+    item;
+    constructor(options) {
+        super(options);
+        const name = "ResponseOutputItemDone";
+        this.type = literal(options.type, "response.output_item.done", name);
+        this.responseId = required(options, "responseId", name);
+        this.outputIndex = required(options, "outputIndex", name);
+        this.item = required(options, "item", name);
+    }
+}
+/**
+ * Event indicating a content part has been added to a response.
+ *
+ * - `type`: event type, always "response.content_part.added".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `contentIndex`: index of the content part.
+ * - `part`: the added content part.
+ */
+export class ResponseContentPartAdded extends ServerEvent {
+    static _nested = { part: model(ItemContent) };
+    responseId;
+    itemId;
+    outputIndex;
+    contentIndex;
+    part;
+    constructor(options) {
+        super(options);
+        const name = "ResponseContentPartAdded";
+        this.type = literal(options.type, "response.content_part.added", name);
+        this.responseId = required(options, "responseId", name);
+        this.itemId = required(options, "itemId", name);
+        this.outputIndex = required(options, "outputIndex", name);
+        this.contentIndex = required(options, "contentIndex", name);
+        this.part = required(options, "part", name);
+    }
+}
+/**
+ * Event indicating a content part is complete.
+ *
+ * - `type`: event type, always "response.content_part.done".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `contentIndex`: index of the content part.
+ * - `part`: the completed content part.
+ */
+export class ResponseContentPartDone extends ServerEvent {
+    static _nested = { part: model(ItemContent) };
+    responseId;
+    itemId;
+    outputIndex;
+    contentIndex;
+    part;
+    constructor(options) {
+        super(options);
+        const name = "ResponseContentPartDone";
+        this.type = literal(options.type, "response.content_part.done", name);
+        this.responseId = required(options, "responseId", name);
+        this.itemId = required(options, "itemId", name);
+        this.outputIndex = required(options, "outputIndex", name);
+        this.contentIndex = required(options, "contentIndex", name);
+        this.part = required(options, "part", name);
+    }
+}
+/**
+ * Event containing incremental text from a response.
+ *
+ * - `type`: event type, always "response.output_text.delta".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `contentIndex`: index of the content part.
+ * - `delta`: incremental text content.
+ */
+export class ResponseTextDelta extends ServerEvent {
+    responseId;
+    itemId;
+    outputIndex;
+    contentIndex;
+    delta;
+    constructor(options) {
+        super(options);
+        const name = "ResponseTextDelta";
+        this.type = literal(options.type, "response.output_text.delta", name);
+        this.responseId = required(options, "responseId", name);
+        this.itemId = required(options, "itemId", name);
+        this.outputIndex = required(options, "outputIndex", name);
+        this.contentIndex = required(options, "contentIndex", name);
+        this.delta = required(options, "delta", name);
+    }
+}
+/**
+ * Event indicating text content is complete.
+ *
+ * - `type`: event type, always "response.output_text.done".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `contentIndex`: index of the content part.
+ * - `text`: complete text content.
+ */
+export class ResponseTextDone extends ServerEvent {
+    responseId;
+    itemId;
+    outputIndex;
+    contentIndex;
+    text;
+    constructor(options) {
+        super(options);
+        const name = "ResponseTextDone";
+        this.type = literal(options.type, "response.output_text.done", name);
+        this.responseId = required(options, "responseId", name);
+        this.itemId = required(options, "itemId", name);
+        this.outputIndex = required(options, "outputIndex", name);
+        this.contentIndex = required(options, "contentIndex", name);
+        this.text = required(options, "text", name);
+    }
+}
+/**
+ * Event containing incremental audio transcript from a response.
+ *
+ * - `type`: event type, always "response.output_audio_transcript.delta".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `contentIndex`: index of the content part.
+ * - `delta`: incremental transcript text.
+ */
+export class ResponseAudioTranscriptDelta extends ServerEvent {
+    responseId;
+    itemId;
+    outputIndex;
+    contentIndex;
+    delta;
+    constructor(options) {
+        super(options);
+        const name = "ResponseAudioTranscriptDelta";
+        this.type = literal(options.type, "response.output_audio_transcript.delta", name);
+        this.responseId = required(options, "responseId", name);
+        this.itemId = required(options, "itemId", name);
+        this.outputIndex = required(options, "outputIndex", name);
+        this.contentIndex = required(options, "contentIndex", name);
+        this.delta = required(options, "delta", name);
+    }
+}
+/**
+ * Event indicating audio transcript is complete.
+ *
+ * - `type`: event type, always "response.output_audio_transcript.done".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `contentIndex`: index of the content part.
+ * - `transcript`: complete transcript text.
+ */
+export class ResponseAudioTranscriptDone extends ServerEvent {
+    responseId;
+    itemId;
+    outputIndex;
+    contentIndex;
+    transcript;
+    constructor(options) {
+        super(options);
+        const name = "ResponseAudioTranscriptDone";
+        this.type = literal(options.type, "response.output_audio_transcript.done", name);
+        this.responseId = required(options, "responseId", name);
+        this.itemId = required(options, "itemId", name);
+        this.outputIndex = required(options, "outputIndex", name);
+        this.contentIndex = required(options, "contentIndex", name);
+        this.transcript = required(options, "transcript", name);
+    }
+}
+/**
+ * Event containing incremental audio data from a response.
+ *
+ * - `type`: event type, always "response.output_audio.delta".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `contentIndex`: index of the content part.
+ * - `delta`: base64-encoded incremental audio data.
+ */
+export class ResponseAudioDelta extends ServerEvent {
+    responseId;
+    itemId;
+    outputIndex;
+    contentIndex;
+    delta; // base64-encoded audio
+    constructor(options) {
+        super(options);
+        const name = "ResponseAudioDelta";
+        this.type = literal(options.type, "response.output_audio.delta", name);
+        this.responseId = required(options, "responseId", name);
+        this.itemId = required(options, "itemId", name);
+        this.outputIndex = required(options, "outputIndex", name);
+        this.contentIndex = required(options, "contentIndex", name);
+        this.delta = required(options, "delta", name);
+    }
+}
+/**
+ * Event indicating audio content is complete.
+ *
+ * - `type`: event type, always "response.output_audio.done".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `contentIndex`: index of the content part.
+ */
+export class ResponseAudioDone extends ServerEvent {
+    responseId;
+    itemId;
+    outputIndex;
+    contentIndex;
+    constructor(options) {
+        super(options);
+        const name = "ResponseAudioDone";
+        this.type = literal(options.type, "response.output_audio.done", name);
+        this.responseId = required(options, "responseId", name);
+        this.itemId = required(options, "itemId", name);
+        this.outputIndex = required(options, "outputIndex", name);
+        this.contentIndex = required(options, "contentIndex", name);
+    }
+}
+/**
+ * Event containing incremental function call arguments.
+ *
+ * - `type`: event type, always "response.function_call_arguments.delta".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `callId`: ID of the function call.
+ * - `delta`: incremental function arguments as JSON.
+ */
+export class ResponseFunctionCallArgumentsDelta extends ServerEvent {
+    responseId;
+    itemId;
+    outputIndex;
+    callId;
+    delta;
+    constructor(options) {
+        super(options);
+        const name = "ResponseFunctionCallArgumentsDelta";
+        this.type = literal(options.type, "response.function_call_arguments.delta", name);
+        this.responseId = required(options, "responseId", name);
+        this.itemId = required(options, "itemId", name);
+        this.outputIndex = required(options, "outputIndex", name);
+        this.callId = required(options, "callId", name);
+        this.delta = required(options, "delta", name);
+    }
+}
+/**
+ * Event indicating function call arguments are complete.
+ *
+ * - `type`: event type, always "response.function_call_arguments.done".
+ * - `responseId`: ID of the response.
+ * - `itemId`: ID of the conversation item.
+ * - `outputIndex`: index of the output item.
+ * - `callId`: ID of the function call.
+ * - `arguments`: complete function arguments as JSON string.
+ */
+export class ResponseFunctionCallArgumentsDone extends ServerEvent {
+    responseId;
+    itemId;
+    outputIndex;
+    callId;
+    arguments;
+    constructor(options) {
+        super(options);
+        const name = "ResponseFunctionCallArgumentsDone";
+        this.type = literal(options.type, "response.function_call_arguments.done", name);
+        this.responseId = required(options, "responseId", name);
+        this.itemId = required(options, "itemId", name);
+        this.outputIndex = required(options, "outputIndex", name);
+        this.callId = required(options, "callId", name);
+        this.arguments = required(options, "arguments", name);
+    }
+}
+/**
+ * Event indicating speech has started in the input audio buffer.
+ *
+ * - `type`: event type, always "input_audio_buffer.speech_started".
+ * - `audioStartMs`: start time of speech in milliseconds.
+ * - `itemId`: ID of the associated conversation item.
+ */
+export class InputAudioBufferSpeechStarted extends ServerEvent {
+    audioStartMs;
+    itemId;
+    constructor(options) {
+        super(options);
+        const name = "InputAudioBufferSpeechStarted";
+        this.type = literal(options.type, "input_audio_buffer.speech_started", name);
+        this.audioStartMs = required(options, "audioStartMs", name);
+        this.itemId = required(options, "itemId", name);
+    }
+}
+/**
+ * Event indicating speech has stopped in the input audio buffer.
+ *
+ * - `type`: event type, always "input_audio_buffer.speech_stopped".
+ * - `audioEndMs`: end time of speech in milliseconds.
+ * - `itemId`: ID of the associated conversation item.
+ */
+export class InputAudioBufferSpeechStopped extends ServerEvent {
+    audioEndMs;
+    itemId;
+    constructor(options) {
+        super(options);
+        const name = "InputAudioBufferSpeechStopped";
+        this.type = literal(options.type, "input_audio_buffer.speech_stopped", name);
+        this.audioEndMs = required(options, "audioEndMs", name);
+        this.itemId = required(options, "itemId", name);
+    }
+}
+/**
+ * Event indicating the input audio buffer has been committed.
+ *
+ * - `type`: event type, always "input_audio_buffer.committed".
+ * - `previousItemId`: ID of the previous item, if any.
+ * - `itemId`: ID of the committed conversation item.
+ */
+export class InputAudioBufferCommitted extends ServerEvent {
+    previousItemId;
+    itemId;
+    constructor(options) {
+        super(options);
+        const name = "InputAudioBufferCommitted";
+        this.type = literal(options.type, "input_audio_buffer.committed", name);
+        this.previousItemId = options.previousItemId ?? null;
+        this.itemId = required(options, "itemId", name);
+    }
+}
+/**
+ * Event indicating the input audio buffer has been cleared.
+ *
+ * - `type`: event type, always "input_audio_buffer.cleared".
+ */
+export class InputAudioBufferCleared extends ServerEvent {
+    constructor(options) {
+        super(options);
+        this.type = literal(options.type, "input_audio_buffer.cleared", "InputAudioBufferCleared");
+    }
+}
+/**
+ * Event indicating an error occurred.
+ *
+ * - `type`: event type, always "error".
+ * - `error`: error details.
+ */
+export class ErrorEvent extends ServerEvent {
+    static _nested = { error: model(RealtimeError) };
+    error;
+    constructor(options) {
+        super(options);
+        this.type = literal(options.type, "error", "ErrorEvent");
+        this.error = required(options, "error", "ErrorEvent");
+    }
+}
+/**
+ * Event indicating rate limits have been updated.
+ *
+ * - `type`: event type, always "rate_limits.updated".
+ * - `rateLimits`: list of rate limit information.
+ */
+export class RateLimitsUpdated extends ServerEvent {
+    rateLimits;
+    constructor(options) {
+        super(options);
+        this.type = literal(options.type, "rate_limits.updated", "RateLimitsUpdated");
+        this.rateLimits = required(options, "rateLimits", "RateLimitsUpdated");
+    }
+}
+/**
+ * Details about cached tokens.
+ *
+ * - `textTokens`: number of cached text tokens.
+ * - `audioTokens`: number of cached audio tokens.
+ */
+export class CachedTokensDetails extends BaseModel {
+    textTokens;
+    audioTokens;
+    constructor(options = {}) {
+        super();
+        this.textTokens = options.textTokens === undefined ? 0 : options.textTokens;
+        this.audioTokens = options.audioTokens === undefined ? 0 : options.audioTokens;
+    }
+}
+/**
+ * Detailed token usage information.
+ *
+ * Keys the model doesn't declare are kept (see `modelExtra`).
+ *
+ * - `cachedTokens`: number of cached tokens used. Defaults to 0.
+ * - `textTokens`: number of text tokens used. Defaults to 0.
+ * - `audioTokens`: number of audio tokens used. Defaults to 0.
+ * - `cachedTokensDetails`: detailed breakdown of cached tokens.
+ * - `imageTokens`: number of image tokens used (for input only).
+ */
+export class TokenDetails extends BaseModel {
+    static _nested = {
+        cachedTokensDetails: model(CachedTokensDetails),
+    };
+    static _extraAllowed = true;
+    cachedTokens;
+    textTokens;
+    audioTokens;
+    cachedTokensDetails;
+    imageTokens;
+    constructor(options = {}) {
+        super();
+        this.cachedTokens = options.cachedTokens === undefined ? 0 : options.cachedTokens;
+        this.textTokens = options.textTokens === undefined ? 0 : options.textTokens;
+        this.audioTokens = options.audioTokens === undefined ? 0 : options.audioTokens;
+        this.cachedTokensDetails = options.cachedTokensDetails ?? null;
+        this.imageTokens = options.imageTokens === undefined ? 0 : options.imageTokens;
+    }
+}
+/**
+ * Token usage statistics for a response.
+ *
+ * - `totalTokens`: total number of tokens used.
+ * - `inputTokens`: number of input tokens used.
+ * - `outputTokens`: number of output tokens used.
+ * - `inputTokenDetails`: detailed breakdown of input token usage.
+ * - `outputTokenDetails`: detailed breakdown of output token usage.
+ */
+export class Usage extends BaseModel {
+    static _nested = {
+        inputTokenDetails: model(TokenDetails),
+        outputTokenDetails: model(TokenDetails),
+    };
+    totalTokens;
+    inputTokens;
+    outputTokens;
+    inputTokenDetails;
+    outputTokenDetails;
+    constructor(options) {
+        super();
+        this.totalTokens = required(options, "totalTokens", "Usage");
+        this.inputTokens = required(options, "inputTokens", "Usage");
+        this.outputTokens = required(options, "outputTokens", "Usage");
+        this.inputTokenDetails = required(options, "inputTokenDetails", "Usage");
+        this.outputTokenDetails = required(options, "outputTokenDetails", "Usage");
+    }
+}
+/**
+ * A complete assistant response.
+ *
+ * - `id`: unique identifier for the response.
+ * - `object`: object type, always "realtime.response".
+ * - `status`: current status of the response.
+ * - `statusDetails`: additional status information.
+ * - `output`: list of conversation items in the response.
+ * - `outputModalities`: the set of modalities the model used to respond.
+ * - `maxOutputTokens`: maximum number of output tokens used.
+ * - `audio`: audio configuration for the response.
+ * - `usage`: token usage statistics for the response.
+ * - `voice`: the voice the model used to respond.
+ * - `temperature`: sampling temperature used for the response.
+ * - `outputAudioFormat`: the format of output audio.
+ */
+export class Response extends BaseModel {
+    static _nested = {
+        output: listOf(model(ConversationItem)),
+        audio: model(AudioConfiguration),
+        usage: model(Usage),
+    };
+    id;
+    object;
+    status;
+    statusDetails;
+    output;
+    outputModalities;
+    maxOutputTokens;
+    audio;
+    usage;
+    voice;
+    temperature;
+    outputAudioFormat;
+    constructor(options) {
+        super();
+        this.id = required(options, "id", "Response");
+        this.object = required(options, "object", "Response");
+        this.status = required(options, "status", "Response");
+        this.statusDetails = required(options, "statusDetails", "Response");
+        this.output = required(options, "output", "Response");
+        this.outputModalities = options.outputModalities ?? null;
+        this.maxOutputTokens = options.maxOutputTokens ?? null;
+        this.audio = options.audio ?? null;
+        this.usage = options.usage ?? null;
+        this.voice = options.voice ?? null;
+        this.temperature = options.temperature ?? null;
+        this.outputAudioFormat = options.outputAudioFormat ?? null;
+    }
+}
+const _serverEventTypes = {
+    error: ErrorEvent,
+    "session.created": SessionCreatedEvent,
+    "session.updated": SessionUpdatedEvent,
+    "conversation.created": ConversationCreated,
+    "input_audio_buffer.committed": InputAudioBufferCommitted,
+    "input_audio_buffer.cleared": InputAudioBufferCleared,
+    "input_audio_buffer.speech_started": InputAudioBufferSpeechStarted,
+    "input_audio_buffer.speech_stopped": InputAudioBufferSpeechStopped,
+    "conversation.item.added": ConversationItemAdded,
+    "conversation.item.done": ConversationItemDone,
+    "conversation.item.input_audio_transcription.delta": ConversationItemInputAudioTranscriptionDelta,
+    "conversation.item.input_audio_transcription.completed": ConversationItemInputAudioTranscriptionCompleted,
+    "conversation.item.input_audio_transcription.failed": ConversationItemInputAudioTranscriptionFailed,
+    "conversation.item.truncated": ConversationItemTruncated,
+    "conversation.item.deleted": ConversationItemDeleted,
+    "conversation.item.retrieved": ConversationItemRetrieved,
+    "response.created": ResponseCreated,
+    "response.done": ResponseDone,
+    "response.output_item.added": ResponseOutputItemAdded,
+    "response.output_item.done": ResponseOutputItemDone,
+    "response.content_part.added": ResponseContentPartAdded,
+    "response.content_part.done": ResponseContentPartDone,
+    "response.output_text.delta": ResponseTextDelta,
+    "response.output_text.done": ResponseTextDone,
+    "response.output_audio_transcript.delta": ResponseAudioTranscriptDelta,
+    "response.output_audio_transcript.done": ResponseAudioTranscriptDone,
+    "response.output_audio.delta": ResponseAudioDelta,
+    "response.output_audio.done": ResponseAudioDone,
+    "response.function_call_arguments.delta": ResponseFunctionCallArgumentsDelta,
+    "response.function_call_arguments.done": ResponseFunctionCallArgumentsDone,
+    "rate_limits.updated": RateLimitsUpdated,
+};
+/**
+ * Parse a server event from JSON string.
+ *
+ * @param str JSON string (or UTF-8 bytes) containing the server event.
+ * @returns Parsed server event object of the appropriate type.
+ * @throws Error If the event type is unimplemented or parsing fails.
+ */
+export function parseServerEvent(str) {
+    const text = typeof str === "string" ? str : new TextDecoder().decode(str);
+    try {
+        const event = pyJsonLoads(text);
+        if (!isPlainObject(event) || !("type" in event)) {
+            // Python's KeyError for the missing key.
+            throw new Error("'type'");
+        }
+        const eventType = event.type;
+        if (typeof eventType !== "string" || !Object.hasOwn(_serverEventTypes, eventType)) {
+            throw new Error(`Unimplemented server event type: ${eventType}`);
+        }
+        return _serverEventTypes[eventType].modelValidate(event);
+    }
+    catch (e) {
+        rethrowIfCancelled(e);
+        throw new Error(`${e instanceof Error ? e.message : String(e)} \n\n${text}`);
+    }
+}
+//# sourceMappingURL=events.js.map