@pipedog/core 0.0.0 → 0.2.0

package/dist/processors/aggregators/llm_text_processor.d.ts

@@ -0,0 +1,53 @@
+/**
+ * LLM text processor module for processing and aggregating raw LLM output text.
+ *
+ * This processor will convert LLMTextFrames into AggregatedTextFrames based on
+ * the configured text aggregator. Using the customizable aggregator, it
+ * provides functionality to handle or manipulate LLM text frames before they
+ * are sent to other components such as TTS services or context aggregators. It
+ * can be used to pre-aggregate and categorize, modify, or filter direct output
+ * tokens from the LLM.
+ */
+import { type Frame, InterruptionFrame, LLMTextFrame } from "../../frames/frames.ts";
+import type { BaseTextAggregator } from "../../utils/text/base_text_aggregator.ts";
+import { type FrameDirection, FrameProcessor, type FrameProcessorOptions } from "../frame_processor.ts";
+export interface LLMTextProcessorOptions extends FrameProcessorOptions {
+    /**
+     * An optional text aggregator to use for processing LLM text frames. By
+     * default, a SimpleTextAggregator aggregating by sentence will be used.
+     */
+    textAggregator?: BaseTextAggregator | null;
+}
+/**
+ * A processor for handling or manipulating LLM text frames before they are processed further.
+ *
+ * This processor will convert LLMTextFrames into AggregatedTextFrames based on
+ * the configured text aggregator. Using the customizable aggregator, it
+ * provides functionality to handle or manipulate LLM text frames before they
+ * are sent to other components such as TTS services or context aggregators. It
+ * can be used to pre-aggregate and categorize, modify, or filter direct output
+ * tokens from the LLM.
+ */
+export declare class LLMTextProcessor extends FrameProcessor {
+    protected _textAggregator: BaseTextAggregator;
+    /**
+     * Initialize the LLM text processor.
+     *
+     * TODO: Allow transformations per text type or all (and deprecate the TTS filters).
+     */
+    constructor(options?: LLMTextProcessorOptions);
+    /**
+     * Process an LLMTextFrames using the aggregator to generate AggregatedTextFrames.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+    /** Handle interruptions by resetting the text aggregator. */
+    protected _handleInterruption(_: InterruptionFrame): Promise<void>;
+    /** Reset the internal state of the text processor and its aggregator. */
+    reset(): Promise<void>;
+    protected _handleLlmText(inFrame: LLMTextFrame): Promise<void>;
+    protected _handleLlmEnd(skipTts?: boolean | null): Promise<void>;
+}
+//# sourceMappingURL=llm_text_processor.d.ts.map

package/dist/processors/aggregators/llm_text_processor.js

@@ -0,0 +1,102 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/aggregators/llm_text_processor.py
+/**
+ * LLM text processor module for processing and aggregating raw LLM output text.
+ *
+ * This processor will convert LLMTextFrames into AggregatedTextFrames based on
+ * the configured text aggregator. Using the customizable aggregator, it
+ * provides functionality to handle or manipulate LLM text frames before they
+ * are sent to other components such as TTS services or context aggregators. It
+ * can be used to pre-aggregate and categorize, modify, or filter direct output
+ * tokens from the LLM.
+ */
+import { AggregatedTextFrame, EndFrame, InterruptionFrame, LLMFullResponseEndFrame, LLMTextFrame, } from "../../frames/frames.js";
+import { PatternMatch } from "../../utils/text/pattern_pair_aggregator.js";
+import { SimpleTextAggregator } from "../../utils/text/simple_text_aggregator.js";
+import { FrameProcessor, } from "../frame_processor.js";
+/**
+ * A processor for handling or manipulating LLM text frames before they are processed further.
+ *
+ * This processor will convert LLMTextFrames into AggregatedTextFrames based on
+ * the configured text aggregator. Using the customizable aggregator, it
+ * provides functionality to handle or manipulate LLM text frames before they
+ * are sent to other components such as TTS services or context aggregators. It
+ * can be used to pre-aggregate and categorize, modify, or filter direct output
+ * tokens from the LLM.
+ */
+export class LLMTextProcessor extends FrameProcessor {
+    _textAggregator;
+    /**
+     * Initialize the LLM text processor.
+     *
+     * TODO: Allow transformations per text type or all (and deprecate the TTS filters).
+     */
+    constructor(options = {}) {
+        super(options);
+        this._textAggregator = options.textAggregator || new SimpleTextAggregator();
+    }
+    /**
+     * Process an LLMTextFrames using the aggregator to generate AggregatedTextFrames.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    async processFrame(frame, direction) {
+        await super.processFrame(frame, direction);
+        if (frame instanceof InterruptionFrame) {
+            await this._handleInterruption(frame);
+            await this.pushFrame(frame, direction);
+        }
+        else if (frame instanceof LLMTextFrame) {
+            await this._handleLlmText(frame);
+        }
+        else if (frame instanceof LLMFullResponseEndFrame) {
+            await this._handleLlmEnd(frame.skipTts);
+            await this.pushFrame(frame, direction);
+        }
+        else if (frame instanceof EndFrame) {
+            await this._handleLlmEnd();
+            await this.pushFrame(frame, direction);
+        }
+        else {
+            await this.pushFrame(frame, direction);
+        }
+    }
+    /** Handle interruptions by resetting the text aggregator. */
+    async _handleInterruption(_) {
+        await this._textAggregator.handleInterruption();
+    }
+    /** Reset the internal state of the text processor and its aggregator. */
+    async reset() {
+        await this._textAggregator.reset();
+    }
+    async _handleLlmText(inFrame) {
+        for await (const aggregation of this._textAggregator.aggregate(inFrame.text)) {
+            const outFrame = new AggregatedTextFrame({
+                text: aggregation.text,
+                textType: aggregation.type,
+                rawText: aggregation instanceof PatternMatch ? aggregation.fullMatch : aggregation.text,
+            });
+            outFrame.appendToContext = true;
+            outFrame.skipTts = inFrame.skipTts;
+            await this.pushFrame(outFrame);
+        }
+    }
+    async _handleLlmEnd(skipTts = null) {
+        // Flush any remaining text
+        const remaining = await this._textAggregator.flush();
+        if (remaining) {
+            const outFrame = new AggregatedTextFrame({
+                text: remaining.text,
+                textType: remaining.type,
+                rawText: remaining instanceof PatternMatch ? remaining.fullMatch : remaining.text,
+            });
+            outFrame.skipTts = skipTts;
+            await this.pushFrame(outFrame);
+        }
+    }
+}
+//# sourceMappingURL=llm_text_processor.js.map

package/dist/processors/aggregators/sentence.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Text sentence aggregation processor for Pipecat.
+ *
+ * This module provides a frame processor that accumulates text frames into
+ * complete sentences, only outputting when a sentence-ending pattern is
+ * detected.
+ */
+import { type Frame } from "../../frames/frames.ts";
+import { type FrameDirection, FrameProcessor } from "../frame_processor.ts";
+/**
+ * Aggregates text frames into complete sentences.
+ *
+ * This processor accumulates incoming text frames until a sentence-ending
+ * pattern is detected, then outputs the complete sentence as a single frame.
+ * Useful for ensuring downstream processors receive coherent, complete
+ * sentences rather than fragmented text.
+ *
+ * Frame input/output:
+ *
+ *     TextFrame("Hello,") -> None
+ *     TextFrame(" world.") -> TextFrame("Hello, world.")
+ */
+export declare class SentenceAggregator extends FrameProcessor {
+    protected _aggregation: string;
+    /**
+     * Initialize the sentence aggregator.
+     *
+     * Sets up internal state for accumulating text frames into complete sentences.
+     */
+    constructor();
+    /**
+     * Process incoming frames and aggregate text into complete sentences.
+     *
+     * @param frame The incoming frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+}
+//# sourceMappingURL=sentence.d.ts.map

package/dist/processors/aggregators/sentence.js

@@ -0,0 +1,69 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/aggregators/sentence.py
+/**
+ * Text sentence aggregation processor for Pipecat.
+ *
+ * This module provides a frame processor that accumulates text frames into
+ * complete sentences, only outputting when a sentence-ending pattern is
+ * detected.
+ */
+import { EagerTranscriptionFrame, EndFrame, InterimTranscriptionFrame, TextFrame, } from "../../frames/frames.js";
+import { matchEndofsentence } from "../../utils/string.js";
+import { FrameProcessor } from "../frame_processor.js";
+/**
+ * Aggregates text frames into complete sentences.
+ *
+ * This processor accumulates incoming text frames until a sentence-ending
+ * pattern is detected, then outputs the complete sentence as a single frame.
+ * Useful for ensuring downstream processors receive coherent, complete
+ * sentences rather than fragmented text.
+ *
+ * Frame input/output:
+ *
+ *     TextFrame("Hello,") -> None
+ *     TextFrame(" world.") -> TextFrame("Hello, world.")
+ */
+export class SentenceAggregator extends FrameProcessor {
+    _aggregation = "";
+    /**
+     * Initialize the sentence aggregator.
+     *
+     * Sets up internal state for accumulating text frames into complete sentences.
+     */
+    constructor() {
+        super();
+    }
+    /**
+     * Process incoming frames and aggregate text into complete sentences.
+     *
+     * @param frame The incoming frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    async processFrame(frame, direction) {
+        await super.processFrame(frame, direction);
+        // We ignore interim and eager (provisional) transcriptions at this point.
+        if (frame instanceof InterimTranscriptionFrame || frame instanceof EagerTranscriptionFrame) {
+            return;
+        }
+        if (frame instanceof TextFrame) {
+            this._aggregation += frame.text;
+            if (matchEndofsentence(this._aggregation)) {
+                await this.pushFrame(new TextFrame({ text: this._aggregation }));
+                this._aggregation = "";
+            }
+        }
+        else if (frame instanceof EndFrame) {
+            if (this._aggregation) {
+                await this.pushFrame(new TextFrame({ text: this._aggregation }));
+            }
+            await this.pushFrame(frame);
+        }
+        else {
+            await this.pushFrame(frame, direction);
+        }
+    }
+}
+//# sourceMappingURL=sentence.js.map

package/dist/processors/async_generator.d.ts

@@ -0,0 +1,42 @@
+/** Async generator processor for frame serialization and streaming. */
+import { Queue } from "@pipedog/asyncio";
+import { type Frame } from "../frames/frames.ts";
+import type { FrameSerializer } from "../serializers/base_serializer.ts";
+import { type FrameDirection, FrameProcessor, type FrameProcessorOptions } from "./frame_processor.ts";
+export interface AsyncGeneratorProcessorOptions extends FrameProcessorOptions {
+    /** The frame serializer to use for converting frames to data. */
+    serializer: FrameSerializer;
+}
+/**
+ * A frame processor that serializes frames and provides them via async generator.
+ *
+ * This processor passes frames through unchanged while simultaneously
+ * serializing them and making the serialized data available through an async
+ * generator interface. Useful for streaming frame data to external consumers
+ * while maintaining the normal frame processing pipeline.
+ */
+export declare class AsyncGeneratorProcessor extends FrameProcessor {
+    protected _serializer: FrameSerializer;
+    protected _dataQueue: Queue<unknown>;
+    /**
+     * Initialize the async generator processor.
+     *
+     * @param options.serializer The frame serializer to use for converting frames to data.
+     */
+    constructor(options: AsyncGeneratorProcessorOptions);
+    /**
+     * Process frames by passing them through and queuing serialized data.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+    /**
+     * Generate serialized frame data asynchronously.
+     *
+     * Yields serialized frame data from the internal queue until a termination
+     * signal (null) is received.
+     */
+    generator(): AsyncGenerator<unknown, void, unknown>;
+}
+//# sourceMappingURL=async_generator.d.ts.map

package/dist/processors/async_generator.js

@@ -0,0 +1,76 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/async_generator.py
+/** Async generator processor for frame serialization and streaming. */
+import { Queue } from "@pipedog/asyncio";
+import { CancelFrame, EndFrame } from "../frames/frames.js";
+import { FrameProcessor, } from "./frame_processor.js";
+/**
+ * A frame processor that serializes frames and provides them via async generator.
+ *
+ * This processor passes frames through unchanged while simultaneously
+ * serializing them and making the serialized data available through an async
+ * generator interface. Useful for streaming frame data to external consumers
+ * while maintaining the normal frame processing pipeline.
+ */
+export class AsyncGeneratorProcessor extends FrameProcessor {
+    _serializer;
+    _dataQueue = new Queue();
+    /**
+     * Initialize the async generator processor.
+     *
+     * @param options.serializer The frame serializer to use for converting frames to data.
+     */
+    constructor(options) {
+        super(options);
+        this._serializer = options.serializer;
+    }
+    /**
+     * Process frames by passing them through and queuing serialized data.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    async processFrame(frame, direction) {
+        await super.processFrame(frame, direction);
+        await this.pushFrame(frame, direction);
+        if (frame instanceof CancelFrame || frame instanceof EndFrame) {
+            await this._dataQueue.put(null);
+        }
+        else {
+            const data = await this._serializer.serialize(frame);
+            if (isTruthy(data)) {
+                await this._dataQueue.put(data);
+            }
+        }
+    }
+    /**
+     * Generate serialized frame data asynchronously.
+     *
+     * Yields serialized frame data from the internal queue until a termination
+     * signal (null) is received.
+     */
+    async *generator() {
+        let running = true;
+        while (running) {
+            const data = await this._dataQueue.get();
+            running = data !== null;
+            if (isTruthy(data)) {
+                yield data;
+            }
+        }
+    }
+}
+/** Python truthiness for serialized data: empty strings and byte arrays are falsy. */
+function isTruthy(data) {
+    if (data === null || data === undefined)
+        return false;
+    if (typeof data === "string")
+        return data.length > 0;
+    if (data instanceof Uint8Array)
+        return data.length > 0;
+    return Boolean(data);
+}
+//# sourceMappingURL=async_generator.js.map

package/dist/processors/audio/audio_buffer_processor.d.ts

@@ -0,0 +1,241 @@
+import type { BaseAudioResampler } from "../../audio/resamplers/base_audio_resampler.ts";
+import { type Frame, InputAudioRawFrame, OutputAudioRawFrame } from "../../frames/frames.ts";
+import { type FrameDirection, FrameProcessor, type FrameProcessorOptions, type FrameProcessorSetup } from "../frame_processor.ts";
+/**
+ * A growable byte buffer, standing in for Python's `bytearray`: appends are
+ * amortized and the buffer is mutated in place.
+ */
+export declare class ByteBuffer {
+    #private;
+    get length(): number;
+    /** Append `bytes` to the buffer. */
+    extend(bytes: Uint8Array): void;
+    /** Append `count` zero bytes (silence) to the buffer. */
+    extendZeros(count: number): void;
+    /** Drop the first `count` bytes. */
+    discardFront(count: number): void;
+    /** A copy of the buffer's contents (Python `bytes(buffer)`). */
+    bytes(): Uint8Array;
+}
+/** Options for TurnAudioData. */
+export interface TurnAudioDataOptions {
+    /** The turn this audio belongs to. */
+    turnNumber: number;
+    /**
+     * Everything the speaker said during the turn, as raw PCM, with the pauses
+     * between their runs of speech left out.
+     */
+    audio: Uint8Array;
+    /** Sample rate of the audio in Hz. */
+    sampleRate: number;
+    /** Number of channels in the audio. */
+    numChannels: number;
+}
+/**
+ * One speaker's audio for one conversation turn.
+ *
+ * - `turnNumber`: the turn this audio belongs to.
+ * - `audio`: everything the speaker said during the turn, as raw PCM, with
+ *   the pauses between their runs of speech left out.
+ * - `sampleRate`: sample rate of the audio in Hz.
+ * - `numChannels`: number of channels in the audio.
+ */
+export declare class TurnAudioData {
+    turnNumber: number;
+    audio: Uint8Array;
+    sampleRate: number;
+    numChannels: number;
+    constructor(options: TurnAudioDataOptions);
+}
+export interface AudioBufferProcessorOptions extends FrameProcessorOptions {
+    /** Desired output sample rate. If null, uses source rate. */
+    sampleRate?: number | null;
+    /** Number of channels (1 for mono, 2 for stereo). Defaults to 1. */
+    numChannels?: number;
+    /** Size of buffer before triggering events. 0 for no buffering. */
+    bufferSize?: number;
+    /** Whether turn audio event handlers should be triggered. */
+    enableTurnAudio?: boolean;
+    /**
+     * Whether to start recording automatically when the pipeline starts,
+     * without requiring a call to `startRecording()` or an
+     * `AudioBufferStartRecordingFrame`.
+     */
+    autoStartRecording?: boolean;
+}
+/**
+ * Processes and buffers audio frames from both input (user) and output (bot)
+ * sources.
+ *
+ * This processor manages audio buffering and synchronization, providing both
+ * merged and track-specific audio access through event handlers. It supports
+ * various audio configurations including sample rate conversion and
+ * mono/stereo output.
+ *
+ * Events:
+ *
+ * - on_audio_data: triggered when bufferSize is reached, providing merged audio
+ * - on_track_audio_data: triggered when bufferSize is reached, providing
+ *   separate tracks
+ * - on_user_turn_audio: triggered when a turn ends, providing a
+ *   TurnAudioData with everything the user said during it
+ * - on_bot_turn_audio: triggered when a turn ends, providing a TurnAudioData
+ *   with everything the bot said during it
+ * - on_recording_started: triggered when recording starts (state transitions
+ *   to active)
+ * - on_recording_stopped: triggered after recording stops and the final audio
+ *   has been emitted
+ *
+ * Audio handling:
+ *
+ * - Mono output (numChannels=1): user and bot audio are mixed
+ * - Stereo output (numChannels=2): user audio on left, bot audio on right
+ * - Automatic resampling of incoming audio to match desired sampleRate
+ * - Silence insertion for non-continuous audio streams
+ * - Buffer synchronization between user and bot audio
+ */
+export declare class AudioBufferProcessor extends FrameProcessor {
+    protected _initSampleRate: number | null;
+    protected _sampleRate: number;
+    protected _audioBufferSize1s: number;
+    protected _numChannels: number;
+    protected _bufferSize: number;
+    protected _enableTurnAudio: boolean;
+    protected _autoStartRecording: boolean;
+    protected _userAudioBuffer: ByteBuffer;
+    protected _botAudioBuffer: ByteBuffer;
+    protected _userSpeaking: boolean;
+    protected _botSpeaking: boolean;
+    protected _userTurnAudioBuffer: ByteBuffer;
+    protected _botTurnAudioBuffer: ByteBuffer;
+    protected _userTurnAudio: ByteBuffer;
+    protected _botTurnAudio: ByteBuffer;
+    protected _turnTrackerAttached: boolean;
+    protected _recording: boolean;
+    protected _inputResampler: BaseAudioResampler;
+    protected _outputResampler: BaseAudioResampler;
+    protected _lastUserBufferUpdateTime: number | null;
+    protected _lastBotBufferUpdateTime: number | null;
+    /**
+     * Initialize the audio buffer processor.
+     *
+     * @param options.sampleRate Desired output sample rate. If null, uses
+     *   source rate.
+     * @param options.numChannels Number of channels (1 for mono, 2 for stereo).
+     *   Defaults to 1.
+     * @param options.bufferSize Size of buffer before triggering events. 0 for
+     *   no buffering.
+     * @param options.enableTurnAudio Whether turn audio event handlers should
+     *   be triggered.
+     * @param options.autoStartRecording Whether to start recording
+     *   automatically when the pipeline starts, without requiring a call to
+     *   `startRecording()` or an `AudioBufferStartRecordingFrame`. Other options
+     *   are passed to the parent class.
+     */
+    constructor(options?: AudioBufferProcessorOptions);
+    /** Current sample rate of the audio processor, in Hz. */
+    get sampleRate(): number;
+    /** Number of channels in the audio output (1 for mono, 2 for stereo). */
+    get numChannels(): number;
+    /**
+     * Check if either user or bot audio buffers contain data.
+     *
+     * @returns True if either buffer contains audio data.
+     */
+    hasAudio(): boolean;
+    /**
+     * Merge user and bot audio buffers into a single audio stream.
+     *
+     * For mono output, audio is mixed. For stereo output, user audio is placed
+     * on the left channel and bot audio on the right channel.
+     *
+     * @returns Mixed audio data as bytes.
+     */
+    mergeAudioBuffers(): Uint8Array;
+    /**
+     * Set up the processor.
+     *
+     * @param setup Configuration object containing setup parameters.
+     */
+    setup(setup: FrameProcessorSetup): Promise<void>;
+    /**
+     * Start recording audio from both user and bot.
+     *
+     * Initializes recording state, resets audio buffers and triggers the
+     * `on_recording_started` event. Does nothing when recording is already
+     * active.
+     */
+    startRecording(): Promise<void>;
+    /**
+     * Stop recording and trigger final audio data handlers.
+     *
+     * Calls audio handlers with any remaining buffered audio before stopping,
+     * then triggers the `on_recording_stopped` event. Does nothing when
+     * recording is not active.
+     */
+    stopRecording(): Promise<void>;
+    /**
+     * Process incoming audio frames and manage audio buffers.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+    /** Process audio frames for recording. */
+    protected _processRecording(frame: Frame): Promise<void>;
+    /**
+     * Pad buffer with silence if it's behind the target position.
+     *
+     * This ensures both buffers stay synchronized by padding the lagging
+     * buffer before new audio is added to the other buffer.
+     *
+     * @param buffer The buffer to potentially pad.
+     * @param targetPosition The position (in bytes) the buffer should reach.
+     */
+    protected _syncBufferToPosition(buffer: ByteBuffer, targetPosition: number): void;
+    /**
+     * Insert silence into a buffer when a wall-clock gap is detected.
+     *
+     * Called before adding new audio to a buffer. Compares the elapsed
+     * wall-clock time since the buffer was last written against the duration
+     * of the incoming frame. Any excess time (e.g., a muted mic or an idle
+     * period between bot utterances) is filled with silence so the recorded
+     * utterances remain temporally separated.
+     *
+     * @param buffer The audio buffer to pad (user or bot).
+     * @param lastUpdateTime Monotonic time of the last write to this buffer, or
+     *   null if the buffer has never been written.
+     * @param now Current monotonic time.
+     * @param frameBytes Byte length of the incoming (resampled) audio frame.
+     */
+    protected _fillBufferSilenceGap(buffer: ByteBuffer, lastUpdateTime: number | null, now: number, frameBytes: number): void;
+    /** Process frames for turn-based audio recording. */
+    protected _processTurnRecording(frame: Frame, resampledAudio?: Uint8Array | null): Promise<void>;
+    /** Emit turn audio when the pipeline's turn tracker ends a turn. */
+    protected _attachTurnTracker(): void;
+    /** Fold the user's finished run of speech into the current turn. */
+    protected _endUserRun(): void;
+    /** Fold the bot's finished run of speech into the current turn. */
+    protected _endBotRun(): void;
+    /** Report each speaker's audio for a turn that just ended. */
+    protected _emitTurnAudio(turnNumber: number): Promise<void>;
+    /** Call the audio data event handlers with buffered audio. */
+    protected _callOnAudioDataHandler(): Promise<void>;
+    /** Check if a buffer contains audio data. */
+    protected _bufferHasAudio(buffer: ByteBuffer | null): boolean;
+    /** Reset recording state and buffers. */
+    protected _resetRecording(clearTurnAudio?: boolean): void;
+    /** Reset all audio buffers to empty state. */
+    protected _resetAllAudioBuffers(clearTurnAudio?: boolean): void;
+    /** Clear user and bot buffers while preserving turn buffers and timestamps. */
+    protected _resetPrimaryAudioBuffers(): void;
+    /** Clear user and bot turn buffers while preserving primary buffers and timestamps. */
+    protected _resetTurnAudioBuffers(): void;
+    /** Pad the shorter track with silence so both tracks stay in sync. */
+    protected _alignTrackBuffers(): void;
+    /** Resample audio frame to the target sample rate. */
+    protected _resampleInputAudio(frame: InputAudioRawFrame): Promise<Uint8Array>;
+    /** Resample audio frame to the target sample rate. */
+    protected _resampleOutputAudio(frame: OutputAudioRawFrame): Promise<Uint8Array>;
+}
+//# sourceMappingURL=audio_buffer_processor.d.ts.map