@pipedog/core 0.0.0 → 0.2.0

package/dist/services/stt_service.d.ts

@@ -0,0 +1,601 @@
+/** Base classes for Speech-to-Text services with continuous and segmented processing. */
+import { Queue, type Task } from "@pipedog/asyncio";
+import { type CancelFrame, type EndFrame, type ErrorFrame, type Frame, InputAudioRawFrame, STTMetadataFrame, type StartFrame, VADUserStartedSpeakingFrame, VADUserStoppedSpeakingFrame } from "../frames/frames.ts";
+import { FrameDirection, type FrameProcessorSetup } from "../processors/frame_processor.ts";
+import { type Language } from "../transcriptions/language.ts";
+import { AIService, type AIServiceOptions } from "./ai_service.ts";
+import { STTSettings } from "./settings.ts";
+import { WebsocketService, type WebsocketServiceOptions } from "./websocket_service.ts";
+export interface STTServiceOptions extends AIServiceOptions {
+    /** Whether to pass audio frames downstream after processing. Defaults to true. */
+    audioPassthrough?: boolean;
+    /**
+     * The sample rate for audio input. If null, will be determined from the
+     * start frame.
+     */
+    sampleRate?: number | null;
+    /**
+     * Time in seconds to wait after VAD stop before reporting TTFB. This delay
+     * allows the final transcription to arrive. Defaults to 2.0.
+     */
+    sttTtfbTimeout?: number;
+    /**
+     * P99 latency from speech end to final transcript in seconds. Broadcast via
+     * STTMetadataFrame at pipeline start.
+     */
+    ttfsP99Latency?: number | null;
+    /**
+     * Seconds of no audio before sending silence to keep the connection alive.
+     * null disables keepalive.
+     */
+    keepaliveTimeout?: number | null;
+    /** Seconds between idle checks when keepalive is enabled. */
+    keepaliveInterval?: number;
+    /** The runtime-updatable settings for the STT service. */
+    settings?: STTSettings | null;
+}
+/**
+ * Base class for speech-to-text services.
+ *
+ * Provides common functionality for STT services including audio
+ * passthrough, muting, settings management, and audio processing. Subclasses
+ * must implement the `runStt` method to provide actual speech recognition.
+ *
+ * Includes an optional keepalive mechanism that sends silent audio when no
+ * real audio has been sent for a configurable timeout, preventing servers from
+ * closing idle connections (e.g. when behind a ServiceSwitcher). Subclasses
+ * that enable keepalive must override `_sendKeepalive()` to deliver the
+ * silence in the appropriate service-specific protocol.
+ *
+ * A streaming STT reports latency through TTFB — speech end to final
+ * transcript — and not through processing metrics. Audio arrives
+ * continuously, so there is no discrete request whose duration a
+ * `FrameProcessor.startProcessingMetrics()` window could measure; anchoring
+ * one to a speech or turn boundary measures how long the user talked.
+ * SegmentedSTTService does issue a discrete request per utterance, so its
+ * subclasses time that call and report both.
+ *
+ * Event handlers:
+ *
+ * - on_connected: called when connected to the STT service.
+ * - on_disconnected: called when disconnected from the STT service.
+ * - on_connection_error: called when a connection to the STT service error
+ *   occurs.
+ *
+ * @example
+ * stt.addEventHandler("on_connected", async (stt: STTService) => {
+ *   logger.debug("STT connected");
+ * });
+ *
+ * stt.addEventHandler("on_disconnected", async (stt: STTService) => {
+ *   logger.debug("STT disconnected");
+ * });
+ *
+ * stt.addEventHandler("on_connection_error", async (stt: STTService, error: string) => {
+ *   logger.error(`STT connection error: ${error}`);
+ * });
+ */
+export declare abstract class STTService extends AIService {
+    protected _settings: STTSettings;
+    protected _audioPassthrough: boolean;
+    protected _initSampleRate: number | null;
+    protected _sampleRate: number;
+    protected _muted: boolean;
+    protected _userId: string;
+    protected _ttfsP99Latency: number | null;
+    protected _sttTtfbTimeout: number;
+    protected _ttfbTimeoutTask: Task<unknown> | null;
+    protected _userSpeaking: boolean;
+    protected _finalizePending: boolean;
+    protected _finalizeRequested: boolean;
+    protected _lastTranscriptTime: number;
+    protected _keepaliveTimeout: number | null;
+    protected _keepaliveInterval: number;
+    protected _keepaliveTask: Task<unknown> | null;
+    protected _lastAudioTime: number;
+    protected _sttUsagePendingSeconds: number;
+    protected _canReconnect: boolean;
+    protected _needReconnect: boolean;
+    protected _reconnecting: boolean;
+    protected _reconnectAudioBuffer: [InputAudioRawFrame, FrameDirection][];
+    /**
+     * Initialize the STT service.
+     *
+     * @param options.audioPassthrough Whether to pass audio frames downstream
+     *   after processing. Defaults to true.
+     * @param options.sampleRate The sample rate for audio input. If null, will
+     *   be determined from the start frame.
+     * @param options.sttTtfbTimeout Time in seconds to wait after VAD stop
+     *   before reporting TTFB. This delay allows the final transcription to
+     *   arrive. Defaults to 2.0. Note: STT "TTFB" differs from traditional TTFB
+     *   (which measures from a discrete request to first response byte). Since
+     *   STT receives continuous audio, we measure from when the user stops
+     *   speaking to when the final transcript arrives—capturing the latency that
+     *   matters for voice AI applications.
+     * @param options.ttfsP99Latency P99 latency from speech end to final
+     *   transcript in seconds. This is broadcast via STTMetadataFrame at
+     *   pipeline start for downstream processors (e.g., turn strategies) to
+     *   optimize timing. Subclasses provide measured defaults; pass a value here
+     *   to override for your deployment. Turn-based services where the server
+     *   defines turn boundaries should override `supportsTtfs` to return false
+     *   instead of supplying a value.
+     * @param options.keepaliveTimeout Seconds of no audio before sending
+     *   silence to keep the connection alive. null disables keepalive. Useful
+     *   for services that close idle connections (e.g. behind a
+     *   ServiceSwitcher).
+     * @param options.keepaliveInterval Seconds between idle checks when
+     *   keepalive is enabled.
+     * @param options.settings The runtime-updatable settings for the STT
+     *   service. Other options are passed to the parent AIService.
+     */
+    constructor(options?: STTServiceOptions);
+    /** The service's current settings, for reading. */
+    get settings(): STTSettings;
+    /** Whether the STT service is currently muted and will not process audio. */
+    get isMuted(): boolean;
+    /**
+     * Mark that a finalize request has been sent, awaiting server confirmation.
+     *
+     * For providers that have explicit server confirmation of finalization
+     * (e.g., Deepgram's from_finalize field), call this when sending the
+     * finalize request. Then call `confirmFinalize()` when the server confirms.
+     *
+     * For providers without server confirmation, don't call this method - just
+     * send the finalize/flush/commit command and rely on the TTFB timeout.
+     */
+    requestFinalize(): void;
+    /**
+     * Confirm that the server has acknowledged the finalize request.
+     *
+     * Call this when the server response confirms finalization (e.g.,
+     * Deepgram's from_finalize=True). The next TranscriptionFrame pushed will be
+     * marked as finalized.
+     *
+     * Only has effect if `requestFinalize()` was previously called.
+     */
+    confirmFinalize(): void;
+    /** The current sample rate for audio processing, in Hz. */
+    get sampleRate(): number;
+    /**
+     * Accumulate client-measured audio seconds for usage metrics.
+     *
+     * @param audio Raw 16-bit mono PCM audio bytes submitted to the service.
+     */
+    protected _recordSttAudioUsage(audio: Uint8Array): void;
+    /**
+     * Emit an incremental STT usage metrics event.
+     *
+     * Reports the audio seconds accumulated since the last report as an
+     * `STTUsageMetricsData` in a `MetricsFrame`. Services call this once per
+     * billing event (e.g. on each final transcript); the base class calls it a
+     * final time on stop/cancel to flush trailing audio. Does nothing if there
+     * is no usage to report.
+     */
+    emitSttUsageMetrics(): Promise<void>;
+    /** Flush any trailing audio usage not yet reported by a billing event. */
+    protected _flushSttUsageMetrics(): Promise<void>;
+    /**
+     * Convert a language to the service-specific language format.
+     *
+     * @param language The language to convert.
+     * @returns The service-specific language identifier. Return `null` to
+     *   indicate an unsupported language. This optional return is an extension
+     *   hook for future or third-party subclasses; as of 2026-04-28,
+     *   first-party services return a string.
+     */
+    languageToServiceLanguage(language: Language): string | null;
+    /**
+     * Called when the assistant's turn completes with the aggregated reply text.
+     *
+     * Override in subclasses to react to each completed bot reply — for
+     * example, to feed the text to a provider-side context carryover API. The
+     * default implementation is a no-op.
+     *
+     * @param text The assistant's aggregated spoken text for this turn.
+     */
+    protected _processAssistantTurn(_text: string): Promise<void>;
+    /**
+     * Run speech-to-text on the provided audio data.
+     *
+     * This method must be implemented by subclasses to provide actual speech
+     * recognition functionality.
+     *
+     * @param audio Raw audio bytes to transcribe.
+     * @returns An async generator yielding frames containing transcription
+     *   results (typically TextFrame).
+     */
+    abstract runStt(audio: Uint8Array): AsyncGenerator<Frame | null, void, unknown>;
+    /**
+     * Set up the service.
+     *
+     * @param setup Configuration object containing setup parameters.
+     */
+    setup(setup: FrameProcessorSetup): Promise<void>;
+    /** Clean up STT service resources. */
+    cleanup(): Promise<void>;
+    /**
+     * Stop the STT service on a graceful end.
+     *
+     * @param frame The end frame.
+     */
+    stop(frame: EndFrame): Promise<void>;
+    /**
+     * Cancel the STT service immediately.
+     *
+     * @param frame The cancel frame.
+     */
+    cancel(frame: CancelFrame): Promise<void>;
+    /**
+     * Apply an STT settings delta.
+     *
+     * Handles `model` (via parent). Translates `Language` values before
+     * applying so the stored value is a service-specific string. Concrete
+     * services should override this method and handle language changes
+     * (including any reconnect logic) based on the returned changed-field
+     * record.
+     *
+     * @param delta An STT settings delta.
+     * @returns Record mapping changed field names to their previous values.
+     */
+    protected _updateSettings(delta: STTSettings): Promise<Record<string, unknown>>;
+    /**
+     * Process an audio frame for speech recognition.
+     *
+     * If a reconnect is in progress, the frame is buffered and replayed once
+     * the connection is restored. If the service is muted, the frame is
+     * dropped. Otherwise the frame is sent to the STT service and, if a userId
+     * is present, it is stored for use in transcription results.
+     *
+     * @param frame The audio frame to process.
+     * @param direction The direction of frame processing.
+     */
+    processAudioFrame(frame: InputAudioRawFrame, direction: FrameDirection): Promise<void>;
+    /**
+     * Process frames, handling VAD events and audio segmentation.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame processing.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+    /**
+     * Push a frame downstream, tracking TranscriptionFrame timestamps for TTFB.
+     *
+     * Stores the timestamp of each TranscriptionFrame for TTFB calculation. If
+     * the frame is marked as finalized (via requestFinalize/confirmFinalize),
+     * reports TTFB immediately and cancels any pending timeout. Otherwise, TTFB
+     * is reported after a timeout.
+     *
+     * @param frame The frame to push.
+     * @param direction The direction to push the frame.
+     */
+    pushFrame(frame: Frame, direction?: FrameDirection): Promise<void>;
+    /**
+     * Whether this STT service has a meaningful TTFS-to-final-transcript metric.
+     *
+     * Returns false for turn-based STTs where the server defines the turn
+     * boundary, so there is no separate "speech end → final transcript"
+     * interval to measure. Downstream turn-stop strategies that consume
+     * STTMetadataFrame treat a 0 latency as "no extra wait."
+     */
+    get supportsTtfs(): boolean;
+    /**
+     * Build the STT metadata frame broadcast at start.
+     *
+     * Overrides `AIService.serviceMetadataFrame()` to return an
+     * STTMetadataFrame carrying the service's TTFS P99 latency. A service that
+     * does its own server-side end-of-turn detection overrides this (calling
+     * `super`) to set `userTurnStrategies` on the returned frame.
+     */
+    serviceMetadataFrame(): STTMetadataFrame;
+    /** Cancel any pending TTFB timeout task. */
+    protected _cancelTtfbTimeout(): Promise<void>;
+    /**
+     * Reset STT TTFB measurement state.
+     *
+     * Called when starting a new utterance or on interruption to ensure we
+     * don't use stale state for TTFB calculations. This specifically guards
+     * against the case where a TranscriptionFrame is received without
+     * corresponding VADUserStartedSpeakingFrame and VADUserStoppedSpeakingFrame
+     * frames.
+     *
+     * Note: does not reset `_userSpeaking` since InterruptionFrame can arrive
+     * while user is still speaking.
+     */
+    protected _resetSttTtfbState(): Promise<void>;
+    /**
+     * Handle VAD user started speaking frame to start tracking transcriptions.
+     *
+     * Cancels any pending TTFB timeout, resets TTFB tracking state, and marks
+     * user as speaking. Also resets finalization state to prevent stale
+     * finalization from a previous utterance.
+     *
+     * @param frame The VAD user started speaking frame.
+     */
+    protected _handleVadUserStartedSpeaking(_frame: VADUserStartedSpeakingFrame): Promise<void>;
+    /**
+     * Check if reconnection is needed after the user stops speaking.
+     *
+     * Called when the user's full turn has ended and the transcription has been
+     * received. Re-enables reconnection and triggers any deferred reconnect
+     * that was requested while the user was speaking.
+     */
+    protected _maybeReconnectOnUserStoppedSpeaking(): Promise<void>;
+    /**
+     * Handle VAD user stopped speaking frame.
+     *
+     * Calculates the actual speech end time and starts a timeout task to wait
+     * for the final transcription before reporting TTFB.
+     *
+     * @param frame The VAD user stopped speaking frame.
+     */
+    protected _handleVadUserStoppedSpeaking(frame: VADUserStoppedSpeakingFrame): Promise<void>;
+    /**
+     * Wait for timeout then report TTFB using the last transcript timestamp.
+     *
+     * This timeout allows the final transcription to arrive before we
+     * calculate and report TTFB. Uses `_lastTranscriptTime` as the end time so
+     * we measure to when the transcript actually arrived, not when the timeout
+     * fired.
+     *
+     * A transcript that predates the end of speech belongs to an earlier
+     * segment the service finalized on its own endpointing; the metrics
+     * collector refuses it rather than report the negative interval it would
+     * produce.
+     */
+    protected _ttfbTimeoutHandler(): Promise<void>;
+    /** Start the keepalive task if keepalive is enabled. */
+    protected _createKeepaliveTask(): void;
+    /** Stop the keepalive task if running. */
+    protected _cancelKeepaliveTask(): Promise<void>;
+    /**
+     * Perform a full reconnect cycle with audio buffering.
+     *
+     * Sets `_reconnecting` so incoming audio frames are buffered rather than
+     * sent to a dead connection. Delegates the actual connection reset to
+     * `_doReconnect()`. After the new connection is established all buffered
+     * frames are replayed. On failure the error is reported via `pushError`
+     * and the `on_connection_error` event handler.
+     */
+    protected _reconnect(): Promise<void>;
+    /**
+     * Perform the service-specific connection reset.
+     *
+     * Called by `_reconnect()` inside the reconnecting guard. The default
+     * implementation is a no-op. Subclasses that support explicit reconnection
+     * (e.g. WebsocketSTTService) should override this to tear down and
+     * re-establish their connection.
+     */
+    protected _doReconnect(): Promise<void>;
+    /**
+     * Reconnect immediately if safe, or defer until after the current user turn.
+     *
+     * Reconnection is unsafe while the user is speaking because the service is
+     * actively receiving audio. Calling this method while the user is speaking
+     * schedules a reconnect that fires as soon as `UserStoppedSpeakingFrame` is
+     * received.
+     */
+    protected _requestReconnect(): Promise<void>;
+    /**
+     * Send periodic silent audio to prevent the server from closing the
+     * connection.
+     *
+     * When keepalive is enabled, this task checks periodically if the
+     * connection has been idle (no audio sent) for longer than
+     * keepaliveTimeout seconds. If so, it generates silent 16-bit mono PCM
+     * audio and passes it to `_sendKeepalive()` for service-specific formatting
+     * and sending. A failed send is logged and the loop keeps going.
+     */
+    protected _keepaliveTaskHandler(): Promise<void>;
+    /**
+     * Check if the service is ready to send keepalive.
+     *
+     * Subclasses should override this to check their connection state.
+     *
+     * @returns True if keepalive can be sent.
+     */
+    protected _isKeepaliveReady(): boolean;
+    /**
+     * Send silent audio to keep the connection alive.
+     *
+     * Subclasses that enable keepalive must override this to deliver silence in
+     * their service-specific protocol.
+     *
+     * @param silence Silent 16-bit mono PCM audio bytes.
+     */
+    protected _sendKeepalive(_silence: Uint8Array): Promise<void>;
+}
+export interface SegmentedSTTServiceOptions extends STTServiceOptions {
+    /**
+     * Seconds of silence appended to each segment before it is transcribed, so
+     * the model hears the end of speech and can finish the last word. Set to 0
+     * to disable. Defaults to 0.5.
+     */
+    trailingSilenceSecs?: number;
+}
+/**
+ * STT service that processes speech in segments using VAD events.
+ *
+ * Uses Voice Activity Detection (VAD) events to detect speech segments and
+ * runs speech-to-text only on those segments, rather than continuously.
+ *
+ * Requires VAD to be enabled in the pipeline to function properly. Maintains
+ * a small audio buffer to account for the delay between actual speech start
+ * and VAD detection.
+ *
+ * The buffered segment is passed to `runStt` as a WAV container by default,
+ * which is what cloud providers want for their upload APIs. Local models that
+ * consume raw 16-bit PCM directly override `wantsWavSegments` to return false
+ * so they receive the unwrapped buffer instead. This is a subclass-level
+ * contract, not a user-configurable option: the format is dictated by what
+ * the model expects.
+ *
+ * A segment ends right where the VAD stopped, and models tend to drop or
+ * garble the final word when the audio ends that abruptly, so each segment is
+ * padded with `trailingSilenceSecs` of silence before transcription.
+ *
+ * Transcription runs off the audio path. When the VAD stops, the segment is
+ * queued and one background task transcribes queued segments in order,
+ * pushing each transcript as it completes; meanwhile audio and other frames
+ * keep flowing through the service, as they do through a streaming STT whose
+ * transcripts arrive asynchronously. A graceful stop transcribes what is
+ * queued before the service stops; a cancel drops it.
+ */
+export declare abstract class SegmentedSTTService extends STTService {
+    protected _trailingSilenceSecs: number;
+    protected _content: unknown;
+    protected _wave: unknown;
+    protected _audioBuffer: Uint8Array;
+    protected _audioBufferSize1s: number;
+    protected _segmentQueue: Queue<Uint8Array<ArrayBufferLike> | null>;
+    protected _segmentTask: Task<unknown> | null;
+    /**
+     * Initialize the segmented STT service.
+     *
+     * @param options.sampleRate The sample rate for audio input. If null, will
+     *   be determined from the start frame.
+     * @param options.trailingSilenceSecs Seconds of silence appended to each
+     *   segment before it is transcribed, so the model hears the end of speech
+     *   and can finish the last word. Set to 0 to disable. Other options are
+     *   passed to the parent STTService.
+     */
+    constructor(options?: SegmentedSTTServiceOptions);
+    /**
+     * Set up the service.
+     *
+     * @param setup Configuration object containing setup parameters.
+     */
+    setup(setup: FrameProcessorSetup): Promise<void>;
+    /**
+     * Start the service and its transcription task.
+     *
+     * @param frame The start frame.
+     */
+    start(frame: StartFrame): Promise<void>;
+    /**
+     * Transcribe the queued segments, then stop the service.
+     *
+     * @param frame The end frame.
+     */
+    stop(frame: EndFrame): Promise<void>;
+    /**
+     * Stop the service at once, dropping any queued segments.
+     *
+     * @param frame The cancel frame.
+     */
+    cancel(frame: CancelFrame): Promise<void>;
+    /**
+     * Whether segments are passed to `runStt` as a WAV container.
+     *
+     * Returns true (the default) for cloud providers whose upload APIs expect a
+     * WAV file. Local models that read the buffer as raw 16-bit PCM override
+     * this to return false; otherwise they would misinterpret the 44-byte WAV
+     * header as audio samples.
+     */
+    get wantsWavSegments(): boolean;
+    /**
+     * Push a frame, marking TranscriptionFrames as finalized.
+     *
+     * Segmented STT services process complete speech segments and return a
+     * single TranscriptionFrame per segment, so every transcription is
+     * inherently finalized.
+     *
+     * @param frame The frame to push.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    pushFrame(frame: Frame, direction?: FrameDirection): Promise<void>;
+    /** Process frames, handling VAD events and audio segmentation. */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+    protected _handleUserStartedSpeaking(_frame: VADUserStartedSpeakingFrame): Promise<void>;
+    protected _handleUserStoppedSpeaking(_frame: VADUserStoppedSpeakingFrame): Promise<void>;
+    /** Transcribe queued segments one at a time, in order, until told to finish. */
+    protected _segmentTaskHandler(): Promise<void>;
+    protected _cancelSegmentTask(): Promise<void>;
+    /** Silence appended to a segment, as 16-bit mono PCM at the service sample rate. */
+    protected _trailingSilence(): Uint8Array;
+    /**
+     * Process audio frames by buffering them for segmented transcription.
+     *
+     * Continuously buffers audio, growing the buffer while user is speaking and
+     * maintaining a small buffer when not speaking to account for VAD delay.
+     *
+     * If the frame has a userId, it is stored for later use in transcription.
+     *
+     * @param frame The audio frame to process.
+     * @param direction The direction of frame processing.
+     */
+    processAudioFrame(frame: InputAudioRawFrame, _direction: FrameDirection): Promise<void>;
+}
+export interface WebsocketSTTServiceOptions extends STTServiceOptions, WebsocketServiceOptions {
+    /** Whether to automatically reconnect on websocket errors. Defaults to true. */
+    reconnectOnError?: boolean;
+}
+declare const WebsocketSTTService_base: typeof STTService & (abstract new (...args: any[]) => WebsocketService);
+/**
+ * Base class for websocket-based STT services.
+ *
+ * Combines STT functionality with websocket connectivity, providing
+ * automatic error handling, reconnection capabilities, and optional
+ * silence-based keepalive.
+ *
+ * The keepalive feature (inherited from STTService) sends silent audio when
+ * no real audio has been sent for a configurable timeout, preventing servers
+ * from closing idle connections (e.g. when behind a ServiceSwitcher).
+ * Subclasses can override `_sendKeepalive()` to wrap the silence in a
+ * service-specific protocol.
+ */
+export declare abstract class WebsocketSTTService extends WebsocketSTTService_base {
+    /**
+     * Initialize the Websocket STT service.
+     *
+     * @param options.reconnectOnError Whether to automatically reconnect on
+     *   websocket errors. Other options are passed to the parent classes
+     *   (including keepaliveTimeout and keepaliveInterval for STTService).
+     */
+    constructor(options?: WebsocketSTTServiceOptions);
+    /**
+     * Stop the websocket STT service on a graceful end.
+     *
+     * @param frame The end frame.
+     */
+    stop(frame: EndFrame): Promise<void>;
+    /**
+     * Cancel the websocket STT service immediately.
+     *
+     * Disconnecting here is the prompt teardown: the websocket receive loop
+     * runs independently and keeps reading transcripts from the provider until
+     * the socket is closed.
+     *
+     * @param frame The cancel frame.
+     */
+    cancel(frame: CancelFrame): Promise<void>;
+    /** Release websocket STT resources at teardown. */
+    cleanup(): Promise<void>;
+    /** Connect and start keepalive task if enabled. */
+    _connect(): Promise<void>;
+    /** Disconnect and cancel keepalive task. */
+    _disconnect(): Promise<void>;
+    /**
+     * Disconnect and reconnect the websocket.
+     *
+     * Called by `STTService._reconnect()` inside the reconnecting guard. Tears
+     * down the current websocket connection and re-establishes it. Keepalive
+     * management is handled by `_connect` / `_disconnect`.
+     */
+    protected _doReconnect(): Promise<void>;
+    /** Check if the websocket is open and ready for keepalive. */
+    protected _isKeepaliveReady(): boolean;
+    /**
+     * Send silent audio over the websocket to keep the connection alive.
+     *
+     * The default implementation sends raw PCM bytes directly. Subclasses can
+     * override this to wrap the silence in a service-specific protocol.
+     *
+     * @param silence Silent 16-bit mono PCM audio bytes.
+     */
+    protected _sendKeepalive(silence: Uint8Array): Promise<void>;
+    protected _reportError(error: ErrorFrame, options?: {
+        forceTreatAsPermanent?: boolean;
+    }): Promise<void>;
+}
+export {};
+//# sourceMappingURL=stt_service.d.ts.map