@rebyteai/agent-sdk 0.2.0

package/resources/live/live.d.mts

@@ -0,0 +1,1864 @@
+import { APIResource } from "../../core/resource.mjs";
+import * as LiveAPI from "./live.mjs";
+import * as SessionsAPI from "./sessions.mjs";
+import { SessionAcceptParams, SessionForkParams, SessionForkResponse, SessionReferParams, SessionRejectParams, Sessions } from "./sessions.mjs";
+import * as ResponsesAPI from "../responses/responses.mjs";
+import * as ForksAPI from "./forks/forks.mjs";
+import { ForkClientEvent, ForkServerEvent, Forks } from "./forks/forks.mjs";
+import * as SidebandAPI from "./sideband/sideband.mjs";
+import { ConnectClientEvent, ConnectServerEvent, Sideband, SidebandConnectParams } from "./sideband/sideband.mjs";
+import { APIPromise } from "../../core/api-promise.mjs";
+import { RequestOptions } from "../../internal/request-options.mjs";
+export declare class Live extends APIResource {
+    sideband: SidebandAPI.Sideband;
+    forks: ForksAPI.Forks;
+    sessions: SessionsAPI.Sessions;
+    /**
+     * Create a Live WebRTC session. Start with the
+     * [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting).
+     *
+     * @example
+     * ```ts
+     * const live = await client.live.create({
+     *   session: { model: 'gpt-live-1' },
+     *   transport: { sdp: 'x', type: 'webrtc' },
+     * });
+     * ```
+     */
+    create(body: LiveCreateParams, options?: RequestOptions): APIPromise<LiveCreateResponse>;
+}
+/**
+ * Audio encoding and sample rate for audio sent and received over a Live WebSocket
+ * connection. WebRTC and SIP negotiate their media format separately.
+ */
+export type AudioFormat = AudioFormat.AudioPCM | AudioFormat.AudioPCMU | AudioFormat.AudioPCMA;
+export declare namespace AudioFormat {
+    /**
+     * Raw, mono 16-bit little-endian PCM audio for a Live WebSocket connection.
+     */
+    interface AudioPCM {
+        /**
+         * Audio sample rate in hertz. Live WebSocket PCM audio supports 16000 or 24000 Hz.
+         */
+        rate: 16000 | 24000;
+        /**
+         * The audio encoding. Always `audio/pcm`.
+         */
+        type: 'audio/pcm';
+    }
+    /**
+     * Raw, mono G.711 μ-law audio for a Live WebSocket connection.
+     */
+    interface AudioPCMU {
+        /**
+         * Audio sample rate in hertz. G.711 audio uses 8000 Hz.
+         */
+        rate: number;
+        /**
+         * The audio encoding. Always `audio/pcmu`.
+         */
+        type: 'audio/pcmu';
+    }
+    /**
+     * Raw, mono G.711 A-law audio for a Live WebSocket connection.
+     */
+    interface AudioPCMA {
+        /**
+         * Audio sample rate in hertz. G.711 audio uses 8000 Hz.
+         */
+        rate: number;
+        /**
+         * The audio encoding. Always `audio/pcma`.
+         */
+        type: 'audio/pcma';
+    }
+}
+/**
+ * A built-in voice available for Live speech.
+ */
+export type BuiltInVoice = 'alloy' | 'ash' | 'ballad' | 'beacon' | 'bossa' | 'cedar' | 'cinder' | 'coral' | 'delta' | 'echo' | 'gleam' | 'marin' | 'meridian' | 'quartz' | 'ripple' | 'sage' | 'shimmer' | 'stone' | 'tempo' | 'verse' | 'vesper' | 'willow';
+/**
+ * Startup-only capabilities for an untrusted frontend attached to a unified WebRTC
+ * session. Trusted sideband connections are unaffected.
+ */
+export interface ClientConfig {
+    /**
+     * Client and server event permissions for the WebRTC frontend data channel.
+     */
+    data_channel: DataChannelConfig;
+}
+/**
+ * Delegate tasks to your application. The Live session emits delegation events
+ * that your backend handles.
+ */
+export interface ClientDelegation {
+    /**
+     * The delegation owner. Always `client` for tasks handled by your application.
+     */
+    type: 'client';
+}
+/**
+ * Client events for Live. Initialize a primary WebSocket with session.start and
+ * wait for session.started. WebRTC creation already starts the session. Audio
+ * append is primary WebSocket-only. See the
+ * [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting)
+ * before writing frontend instructions and delegation policies.
+ */
+export type ClientEvent = SessionStartEvent | SessionUpdateEvent | InputAudioAppendEvent | InputAudioMuteEvent | InputAudioUnmuteEvent | InstructionsAppendEvent | ThinkingAppendEvent | CommentaryAppendEvent | ResponseItemCreateEvent | ResponseCreateEvent | SessionCloseEvent;
+/**
+ * Provide context the Live model can communicate to the user, optionally for an
+ * existing client delegation.
+ */
+export interface CommentaryAppendEvent {
+    /**
+     * Speakable context for the Live model, limited to 500 tokens. Use this for a
+     * result the model should communicate; use session.thinking.append for silent
+     * context.
+     */
+    content: string;
+    /**
+     * Required, nullable. Set null for general session context, or use the ID from
+     * session.delegation.created for an existing client delegation. Non-null IDs are
+     * not accepted with Responses delegation.
+     */
+    delegation_id: string | null;
+    /**
+     * The Live client event type. Always `session.commentary.append`.
+     */
+    type: 'session.commentary.append';
+    /**
+     * Optional client identifier for correlating this command with a server event's
+     * client_event_id or error.client_event_id.
+     */
+    event_id?: string | null;
+}
+/**
+ * Returned when a session.commentary.append command is accepted into the Live
+ * session timeline. Acknowledges the added commentary without guaranteeing exact
+ * wording or completed audio playback.
+ */
+export interface CommentaryAppendedEvent {
+    /**
+     * The end of this event on the Live session timeline, in milliseconds from the
+     * beginning of the session. For appended context, this can equal start_ms.
+     */
+    end_ms: number;
+    /**
+     * The unique ID of the Live server event.
+     */
+    event_id: string;
+    /**
+     * The start of this event on the Live session timeline, in milliseconds from the
+     * beginning of the session.
+     */
+    start_ms: number;
+    /**
+     * The event type, always `session.commentary.appended`.
+     */
+    type: 'session.commentary.appended';
+    /**
+     * The event_id of the client command associated with this server event, when
+     * supplied.
+     */
+    client_event_id?: string;
+}
+export interface CustomVoice {
+    id: string;
+}
+/**
+ * Control which Live events an untrusted WebRTC frontend can send and receive over
+ * its data channel. These restrictions do not apply to trusted sideband
+ * connections.
+ */
+export interface DataChannelConfig {
+    /**
+     * Client event types that the frontend data channel may send. Use 'all' to allow
+     * every client event; an empty array allows none. Omission preserves the existing
+     * allow-all behavior.
+     */
+    allowed_client_events?: 'all' | Array<string>;
+    /**
+     * Server events that may be sent to the frontend data channel. Use 'all' to allow
+     * every server event; an empty array allows none. Omission preserves the existing
+     * allow-all behavior. Responses events use an object with type 'response.event'
+     * and a response_event selector.
+     */
+    allowed_server_events?: 'all' | Array<ServerEventSelector>;
+}
+/**
+ * Returned when the Live model delegates work to your application or a Responses
+ * backend. Contains delegation metadata and the position on the session timeline
+ * where the work was delegated.
+ */
+export interface DelegationCreatedEvent {
+    /**
+     * The delegated work identifier and destination. This object contains metadata,
+     * not the task text.
+     */
+    delegation: DelegationCreatedEvent.Delegation;
+    /**
+     * The unique ID of the Live server event.
+     */
+    event_id: string;
+    /**
+     * The position on the Live session timeline where the delegation was created, in
+     * milliseconds from the beginning of the session.
+     */
+    offset_ms: number;
+    /**
+     * The event type, always `session.delegation.created`.
+     */
+    type: 'session.delegation.created';
+    /**
+     * The event_id of the client command associated with this server event, when
+     * supplied.
+     */
+    client_event_id?: string;
+}
+export declare namespace DelegationCreatedEvent {
+    /**
+     * The delegated work identifier and destination. This object contains metadata,
+     * not the task text.
+     */
+    interface Delegation {
+        /**
+         * The unique ID of the delegation. Use this as delegation_id when replying to
+         * client-owned work or correlating Responses events.
+         */
+        id: string;
+        /**
+         * Where the Live model delegated the work: `client` for your application, or
+         * `responses` for the configured Responses backend.
+         */
+        target: 'client' | 'responses';
+        /**
+         * The object type, always `delegation`.
+         */
+        type: 'delegation';
+        /**
+         * The ID of the Responses API response associated with a Responses delegation.
+         * Omitted for client delegations.
+         */
+        response_id?: string;
+    }
+}
+/**
+ * Details of an error encountered by the Live session, including the affected
+ * parameter or client command when available.
+ */
+export interface Error {
+    /**
+     * A machine-readable code identifying the Live error, such as `unknown_parameter`.
+     */
+    code: string;
+    /**
+     * A human-readable explanation of the Live error.
+     */
+    message: string;
+    /**
+     * The category of error, such as `invalid_request_error` for an invalid Live
+     * client command.
+     */
+    type: string;
+    /**
+     * The event_id of the client command that caused the error, when supplied.
+     */
+    client_event_id?: string;
+    /**
+     * The parameter that caused the error, when applicable, such as `session.voice`.
+     */
+    param?: string;
+}
+/**
+ * Reports an error in the Live session, such as an invalid client command. Use
+ * error.client_event_id, when present, to identify the command that caused the
+ * error.
+ */
+export interface ErrorEvent {
+    /**
+     * Details of the Live error and the client command that caused it, when known.
+     */
+    error: Error;
+    /**
+     * The unique ID of the Live server event.
+     */
+    event_id: string;
+    /**
+     * The event type, always `error`.
+     */
+    type: 'error';
+    /**
+     * The event_id of the client command associated with this server event, when
+     * supplied.
+     */
+    client_event_id?: string;
+}
+/**
+ * Overrides for a stored session after connecting to the fork WebSocket. An empty
+ * object inherits the stored configuration; do not supply a new model.
+ * audio.format applies only to the new WebSocket connection. client overrides are
+ * only supported for WebRTC forks.
+ */
+export interface ForkSessionConfig {
+    /**
+     * Audio format for a WebSocket fork. WebRTC forks negotiate their audio format and
+     * must omit this field.
+     */
+    audio?: ForkSessionConfig.Audio;
+    /**
+     * Frontend data-channel permissions for a WebRTC fork. Omitted permissions inherit
+     * the stored values. Not supported for WebSocket forks.
+     */
+    client?: ClientConfig;
+    /**
+     * Overrides for the stored session’s Responses backend. Only supported when the
+     * stored session already uses Responses delegation; the delegation type cannot
+     * change.
+     */
+    delegation?: ForkSessionConfig.Delegation;
+    /**
+     * Whether to store the forked session. Omission inherits the stored session's
+     * setting.
+     */
+    store?: boolean;
+}
+export declare namespace ForkSessionConfig {
+    /**
+     * Audio format for a WebSocket fork. WebRTC forks negotiate their audio format and
+     * must omit this field.
+     */
+    interface Audio {
+        /**
+         * Audio encoding and sample rate for audio sent and received over a Live WebSocket
+         * connection. WebRTC and SIP negotiate their media format separately.
+         */
+        format?: LiveAPI.AudioFormat;
+    }
+    /**
+     * Overrides for the stored session’s Responses backend. Only supported when the
+     * stored session already uses Responses delegation; the delegation type cannot
+     * change.
+     */
+    interface Delegation {
+        /**
+         * The delegation owner. Always `responses` for tasks handled by the Responses API.
+         */
+        type: 'responses';
+        /**
+         * Responses backend settings to update. Omitted settings keep their existing
+         * values.
+         */
+        responses?: LiveAPI.ResponsesDelegationUpdateConfig;
+    }
+}
+/**
+ * Start a Live session after connecting to a stored session’s fork WebSocket. Send
+ * an empty `session` object to use the stored configuration.
+ */
+export interface ForkSessionStartEvent {
+    /**
+     * Overrides for a stored session after connecting to the fork WebSocket. An empty
+     * object inherits the stored configuration; do not supply a new model.
+     * audio.format applies only to the new WebSocket connection. client overrides are
+     * only supported for WebRTC forks.
+     */
+    session: ForkSessionConfig;
+    /**
+     * The Live client event type. Always `session.start`.
+     */
+    type: 'session.start';
+    /**
+     * Optional client identifier for correlating this command with a server event's
+     * client_event_id or error.client_event_id.
+     */
+    event_id?: string | null;
+}
+/**
+ * A function tool available to the Responses backend when the Live model delegates
+ * a task.
+ */
+export interface FunctionTool {
+    /**
+     * The name the delegated Responses model uses when calling this function.
+     */
+    name: string;
+    /**
+     * The tool type. Always `function`.
+     */
+    type: 'function';
+    /**
+     * What the function does and when the delegated Responses model should call it.
+     */
+    description?: string | null;
+    /**
+     * A JSON Schema object describing the arguments accepted by the function.
+     */
+    parameters?: {
+        [key: string]: unknown;
+    } | null;
+    /**
+     * Whether the delegated Responses model must follow the function’s parameter
+     * schema exactly.
+     */
+    strict?: boolean | null;
+}
+/**
+ * An informational notice about the Live session, such as the event permissions
+ * applied to a frontend data channel.
+ */
+export interface InfoEvent {
+    /**
+     * A machine-readable code for the notice, such as `data_channel_permissions`.
+     */
+    code: string;
+    /**
+     * The unique ID of the Live server event.
+     */
+    event_id: string;
+    /**
+     * A human-readable explanation of the Live session notice.
+     */
+    message: string;
+    /**
+     * The event type, always `info`.
+     */
+    type: 'info';
+    /**
+     * The event_id of the client command associated with this server event, when
+     * supplied.
+     */
+    client_event_id?: string;
+}
+/**
+ * A developer, user, or assistant message supplied as text history before the Live
+ * session starts.
+ */
+export type InitialItem = InitialItem.Developer | InitialItem.User | InitialItem.Assistant;
+export declare namespace InitialItem {
+    /**
+     * A developer message included in the initial text history of a Live session.
+     */
+    interface Developer {
+        /**
+         * The message content. Supply exactly one text part for the initial Live
+         * conversation history.
+         */
+        content: Array<Developer.Content>;
+        /**
+         * The author of this history message. Always `developer`.
+         */
+        role: 'developer';
+        /**
+         * An optional identifier for the supplied history message. Live uses the message’s
+         * role and text to initialize the conversation.
+         */
+        id?: string | null;
+        /**
+         * The supplied message’s status. Live uses its text as history and does not resume
+         * an incomplete message.
+         */
+        status?: 'incomplete' | 'completed' | null;
+        /**
+         * The history item type. Always `message`.
+         */
+        type?: 'message';
+    }
+    namespace Developer {
+        /**
+         * Text supplied in a developer or user message when starting a Live session.
+         */
+        interface Content {
+            /**
+             * The message text to include in the Live session’s initial conversation history.
+             */
+            text: string;
+            /**
+             * The text content type. Always `input_text`.
+             */
+            type?: 'input_text';
+        }
+    }
+    /**
+     * A user message included in the initial text history of a Live session.
+     */
+    interface User {
+        /**
+         * The message content. Supply exactly one text part for the initial Live
+         * conversation history.
+         */
+        content: Array<User.Content>;
+        /**
+         * The author of this history message. Always `user`.
+         */
+        role: 'user';
+        /**
+         * An optional identifier for the supplied history message. Live uses the message’s
+         * role and text to initialize the conversation.
+         */
+        id?: string | null;
+        /**
+         * The supplied message’s status. Live uses its text as history and does not resume
+         * an incomplete message.
+         */
+        status?: 'incomplete' | 'completed' | null;
+        /**
+         * The history item type. Always `message`.
+         */
+        type?: 'message';
+    }
+    namespace User {
+        /**
+         * Text supplied in a developer or user message when starting a Live session.
+         */
+        interface Content {
+            /**
+             * The message text to include in the Live session’s initial conversation history.
+             */
+            text: string;
+            /**
+             * The text content type. Always `input_text`.
+             */
+            type?: 'input_text';
+        }
+    }
+    /**
+     * An assistant message included in the initial text history of a Live session.
+     */
+    interface Assistant {
+        /**
+         * The message content. Supply exactly one text part for the initial Live
+         * conversation history.
+         */
+        content: Array<Assistant.Text | Assistant.OutputText>;
+        /**
+         * The author of this history message. Always `assistant`.
+         */
+        role: 'assistant';
+        /**
+         * An optional identifier for the supplied history message. Live uses the message’s
+         * role and text to initialize the conversation.
+         */
+        id?: string | null;
+        /**
+         * The supplied message’s status. Live uses its text as history and does not resume
+         * an incomplete message.
+         */
+        status?: 'incomplete' | 'completed' | null;
+        /**
+         * The history item type. Always `message`.
+         */
+        type?: 'message';
+    }
+    namespace Assistant {
+        /**
+         * Assistant text supplied as conversation history when starting a Live session.
+         */
+        interface Text {
+            /**
+             * The message text to include in the Live session’s initial conversation history.
+             */
+            text: string;
+            /**
+             * The text content type. Always `text`.
+             */
+            type?: 'text';
+        }
+        /**
+         * Assistant output text supplied as conversation history when starting a Live
+         * session.
+         */
+        interface OutputText {
+            /**
+             * The message text to include in the Live session’s initial conversation history.
+             */
+            text: string;
+            /**
+             * The text content type. Always `output_text`.
+             */
+            type: 'output_text';
+        }
+    }
+}
+/**
+ * Send audio to a Live session over its primary WebSocket. WebRTC and SIP sessions
+ * send audio over their media transport.
+ */
+export interface InputAudioAppendEvent {
+    /**
+     * Base64-encoded raw audio in the startup-selected format, without a WAV or other
+     * container header. Primary WebSocket only; media transports use their audio
+     * track. Audio appends have no acknowledgment. Reflected sideband server events
+     * reuse this event type and audio key, with no timestamps or event_id; their audio
+     * is always mono PCM16LE at 24 kHz.
+     */
+    audio: string;
+    /**
+     * The Live client event type. Always `session.input_audio.append`.
+     */
+    type: 'session.input_audio.append';
+    /**
+     * Optional client identifier for correlating this command with a server event's
+     * client_event_id or error.client_event_id.
+     */
+    event_id?: string | null;
+}
+/**
+ * Mute audio input to the Live model without closing the session. The server
+ * acknowledges with `session.input_audio.muted`.
+ */
+export interface InputAudioMuteEvent {
+    /**
+     * The Live client event type. Always `session.input_audio.mute`.
+     */
+    type: 'session.input_audio.mute';
+    /**
+     * Optional client identifier for correlating this command with a server event's
+     * client_event_id or error.client_event_id.
+     */
+    event_id?: string | null;
+}
+/**
+ * Returned when a session.input_audio.mute command is accepted. Input audio is no
+ * longer sent to the model; sideband audio reflection continues.
+ */
+export interface InputAudioMutedEvent {
+    /**
+     * The unique ID of the Live server event.
+     */
+    event_id: string;
+    /**
+     * The event type, always `session.input_audio.muted`.
+     */
+    type: 'session.input_audio.muted';
+    /**
+     * The event_id of the client command associated with this server event, when
+     * supplied.
+     */
+    client_event_id?: string;
+}
+/**
+ * Resume audio input to a Live model after muting it. The server acknowledges with
+ * `session.input_audio.unmuted`.
+ */
+export interface InputAudioUnmuteEvent {
+    /**
+     * The Live client event type. Always `session.input_audio.unmute`.
+     */
+    type: 'session.input_audio.unmute';
+    /**
+     * Optional client identifier for correlating this command with a server event's
+     * client_event_id or error.client_event_id.
+     */
+    event_id?: string | null;
+}
+/**
+ * Returned when a session.input_audio.unmute command is accepted. Input audio is
+ * sent to the model again.
+ */
+export interface InputAudioUnmutedEvent {
+    /**
+     * The unique ID of the Live server event.
+     */
+    event_id: string;
+    /**
+     * The event type, always `session.input_audio.unmuted`.
+     */
+    type: 'session.input_audio.unmuted';
+    /**
+     * The event_id of the client command associated with this server event, when
+     * supplied.
+     */
+    client_event_id?: string;
+}
+/**
+ * A transcript fragment for user input audio in the Live session. Accumulate
+ * fragments in delivery order; these events do not define complete turns or
+ * include a transcript-done event.
+ */
+export interface InputTranscriptDeltaEvent {
+    /**
+     * The transcript text fragment for the audio in this time range. Append fragments
+     * in delivery order to build the transcript.
+     */
+    delta: string;
+    /**
+     * The end of this event on the Live session timeline, in milliseconds from the
+     * beginning of the session. For appended context, this can equal start_ms.
+     */
+    end_ms: number;
+    /**
+     * The unique ID of the Live server event.
+     */
+    event_id: string;
+    /**
+     * The start of this event on the Live session timeline, in milliseconds from the
+     * beginning of the session.
+     */
+    start_ms: number;
+    /**
+     * The event type, always `session.input_transcript.delta`.
+     */
+    type: 'session.input_transcript.delta';
+    /**
+     * The event_id of the client command associated with this server event, when
+     * supplied.
+     */
+    client_event_id?: string;
+}
+/**
+ * Append instructions to the Live conversation while it is running, optionally
+ * associating them with an existing client delegation.
+ */
+export interface InstructionsAppendEvent {
+    /**
+     * Instruction text to append, limited to 500 tokens. This is a plain string, not
+     * an array of content parts.
+     */
+    content: string;
+    /**
+     * Required, nullable. Set null for general session context, or use the ID from
+     * session.delegation.created for an existing client delegation. Non-null IDs are
+     * not accepted with Responses delegation.
+     */
+    delegation_id: string | null;
+    /**
+     * The Live client event type. Always `session.instructions.append`.
+     */
+    type: 'session.instructions.append';
+    /**
+     * Optional client identifier for correlating this command with a server event's
+     * client_event_id or error.client_event_id.
+     */
+    event_id?: string | null;
+}
+/**
+ * Returned when a session.instructions.append command is accepted into the Live
+ * session timeline. Acknowledges the appended instructions without guaranteeing
+ * that the model has acted on them.
+ */
+export interface InstructionsAppendedEvent {
+    /**
+     * The end of this event on the Live session timeline, in milliseconds from the
+     * beginning of the session. For appended context, this can equal start_ms.
+     */
+    end_ms: number;
+    /**
+     * The unique ID of the Live server event.
+     */
+    event_id: string;
+    /**
+     * The start of this event on the Live session timeline, in milliseconds from the
+     * beginning of the session.
+     */
+    start_ms: number;
+    /**
+     * The event type, always `session.instructions.appended`.
+     */
+    type: 'session.instructions.appended';
+    /**
+     * The event_id of the client command associated with this server event, when
+     * supplied.
+     */
+    client_event_id?: string;
+}
+/**
+ * Startup configuration for a Live media session. Follow the
+ * [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting)
+ * when writing frontend instructions and the backend prompt under
+ * delegation.responses.instructions.
+ */
+export interface MediaSessionConfig {
+    /**
+     * The Live model. Required in the session configuration for every transport; do
+     * not pass it as a URL query parameter.
+     */
+    model: (string & {}) | 'gpt-live-1';
+    /**
+     * Startup audio configuration. WebRTC and SIP negotiate their audio format on the
+     * media transport.
+     */
+    audio?: MediaSessionConfig.Audio;
+    /**
+     * Startup-only capabilities for an untrusted frontend attached to a unified WebRTC
+     * session. Trusted sideband connections are unaffected.
+     */
+    client?: ClientConfig;
+    /**
+     * Who handles tasks delegated by the Live model. Omitted or null selects your
+     * application; use `responses` to let the API manage a Responses backend.
+     */
+    delegation?: ClientDelegation | MediaSessionConfig.Responses | null;
+    /**
+     * Ordered text-only history supplied before startup. Supports developer, user, and
+     * assistant messages with one text part each; at most 128 messages and 8,192
+     * rendered tokens in total.
+     */
+    input?: Array<InitialItem>;
+    /**
+     * Frontend instructions for voice, conversation, interruptions, and when to
+     * delegate. Start with the
+     * [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting);
+     * put business rules and tool workflows in a separate
+     * [backend prompt](https://developers.openai.com/api/docs/guides/live-delegation#start-with-your-existing-backend-prompt).
+     * Limited to 16,384 client-supplied tokens. Omitted or blank instructions use
+     * server defaults. Immutable after startup.
+     */
+    instructions?: string | null;
+    /**
+     * Whether to store the session for later forking and recording download. Defaults
+     * to false for new sessions.
+     */
+    store?: boolean;
+}
+export declare namespace MediaSessionConfig {
+    /**
+     * Startup audio configuration. WebRTC and SIP negotiate their audio format on the
+     * media transport.
+     */
+    interface Audio {
+        /**
+         * Settings for speech generated by the Live model. Choose the voice before
+         * starting the session.
+         */
+        output?: Audio.Output;
+    }
+    namespace Audio {
+        /**
+         * Settings for speech generated by the Live model. Choose the voice before
+         * starting the session.
+         */
+        interface Output {
+            /**
+             * The voice used for Live speech, as a built-in voice name or a custom voice
+             * object containing its ID. Defaults to `marin` and cannot change after startup.
+             */
+            voice?: string | LiveAPI.BuiltInVoice | LiveAPI.CustomVoice;
+        }
+    }
+    /**
+     * Delegate tasks to a Responses model managed by the Live session.
+     */
+    interface Responses {
+        /**
+         * Backend model, prompt, and tools used when the Live session delegates a task to
+         * Responses.
+         */
+        responses: LiveAPI.ResponsesDelegationConfig;
+        /**
+         * The delegation owner. Always `responses` for tasks handled by the Responses API.
+         */
+        type: 'responses';
+    }
+}
+/**
+ * Optional overrides for a stored Live session. Omitted settings are inherited.
+ * The model, voice, frontend instructions, and prior conversation come from the
+ * stored session. WebRTC negotiates its audio format; audio.format is only
+ * supported on WebSocket forks.
+ */
+export interface MediaSessionForkConfig {
+    /**
+     * Startup-only capabilities for an untrusted frontend attached to a unified WebRTC
+     * session. Trusted sideband connections are unaffected.
+     */
+    client?: ClientConfig;
+    /**
+     * Update the Responses backend for an existing Live session without changing
+     * delegation ownership.
+     */
+    delegation?: MediaSessionForkConfig.Delegation;
+    /**
+     * Whether to store the forked session. Omission inherits the stored session's
+     * setting.
+     */
+    store?: boolean;
+}
+export declare namespace MediaSessionForkConfig {
+    /**
+     * Update the Responses backend for an existing Live session without changing
+     * delegation ownership.
+     */
+    interface Delegation {
+        /**
+         * The delegation owner. Always `responses` for tasks handled by the Responses API.
+         */
+        type: 'responses';
+        /**
+         * Responses backend settings to update. Omitted settings keep their existing
+         * values.
+         */
+        responses?: LiveAPI.ResponsesDelegationUpdateConfig;
+    }
+}
+/**
+ * An audio chunk generated by the Live model. Decode and play primary WebSocket
+ * chunks in delivery order using the configured session audio format. Sideband
+ * connections receive reflected output audio with timestamps.
+ */
+export interface OutputAudioDeltaEvent {
+    /**
+     * Base64-encoded raw audio. Primary WebSocket events use the session's configured
+     * format; reflected sideband events use mono PCM16LE at 24 kHz.
+     */
+    delta: string;
+    /**
+     * The event type, always `session.output_audio.delta`.
+     */
+    type: 'session.output_audio.delta';
+    /**
+     * Exclusive session-relative end in milliseconds. Required on reflected sideband
+     * events; omitted on the primary WebSocket. Dropped output frames leave gaps
+     * between reflected ranges.
+     */
+    end_ms?: number;
+    /**
+     * Inclusive session-relative start in milliseconds. Required on reflected sideband
+     * events; omitted on the primary WebSocket.
+     */
+    start_ms?: number;
+}
+/**
+ * A transcript fragment for assistant output audio in the Live session. Accumulate
+ * fragments in delivery order; these events do not define complete turns or
+ * include a transcript-done event.
+ */
+export interface OutputTranscriptDeltaEvent {
+    /**
+     * The transcript text fragment for the audio in this time range. Append fragments
+     * in delivery order to build the transcript.
+     */
+    delta: string;
+    /**
+     * The end of this event on the Live session timeline, in milliseconds from the
+     * beginning of the session. For appended context, this can equal start_ms.
+     */
+    end_ms: number;
+    /**
+     * The unique ID of the Live server event.
+     */
+    event_id: string;
+    /**
+     * The start of this event on the Live session timeline, in milliseconds from the
+     * beginning of the session.
+     */
+    start_ms: number;
+    /**
+     * The event type, always `session.output_transcript.delta`.
+     */
+    type: 'session.output_transcript.delta';
+    /**
+     * The event_id of the client command associated with this server event, when
+     * supplied.
+     */
+    client_event_id?: string;
+}
+/**
+ * Request a response from the Live session’s Responses backend, or continue a
+ * delegated response waiting for tool results. Requires Responses delegation.
+ */
+export interface ResponseCreateEvent {
+    /**
+     * The Live client event type. Always `response.create`.
+     */
+    type: 'response.create';
+    /**
+     * Optional client identifier for correlating this command with a server event's
+     * client_event_id or error.client_event_id.
+     */
+    event_id?: string | null;
+}
+/**
+ * A streaming Responses API event from a backend delegated to by the Live session.
+ * Use the outer delegation_id to associate the nested stream with its Live
+ * delegation.
+ */
+export interface ResponseEvent {
+    /**
+     * The nested Responses streaming event. Dispatch on its type field. Response
+     * lifecycle snapshots omit input and clear instructions, tools, and output to keep
+     * messages small; consume granular output events for the generated content.
+     */
+    event: {
+        [key: string]: unknown;
+    };
+    /**
+     * The unique ID of the Live server event.
+     */
+    event_id: string;
+    /**
+     * The event type, always `response.event`.
+     */
+    type: 'response.event';
+    /**
+     * The event_id of the client command associated with this server event, when
+     * supplied.
+     */
+    client_event_id?: string;
+    /**
+     * The Live delegation associated with the nested Responses event. May be null or
+     * omitted when the event cannot be correlated with a delegation.
+     */
+    delegation_id?: string | null;
+}
+/**
+ * Add an input item to the Live session’s Responses backend. Requires Responses
+ * delegation; use `response.create` to request a response.
+ */
+export interface ResponseItemCreateEvent {
+    /**
+     * An input item to append to the Responses backend conversation, such as a user
+     * message or a function tool result.
+     */
+    item: ResponsesAPI.ResponseInputItem;
+    /**
+     * The Live client event type. Always `response.item.create`.
+     */
+    type: 'response.item.create';
+    /**
+     * Optional client identifier for correlating this command with a server event's
+     * client_event_id or error.client_event_id.
+     */
+    event_id?: string | null;
+}
+/**
+ * Model, prompt, and tool settings for tasks delegated by the Live session to a
+ * Responses backend.
+ */
+export interface ResponsesDelegationConfig {
+    /**
+     * The model used for server-owned Responses delegations.
+     */
+    model: string;
+    /**
+     * Instructions for the delegated Responses model, separate from Live instructions.
+     * See
+     * [backend prompting](https://developers.openai.com/api/docs/guides/live-delegation#start-with-your-existing-backend-prompt).
+     */
+    instructions?: string | null;
+    /**
+     * Maximum number of output tokens for each delegated response.
+     */
+    max_output_tokens?: number | null;
+    /**
+     * Whether the delegated Responses model may request multiple tool calls in a
+     * single response.
+     */
+    parallel_tool_calls?: boolean | null;
+    /**
+     * Reasoning settings passed to each delegated Responses request.
+     */
+    reasoning?: ResponsesDelegationConfig.Reasoning | null;
+    /**
+     * Service tier for delegated Responses requests.
+     */
+    service_tier?: 'auto' | 'default' | 'fast_tier_temp_pilot' | 'flex' | 'priority' | 'ultrafast' | null;
+    /**
+     * Text generation settings passed to each delegated Responses request.
+     */
+    text?: ResponsesDelegationConfig.Text | null;
+    /**
+     * Controls which tool the Responses backend uses when handling a task delegated by
+     * the Live model.
+     */
+    tool_choice?: 'auto' | 'none' | 'required' | ResponsesDelegationConfig.LiveFunctionToolChoiceParam | ResponsesDelegationConfig.LiveMCPToolChoiceParam;
+    /**
+     * Tools available to the Responses backend while it handles tasks delegated by the
+     * Live model.
+     */
+    tools?: Array<FunctionTool | ResponsesDelegationConfig.WebSearch>;
+}
+export declare namespace ResponsesDelegationConfig {
+    /**
+     * Reasoning settings passed to each delegated Responses request.
+     */
+    interface Reasoning {
+        /**
+         * How much reasoning effort the delegated Responses model should use. Supported
+         * values depend on the backend model.
+         */
+        effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | null;
+        /**
+         * The reasoning summary to request from the delegated Responses model, when
+         * supported.
+         */
+        summary?: 'concise' | 'detailed' | 'auto' | null;
+    }
+    /**
+     * Text generation settings passed to each delegated Responses request.
+     */
+    interface Text {
+        /**
+         * The amount of detail in text generated by the Responses backend. This does not
+         * configure the Live model’s spoken delivery.
+         */
+        verbosity?: 'low' | 'medium' | 'high' | null;
+    }
+    interface LiveFunctionToolChoiceParam {
+        name: string;
+        type: 'function';
+    }
+    interface LiveMCPToolChoiceParam {
+        name: string;
+        server_label: string;
+        type: 'mcp';
+    }
+    /**
+     * A web search tool available to the Live session’s Responses backend.
+     */
+    interface WebSearch {
+        /**
+         * The tool type. Always `web_search`.
+         */
+        type: 'web_search';
+    }
+}
+/**
+ * Updates to the Responses backend of an existing Live session. Omitted settings
+ * retain their current values.
+ */
+export interface ResponsesDelegationUpdateConfig {
+    /**
+     * Instructions for the delegated Responses model, separate from Live instructions.
+     * See
+     * [backend prompting](https://developers.openai.com/api/docs/guides/live-delegation#start-with-your-existing-backend-prompt).
+     */
+    instructions?: string | null;
+    /**
+     * Maximum number of output tokens for each delegated response.
+     */
+    max_output_tokens?: number | null;
+    /**
+     * The Responses backend model to use for subsequent delegated requests. Omit to
+     * keep the current backend model.
+     */
+    model?: string;
+    /**
+     * Whether the delegated Responses model may request multiple tool calls in a
+     * single response.
+     */
+    parallel_tool_calls?: boolean | null;
+    /**
+     * Reasoning settings passed to each delegated Responses request.
+     */
+    reasoning?: ResponsesDelegationUpdateConfig.Reasoning | null;
+    /**
+     * Service tier for delegated Responses requests.
+     */
+    service_tier?: 'auto' | 'default' | 'fast_tier_temp_pilot' | 'flex' | 'priority' | 'ultrafast' | null;
+    /**
+     * Text generation settings passed to each delegated Responses request.
+     */
+    text?: ResponsesDelegationUpdateConfig.Text | null;
+    /**
+     * Controls which tool the Responses backend uses when handling a task delegated by
+     * the Live model.
+     */
+    tool_choice?: 'auto' | 'none' | 'required' | ResponsesDelegationUpdateConfig.LiveFunctionToolChoiceParam | ResponsesDelegationUpdateConfig.LiveMCPToolChoiceParam;
+    /**
+     * Tools available to the Responses backend while it handles tasks delegated by the
+     * Live model.
+     */
+    tools?: Array<FunctionTool | ResponsesDelegationUpdateConfig.WebSearch>;
+}
+export declare namespace ResponsesDelegationUpdateConfig {
+    /**
+     * Reasoning settings passed to each delegated Responses request.
+     */
+    interface Reasoning {
+        /**
+         * How much reasoning effort the delegated Responses model should use. Supported
+         * values depend on the backend model.
+         */
+        effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | null;
+        /**
+         * The reasoning summary to request from the delegated Responses model, when
+         * supported.
+         */
+        summary?: 'concise' | 'detailed' | 'auto' | null;
+    }
+    /**
+     * Text generation settings passed to each delegated Responses request.
+     */
+    interface Text {
+        /**
+         * The amount of detail in text generated by the Responses backend. This does not
+         * configure the Live model’s spoken delivery.
+         */
+        verbosity?: 'low' | 'medium' | 'high' | null;
+    }
+    interface LiveFunctionToolChoiceParam {
+        name: string;
+        type: 'function';
+    }
+    interface LiveMCPToolChoiceParam {
+        name: string;
+        server_label: string;
+        type: 'mcp';
+    }
+    /**
+     * A web search tool available to the Live session’s Responses backend.
+     */
+    interface WebSearch {
+        /**
+         * The tool type. Always `web_search`.
+         */
+        type: 'web_search';
+    }
+}
+/**
+ * Server events for Live. Response lifecycle events are wrapped inside
+ * response.event; dispatch the nested event by its full type and tolerate new
+ * response event types. Follow the
+ * [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting)
+ * when designing the conversation and delegation policy.
+ */
+export type ServerEvent = SessionStartedEvent | SessionUpdatedEvent | InputAudioMutedEvent | InputAudioUnmutedEvent | InstructionsAppendedEvent | ThinkingAppendedEvent | CommentaryAppendedEvent | ServerEvent.SessionInputAudioAppend | OutputAudioDeltaEvent | InputTranscriptDeltaEvent | OutputTranscriptDeltaEvent | DelegationCreatedEvent | ResponseEvent | SessionUsageUpdatedEvent | SessionClosedEvent | ErrorEvent | InfoEvent | ServerEvent.TransportDtmfReceived | ServerEvent.TransportDtmfSend | ServerEvent.TransportRinging | ServerEvent.TransportAnswered | ServerEvent.TransportFailed;
+export declare namespace ServerEvent {
+    /**
+     * Input audio received from the primary transport and reflected to a Live sideband
+     * connection before model-input muting.
+     */
+    interface SessionInputAudioAppend {
+        /**
+         * Base64-encoded raw mono PCM16LE at 24 kHz received from the primary transport,
+         * reflected to the sideband before model-input muting. This server event uses the
+         * same audio key as the client command, but is not an acknowledgment of it.
+         */
+        audio: string;
+        /**
+         * The event type, always `session.input_audio.append`.
+         */
+        type: 'session.input_audio.append';
+    }
+    /**
+     * A SIP DTMF keypress received from the caller. Delivered only to sideband
+     * observers.
+     */
+    interface TransportDtmfReceived {
+        event: string;
+        event_id: string;
+        type: 'transport.dtmf.received';
+    }
+    /**
+     * A SIP DTMF keypress successfully sent by the hosted tool. Delivered only to
+     * sideband observers; this is not a client command.
+     */
+    interface TransportDtmfSend {
+        event: string;
+        event_id: string;
+        type: 'transport.dtmf.send';
+    }
+    /**
+     * The outbound SIP provider leg is ringing or providing early media. Delivered
+     * only to sideband observers.
+     */
+    interface TransportRinging {
+        event_id: string;
+        /**
+         * The canonical Live session ID.
+         */
+        session_id: string;
+        type: 'transport.ringing';
+    }
+    /**
+     * The outbound SIP provider leg answered and media is established. Delivered only
+     * to sideband observers.
+     */
+    interface TransportAnswered {
+        event_id: string;
+        /**
+         * The canonical Live session ID.
+         */
+        session_id: string;
+        type: 'transport.answered';
+    }
+    /**
+     * An asynchronous outbound SIP setup failure. Delivered only to sideband
+     * observers.
+     */
+    interface TransportFailed {
+        error: TransportFailed.Error;
+        event_id: string;
+        /**
+         * The canonical Live session ID.
+         */
+        session_id: string;
+        type: 'transport.failed';
+    }
+    namespace TransportFailed {
+        interface Error {
+            /**
+             * The call setup failure code.
+             */
+            code: string;
+            message: string;
+            type: 'call_error';
+            /**
+             * The parameter related to the error, if any. Empty when no parameter applies.
+             */
+            param?: string;
+        }
+    }
+}
+/**
+ * A Live server event selector for the WebRTC frontend data channel.
+ */
+export interface ServerEventSelector {
+    /**
+     * The outer Live server event type. Use 'response.event' for Responses events.
+     */
+    type: string;
+    /**
+     * The nested Responses event type. Required when type is 'response.event';
+     * forbidden for other event types.
+     */
+    response_event?: string;
+}
+/**
+ * Request that the Live session close. The terminal `session.closed` event
+ * contains the close reason and final usage.
+ */
+export interface SessionCloseEvent {
+    /**
+     * The Live client event type. Always `session.close`.
+     */
+    type: 'session.close';
+    /**
+     * Optional client identifier for correlating this command with a server event's
+     * client_event_id or error.client_event_id.
+     */
+    event_id?: string | null;
+}
+/**
+ * Returned after the Live session finishes finalizing, with the close reason,
+ * final session snapshot, and cumulative audio usage. A connection closing without
+ * this event does not confirm successful finalization.
+ */
+export interface SessionClosedEvent {
+    /**
+     * The unique ID of the Live server event.
+     */
+    event_id: string;
+    /**
+     * Why the Live session ended: `close_requested` for an application close or hangup
+     * request, `expired` for the session duration limit, `content` for a safety
+     * filter, `remote_hangup` for a graceful remote disconnect, or `connection_lost`
+     * for an unexpected primary or upstream disconnection.
+     */
+    reason: 'close_requested' | 'expired' | 'content' | 'remote_hangup' | 'connection_lost';
+    /**
+     * The resolved Live session configuration and server-assigned session metadata.
+     */
+    session: SessionResource;
+    /**
+     * The event type, always `session.closed`.
+     */
+    type: 'session.closed';
+    /**
+     * The final cumulative Live audio usage after session finalization.
+     */
+    usage: SessionUsage;
+    /**
+     * The event_id of the client command associated with this server event, when
+     * supplied.
+     */
+    client_event_id?: string;
+}
+/**
+ * Initial configuration for a Live session, including its model, conversation
+ * instructions, audio, and delegated task handling.
+ */
+export interface SessionConfig {
+    /**
+     * The Live model. Required in the session configuration for every transport; do
+     * not pass it as a URL query parameter.
+     */
+    model: (string & {}) | 'gpt-live-1';
+    /**
+     * Startup audio configuration. Only primary WebSockets accept audio.format; WebRTC
+     * and SIP negotiate their media format. Voice and format are immutable after
+     * startup.
+     */
+    audio?: SessionConfig.Audio;
+    /**
+     * Startup-only capabilities for an untrusted frontend attached to a unified WebRTC
+     * session. Trusted sideband connections are unaffected.
+     */
+    client?: ClientConfig;
+    /**
+     * Who handles tasks delegated by the Live model. Omitted or null selects your
+     * application; use `responses` to let the API manage a Responses backend.
+     */
+    delegation?: ClientDelegation | SessionConfig.Responses | null;
+    /**
+     * Ordered text-only history supplied before startup. Supports developer, user, and
+     * assistant messages with one text part each; at most 128 messages and 8,192
+     * rendered tokens in total.
+     */
+    input?: Array<InitialItem>;
+    /**
+     * Frontend instructions for voice, conversation, interruptions, and when to
+     * delegate. Start with the
+     * [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting);
+     * put business rules and tool workflows in a separate
+     * [backend prompt](https://developers.openai.com/api/docs/guides/live-delegation#start-with-your-existing-backend-prompt).
+     * Limited to 16,384 client-supplied tokens. Omitted or blank instructions use
+     * server defaults. Immutable after startup.
+     */
+    instructions?: string | null;
+    /**
+     * Whether to store the session for later forking and recording download. Defaults
+     * to false for new sessions.
+     */
+    store?: boolean;
+}
+export declare namespace SessionConfig {
+    /**
+     * Startup audio configuration. Only primary WebSockets accept audio.format; WebRTC
+     * and SIP negotiate their media format. Voice and format are immutable after
+     * startup.
+     */
+    interface Audio {
+        /**
+         * Audio encoding and sample rate for audio sent and received over a Live WebSocket
+         * connection. WebRTC and SIP negotiate their media format separately.
+         */
+        format?: LiveAPI.AudioFormat;
+        /**
+         * The voice used for speech generated by the Live model.
+         */
+        output?: Audio.Output;
+    }
+    namespace Audio {
+        /**
+         * The voice used for speech generated by the Live model.
+         */
+        interface Output {
+            /**
+             * The voice used for Live speech, as a built-in voice name or a custom voice
+             * object containing its ID. Defaults to `marin` and cannot change after startup.
+             */
+            voice?: string | LiveAPI.BuiltInVoice | LiveAPI.CustomVoice;
+        }
+    }
+    /**
+     * Delegate tasks to a Responses model managed by the Live session.
+     */
+    interface Responses {
+        /**
+         * Backend model, prompt, and tools used when the Live session delegates a task to
+         * Responses.
+         */
+        responses: LiveAPI.ResponsesDelegationConfig;
+        /**
+         * The delegation owner. Always `responses` for tasks handled by the Responses API.
+         */
+        type: 'responses';
+    }
+}
+/**
+ * The resolved Live session configuration and server-assigned session metadata.
+ */
+export interface SessionResource {
+    /**
+     * The unique ID of the Live session. Use this ID for sideband connections,
+     * forking, and recording download.
+     */
+    id: string;
+    /**
+     * The Unix timestamp, in seconds, at which the Live session expires.
+     */
+    expires_at: number;
+    /**
+     * The Live model. Required in the session configuration for every transport; do
+     * not pass it as a URL query parameter.
+     */
+    model: (string & {}) | 'gpt-live-1';
+    /**
+     * The status of the session snapshot. Always `active`, including the final
+     * snapshot in session.closed; use the event type to determine that the session has
+     * closed.
+     */
+    status: 'active';
+    /**
+     * Startup audio configuration. Only primary WebSockets accept audio.format; WebRTC
+     * and SIP negotiate their media format. Voice and format are immutable after
+     * startup.
+     */
+    audio?: SessionResource.Audio;
+    /**
+     * Startup-only capabilities for an untrusted frontend attached to a unified WebRTC
+     * session. Trusted sideband connections are unaffected.
+     */
+    client?: ClientConfig;
+    /**
+     * Who handles tasks delegated by the Live model. Omitted or null selects your
+     * application; use `responses` to let the API manage a Responses backend.
+     */
+    delegation?: ClientDelegation | SessionResource.Responses | null;
+    /**
+     * Ordered text-only history supplied before startup. Supports developer, user, and
+     * assistant messages with one text part each; at most 128 messages and 8,192
+     * rendered tokens in total.
+     */
+    input?: Array<InitialItem>;
+    /**
+     * Frontend instructions for voice, conversation, interruptions, and when to
+     * delegate. Start with the
+     * [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting);
+     * put business rules and tool workflows in a separate
+     * [backend prompt](https://developers.openai.com/api/docs/guides/live-delegation#start-with-your-existing-backend-prompt).
+     * Limited to 16,384 client-supplied tokens. Omitted or blank instructions use
+     * server defaults. Immutable after startup.
+     */
+    instructions?: string | null;
+    /**
+     * Whether to store the session for later forking and recording download. Defaults
+     * to false for new sessions.
+     */
+    store?: boolean;
+}
+export declare namespace SessionResource {
+    /**
+     * Startup audio configuration. Only primary WebSockets accept audio.format; WebRTC
+     * and SIP negotiate their media format. Voice and format are immutable after
+     * startup.
+     */
+    interface Audio {
+        /**
+         * Audio encoding and sample rate for audio sent and received over a Live WebSocket
+         * connection. WebRTC and SIP negotiate their media format separately.
+         */
+        format?: LiveAPI.AudioFormat;
+        /**
+         * The voice used for speech generated by the Live model.
+         */
+        output?: Audio.Output;
+    }
+    namespace Audio {
+        /**
+         * The voice used for speech generated by the Live model.
+         */
+        interface Output {
+            /**
+             * The voice used for Live speech, as a built-in voice name or a custom voice
+             * object containing its ID. Defaults to `marin` and cannot change after startup.
+             */
+            voice?: string | LiveAPI.BuiltInVoice | LiveAPI.CustomVoice;
+        }
+    }
+    /**
+     * Delegate tasks to a Responses model managed by the Live session.
+     */
+    interface Responses {
+        /**
+         * Backend model, prompt, and tools used when the Live session delegates a task to
+         * Responses.
+         */
+        responses: LiveAPI.ResponsesDelegationConfig;
+        /**
+         * The delegation owner. Always `responses` for tasks handled by the Responses API.
+         */
+        type: 'responses';
+    }
+}
+/**
+ * Start a Live session on a primary WebSocket. Send this event before other
+ * commands and wait for `session.started`.
+ */
+export interface SessionStartEvent {
+    /**
+     * Initial configuration for a primary WebSocket. Send session.start first and wait
+     * for session.started before application commands. WebRTC creation already starts
+     * the session; do not send this event again on its data channel.
+     */
+    session: SessionConfig;
+    /**
+     * The Live client event type. Always `session.start`.
+     */
+    type: 'session.start';
+    /**
+     * Optional client identifier for correlating this command with a server event's
+     * client_event_id or error.client_event_id.
+     */
+    event_id?: string | null;
+}
+/**
+ * Returned when a Live session has started. Contains the resolved session
+ * configuration, including server defaults.
+ */
+export interface SessionStartedEvent {
+    /**
+     * The unique ID of the Live server event.
+     */
+    event_id: string;
+    /**
+     * The resolved Live session configuration and server-assigned session metadata.
+     */
+    session: SessionResource;
+    /**
+     * The event type, always `session.started`.
+     */
+    type: 'session.started';
+    /**
+     * The event_id of the client command associated with this server event, when
+     * supplied.
+     */
+    client_event_id?: string;
+}
+/**
+ * Changes to an active Live session. Only delegation backend settings can be
+ * updated after startup.
+ */
+export interface SessionUpdateConfig {
+    /**
+     * Delegation settings to update. The delegation type must match the current
+     * session; omitted settings retain their values.
+     */
+    delegation?: ClientDelegation | SessionUpdateConfig.Responses | null;
+}
+export declare namespace SessionUpdateConfig {
+    /**
+     * Update the Responses backend for an existing Live session without changing
+     * delegation ownership.
+     */
+    interface Responses {
+        /**
+         * The delegation owner. Always `responses` for tasks handled by the Responses API.
+         */
+        type: 'responses';
+        /**
+         * Responses backend settings to update. Omitted settings keep their existing
+         * values.
+         */
+        responses?: LiveAPI.ResponsesDelegationUpdateConfig;
+    }
+}
+/**
+ * Update the delegation settings of an active Live session. The server
+ * acknowledges accepted changes with `session.updated`.
+ */
+export interface SessionUpdateEvent {
+    /**
+     * Sparse delegation updates. Omitted settings retain their values. The delegation
+     * type cannot change, including resetting Responses delegation to null or client.
+     * Model, frontend instructions, audio, and startup input are immutable.
+     */
+    session: SessionUpdateConfig;
+    /**
+     * The Live client event type. Always `session.update`.
+     */
+    type: 'session.update';
+    /**
+     * Optional client identifier for correlating this command with a server event's
+     * client_event_id or error.client_event_id.
+     */
+    event_id?: string | null;
+}
+/**
+ * Returned when a Live session update is accepted. Contains the resolved session
+ * configuration after the update.
+ */
+export interface SessionUpdatedEvent {
+    /**
+     * The unique ID of the Live server event.
+     */
+    event_id: string;
+    /**
+     * The resolved Live session configuration and server-assigned session metadata.
+     */
+    session: SessionResource;
+    /**
+     * The event type, always `session.updated`.
+     */
+    type: 'session.updated';
+    /**
+     * The event_id of the client command associated with this server event, when
+     * supplied.
+     */
+    client_event_id?: string;
+}
+/**
+ * Cumulative audio duration for a Live session. Values are totals for the session,
+ * not increments to sum across usage events.
+ */
+export interface SessionUsage {
+    /**
+     * The cumulative Live audio duration in seconds. Do not sum this value across
+     * usage events.
+     */
+    seconds: number;
+}
+/**
+ * Reports cumulative Live audio usage and, when available, the most recent
+ * context-window usage. Delegated Responses token usage is reported separately in
+ * response.event events.
+ */
+export interface SessionUsageUpdatedEvent {
+    /**
+     * The unique ID of the Live server event.
+     */
+    event_id: string;
+    /**
+     * The event type, always `session.usage.updated`.
+     */
+    type: 'session.usage.updated';
+    /**
+     * The cumulative Live audio usage so far.
+     */
+    usage: SessionUsage;
+    /**
+     * The event_id of the client command associated with this server event, when
+     * supplied.
+     */
+    client_event_id?: string;
+    /**
+     * The latest measured Live context-window usage. Omitted when the context limit is
+     * unknown.
+     */
+    context_window?: SessionUsageUpdatedEvent.ContextWindow;
+}
+export declare namespace SessionUsageUpdatedEvent {
+    /**
+     * The latest measured Live context-window usage. Omitted when the context limit is
+     * unknown.
+     */
+    interface ContextWindow {
+        /**
+         * The latest active context token count divided by the Live model context limit.
+         * Can decrease after compaction and may lag between measured audio frames.
+         */
+        usage_ratio: number;
+    }
+}
+/**
+ * Provide silent reasoning or progress context to the Live model, optionally for
+ * an existing client delegation.
+ */
+export interface ThinkingAppendEvent {
+    /**
+     * Silent reasoning or progress context, limited to 500 tokens. It does not
+     * directly request speech, but can influence later speech and is not a secrecy
+     * boundary.
+     */
+    content: string;
+    /**
+     * Required, nullable. Set null for general session context, or use the ID from
+     * session.delegation.created for an existing client delegation. Non-null IDs are
+     * not accepted with Responses delegation.
+     */
+    delegation_id: string | null;
+    /**
+     * The Live client event type. Always `session.thinking.append`.
+     */
+    type: 'session.thinking.append';
+    /**
+     * Optional client identifier for correlating this command with a server event's
+     * client_event_id or error.client_event_id.
+     */
+    event_id?: string | null;
+}
+/**
+ * Returned when a session.thinking.append command is accepted into the Live
+ * session timeline. Acknowledges the added reasoning context without guaranteeing
+ * any spoken output.
+ */
+export interface ThinkingAppendedEvent {
+    /**
+     * The end of this event on the Live session timeline, in milliseconds from the
+     * beginning of the session. For appended context, this can equal start_ms.
+     */
+    end_ms: number;
+    /**
+     * The unique ID of the Live server event.
+     */
+    event_id: string;
+    /**
+     * The start of this event on the Live session timeline, in milliseconds from the
+     * beginning of the session.
+     */
+    start_ms: number;
+    /**
+     * The event type, always `session.thinking.appended`.
+     */
+    type: 'session.thinking.appended';
+    /**
+     * The event_id of the client command associated with this server event, when
+     * supplied.
+     */
+    client_event_id?: string;
+}
+/**
+ * The created Live session identifier and WebRTC answer. Apply transport.sdp as
+ * the peer's remote answer and wait for session.started on the data channel before
+ * sending commands.
+ */
+export interface LiveCreateResponse {
+    /**
+     * The newly created Live session. Use its ID for session controls and sideband
+     * connections.
+     */
+    session: LiveCreateResponse.Session;
+    /**
+     * WebRTC transport with the SDP answer.
+     */
+    transport: LiveCreateResponse.Transport;
+}
+export declare namespace LiveCreateResponse {
+    /**
+     * The newly created Live session. Use its ID for session controls and sideband
+     * connections.
+     */
+    interface Session {
+        /**
+         * Opaque session identifier. Preserve the returned value unchanged, including its
+         * prefix.
+         */
+        id: string;
+    }
+    /**
+     * WebRTC transport with the SDP answer.
+     */
+    interface Transport {
+        /**
+         * Session Description Protocol message for the WebRTC connection.
+         */
+        sdp: string;
+        /**
+         * The transport used for the Live session. Always `webrtc`.
+         */
+        type: 'webrtc';
+    }
+}
+export interface LiveCreateParams {
+    /**
+     * Startup configuration for the Live session.
+     */
+    session: MediaSessionConfig;
+    /**
+     * WebRTC transport with the browser's SDP offer.
+     */
+    transport: LiveCreateParams.Transport;
+}
+export declare namespace LiveCreateParams {
+    /**
+     * WebRTC transport with the browser's SDP offer.
+     */
+    interface Transport {
+        /**
+         * Session Description Protocol message for the WebRTC connection.
+         */
+        sdp: string;
+        /**
+         * The transport used for the Live session. Always `webrtc`.
+         */
+        type: 'webrtc';
+    }
+}
+export declare namespace Live {
+    export { type AudioFormat as AudioFormat, type BuiltInVoice as BuiltInVoice, type ClientConfig as ClientConfig, type ClientDelegation as ClientDelegation, type ClientEvent as ClientEvent, type CommentaryAppendEvent as CommentaryAppendEvent, type CommentaryAppendedEvent as CommentaryAppendedEvent, type CustomVoice as CustomVoice, type DataChannelConfig as DataChannelConfig, type DelegationCreatedEvent as DelegationCreatedEvent, type Error as Error, type ErrorEvent as ErrorEvent, type ForkSessionConfig as ForkSessionConfig, type ForkSessionStartEvent as ForkSessionStartEvent, type FunctionTool as FunctionTool, type InfoEvent as InfoEvent, type InitialItem as InitialItem, type InputAudioAppendEvent as InputAudioAppendEvent, type InputAudioMuteEvent as InputAudioMuteEvent, type InputAudioMutedEvent as InputAudioMutedEvent, type InputAudioUnmuteEvent as InputAudioUnmuteEvent, type InputAudioUnmutedEvent as InputAudioUnmutedEvent, type InputTranscriptDeltaEvent as InputTranscriptDeltaEvent, type InstructionsAppendEvent as InstructionsAppendEvent, type InstructionsAppendedEvent as InstructionsAppendedEvent, type MediaSessionConfig as MediaSessionConfig, type MediaSessionForkConfig as MediaSessionForkConfig, type OutputAudioDeltaEvent as OutputAudioDeltaEvent, type OutputTranscriptDeltaEvent as OutputTranscriptDeltaEvent, type ResponseCreateEvent as ResponseCreateEvent, type ResponseEvent as ResponseEvent, type ResponseItemCreateEvent as ResponseItemCreateEvent, type ResponsesDelegationConfig as ResponsesDelegationConfig, type ResponsesDelegationUpdateConfig as ResponsesDelegationUpdateConfig, type ServerEvent as ServerEvent, type ServerEventSelector as ServerEventSelector, type SessionCloseEvent as SessionCloseEvent, type SessionClosedEvent as SessionClosedEvent, type SessionConfig as SessionConfig, type SessionResource as SessionResource, type SessionStartEvent as SessionStartEvent, type SessionStartedEvent as SessionStartedEvent, type SessionUpdateConfig as SessionUpdateConfig, type SessionUpdateEvent as SessionUpdateEvent, type SessionUpdatedEvent as SessionUpdatedEvent, type SessionUsage as SessionUsage, type SessionUsageUpdatedEvent as SessionUsageUpdatedEvent, type ThinkingAppendEvent as ThinkingAppendEvent, type ThinkingAppendedEvent as ThinkingAppendedEvent, type LiveCreateResponse as LiveCreateResponse, type LiveCreateParams as LiveCreateParams, };
+    export { Sideband as Sideband, type ConnectClientEvent as ConnectClientEvent, type ConnectServerEvent as ConnectServerEvent, type SidebandConnectParams as SidebandConnectParams, };
+    export { Forks as Forks, type ForkClientEvent as ForkClientEvent, type ForkServerEvent as ForkServerEvent };
+    export { Sessions as Sessions, type SessionForkResponse as SessionForkResponse, type SessionAcceptParams as SessionAcceptParams, type SessionForkParams as SessionForkParams, type SessionReferParams as SessionReferParams, type SessionRejectParams as SessionRejectParams, };
+}
+//# sourceMappingURL=live.d.mts.map