@memberjunction/ai-realtime-client 5.48.0 → 5.50.0

package/dist/drivers/xaiRealtimeClient.d.ts

@@ -1,7 +1,5 @@
-import { ClientRealtimeSessionConfig, JSONObject } from '@memberjunction/ai';
-import { BaseRealtimeClient } from '../generic/baseRealtimeClient.js';
-import { IRealtimePcmPlayback } from '../audio/pcmPlayback.js';
-import { IPcmMicCapture } from '../audio/micCapture.js';
+import { ClientRealtimeSessionConfig } from '@memberjunction/ai';
+import { OpenAIProtocolWebSocketRealtimeClient, IOpenAIProtocolClientSocket, OpenAIProtocolClientEvent, OpenAIProtocolServerEvent } from '../generic/openAIProtocolClient.js';
 /**
  * The Grok Voice realtime websocket endpoint. The model is appended as a `?model=` query
  * parameter, derived from `config.Model` (e.g. `grok-voice-latest`) — unlike OpenAI's GA
@@ -21,143 +19,6 @@ export declare const XAI_CLIENT_SECRET_SUBPROTOCOL_PREFIX = "xai-client-secret."
  * down) — there is no per-session format negotiation on this provider.
  */
 export declare const XAI_PCM_SAMPLE_RATE = 24000;
-/** Streaming delta of the assistant's spoken-text transcript (GA or beta event name). */
-export interface XAIResponseAudioTranscriptDelta {
-    type: 'response.output_audio_transcript.delta' | 'response.audio_transcript.delta';
-    delta: string;
-    response_id?: string;
-    item_id?: string;
-}
-/** Final assistant transcript for a turn (GA or beta event name). */
-export interface XAIResponseAudioTranscriptDone {
-    type: 'response.output_audio_transcript.done' | 'response.audio_transcript.done';
-    transcript: string;
-    response_id?: string;
-    item_id?: string;
-}
-/**
- * One base64 PCM16 chunk of the agent's spoken output. The GA event is
- * `response.audio.delta`; the GA-output alias `response.output_audio.delta` is also accepted
- * so playback populates regardless of the model generation.
- */
-export interface XAIResponseAudioDelta {
-    type: 'response.audio.delta' | 'response.output_audio.delta';
-    delta: string;
-    response_id?: string;
-    item_id?: string;
-}
-/** Final transcription of the user's spoken input for a turn. */
-export interface XAIInputAudioTranscriptionCompleted {
-    type: 'conversation.item.input_audio_transcription.completed';
-    transcript: string;
-    item_id?: string;
-}
-/** The model finished assembling a function (tool) call and wants it executed. */
-export interface XAIFunctionCallArgumentsDone {
-    type: 'response.function_call_arguments.done';
-    call_id: string;
-    name: string;
-    /** JSON-encoded arguments. */
-    arguments: string;
-}
-/** The provider detected the user starting to speak (barge-in). */
-export interface XAIInputAudioBufferSpeechStarted {
-    type: 'input_audio_buffer.speech_started';
-}
-/** A new response (turn) started — tracked so we never start a second overlapping response. */
-export interface XAIResponseCreated {
-    type: 'response.created';
-}
-/**
- * A full response (turn) completed — carries the usage payload for THIS response
- * (`input_tokens` / `output_tokens`), i.e. per-response DELTAS, exactly the `OnUsage`
- * contract shape.
- */
-export interface XAIResponseDone {
-    type: 'response.done';
-    response?: {
-        usage?: {
-            input_tokens?: number;
-            output_tokens?: number;
-            [detail: string]: unknown;
-        };
-    };
-}
-/** Provider-side error frame. */
-export interface XAIErrorEvent {
-    type: 'error';
-    error?: {
-        message?: string;
-        code?: string;
-    };
-}
-/** Events whose `type` we don't explicitly handle still parse to this shape. */
-export interface XAIUnknownEvent {
-    type: string;
-}
-export type XAIRealtimeEvent = XAIResponseAudioTranscriptDelta | XAIResponseAudioTranscriptDone | XAIResponseAudioDelta | XAIInputAudioTranscriptionCompleted | XAIFunctionCallArgumentsDone | XAIInputAudioBufferSpeechStarted | XAIResponseCreated | XAIResponseDone | XAIErrorEvent | XAIUnknownEvent;
-/** Applies the server-built session config (instructions + tools) to the live session. */
-export interface XAISessionUpdateEvent {
-    type: 'session.update';
-    session: JSONObject;
-}
-/** A user or system `message` conversation item. */
-export interface XAIMessageItem {
-    type: 'message';
-    role: 'user' | 'system';
-    content: Array<{
-        type: 'input_text';
-        text: string;
-    }>;
-}
-/** The output of an executed function (tool) call, correlated by `call_id`. */
-export interface XAIFunctionCallOutputItem {
-    type: 'function_call_output';
-    call_id: string;
-    output: string;
-}
-/** Creates a conversation item (message or tool output). */
-export interface XAIConversationItemCreateEvent {
-    type: 'conversation.item.create';
-    item: XAIMessageItem | XAIFunctionCallOutputItem;
-}
-/** Asks the model to produce a response, optionally with one-off instructions. */
-export interface XAIResponseCreateEvent {
-    type: 'response.create';
-    response?: {
-        instructions: string;
-    };
-}
-/** Cancels the model's in-flight response (generation stops; a response.done follows). */
-export interface XAIResponseCancelEvent {
-    type: 'response.cancel';
-}
-/** Appends one base64 PCM16 mic chunk to the provider's input audio buffer. */
-export interface XAIInputAudioBufferAppendEvent {
-    type: 'input_audio_buffer.append';
-    audio: string;
-}
-export type XAIRealtimeClientEvent = XAISessionUpdateEvent | XAIConversationItemCreateEvent | XAIResponseCreateEvent | XAIResponseCancelEvent | XAIInputAudioBufferAppendEvent;
-/**
- * The minimal websocket surface this client depends on: assignable lifecycle handlers plus
- * `send`/`close`. Declaring the seam as an interface (rather than the platform `WebSocket`)
- * lets unit tests inject a fully in-memory fake that captures outbound frames and drives the
- * handlers with xAI-shaped events — no websocket, no network.
- */
-export interface IxAIClientSocket {
-    /** Invoked once the socket is open. */
-    onopen: (() => void) | null;
-    /** Invoked with each inbound frame's raw string payload. */
-    onmessage: ((data: string) => void) | null;
-    /** Invoked on a socket-level error (fatal). */
-    onerror: ((message: string) => void) | null;
-    /** Invoked when the socket closes (any reason). */
-    onclose: (() => void) | null;
-    /** Sends one JSON-serialized client frame. */
-    send(data: string): void;
-    /** Terminates the underlying connection. */
-    close(): void;
-}
 /**
  * xAI Grok Voice implementation of {@link BaseRealtimeClient}: a **browser-direct** websocket
  * connection to xAI's Grok Voice realtime API, authenticated with the server-minted ONE-TIME
@@ -168,38 +29,19 @@ export interface IxAIClientSocket {
  * matching Grok Voice driver stamps on its `ClientRealtimeSessionConfig` — so hosts resolve it
  * without referencing this class directly.
  *
- * It is the structural CROSS of the two sibling drivers:
- * - Like the AssemblyAI client driver, the transport is a WEBSOCKET and the audio plane is
- *   CLIENT-OWNED: mic PCM16 streams out as base64 frames via the shared {@link createPcmMicCapture}
- *   worklet, and the agent's base64 audio chunks feed the shared {@link RealtimePcmPlayback}
- *   engine ({@link IsAudioPlaying} comes from its playout clock). There is NO SDP handshake, NO
- *   peer connection, NO remote-audio sink element.
- * - Like the OpenAI client driver, the EVENT PROTOCOL is OpenAI-Realtime-API compatible: the
- *   same client events (session.update, conversation.item.create, response.create,
- *   response.cancel, input_audio_buffer.append) and the same server events
- *   (response.output_audio_transcript.delta and .done, response.audio.delta,
- *   conversation.item.input_audio_transcription.completed,
- *   response.function_call_arguments.done, response.created, response.done,
- *   input_audio_buffer.speech_started, error). The response state machine, narration-kind
- *   tagging, and tool-result queueing are identical to the OpenAI driver.
+ * Grok Voice speaks the OpenAI Realtime wire protocol over a websocket with a client-owned PCM
+ * audio plane, so nearly everything lives in the shared layers: the protocol brain
+ * (`OpenAIProtocolRealtimeClient`) and the websocket+PCM transport
+ * ({@link OpenAIProtocolWebSocketRealtimeClient}). This class supplies only the Grok
+ * specifics: the model-on-URL endpoint + subprotocol auth, the FIXED 24 kHz audio format,
+ * Grok's STREAMED input-transcription behavior, and wire diagnostics.
  *
- * Connect handshake: open the model-on-URL endpoint with the subprotocol auth → on socket open,
- * apply the server-authored `config.SessionConfig` via a `session.update` frame → build the
- * audio plane at the provider's FIXED 24 kHz PCM16 format → report `'listening'`. The
- * `'listening'` gate is the socket-open + session.update applied point (obligation #7): unlike
- * AssemblyAI there is no separate `session.ready` confirmation in this protocol, so applying the
- * config on open is the readiness boundary.
+ * Connect handshake (shared skeleton): open the socket → apply the server-authored
+ * `config.SessionConfig` via `session.update` on OPEN (this protocol has no separate readiness
+ * ack, so applying the config on open is the readiness boundary — obligation #7) → build the
+ * audio plane at 24 kHz → report `'listening'`.
  */
-export declare class xAIRealtimeClient extends BaseRealtimeClient {
-    private socket;
-    private micStream;
-    private micCapture;
-    private playback;
-    /**
-     * The server-built session config applied verbatim via `session.update` once the socket
-     * opens. Protected so test subclasses can seed it without a full Connect.
-     */
-    protected sessionConfig: JSONObject | null;
+export declare class xAIRealtimeClient extends OpenAIProtocolWebSocketRealtimeClient {
     /**
      * Whether the CURRENT user turn has already emitted a transcription. Grok streams input
      * transcription as repeated `.completed` events (each the full growing text), so the first emission
@@ -207,219 +49,64 @@ export declare class xAIRealtimeClient extends BaseRealtimeClient {
      * stack of growing duplicates. Reset on each `input_audio_buffer.speech_started` (new turn).
      */
     private userTurnTranscribed;
-    /** Accumulates the in-flight assistant transcript across delta frames. */
-    private pendingAssistantText;
-    /** True while the model has a response in flight; gates narration + queues the tool result. */
-    private responseActive;
-    /** Set when a tool result is ready while a response is active; sent on the next response.done. */
-    private pendingResultResponse;
-    /**
-     * Set by {@link RequestSpokenUpdate} just before it sends its `response.create`, and
-     * CONSUMED by the very next `response.created` frame, which stamps
-     * {@link activeResponseKind} for that turn.
-     */
-    private pendingNarrationKind;
-    /**
-     * The kind of the response currently in flight. Event ordering: `response.created` →
-     * transcript deltas → `*_audio_transcript.done` → `response.done`. The transcript-done
-     * frame therefore arrives while the kind is still set, letting {@link onAssistantDone}
-     * classify the turn; `response.done` then resets the kind to `'normal'`.
-     */
-    private activeResponseKind;
     /**
-     * The client's own view of the session state — mirrors what {@link emitStateChange} last
-     * reported, EXCEPT after a tool call is emitted: the host typically shows its own busy
-     * indicator then, so the client silently leaves `'speaking'` (no emission) to preserve the
-     * host's indicator until the result reply starts (see {@link handleEvent}).
+     * Text of the current user turn's latest streamed caption, used to recognize that a post-pause
+     * caption CONTINUES the same utterance (Grok re-emits the full accumulated text) rather than
+     * starting a new turn. Cleared in {@link onResponseStarted} — once the model replies, the user's
+     * turn is over and a later utterance must never merge into it. Mirrors the server session.
      */
-    private currentState;
-    /** True once Disconnect ran — an expected socket close must not surface as fatal. */
-    private closedByConsumer;
+    private lastUserTranscript;
+    /** @inheritdoc — used in the shared diagnostics + close messages. */
+    protected get providerDebugLabel(): string;
+    /** @inheritdoc — model on the URL, ephemeral secret as the subprotocol. */
+    protected openProviderSocket(config: ClientRealtimeSessionConfig): IOpenAIProtocolClientSocket;
+    /** @inheritdoc — the Grok Voice wire format is fixed at 24 kHz PCM16 both directions. */
+    protected resolveSampleRate(_config: ClientRealtimeSessionConfig): number;
     /**
-     * Opens the client-direct Grok Voice websocket: the model-on-URL endpoint with the
-     * subprotocol auth, the server-authored `config.SessionConfig` applied via `session.update`
-     * once the socket opens, then the audio plane at the provider's fixed 24 kHz format. Reports
-     * `'listening'` only after all of that (obligation #7).
-     */
-    Connect(config: ClientRealtimeSessionConfig, micStream: MediaStream): Promise<void>;
-    /**
-     * Tears down the socket, mic capture, mic tracks, and playout engine, resets the response
-     * state machine, and emits a final `'closed'` (unless already `'error'`). Safe to call more
-     * than once.
-     */
-    Disconnect(): Promise<void>;
-    /**
-     * Injects typed text as a user-role `message` conversation item, then triggers a reply
-     * through the SAME collision-safe path tool results use ({@link requestResultResponse}).
-     * No-op when the socket isn't open.
-     *
-     * **SendText implies barge-in** (base-contract rule): an active spoken response is cancelled
-     * via {@link CancelActiveResponse} before the text is injected, so the typed turn takes the
-     * floor immediately instead of waiting behind stale speech. When nothing is active the cancel
-     * is a no-op and the reply triggers immediately.
+     * Creation seam for the realtime websocket. Production wraps the platform-global `WebSocket`
+     * opened against the model-on-URL endpoint WITH the `xai-client-secret.<token>` subprotocol
+     * (browser auth — no handshake header is possible); unit tests override this to return an
+     * in-memory fake. Handlers are attached by the shared Connect AFTER this returns, so the
+     * implementation must not require them at construction time.
      */
-    SendText(text: string): void;
+    protected createSocket(url: string, subprotocol: string): IOpenAIProtocolClientSocket;
     /**
      * @inheritdoc
      *
-     * Sends `response.cancel` (only when a response is actually in flight) and flushes the
-     * locally-owned playout queue so already-generated speech stops coming out of the speaker
-     * immediately. Resets the local response state machine (active flag, narration kind,
-     * accumulated transcript) but PRESERVES any queued tool-result trigger: delegated work is
-     * never affected by a floor-control cancel, and the queued trigger still fires on the
-     * cancelled response's trailing `response.done`. No-op when idle or when the socket is gone.
+     * Grok STREAMS the input transcription — repeated `input_audio_transcription.completed`
+     * events, each carrying the full text so far — unlike OpenAI's single final. So the FIRST
+     * emission of a turn appends a fresh caption and every later one is flagged
+     * ReplacesPrevious, collapsing the stream into ONE in-place-updating user bubble. The
+     * per-turn flag resets on the next `speech_started` ({@link onSpeechStartedFrame}).
      */
-    CancelActiveResponse(): void;
+    protected onUserTranscriptFrame(transcript: string): void;
     /**
-     * Injects a system-role context item the model can draw on the next time it speaks, WITHOUT
-     * forcing a reply. Item creation is always safe mid-response, so it is sent immediately even
-     * while a reply is in flight.
-     *
-     * NOTE: role must be 'system' — the OpenAI-compatible realtime API rejects 'developer' items.
-     */
-    SendContextNote(text: string): void;
-    /**
-     * Triggers ONE short spoken update with the given instructions. Marks the upcoming response
-     * as `'narration'` (flag consumed by the next `response.created`) so its transcripts are
-     * emitted with `Kind: 'narration'` — ephemeral by contract. Sets {@link responseActive}
-     * eagerly so a tool result landing mid-narration queues instead of colliding.
+     * @inheritdoc
      *
-     * **Skips when busy** (base-contract collision rule — drivers MUST queue or skip): a
-     * `response.create` sent while a response is in flight would be rejected/garbled by the
-     * provider, and narration is disposable by contract, so the update is dropped with a debug
-     * log rather than queued to come out late and stale. Hosts SHOULD still gate on
-     * {@link IsBusy} / {@link IsAudioPlaying} for timing quality.
-     */
-    RequestSpokenUpdate(instructions: string): void;
-    /**
-     * Sends the tool result back as a `function_call_output` conversation item, then triggers a
-     * reply — immediately if the model is idle, otherwise queued until the current response
-     * (e.g. a progress narration) finishes. Without the queueing the result's `response.create`
-     * would collide with an in-flight narration and be dropped, leaving the model silent when
-     * delegated work comes back.
+     * On top of the shared websocket behavior (flush local playout on TRUE barge-in, gated
+     * interruption): a new user turn begins, so the streamed-transcription flag resets, and an
+     * interrupted response's busy flag is cleared eagerly (Grok cancels its own turn; clearing
+     * now lets a queued tool result fire without waiting on the trailing `response.done`).
      */
-    SendToolResult(callID: string, outputJson: string): void;
-    /**
-     * Mutes / unmutes by toggling the mic tracks' `enabled` flag: the capture pipeline stays up
-     * and streams SILENCE while muted (the provider's VAD sees a continuous stream and the
-     * un-mute is glitch-free — same policy as the other client drivers).
-     */
-    SetMuted(muted: boolean): void;
-    /** @inheritdoc */
-    get IsBusy(): boolean;
     /**
      * @inheritdoc
      *
-     * Computed directly from the playout engine's playhead clock — this client OWNS the output
-     * buffer, so "audibly playing" is precisely "scheduled audio extends beyond the audio
-     * context's current time".
-     */
-    get IsAudioPlaying(): boolean;
-    /**
-     * Creation seam for the realtime websocket. Production wraps the platform-global `WebSocket`
-     * opened against the model-on-URL endpoint WITH the `xai-client-secret.<token>` subprotocol
-     * (browser auth — no handshake header is possible); unit tests override this to return an
-     * in-memory fake. Handlers are attached by {@link Connect} AFTER this returns, so the
-     * implementation must not require them at construction time.
-     */
-    protected createSocket(url: string, subprotocol: string): IxAIClientSocket;
-    /**
-     * Creation seam for the mic-capture pipeline at the provider's fixed 24 kHz rate. Production
-     * delegates to the shared {@link createPcmMicCapture}; unit tests override this with a no-op
-     * fake (and may capture `onPcmChunk` to simulate mic frames).
-     */
-    protected createMicCapture(micStream: MediaStream, sampleRate: number, onPcmChunk: (base64Pcm16: string) => void): Promise<IPcmMicCapture>;
-    /**
-     * Creation seam for the playout engine at the provider's fixed 24 kHz rate. Production
-     * returns the shared {@link RealtimePcmPlayback}.
-     */
-    protected createPlayback(sampleRate: number): IRealtimePcmPlayback;
-    /**
-     * Sends the server-controlled session config (instructions + tools) as a `session.update` so
-     * the co-agent's identity and tool set apply. Skipped when the host supplied no config (e.g.
-     * it failed to parse the server payload — the host already logged that; sending an EMPTY
-     * `session.update` would be wrong).
-     */
-    private applySessionConfig;
-    /** Streams one base64 PCM16 mic chunk as an `input_audio_buffer.append` frame. */
-    private sendMicChunk;
-    /** Surfaces a fatal socket error and marks the session unusable (obligation #6). */
-    private handleSocketError;
-    /**
-     * A socket close the CONSUMER didn't ask for is fatal: the provider hard-closes at token
-     * expiry and when it ends the session itself, so an unexpected close is how credential /
-     * session death reaches the host (obligation #6).
-     */
-    private handleSocketClose;
-    /** Parses one raw socket payload; non-JSON frames are ignored. */
-    private handleSocketMessage;
-    /** Dispatches a typed xAI realtime server event to the appropriate behavior. */
-    private handleEvent;
-    /** Appends an assistant transcript delta, reflects `'speaking'`, and emits the delta. */
-    private onAssistantDelta;
-    /**
-     * Finalizes the assistant turn: emits the final transcript tagged with the ACTIVE response
-     * kind (the transcript-done frame arrives BEFORE `response.done`, so
-     * {@link activeResponseKind} still reflects this turn), then returns to `'listening'`. Empty
-     * turns emit nothing.
-     */
-    private onAssistantDone;
-    /**
-     * Decodes one base64 PCM16 chunk of the agent's spoken output into the playout queue and
-     * reflects `'speaking'`. The client OWNS the audio plane on this websocket transport (unlike
-     * the WebRTC OpenAI driver where the peer connection plays the remote track), so agent audio
-     * arrives as these deltas and is scheduled by the shared playout engine.
-     */
-    private onAudioDelta;
-    /**
-     * Emits the user's spoken-input transcription. Grok STREAMS this — repeated
-     * `input_audio_transcription.completed` events, each carrying the full text so far — unlike OpenAI's
-     * single final. So the FIRST emission of a turn appends a fresh caption and every later one is flagged
-     * ReplacesPrevious, collapsing the stream into ONE in-place-updating user bubble. The per-turn flag
-     * resets on the next `speech_started` ({@link onSpeechStarted}).
-     */
-    private onUserTranscript;
-    /**
-     * Surfaces a completed tool call to the host. Two deliberate behaviors mirror the OpenAI
-     * driver: (1) the client silently leaves `'speaking'` (NO emission) so a host-rendered busy
-     * indicator isn't clobbered by this turn's trailing `response.done` / playback frames
-     * (obligation #1); (2) {@link responseActive} is CLEARED — the model has yielded the floor
-     * pending the result, so a queued {@link SendToolResult} can never deadlock (obligation #2).
-     */
-    private onToolCallFrame;
-    /**
-     * The user started speaking. This is a TRUE barge-in only when it cut off active model output
-     * (a response in flight or audio audibly playing) — a normal turn while the model is idle is
-     * NOT an interruption, so the emission is gated (base-contract rule). On a true barge-in the
-     * client OWNS the audio plane, so it flushes its own playout queue NOW (obligation #3),
-     * surfaces the interruption, and returns the floor; the provider cancels its own turn and
-     * emits a terminal `response.done`.
-     */
-    private onSpeechStarted;
-    /**
-     * Emits the completed response's usage to the host as a DELTA (the `response.done` usage
-     * payload covers exactly this response, so it is already incremental — the `OnUsage`
-     * contract's preferred shape). Frames without a usage payload emit nothing.
-     */
-    private emitResponseUsage;
-    /** Surfaces a provider error frame (non-fatal; the session continues). */
-    private onErrorFrame;
-    /**
-     * Asks the model to speak (a tool result or typed-text reply) — immediately if it's idle,
-     * otherwise queued until the current response finishes. An immediate trigger also CONSUMES
-     * any queued trigger debt: every payload item is already in the conversation, so one
-     * `response.create` voices everything (e.g. typed text barging in over a narration that had
-     * tool results queued behind it).
-     */
-    private requestResultResponse;
-    /** On a turn completing, fire any queued tool-result response so the answer is spoken. */
-    private flushPendingResultResponse;
-    /** Resets the per-session response state machine (used on Disconnect). */
-    private resetResponseState;
-    /** Updates the client's own state view and emits the change to the host. */
-    private setState;
-    /** JSON-serializes + sends a client event over the socket (only when open). */
-    private sendEvent;
+     * The model has taken the floor, so the user's turn is definitively over — drop the continuation
+     * anchor. Without this, a later utterance that happened to open with the same words could be
+     * merged into the previous turn instead of appending its own.
+     */
+    protected onResponseStarted(): void;
+    protected onSpeechStartedFrame(): void;
+    /** @inheritdoc — provider-branded transport-error message (kept stable for hosts/logs). */
+    protected formatTransportError(message: string): string;
+    /** @inheritdoc — provider-branded unexpected-close message (kept stable for hosts/logs). */
+    protected get unexpectedCloseMessage(): string;
+    /** @inheritdoc — log every inbound event type; error frames include their payload. */
+    protected logInboundEvent(event: OpenAIProtocolServerEvent): void;
+    /** @inheritdoc */
+    protected onNonJsonFrame(raw: string): void;
+    /** @inheritdoc — log outbound control frames (skip the high-frequency mic audio). */
+    protected logOutboundEvent(event: OpenAIProtocolClientEvent): void;
 }
 /**
  * Tree-shaking prevention: bundlers cannot see that {@link xAIRealtimeClient} is instantiated

package/dist/drivers/xaiRealtimeClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"xaiRealtimeClient.d.ts","sourceRoot":"","sources":["../../src/drivers/xaiRealtimeClient.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"xaiRealtimeClient.d.ts","sourceRoot":"","sources":["../../src/drivers/xaiRealtimeClient.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,2BAA2B,EAA4B,MAAM,oBAAoB,CAAC;AAE3F,OAAO,EACH,qCAAqC,EACrC,2BAA2B,EAC3B,yBAAyB,EACzB,yBAAyB,EAC5B,MAAM,iCAAiC,CAAC;AAIzC;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,+BAA+B,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,oCAAoC,uBAAuB,CAAC;AAEzE;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,QAAQ,CAAC;AAkBzC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBACa,iBAAkB,SAAQ,qCAAqC;IACxE;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB,CAAS;IAEpC;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB,CAAM;IAEhC,qEAAqE;IACrE,cAAuB,kBAAkB,IAAI,MAAM,CAElD;IAID,2EAA2E;IAC3E,SAAS,CAAC,kBAAkB,CAAC,MAAM,EAAE,2BAA2B,GAAG,2BAA2B;IAM9F,yFAAyF;IACzF,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,2BAA2B,GAAG,MAAM;IAIzE;;;;;;OAMG;IACH,SAAS,CAAC,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,2BAA2B;IAuBrF;;;;;;;;OAQG;cACgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAkBlE;;;;;;;OAOG;IACH;;;;;;OAMG;cACgB,iBAAiB,IAAI,IAAI;cAIzB,oBAAoB,IAAI,IAAI;IAa/C,2FAA2F;cACxE,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAIhE,4FAA4F;IAC5F,cAAuB,sBAAsB,IAAI,MAAM,CAEtD;IAID,sFAAsF;cACnE,eAAe,CAAC,KAAK,EAAE,yBAAyB,GAAG,IAAI;IAK1E,kBAAkB;cACC,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIpD,qFAAqF;cAClE,gBAAgB,CAAC,KAAK,EAAE,yBAAyB,GAAG,IAAI;CAK9E;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C"}