@memberjunction/ai-realtime-client 0.0.1 → 5.41.0

package/dist/drivers/xaiRealtimeClient.d.ts

@@ -0,0 +1,430 @@
+import { ClientRealtimeSessionConfig, JSONObject } from '@memberjunction/ai';
+import { BaseRealtimeClient } from '../generic/baseRealtimeClient.js';
+import { IRealtimePcmPlayback } from '../audio/pcmPlayback.js';
+import { IPcmMicCapture } from '../audio/micCapture.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
+ * browser flow (where the ephemeral secret encodes the model), xAI takes the model on the URL.
+ */
+export declare const XAI_REALTIME_WS_URL = "wss://api.x.ai/v1/realtime";
+/**
+ * Browser auth rides as a websocket SUBPROTOCOL with this prefix: the ephemeral client secret
+ * is passed as `"xai-client-secret." + token`. Browsers cannot set request headers on a
+ * websocket handshake, so an `Authorization` header is impossible — the subprotocol channel is
+ * how the server-minted one-time credential reaches xAI (no API key ever touches the browser).
+ */
+export declare const XAI_CLIENT_SECRET_SUBPROTOCOL_PREFIX = "xai-client-secret.";
+/**
+ * The Grok Voice wire audio format is FIXED: 16-bit signed little-endian PCM, mono, 24 kHz,
+ * base64-encoded, in BOTH directions (`input_audio_buffer.append` up, `response.audio.delta`
+ * 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
+ * ephemeral client secret passed as a websocket SUBPROTOCOL (no API key ever reaches the
+ * browser, and browsers cannot set a handshake `Authorization` header).
+ *
+ * Registered with the ClassFactory under the key `'xai'` — the `Provider` string the server's
+ * 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.
+ *
+ * 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.
+ */
+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;
+    /**
+     * 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
+     * of a turn appends a caption and the rest are flagged ReplacesPrevious — one in-place bubble, not a
+     * 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}).
+     */
+    private currentState;
+    /** True once Disconnect ran — an expected socket close must not surface as fatal. */
+    private closedByConsumer;
+    /**
+     * 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.
+     */
+    SendText(text: string): void;
+    /**
+     * @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.
+     */
+    CancelActiveResponse(): 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.
+     *
+     * **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.
+     */
+    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;
+}
+/**
+ * Tree-shaking prevention: bundlers cannot see that {@link xAIRealtimeClient} is instantiated
+ * dynamically through the ClassFactory, so a consumer must call this no-op to create a static
+ * code path that keeps the `@RegisterClass` side effect alive.
+ */
+export declare function LoadxAIRealtimeClient(): void;
+//# sourceMappingURL=xaiRealtimeClient.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"xaiRealtimeClient.d.ts","sourceRoot":"","sources":["../../src/drivers/xaiRealtimeClient.ts"],"names":[],"mappings":"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"}