@pipedog/core 0.0.0 → 0.2.0

package/dist/frames/frames.d.ts

@@ -0,0 +1,2533 @@
+/**
+ * Core frame definitions for the Pipecat framework.
+ *
+ * Contains all frame types used throughout the pipeline system, including
+ * data frames, system frames, and control frames for audio, video, text, and
+ * LLM processing.
+ *
+ * Porting notes (see docs/CONVENTIONS.md, "Frames"):
+ * - Python dataclass fields become class fields; `init=True` fields are read
+ *   from the constructor's options object (`new TextFrame({ text: "hi" })`),
+ *   `init=False` fields are plain field initializers.
+ * - `__post_init__` overrides become field initializers or constructor code
+ *   in the subclass (they run base-first, like the `super().__post_init__()` chain).
+ * - Non-Frame dataclass mixins (AudioRawFrame, ImageRawFrame, ...) use
+ *   `defineMixin`; a second concrete Frame base uses `addVirtualBase`.
+ * - `__str__` becomes `toString()`.
+ */
+import { type Event } from "@pipedog/asyncio";
+import type { DirectFunction } from "../adapters/schemas/direct_function.ts";
+import type { FunctionSchema } from "../adapters/schemas/function_schema.ts";
+import type { ToolsSchema } from "../adapters/schemas/tools_schema.ts";
+import { KeypadEntry } from "../audio/dtmf/types.ts";
+import type { BaseTurnParams } from "../audio/turn/base_turn_analyzer.ts";
+import type { VADParams } from "../audio/vad/vad_analyzer.ts";
+import type { MetricsData } from "../metrics/metrics.ts";
+import type { LLMContext, LLMContextMessage } from "../processors/aggregators/llm_context.ts";
+import type { FrameProcessor } from "../processors/frame_processor.ts";
+import type { LLMSettings, ServiceSettings, STTSettings, TTSSettings } from "../services/settings.ts";
+import type { Language } from "../transcriptions/language.ts";
+import type { UserTurnStrategies } from "../turns/user_turn_strategies.ts";
+import type { LLMContextSummaryConfig } from "../utils/context/llm_context_summarization.ts";
+import { ErrorCategory } from "../utils/errors.ts";
+import { type Ctor } from "../utils/mixin.ts";
+import { TextType } from "../utils/text/base_text_aggregator.ts";
+import type { NotGiven } from "../utils/types.ts";
+export { TextType };
+/** Format a presentation timestamp (nanoseconds) to a human-readable string. */
+export declare function formatPts(pts: number | null | undefined): string | null;
+/**
+ * Base frame class for all frames in the Pipecat pipeline.
+ *
+ * All frames automatically receive unique identifiers, names, and metadata.
+ *
+ * - `id`: unique identifier for the frame instance.
+ * - `name`: class name and instance count.
+ * - `pts`: presentation timestamp in nanoseconds.
+ * - `broadcastSiblingId`: id of the paired frame when broadcast in both
+ *   directions; set by `broadcastFrame()` / `broadcastFrameInstance()`.
+ * - `metadata`: arbitrary frame metadata.
+ * - `transportSource` / `transportDestination`: transport routing names.
+ * - `interruptible`: whether an interruption may drop this frame from a
+ *   processor's queue or cancel its processing. Subclasses that are
+ *   uninterruptible by default declare `override interruptible = false`.
+ */
+export declare class Frame {
+    id: number;
+    name: string;
+    pts: number | null;
+    broadcastSiblingId: number | null;
+    metadata: Record<string, unknown>;
+    transportSource: string | null;
+    transportDestination: string | null;
+    interruptible: boolean;
+    constructor(_options?: object);
+    toString(): string;
+}
+/** Give a copied frame a fresh `id` and `name`, as dataclass re-construction does. */
+export declare function renewFrameIdentity(frame: Frame): void;
+/**
+ * System frame class for immediate processing.
+ *
+ * Takes higher priority than other frames. System frames are handled in order
+ * and are not affected by user interruptions.
+ */
+export declare class SystemFrame extends Frame {
+}
+/**
+ * Data frame class for processing data in order.
+ *
+ * Processed in order; usually contains data such as LLM context, text, audio
+ * or images. Data frames are cancelled by user interruptions.
+ */
+export declare class DataFrame extends Frame {
+}
+/**
+ * Control frame class for processing control information in order.
+ *
+ * Like data frames, processed in order; usually contains control information
+ * such as settings updates or ending the pipeline after everything is flushed.
+ * Cancelled by user interruptions.
+ */
+export declare class ControlFrame extends Frame {
+}
+/** Fields of a chunk of raw audio. */
+export interface AudioRawFrameOptions {
+    /** Raw audio bytes in PCM format (16-bit little endian). */
+    audio: Uint8Array;
+    /** Audio sample rate in Hz. */
+    sampleRate: number;
+    /** Number of audio channels. */
+    numChannels: number;
+}
+/** A frame containing a chunk of raw audio. `numFrames` is computed. */
+export interface AudioRawFrame extends AudioRawFrameOptions {
+    numFrames: number;
+}
+export declare const AudioRawFrame: import("../utils/mixin.ts").Mixin<<B extends Ctor>(base: B) => B & Ctor<AudioRawFrame>, AudioRawFrame>;
+/** Fields of a raw image. */
+export interface ImageRawFrameOptions {
+    /** Raw image bytes. */
+    image: Uint8Array;
+    /** Image dimensions as [width, height]. */
+    size: [number, number];
+    /** Image format (e.g. 'RGB', 'RGBA'). */
+    format: string | null;
+}
+/** A frame containing a raw image. */
+export interface ImageRawFrame extends ImageRawFrameOptions {
+}
+export declare const ImageRawFrame: import("../utils/mixin.ts").Mixin<<B extends Ctor>(base: B) => B & Ctor<ImageRawFrame>, ImageRawFrame>;
+declare const OutputAudioRawFrame_base: typeof DataFrame & Ctor<AudioRawFrame>;
+/**
+ * Audio data frame for output to transport.
+ *
+ * A chunk of raw audio that will be played by the output transport. If the
+ * transport supports multiple audio destinations (e.g. multiple audio tracks)
+ * the destination name can be specified in `transportDestination`.
+ */
+export declare class OutputAudioRawFrame extends OutputAudioRawFrame_base {
+    constructor(options: AudioRawFrameOptions);
+    toString(): string;
+}
+export interface TextFrameOptions {
+    /** The text content. */
+    text: string;
+}
+/**
+ * Text data frame for passing text through the pipeline.
+ *
+ * Emitted by LLM services, consumed by context aggregators, TTS services and
+ * more.
+ *
+ * - `skipTts`: whether this text should be skipped by the TTS service.
+ * - `includesInterFrameSpaces`: whether any necessary inter-frame
+ *   (leading/trailing) spaces are already included in the text.
+ * - `appendToContext`: whether this text should be appended to the LLM context.
+ */
+export declare class TextFrame extends DataFrame {
+    text: string;
+    skipTts: boolean | null;
+    includesInterFrameSpaces: boolean;
+    appendToContext: boolean;
+    constructor(options: TextFrameOptions);
+    toString(): string;
+}
+/** Text frame generated by LLM services. */
+export declare class LLMTextFrame extends TextFrame {
+    includesInterFrameSpaces: boolean;
+}
+/** Type of a raw file: a base64 data URL ('bytes') or a URL string ('url'). */
+export type FileSourceType = "bytes" | "url";
+/** Fields of a raw file. */
+export interface FileRawFrameOptions {
+    /** A base64 data URL, or a URL string, depending on `type`. */
+    file: string;
+    /** Type of the file ('bytes' or 'url'). */
+    type: FileSourceType;
+    /** Optional name of the file. */
+    filename: string | null;
+    /** File format (expected in Mime Format). */
+    format: string;
+}
+/** A frame containing a raw file. */
+export interface FileRawFrame extends FileRawFrameOptions {
+}
+export declare const FileRawFrame: import("../utils/mixin.ts").Mixin<<B extends Ctor>(base: B) => B & Ctor<FileRawFrame>, FileRawFrame>;
+/**
+ * Marker base class for DTMF (Dual-Tone Multi-Frequency) keypad frames.
+ *
+ * Used only as a shared tag so that both input and output DTMF frames can be
+ * identified via `frame instanceof DTMFFrame`. The concrete frames define
+ * their own fields.
+ */
+export interface DTMFFrame {
+}
+export declare const DTMFFrame: import("../utils/mixin.ts").Mixin<<B extends Ctor>(base: B) => B & Ctor<DTMFFrame>, DTMFFrame>;
+declare const OutputImageRawFrame_base: typeof DataFrame & Ctor<ImageRawFrame>;
+/**
+ * Image data frame for output to transport.
+ *
+ * An image that will be shown by the transport. If the transport supports
+ * multiple video destinations (e.g. multiple video tracks) the destination
+ * name can be specified in `transportDestination`.
+ *
+ * - `syncWithAudio`: if true, the image is queued with audio frames so it is
+ *   only displayed after all preceding audio has been sent. Defaults to false
+ *   (image is displayed immediately when the output transport receives it).
+ */
+export declare class OutputImageRawFrame extends OutputImageRawFrame_base {
+    syncWithAudio: boolean;
+    constructor(options: ImageRawFrameOptions);
+    toString(): string;
+}
+export interface TTSAudioRawFrameOptions extends AudioRawFrameOptions {
+    /** Unique identifier for the TTS context that generated this audio. */
+    contextId?: string | null;
+}
+/**
+ * Audio data frame generated by Text-to-Speech services.
+ *
+ * A chunk of output audio generated by a TTS service, ready for playback.
+ *
+ * - `contextId`: unique identifier for the TTS context that generated this audio.
+ */
+export declare class TTSAudioRawFrame extends OutputAudioRawFrame {
+    contextId: string | null;
+    constructor(options: TTSAudioRawFrameOptions);
+}
+/**
+ * An audio frame part of a speech audio stream.
+ *
+ * This frame is part of a continuous stream of audio frames containing speech.
+ * The audio stream might also contain silence frames, so a process to
+ * distinguish between speech and silence might be needed.
+ */
+export declare class SpeechOutputAudioRawFrame extends OutputAudioRawFrame {
+}
+export interface URLImageRawFrameOptions extends ImageRawFrameOptions {
+    /** URL where the image can be downloaded from. */
+    url?: string | null;
+}
+/**
+ * Image frame with an associated URL.
+ *
+ * An output image with an associated URL. These images are usually generated
+ * by third-party services that provide a URL to download the image.
+ *
+ * - `url`: URL where the image can be downloaded from.
+ */
+export declare class URLImageRawFrame extends OutputImageRawFrame {
+    url: string | null;
+    constructor(options: URLImageRawFrameOptions);
+    toString(): string;
+}
+export interface SpriteFrameOptions {
+    /** List of image frames that make up the sprite animation. */
+    images: OutputImageRawFrame[];
+}
+/**
+ * Animated sprite frame containing multiple images.
+ *
+ * An animated sprite that will be shown by the transport if the transport's
+ * camera is enabled. Will play at the framerate specified in the transport's
+ * `cameraOutFramerate` constructor parameter.
+ *
+ * - `images`: list of image frames that make up the sprite animation.
+ */
+export declare class SpriteFrame extends DataFrame {
+    images: OutputImageRawFrame[];
+    constructor(options: SpriteFrameOptions);
+    toString(): string;
+}
+export interface LLMMarkerFrameOptions {
+    /** The marker payload (typically a short string such as a single character). */
+    marker: string;
+    /**
+     * Whether the marker is written to the context as its own standalone
+     * assistant message as soon as it's received. Defaults to true.
+     */
+    appendToContextImmediately?: boolean;
+}
+/**
+ * Sideband marker emitted by an LLM service.
+ *
+ * A marker is short, structured assistant output that should be persisted in
+ * the conversation context but should not flow through the standard text path
+ * (TTS, transcript). The assistant aggregator writes the marker to the context
+ * so the LLM can self-condition on prior markers on subsequent turns.
+ *
+ * The primary use today is the `filterIncompleteUserTurns` protocol, where
+ * `UserTurnCompletionLLMServiceMixin` emits the turn-completion markers
+ * ● / ◐ / ○ on every response. The frame is intentionally generic so other
+ * components — STT services with built-in turn signals, end-of-turn
+ * classifiers, custom annotations, etc. — can use the same mechanism to inject
+ * sideband signals into the assistant context.
+ *
+ * - `marker`: the marker payload (typically a short string such as a single
+ *   character).
+ * - `appendToContextImmediately`: if true, the marker is written to the
+ *   context as its own standalone assistant message as soon as it's received.
+ *   If false, the marker is appended to the running assistant aggregation and
+ *   flushed to the context together with the following text as a single
+ *   message (e.g. for the ● case the context message ends up as
+ *   "● <response>").
+ */
+export declare class LLMMarkerFrame extends DataFrame {
+    marker: string;
+    appendToContextImmediately: boolean;
+    constructor(options: LLMMarkerFrameOptions);
+}
+export interface LLMMarkerResponseFrameOptions {
+    /** The response text as the LLM produced it, markers included. */
+    raw: string;
+    /** The marker found, or null when the response carried none. */
+    marker?: string | null;
+    /** What the marker meant, in the emitter's own vocabulary. */
+    kind?: string | null;
+    /** Every marker the emitter recognizes. */
+    markers?: string[];
+}
+/**
+ * What a marker-reading LLM service made of one whole response.
+ *
+ * Pushed when the response ends, after the `LLMMarkerFrame` and the spoken
+ * text: the marker it found, what it meant, and the raw text the LLM produced
+ * before anything was held back. A diagnostic, for consumers that check how
+ * well the LLM follows the marker protocol; it plays no part in the
+ * conversation.
+ *
+ * - `raw`: the response text as the LLM produced it, markers included.
+ * - `marker`: the marker found, or null when the response carried none.
+ * - `kind`: what the marker meant, in the emitter's own vocabulary, for
+ *   consumers that should not depend on the marker text (which is
+ *   configurable). The turn-completion mixin uses `"complete"`, `"short"` and
+ *   `"long"`.
+ * - `markers`: every marker the emitter recognizes, so a consumer can find
+ *   them in `raw` without knowing the emitter's configuration.
+ */
+export declare class LLMMarkerResponseFrame extends DataFrame {
+    raw: string;
+    marker: string | null;
+    kind: string | null;
+    markers: string[];
+    constructor(options: LLMMarkerResponseFrameOptions);
+}
+export interface AggregatedTextFrameOptions extends TextFrameOptions {
+    /** The kind of text, such as a sentence, a word or a custom type like `"code"`. */
+    textType: TextType | string;
+    /** Unique identifier for the TTS context that generated this text. */
+    contextId?: string | null;
+    /** The full matched text including start/end pattern delimiters. */
+    rawText?: string | null;
+}
+/**
+ * Text frame representing an aggregation of TextFrames.
+ *
+ * This frame contains multiple TextFrames aggregated together for processing
+ * or output along with a field to indicate what kind of text they make.
+ *
+ * - `textType`: the kind of text, such as a sentence, a word or a custom type
+ *   like `"code"`.
+ * - `contextId`: unique identifier for the TTS context that generated this text.
+ * - `rawText`: the full matched text including start/end pattern delimiters,
+ *   set when this frame was produced from a PatternMatch (e.g. a
+ *   `<code>...</code>` block). Null for ordinary sentence aggregations.
+ * - `willBeSpoken`: whether the TTS service will speak this frame. Set to true
+ *   by the TTS service just before synthesis. Defaults to false.
+ */
+export declare class AggregatedTextFrame extends TextFrame {
+    textType: TextType | string;
+    contextId: string | null;
+    rawText: string | null;
+    willBeSpoken: boolean;
+    constructor(options: AggregatedTextFrameOptions);
+}
+/** Text frame generated by vision services. */
+export declare class VisionTextFrame extends LLMTextFrame {
+}
+export interface TTSTextFrameOptions extends AggregatedTextFrameOptions {
+    /** ID of the AggregatedTextFrame this text is part of. */
+    segmentId?: number | null;
+}
+/**
+ * Text frame generated by Text-to-Speech services.
+ *
+ * - `segmentId`: ID of the AggregatedTextFrame this text is part of, when the
+ *   TTS service built it from one. A word reported by the TTS carries the ID
+ *   of the sentence or other segment it was spoken in.
+ */
+export declare class TTSTextFrame extends AggregatedTextFrame {
+    segmentId: number | null;
+    constructor(options: TTSTextFrameOptions);
+}
+export interface AggregatedTextProgressFrameOptions {
+    /** ID of the AggregatedTextFrame being spoken. */
+    segmentId: number;
+    /** TTS context this frame belongs to. */
+    contextId: string | null;
+    /** Full original text of the source AggregatedTextFrame. */
+    text: string;
+    /** Text type of the source AggregatedTextFrame. */
+    textType: TextType | string;
+    /** Text already spoken in this slot (including the current word). */
+    accumulatedText: string;
+    /** Text not yet spoken in this slot. */
+    remainingText: string;
+}
+/**
+ * Progress frame emitted alongside each TTSTextFrame during word-timestamp playback.
+ *
+ * Carries the spoken-so-far / remaining-text breakdown for the active
+ * AggregatedTextFrame slot, enabling downstream consumers (e.g. the RTVI
+ * observer) to do word-level highlighting without coupling to internal
+ * sequencer state.
+ *
+ * - `segmentId`: ID of the AggregatedTextFrame being spoken.
+ * - `contextId`: TTS context this frame belongs to.
+ * - `text`: full original text of the source AggregatedTextFrame.
+ * - `textType`: text type of the source AggregatedTextFrame.
+ * - `accumulatedText`: text already spoken in this slot (including the current word).
+ * - `remainingText`: text not yet spoken in this slot.
+ */
+export declare class AggregatedTextProgressFrame extends DataFrame {
+    segmentId: number;
+    contextId: string | null;
+    text: string;
+    textType: TextType | string;
+    accumulatedText: string;
+    remainingText: string;
+    constructor(options: AggregatedTextProgressFrameOptions);
+}
+export interface TranscriptionFrameOptions extends TextFrameOptions {
+    /** Identifier for the user who spoke. */
+    userId: string;
+    /** When the transcription occurred. */
+    timestamp: string;
+    /** Detected or specified language of the speech. */
+    language?: Language | null;
+    /** Raw result from the STT service. */
+    result?: unknown;
+    /** Whether this is the final transcription for an utterance. */
+    finalized?: boolean;
+}
+/**
+ * Text frame containing speech transcription data.
+ *
+ * A text frame with transcription-specific data. The `result` field contains
+ * the result from the STT service if available.
+ *
+ * - `userId`: identifier for the user who spoke.
+ * - `timestamp`: when the transcription occurred.
+ * - `language`: detected or specified language of the speech.
+ * - `result`: raw result from the STT service.
+ * - `finalized`: whether this is the final transcription for an utterance.
+ *   Set by STT services that support commit/finalize signals.
+ */
+export declare class TranscriptionFrame extends TextFrame {
+    userId: string;
+    timestamp: string;
+    language: Language | null;
+    result: unknown;
+    finalized: boolean;
+    constructor(options: TranscriptionFrameOptions);
+    toString(): string;
+}
+export interface InterimTranscriptionFrameOptions extends TextFrameOptions {
+    /** Identifier for the user who spoke. */
+    userId: string;
+    /** When the interim transcription occurred. */
+    timestamp: string;
+    /** Detected or specified language of the speech. */
+    language?: Language | null;
+    /** Raw result from the STT service. */
+    result?: unknown;
+}
+/**
+ * Text frame containing partial/interim transcription data.
+ *
+ * A text frame with interim transcription-specific data that represents
+ * partial results before final transcription. The `result` field contains the
+ * result from the STT service if available.
+ *
+ * - `userId`: identifier for the user who spoke.
+ * - `timestamp`: when the interim transcription occurred.
+ * - `language`: detected or specified language of the speech.
+ * - `result`: raw result from the STT service.
+ */
+export declare class InterimTranscriptionFrame extends TextFrame {
+    userId: string;
+    timestamp: string;
+    language: Language | null;
+    result: unknown;
+    constructor(options: InterimTranscriptionFrameOptions);
+    toString(): string;
+}
+export interface EagerTranscriptionFrameOptions extends TextFrameOptions {
+    /** Identifier for the user who spoke. */
+    userId: string;
+    /** When the eager end of turn occurred. */
+    timestamp: string;
+    /** Detected or specified language of the speech. */
+    language?: Language | null;
+    /** Raw result from the STT service. */
+    result?: unknown;
+}
+/**
+ * Transcript of a turn a service predicts has ended, before it commits.
+ *
+ * Some STT services emit a provisional end of turn ahead of the real one, so a
+ * response can be generated during the gap. The prediction may be withdrawn
+ * (`EagerEndOfTurnCancelFrame`) and the committed transcript may differ from
+ * this one, so nothing produced from it may reach the user or the context
+ * until it is confirmed. See `EagerUserTurnStopStrategy`.
+ *
+ * - `userId`: identifier for the user who spoke.
+ * - `timestamp`: when the eager end of turn occurred.
+ * - `language`: detected or specified language of the speech.
+ * - `result`: raw result from the STT service.
+ */
+export declare class EagerTranscriptionFrame extends TextFrame {
+    userId: string;
+    timestamp: string;
+    language: Language | null;
+    result: unknown;
+    constructor(options: EagerTranscriptionFrameOptions);
+    toString(): string;
+}
+export interface TranslationFrameOptions extends TextFrameOptions {
+    /** Identifier for the user who spoke. */
+    userId: string;
+    /** When the translation occurred. */
+    timestamp: string;
+    /** Target language of the translation. */
+    language?: Language | null;
+}
+/**
+ * Text frame containing translated transcription data.
+ *
+ * A text frame with translated transcription data that will be placed in the
+ * transport's receive queue when a participant speaks.
+ *
+ * - `userId`: identifier for the user who spoke.
+ * - `timestamp`: when the translation occurred.
+ * - `language`: target language of the translation.
+ */
+export declare class TranslationFrame extends TextFrame {
+    userId: string;
+    timestamp: string;
+    language: Language | null;
+    constructor(options: TranslationFrameOptions);
+    toString(): string;
+}
+export interface UserBackchannelFrameOptions {
+    /** What the user said. */
+    text: string;
+    /** Identifier for the user who spoke. */
+    userId: string;
+    /** When the user said it. */
+    timestamp: string;
+}
+/**
+ * A short acknowledgment the user said while the bot talks, such as "mhm".
+ *
+ * Pushed in place of a transcription, so the bot keeps talking and the
+ * acknowledgment stays out of the LLM context.
+ *
+ * - `text`: what the user said.
+ * - `userId`: identifier for the user who spoke.
+ * - `timestamp`: when the user said it.
+ */
+export declare class UserBackchannelFrame extends DataFrame {
+    text: string;
+    userId: string;
+    timestamp: string;
+    constructor(options: UserBackchannelFrameOptions);
+    toString(): string;
+}
+export interface LLMContextAssistantTimestampFrameOptions {
+    /** Timestamp when the assistant message was created. */
+    timestamp: string;
+}
+/**
+ * Timestamp information for assistant messages in LLM context.
+ *
+ * - `timestamp`: timestamp when the assistant message was created.
+ */
+export declare class LLMContextAssistantTimestampFrame extends DataFrame {
+    timestamp: string;
+    constructor(options: LLMContextAssistantTimestampFrameOptions);
+}
+export interface LLMContextAssistantTurnFrameOptions {
+    /** The assistant's aggregated spoken text for this turn. */
+    text: string;
+    /** ISO-8601 timestamp of when the assistant turn started. */
+    timestamp: string;
+}
+/**
+ * The aggregated text of a completed assistant turn.
+ *
+ * Broadcast by the LLM assistant aggregator when a turn ends, carrying the
+ * same text that is stored in the LLM context. Processors upstream and
+ * downstream (e.g. STT services) can handle this frame to react to each
+ * completed bot reply without needing a separate observer.
+ *
+ * - `text`: the assistant's aggregated spoken text for this turn.
+ * - `timestamp`: ISO-8601 timestamp of when the assistant turn started.
+ */
+export declare class LLMContextAssistantTurnFrame extends DataFrame {
+    text: string;
+    timestamp: string;
+    constructor(options: LLMContextAssistantTurnFrameOptions);
+}
+export interface LLMContextUserTurnFrameOptions {
+    /** The user's aggregated transcript for this turn. */
+    text: string;
+    /** ISO-8601 timestamp of when the user turn started. */
+    timestamp: string;
+}
+/**
+ * The aggregated text of a user turn, as written to the LLM context.
+ *
+ * Broadcast by the LLM user aggregator each time it writes what the user said
+ * to the context, so it holds what the bot heard: a transcription the
+ * aggregator leaves out, such as one while the user is muted, is not in it.
+ *
+ * - `text`: the user's aggregated transcript for this turn.
+ * - `timestamp`: ISO-8601 timestamp of when the user turn started.
+ */
+export declare class LLMContextUserTurnFrame extends DataFrame {
+    text: string;
+    timestamp: string;
+    constructor(options: LLMContextUserTurnFrameOptions);
+}
+export interface LLMContextFrameOptions {
+    /** The LLM context containing messages, tools, and configuration. */
+    context: LLMContext;
+    /** Whether this inference is speculative. Defaults to false. */
+    speculation?: boolean;
+}
+/**
+ * Frame containing a universal LLM context.
+ *
+ * Used as a signal to LLM services to ingest the provided context and generate
+ * a response based on it.
+ *
+ * - `context`: the LLM context containing messages, tools, and configuration.
+ * - `speculation`: whether this inference is speculative, run from a
+ *   provisional context that is not part of the conversation. Its response
+ *   must not reach the user or the context until the turn is confirmed, and
+ *   the service must not execute tool calls for it.
+ */
+export declare class LLMContextFrame extends Frame {
+    context: LLMContext;
+    speculation: boolean;
+    constructor(options: LLMContextFrameOptions);
+}
+export interface LLMThoughtStartFrameOptions {
+    /** Whether the thought should be appended to the LLM context. */
+    appendToContext?: boolean;
+    /** Optional identifier of the LLM provider for LLM-specific handling. */
+    llm?: string | null;
+}
+/**
+ * Frame indicating the start of an LLM thought.
+ *
+ * - `appendToContext`: whether the thought should be appended to the LLM
+ *   context. If it is appended, the `llm` field is required, since it will be
+ *   appended as an `LLMSpecificMessage`.
+ * - `llm`: optional identifier of the LLM provider for LLM-specific handling.
+ *   Only required if `appendToContext` is true, as the thought is appended to
+ *   context as an `LLMSpecificMessage`.
+ */
+export declare class LLMThoughtStartFrame extends ControlFrame {
+    appendToContext: boolean;
+    llm: string | null;
+    constructor(options?: LLMThoughtStartFrameOptions);
+    toString(): string;
+}
+export interface LLMThoughtTextFrameOptions {
+    /** The text (or text chunk) of the thought. */
+    text: string;
+}
+/**
+ * Frame containing the text (or text chunk) of an LLM thought.
+ *
+ * Note that despite this containing text, it is a DataFrame and not a
+ * TextFrame, to avoid most typical text processing, such as TTS.
+ *
+ * - `text`: the text (or text chunk) of the thought.
+ */
+export declare class LLMThoughtTextFrame extends DataFrame {
+    text: string;
+    includesInterFrameSpaces: boolean;
+    constructor(options: LLMThoughtTextFrameOptions);
+    toString(): string;
+}
+export interface LLMThoughtEndFrameOptions {
+    /** Optional signature associated with the thought. */
+    signature?: unknown;
+}
+/**
+ * Frame indicating the end of an LLM thought.
+ *
+ * - `signature`: optional signature associated with the thought. This is used
+ *   by Anthropic, which includes a signature at the end of each thought.
+ */
+export declare class LLMThoughtEndFrame extends ControlFrame {
+    signature: unknown;
+    constructor(options?: LLMThoughtEndFrameOptions);
+    toString(): string;
+}
+/**
+ * Frame to trigger LLM processing with current context.
+ *
+ * A frame that instructs the LLM service to process the current context and
+ * generate a response.
+ */
+export declare class LLMRunFrame extends DataFrame {
+}
+export interface LLMMessagesAppendFrameOptions {
+    /** List of context messages to append. */
+    messages: LLMContextMessage[];
+    /** Whether the context update should be sent to the LLM. */
+    runLlm?: boolean | null;
+}
+/**
+ * Frame containing LLM messages to append to current context.
+ *
+ * A frame containing a list of LLM messages that need to be added to the
+ * current context.
+ *
+ * - `messages`: list of context messages to append.
+ * - `runLlm`: whether the context update should be sent to the LLM.
+ */
+export declare class LLMMessagesAppendFrame extends DataFrame {
+    messages: LLMContextMessage[];
+    runLlm: boolean | null;
+    constructor(options: LLMMessagesAppendFrameOptions);
+}
+export interface LLMMessagesUpdateFrameOptions {
+    /** List of context messages to replace current context. */
+    messages: LLMContextMessage[];
+    /** Whether the context update should be sent to the LLM. */
+    runLlm?: boolean | null;
+}
+/**
+ * Frame containing LLM messages to replace current context.
+ *
+ * A frame containing a list of new LLM messages to replace the current
+ * context LLM messages.
+ *
+ * - `messages`: list of context messages to replace current context.
+ * - `runLlm`: whether the context update should be sent to the LLM.
+ */
+export declare class LLMMessagesUpdateFrame extends DataFrame {
+    messages: LLMContextMessage[];
+    runLlm: boolean | null;
+    constructor(options: LLMMessagesUpdateFrameOptions);
+}
+export interface LLMMessagesTransformFrameOptions {
+    /** A function that takes a list of messages and returns a modified list. */
+    transform: (messages: LLMContextMessage[]) => LLMContextMessage[];
+    /** Whether the context update should be sent to the LLM. */
+    runLlm?: boolean | null;
+}
+/**
+ * Frame containing a transform function to modify the current context's LLM messages.
+ *
+ * A frame containing a transform function that takes the context's current
+ * list of LLM messages and returns a modified list.
+ *
+ * - `transform`: a function that takes a list of messages and returns a
+ *   modified list.
+ * - `runLlm`: whether the context update should be sent to the LLM.
+ */
+export declare class LLMMessagesTransformFrame extends DataFrame {
+    transform: (messages: LLMContextMessage[]) => LLMContextMessage[];
+    runLlm: boolean | null;
+    constructor(options: LLMMessagesTransformFrameOptions);
+}
+export interface LLMSetToolsFrameOptions {
+    /** The tools to advertise. */
+    tools: (FunctionSchema | DirectFunction)[] | ToolsSchema | NotGiven;
+}
+/**
+ * Frame containing tools for LLM function calling.
+ *
+ * Used to change the set of tools advertised to the LLM mid-conversation.
+ *
+ * - `tools`: the tools to advertise. May be a `ToolsSchema`, a plain list of
+ *   direct functions and/or `FunctionSchema` objects (normalized to a
+ *   `ToolsSchema`, with direct-function handlers auto-registered), or
+ *   `NOT_GIVEN` to clear tools. Provider-native tools travel in a
+ *   `ToolsSchema`'s `customTools`, keyed by adapter type.
+ */
+export declare class LLMSetToolsFrame extends DataFrame {
+    tools: (FunctionSchema | DirectFunction)[] | ToolsSchema | NotGiven;
+    constructor(options: LLMSetToolsFrameOptions);
+}
+/** Tool choice setting: 'none', 'auto', 'required', or a specific tool dict. */
+export type LLMToolChoice = "none" | "auto" | "required" | Record<string, unknown>;
+export interface LLMSetToolChoiceFrameOptions {
+    /** Tool choice setting - 'none', 'auto', 'required', or specific tool dict. */
+    toolChoice: LLMToolChoice;
+}
+/**
+ * Frame containing tool choice configuration for LLM function calling.
+ *
+ * - `toolChoice`: tool choice setting - 'none', 'auto', 'required', or
+ *   specific tool dict.
+ */
+export declare class LLMSetToolChoiceFrame extends DataFrame {
+    toolChoice: LLMToolChoice;
+    constructor(options: LLMSetToolChoiceFrameOptions);
+}
+export interface LLMEnablePromptCachingFrameOptions {
+    /** Whether to enable prompt caching. */
+    enable: boolean;
+}
+/**
+ * Frame to enable/disable prompt caching in LLMs.
+ *
+ * - `enable`: whether to enable prompt caching.
+ */
+export declare class LLMEnablePromptCachingFrame extends DataFrame {
+    enable: boolean;
+    constructor(options: LLMEnablePromptCachingFrameOptions);
+}
+export interface LLMConfigureOutputFrameOptions {
+    /** Whether LLM tokens should skip the TTS service (if any). */
+    skipTts: boolean;
+}
+/**
+ * Frame to configure LLM output.
+ *
+ * This frame is used to configure how the LLM produces output. For example, it
+ * can tell the LLM to generate tokens that should be added to the context but
+ * not spoken by the TTS service (if one is present in the pipeline).
+ *
+ * - `skipTts`: whether LLM tokens should skip the TTS service (if any).
+ */
+export declare class LLMConfigureOutputFrame extends DataFrame {
+    skipTts: boolean;
+    constructor(options: LLMConfigureOutputFrameOptions);
+}
+export interface FunctionCallResultPropertiesOptions {
+    /** Whether to run the LLM after receiving this result. */
+    runLlm?: boolean | null;
+    /** Callback to execute when context is updated. */
+    onContextUpdated?: (() => Promise<void>) | null;
+    /** Whether this is the final result for the function call. Defaults to true. */
+    isFinal?: boolean;
+}
+/**
+ * Properties for configuring function call result behavior.
+ *
+ * - `runLlm`: whether to run the LLM after receiving this result.
+ * - `onContextUpdated`: callback to execute when context is updated.
+ * - `isFinal`: whether this is the final result for the function call. When
+ *   false the result is treated as an intermediate update. Defaults to true.
+ *   Only meaningful for async function calls (`cancelOnInterruption: false`).
+ *   A speech-to-speech service takes one output per call, so it puts an
+ *   intermediate result to its model some other way — a conversation item, a
+ *   text event, a response that keeps the call open — and `runLlm` says
+ *   whether the model should answer it or just take it in. A service that
+ *   can't do that at all says so with
+ *   `acceptsIntermediateFunctionCallResults` and drops intermediate results
+ *   with a warning.
+ */
+export declare class FunctionCallResultProperties {
+    runLlm: boolean | null;
+    onContextUpdated: (() => Promise<void>) | null;
+    isFinal: boolean;
+    constructor(options?: FunctionCallResultPropertiesOptions);
+}
+export interface FunctionCallResultFrameOptions {
+    /** Name of the function that was executed. */
+    functionName: string;
+    /** Unique identifier for the function call. */
+    toolCallId: string;
+    /** Arguments that were passed to the function. */
+    arguments: unknown;
+    /** The result returned by the function. */
+    result: unknown;
+    /** Whether to run the LLM after this result. */
+    runLlm?: boolean | null;
+    /** Additional properties for result handling. */
+    properties?: FunctionCallResultProperties | null;
+    /** What went wrong, when the call ended because its handler raised. */
+    error?: string | null;
+}
+/**
+ * Frame containing the result of an LLM function call.
+ *
+ * This is an uninterruptible frame because once a result is generated we
+ * always want to update the context.
+ *
+ * - `functionName`: name of the function that was executed.
+ * - `toolCallId`: unique identifier for the function call.
+ * - `arguments`: arguments that were passed to the function.
+ * - `result`: the result returned by the function.
+ * - `runLlm`: whether to run the LLM after this result.
+ * - `properties`: additional properties for result handling.
+ * - `error`: what went wrong, when the call ended because its handler raised.
+ *   The `result` is then a stand-in message written for the LLM to read,
+ *   rather than anything the handler returned.
+ */
+export declare class FunctionCallResultFrame extends DataFrame {
+    interruptible: boolean;
+    functionName: string;
+    toolCallId: string;
+    arguments: unknown;
+    result: unknown;
+    runLlm: boolean | null;
+    properties: FunctionCallResultProperties | null;
+    error: string | null;
+    constructor(options: FunctionCallResultFrameOptions);
+}
+export interface TTSSpeakFrameOptions {
+    /** The text to be spoken. */
+    text: string;
+    /** Whether the spoken text should be appended to the LLM context. Defaults to true. */
+    appendToContext?: boolean;
+    /** The text type of the text frames the TTS service pushes. Defaults to a sentence. */
+    textType?: TextType | string;
+}
+/**
+ * Frame containing text that should be spoken by TTS.
+ *
+ * A frame that contains text that should be spoken by the TTS service in the
+ * pipeline (if any).
+ *
+ * Set `interruptible = false` on the frame to preserve its synthesis and
+ * generated audio and text through interruptions.
+ *
+ * - `text`: the text to be spoken.
+ * - `appendToContext`: whether the spoken text should be appended to the LLM
+ *   context. Defaults to true.
+ * - `textType`: the text type of the text frames the TTS service pushes for
+ *   the spoken text, a sentence by default. A custom type lets them be told
+ *   apart, for example to keep them from the client with
+ *   `RTVIObserverParams.skipTextTypes`.
+ */
+export declare class TTSSpeakFrame extends DataFrame {
+    text: string;
+    appendToContext: boolean;
+    textType: TextType | string;
+    constructor(options: TTSSpeakFrameOptions);
+}
+export interface BotBackchannelFrameOptions extends Omit<TTSSpeakFrameOptions, "textType"> {
+}
+/**
+ * A short acknowledgment for the bot to say while the user talks, such as "Mm-hmm.".
+ *
+ * The TTS service speaks it like any `TTSSpeakFrame`, and its text frames
+ * have type `TextType.BACKCHANNEL`. Interruptions don't cut it off unless
+ * `interruptible` is set to true on the frame.
+ *
+ * - `appendToContext`: whether the spoken text should be appended to the LLM
+ *   context. Defaults to false.
+ */
+export declare class BotBackchannelFrame extends TTSSpeakFrame {
+    textType: TextType | string;
+    interruptible: boolean;
+    constructor(options: BotBackchannelFrameOptions);
+}
+export interface OutputTransportMessageFrameOptions {
+    /** The transport message payload. */
+    message: unknown;
+}
+/**
+ * Frame containing transport-specific message data.
+ *
+ * - `message`: the transport message payload.
+ */
+export declare class OutputTransportMessageFrame extends DataFrame {
+    message: unknown;
+    constructor(options: OutputTransportMessageFrameOptions);
+    toString(): string;
+}
+export interface OutputDTMFFrameOptions {
+    /** Convenience shortcut for sending a single DTMF keypad entry. */
+    button?: KeypadEntry | null;
+    /** Sequence of one or more DTMF keypad buttons to send. */
+    buttons?: KeypadEntry[] | null;
+}
+declare const OutputDTMFFrame_base: typeof DataFrame & Ctor<DTMFFrame>;
+/**
+ * DTMF keypress output frame for transport queuing.
+ *
+ * - `button`: convenience shortcut for sending a single DTMF keypad entry.
+ *   Equivalent to `buttons: [button]`. If both `buttons` and `button` are
+ *   provided, `buttons` takes precedence.
+ * - `buttons`: sequence of one or more DTMF keypad buttons to send. Use
+ *   `fromString()` to build this from a string like `"123#"`.
+ */
+export declare class OutputDTMFFrame extends OutputDTMFFrame_base {
+    button: KeypadEntry | null;
+    buttons: KeypadEntry[] | null;
+    constructor(options?: OutputDTMFFrameOptions);
+    toString(): string;
+    /**
+     * Build an `OutputDTMFFrame` from a string of DTMF characters.
+     *
+     * @param buttons A string like `"123#"`. Each character must be a valid
+     *   `KeypadEntry` value.
+     * @param options Additional options forwarded to the frame constructor.
+     * @returns A frame of this class with `buttons` populated as a list of `KeypadEntry`.
+     */
+    static fromString<T extends OutputDTMFFrame>(this: new (options: OutputDTMFFrameOptions) => T, buttons: string, options?: Omit<OutputDTMFFrameOptions, "buttons">): T;
+    /**
+     * Return the frame's `buttons` as a dial string. Upstream's `to_string()`;
+     * renamed because `toString()` is the JS `__str__`.
+     *
+     * @returns A string such as `"123#"` formed by concatenating each
+     *   `KeypadEntry` in `buttons`, or an empty string if `buttons` is not set.
+     */
+    toDialString(): string;
+}
+/**
+ * Initial frame to start pipeline processing.
+ *
+ * This is the first frame that should be pushed down a pipeline to initialize
+ * all processors. Processors read the pipeline configuration from
+ * `FrameProcessorSetup`.
+ */
+export declare class StartFrame extends SystemFrame {
+}
+export interface CancelFrameOptions {
+    /** Optional reason for pushing a cancel frame. */
+    reason?: unknown;
+}
+/**
+ * Frame indicating pipeline should stop immediately.
+ *
+ * Indicates that a pipeline needs to stop right away without processing
+ * remaining queued frames.
+ *
+ * - `reason`: optional reason for pushing a cancel frame.
+ */
+export declare class CancelFrame extends SystemFrame {
+    reason: unknown;
+    constructor(options?: CancelFrameOptions);
+    toString(): string;
+}
+export interface ErrorFrameOptions {
+    /** Description of the error that occurred. */
+    error: string;
+    /** The frame processor that generated the error. */
+    processor?: FrameProcessor | null;
+    /** The exception that occurred. */
+    exception?: unknown;
+    /** What kind of failure this was. */
+    category?: ErrorCategory | null;
+}
+/**
+ * Frame notifying of errors in the pipeline.
+ *
+ * This is used to notify upstream that an error has occurred downstream in the
+ * pipeline.
+ *
+ * - `error`: description of the error that occurred. Credentials it quotes
+ *   (an API key, a signed URL's signature, an auth header) are masked, since
+ *   the description is logged and reported wherever the error goes.
+ * - `processor`: the frame processor that generated the error.
+ * - `exception`: the exception that occurred.
+ * - `category`: what kind of failure this was, drawn from `ErrorCategory`:
+ *   rejected credentials, an unreachable provider, a malformed request and so
+ *   on. Null means nobody has said yet, which invites the category to be
+ *   worked out from the exception; set it to `ErrorCategory.UNKNOWN` to
+ *   report an error whose cause can't be attributed. Always set by the time
+ *   the frame travels.
+ */
+export declare class ErrorFrame extends SystemFrame {
+    error: string;
+    processor: FrameProcessor | null;
+    exception: unknown;
+    category: ErrorCategory | null;
+    constructor(options: ErrorFrameOptions);
+    toString(): string;
+}
+export interface FrameProcessorPauseUrgentFrameOptions {
+    /** The frame processor to pause. */
+    processor: FrameProcessor;
+}
+/**
+ * Frame to pause frame processing immediately.
+ *
+ * This frame is used to pause frame processing for the given processor as
+ * fast as possible. Pausing frame processing will keep frames in the internal
+ * queue which will then be processed when frame processing is resumed with
+ * `FrameProcessorResumeFrame`.
+ *
+ * - `processor`: the frame processor to pause.
+ */
+export declare class FrameProcessorPauseUrgentFrame extends SystemFrame {
+    processor: FrameProcessor;
+    constructor(options: FrameProcessorPauseUrgentFrameOptions);
+}
+export interface FrameProcessorResumeUrgentFrameOptions {
+    /** The frame processor to resume. */
+    processor: FrameProcessor;
+}
+/**
+ * Frame to resume frame processing immediately.
+ *
+ * This frame is used to resume frame processing for the given processor if it
+ * was previously paused as fast as possible. After resuming frame processing
+ * all queued frames will be processed in the order received.
+ *
+ * Note: this frame is now equivalent to FrameProcessorResumeFrame, which was
+ * changed to a SystemFrame to fix a bug where resume frames would get stuck in
+ * the blocked processing queue.
+ *
+ * - `processor`: the frame processor to resume.
+ */
+export declare class FrameProcessorResumeUrgentFrame extends SystemFrame {
+    processor: FrameProcessor;
+    constructor(options: FrameProcessorResumeUrgentFrameOptions);
+}
+/**
+ * Frame pushed to interrupt the pipeline.
+ *
+ * This frame is used to interrupt the pipeline. For example, when a user
+ * starts speaking to cancel any in-progress bot output. It can also be pushed
+ * by any processor.
+ */
+export declare class InterruptionFrame extends SystemFrame {
+}
+/**
+ * Frame indicating that the user turn has started.
+ *
+ * Emitted when the user turn starts, which usually means that some
+ * transcriptions are already available.
+ */
+export declare class UserStartedSpeakingFrame extends SystemFrame {
+}
+/**
+ * Frame indicating that the user turn has ended.
+ *
+ * Emitted when the user turn ends. This usually coincides with the start of
+ * the bot turn. A `SpeculationGate` releases whatever speculative response it
+ * is holding on this frame, since the turn that response answers has now
+ * ended.
+ */
+export declare class UserStoppedSpeakingFrame extends SystemFrame {
+}
+/**
+ * Frame withdrawing an eager end of turn.
+ *
+ * Emitted when a service reports the user resumed speaking after an eager end
+ * of turn, or when the committed transcript doesn't match the eager one. The
+ * LLM service stops generating, and its `SpeculationGate` discards what it was
+ * holding — which is everything the response produced, so nothing further
+ * down the pipeline has anything to undo.
+ *
+ * A system frame so it overtakes the speculative output it cancels.
+ */
+export declare class EagerEndOfTurnCancelFrame extends SystemFrame {
+}
+/**
+ * Frame indicating that the user has been muted.
+ *
+ * Emitted when a mute strategy activates, suppressing user frames (audio,
+ * transcription, interruption) from propagating through the pipeline.
+ */
+export declare class UserMuteStartedFrame extends SystemFrame {
+}
+/**
+ * Frame indicating that the user has been unmuted.
+ *
+ * Emitted when a mute strategy deactivates, allowing user frames to propagate
+ * through the pipeline again.
+ */
+export declare class UserMuteStoppedFrame extends SystemFrame {
+}
+/**
+ * Frame indicating the user is speaking.
+ *
+ * Emitted by VAD to indicate the user is speaking.
+ */
+export declare class UserSpeakingFrame extends SystemFrame {
+}
+/**
+ * Frame indicating that the user turn is semantically complete.
+ *
+ * Emitted by any component that can judge conversational turn completeness —
+ * for example an LLM with turn-completion markers, an STT service with
+ * built-in turn detection, or a dedicated end-of-turn classifier. Stop
+ * strategies that gate the user-turn-stop event on an external completeness
+ * signal (e.g. `LLMTurnCompletionUserTurnStopStrategy`) consume this frame to
+ * finalize the turn. Producers should emit this frame only when they judge the
+ * turn complete; an absence of this frame means the turn is not yet considered
+ * complete.
+ */
+export declare class UserTurnInferenceCompletedFrame extends SystemFrame {
+}
+export interface VADUserStartedSpeakingFrameOptions {
+    /** The VAD start_secs duration that was used to confirm the user started speaking. */
+    startSecs?: number;
+    /** Wall-clock time (seconds) when the VAD made its determination. */
+    timestamp?: number;
+}
+/**
+ * Frame emitted when VAD definitively detects user started speaking.
+ *
+ * - `startSecs`: the VAD `startSecs` duration that was used to confirm the
+ *   user started speaking. This represents the speech duration that had to
+ *   elapse before the VAD determined speech began.
+ * - `timestamp`: wall-clock time when the VAD made its determination.
+ */
+export declare class VADUserStartedSpeakingFrame extends SystemFrame {
+    startSecs: number;
+    timestamp: number;
+    constructor(options?: VADUserStartedSpeakingFrameOptions);
+}
+export interface VADUserStoppedSpeakingFrameOptions {
+    /** The VAD stop_secs duration that was used to confirm the user stopped speaking. */
+    stopSecs?: number;
+    /** Wall-clock time (seconds) when the VAD made its determination. */
+    timestamp?: number;
+}
+/**
+ * Frame emitted when VAD definitively detects user stopped speaking.
+ *
+ * - `stopSecs`: the VAD `stopSecs` duration that was used to confirm the user
+ *   stopped speaking. This represents the silence duration that had to elapse
+ *   before the VAD determined speech ended.
+ * - `timestamp`: wall-clock time when the VAD made its determination.
+ */
+export declare class VADUserStoppedSpeakingFrame extends SystemFrame {
+    stopSecs: number;
+    timestamp: number;
+    constructor(options?: VADUserStoppedSpeakingFrameOptions);
+}
+/**
+ * Frame proposing that the user turn has started.
+ *
+ * Emitted by a component with its own turn detection — typically an STT or
+ * realtime LLM service whose provider reports speech boundaries. It is a
+ * proposal, not a decision: an `ExternalUserTurnStartStrategy` resolves it
+ * into a `UserStartedSpeakingFrame` and broadcasts the interruption.
+ *
+ * This is a system frame because resolving it broadcasts an interruption,
+ * which must preempt queued frames rather than wait behind them. Its
+ * end-of-turn counterpart has the opposite requirement and is a control
+ * frame; see `ProposedUserStoppedSpeakingFrame`.
+ */
+export declare class ProposedUserStartedSpeakingFrame extends SystemFrame {
+}
+/**
+ * Frame proposing that the user turn has ended.
+ *
+ * The end-of-turn counterpart to `ProposedUserStartedSpeakingFrame`, resolved
+ * into a `UserStoppedSpeakingFrame` by an `ExternalUserTurnStopStrategy`.
+ *
+ * This is a control frame so it stays ordered against the final
+ * `TranscriptionFrame`. A service with its own turn detection pushes that
+ * transcript and then proposes the stop, and the turn strategy needs that text
+ * in hand to close the turn on.
+ */
+export declare class ProposedUserStoppedSpeakingFrame extends ControlFrame {
+}
+/**
+ * Frame indicating the bot started speaking.
+ *
+ * Emitted upstream and downstream by the BaseTransportOutput to indicate the
+ * bot started speaking.
+ */
+export declare class BotStartedSpeakingFrame extends SystemFrame {
+}
+/**
+ * Frame indicating the bot stopped speaking.
+ *
+ * Emitted upstream and downstream by the BaseTransportOutput to indicate the
+ * bot stopped speaking.
+ */
+export declare class BotStoppedSpeakingFrame extends SystemFrame {
+}
+/**
+ * Frame indicating the bot is currently speaking.
+ *
+ * Emitted upstream and downstream by the BaseOutputTransport while the bot is
+ * still speaking. This can be used, for example, to detect when a user is
+ * idle. That is, while the bot is speaking we don't want to trigger any user
+ * idle timeout since the user might be listening.
+ */
+export declare class BotSpeakingFrame extends SystemFrame {
+}
+export interface MetricsFrameOptions {
+    /** List of metrics data collected by the processor. */
+    data: MetricsData[];
+}
+/**
+ * Frame containing performance metrics data.
+ *
+ * Emitted by processors that can compute metrics like latencies.
+ *
+ * - `data`: list of metrics data collected by the processor.
+ */
+export declare class MetricsFrame extends SystemFrame {
+    data: MetricsData[];
+    constructor(options: MetricsFrameOptions);
+}
+export interface FunctionCallFromLLMOptions {
+    /** The name of the function to call. */
+    functionName: string;
+    /** A unique identifier for the function call. */
+    toolCallId: string;
+    /** The arguments to pass to the function. */
+    arguments: Record<string, unknown>;
+    /** The LLM context when the function call was made. */
+    context: unknown;
+}
+/**
+ * Represents a function call returned by the LLM.
+ *
+ * Represents a function call returned by the LLM to be registered for execution.
+ *
+ * - `functionName`: the name of the function to call.
+ * - `toolCallId`: a unique identifier for the function call.
+ * - `arguments`: the arguments to pass to the function.
+ * - `context`: the LLM context when the function call was made.
+ */
+export declare class FunctionCallFromLLM {
+    functionName: string;
+    toolCallId: string;
+    arguments: Record<string, unknown>;
+    context: unknown;
+    constructor(options: FunctionCallFromLLMOptions);
+}
+export interface FunctionCallsStartedFrameOptions {
+    /** Sequence of function calls that will be executed. */
+    functionCalls: FunctionCallFromLLM[];
+}
+/**
+ * Frame signaling that function call execution is starting.
+ *
+ * A frame signaling that one or more function call execution is going to
+ * start.
+ *
+ * - `functionCalls`: sequence of function calls that will be executed.
+ */
+export declare class FunctionCallsStartedFrame extends SystemFrame {
+    functionCalls: FunctionCallFromLLM[];
+    constructor(options: FunctionCallsStartedFrameOptions);
+}
+export interface ExternalFunctionCallOptions {
+    /** Name of the function called. */
+    functionName: string;
+    /** Unique identifier of the call. */
+    toolCallId: string;
+}
+/**
+ * A function call made outside this pipeline, as announced to it.
+ *
+ * What `ExternalFunctionCallsStartedFrame` carries, one per call.
+ *
+ * - `functionName`: name of the function called.
+ * - `toolCallId`: unique identifier of the call.
+ */
+export declare class ExternalFunctionCall {
+    functionName: string;
+    toolCallId: string;
+    constructor(options: ExternalFunctionCallOptions);
+}
+export interface ExternalFunctionCallsStartedFrameOptions {
+    /** The calls made. */
+    functionCalls: ExternalFunctionCall[];
+}
+/**
+ * Function calls were made outside this pipeline: `FunctionCallsStartedFrame`'s counterpart.
+ *
+ * Nothing in the pipeline acts on one; observers report it as they report the
+ * pipeline's own. The calls ran elsewhere, e.g. in a backend worker's pipeline
+ * on behalf of a tool here, and belong to that pipeline's conversation, not
+ * this one. Like its counterpart it carries every call announced together,
+ * which may be one. Each call's later phases come as
+ * `ExternalFunctionCallInProgressFrame`, `ExternalFunctionCallResultFrame` and
+ * `ExternalFunctionCallCancelFrame`.
+ *
+ * - `functionCalls`: the calls made.
+ */
+export declare class ExternalFunctionCallsStartedFrame extends SystemFrame {
+    functionCalls: ExternalFunctionCall[];
+    constructor(options: ExternalFunctionCallsStartedFrameOptions);
+}
+export interface ExternalFunctionCallInProgressFrameOptions {
+    /** Name of the function called. */
+    functionName: string;
+    /** Unique identifier of the call. */
+    toolCallId: string;
+    /** Arguments passed to the function. */
+    arguments: unknown;
+}
+/**
+ * An external function call is running: `FunctionCallInProgressFrame`'s counterpart.
+ *
+ * Nothing in the pipeline acts on one; observers report it as they report the
+ * pipeline's own. The call ran elsewhere, e.g. in a backend worker's pipeline
+ * on behalf of a tool here, and belongs to that pipeline's conversation, not
+ * this one.
+ *
+ * - `functionName`: name of the function called.
+ * - `toolCallId`: unique identifier of the call.
+ * - `arguments`: arguments passed to the function.
+ */
+export declare class ExternalFunctionCallInProgressFrame extends SystemFrame {
+    functionName: string;
+    toolCallId: string;
+    arguments: unknown;
+    constructor(options: ExternalFunctionCallInProgressFrameOptions);
+}
+export interface ExternalFunctionCallResultFrameOptions {
+    /** Name of the function called. */
+    functionName: string;
+    /** Unique identifier of the call. */
+    toolCallId: string;
+    /** Arguments passed to the function. */
+    arguments: unknown;
+    /** The result. */
+    result: unknown;
+    /** Whether this result completes the call. Defaults to true. */
+    isFinal?: boolean;
+}
+/**
+ * An external function call produced a result: `FunctionCallResultFrame`'s counterpart.
+ *
+ * Nothing in the pipeline acts on one; observers report it as they report the
+ * pipeline's own.
+ *
+ * - `functionName`: name of the function called.
+ * - `toolCallId`: unique identifier of the call.
+ * - `arguments`: arguments passed to the function.
+ * - `result`: the result.
+ * - `isFinal`: whether this result completes the call, or is one of a stream
+ *   of intermediate results before the final one.
+ */
+export declare class ExternalFunctionCallResultFrame extends SystemFrame {
+    functionName: string;
+    toolCallId: string;
+    arguments: unknown;
+    result: unknown;
+    isFinal: boolean;
+    constructor(options: ExternalFunctionCallResultFrameOptions);
+}
+export interface ExternalFunctionCallCancelFrameOptions {
+    /** Name of the function called. */
+    functionName: string;
+    /** Unique identifier of the call. */
+    toolCallId: string;
+}
+/**
+ * An external function call was cancelled: `FunctionCallCancelFrame`'s counterpart.
+ *
+ * Nothing in the pipeline acts on one; observers report it as they report the
+ * pipeline's own.
+ *
+ * - `functionName`: name of the function called.
+ * - `toolCallId`: unique identifier of the call.
+ */
+export declare class ExternalFunctionCallCancelFrame extends SystemFrame {
+    functionName: string;
+    toolCallId: string;
+    constructor(options: ExternalFunctionCallCancelFrameOptions);
+}
+export interface FunctionCallCancelFrameOptions {
+    /** Name of the function that was cancelled. */
+    functionName: string;
+    /** Unique identifier for the cancelled function call. */
+    toolCallId: string;
+    /** Whether to run the LLM after this cancellation. Defaults to false. */
+    runLlm?: boolean;
+}
+/**
+ * Frame signaling that a function call has been cancelled.
+ *
+ * - `functionName`: name of the function that was cancelled.
+ * - `toolCallId`: unique identifier for the cancelled function call.
+ * - `runLlm`: whether to run the LLM after this cancellation. Only a call
+ *   cancelled by its own timeout sets this: an interruption must not trigger
+ *   inference, and a cancellation the LLM asked for already runs inference
+ *   through the result of the tool that requested it.
+ */
+export declare class FunctionCallCancelFrame extends SystemFrame {
+    functionName: string;
+    toolCallId: string;
+    runLlm: boolean;
+    constructor(options: FunctionCallCancelFrameOptions);
+}
+export interface STTMuteFrameOptions {
+    /** Whether to mute (true) or unmute (false) the STT service. */
+    mute: boolean;
+}
+/**
+ * Frame to mute/unmute the Speech-to-Text service.
+ *
+ * - `mute`: whether to mute (true) or unmute (false) the STT service.
+ */
+export declare class STTMuteFrame extends SystemFrame {
+    mute: boolean;
+    constructor(options: STTMuteFrameOptions);
+}
+export interface InputTransportMessageFrameOptions {
+    /** The transport message payload. */
+    message: unknown;
+}
+/**
+ * Frame for transport messages received from external sources.
+ *
+ * - `message`: the urgent transport message payload.
+ */
+export declare class InputTransportMessageFrame extends SystemFrame {
+    message: unknown;
+    constructor(options: InputTransportMessageFrameOptions);
+    toString(): string;
+}
+export interface OutputTransportMessageUrgentFrameOptions {
+    /** The urgent transport message payload. */
+    message: unknown;
+}
+/**
+ * Frame for urgent transport messages that need to be sent immediately.
+ *
+ * - `message`: the urgent transport message payload.
+ */
+export declare class OutputTransportMessageUrgentFrame extends SystemFrame {
+    message: unknown;
+    constructor(options: OutputTransportMessageUrgentFrameOptions);
+    toString(): string;
+}
+export interface UserImageRequestFrameOptions {
+    /** Identifier of the user to request image from. */
+    userId: string;
+    /** An optional text associated to the image request. */
+    text?: string | null;
+    /** Whether the requested image should be appended to the LLM context. */
+    appendToContext?: boolean | null;
+    /** Specific video source to capture from. */
+    videoSource?: string | null;
+    /** Name of function that generated this request (if any). */
+    functionName?: string | null;
+    /** Tool call ID if generated by function call (if any). */
+    toolCallId?: string | null;
+    /** Optional callback to invoke when the image is retrieved. */
+    resultCallback?: unknown;
+}
+/**
+ * Frame requesting an image from a specific user.
+ *
+ * A frame to request an image from the given user. The request might come
+ * with a text that can be later used to describe the requested image.
+ *
+ * - `userId`: identifier of the user to request image from.
+ * - `text`: an optional text associated to the image request.
+ * - `appendToContext`: whether the requested image should be appended to the
+ *   LLM context.
+ * - `videoSource`: specific video source to capture from.
+ * - `functionName`: name of function that generated this request (if any).
+ * - `toolCallId`: tool call ID if generated by function call (if any).
+ * - `resultCallback`: optional callback to invoke when the image is retrieved.
+ */
+export declare class UserImageRequestFrame extends SystemFrame {
+    userId: string;
+    text: string | null;
+    appendToContext: boolean | null;
+    videoSource: string | null;
+    functionName: string | null;
+    toolCallId: string | null;
+    resultCallback: unknown;
+    constructor(options: UserImageRequestFrameOptions);
+    toString(): string;
+}
+declare const InputAudioRawFrame_base: typeof SystemFrame & Ctor<AudioRawFrame>;
+/**
+ * Raw audio input frame from transport.
+ *
+ * A chunk of audio usually coming from an input transport. If the transport
+ * supports multiple audio sources (e.g. multiple audio tracks) the source name
+ * will be specified in `transportSource`.
+ */
+export declare class InputAudioRawFrame extends InputAudioRawFrame_base {
+    constructor(options: AudioRawFrameOptions);
+    toString(): string;
+}
+declare const InputImageRawFrame_base: typeof SystemFrame & Ctor<ImageRawFrame>;
+/**
+ * Raw image input frame from transport.
+ *
+ * An image usually coming from an input transport. If the transport supports
+ * multiple video sources (e.g. multiple video tracks) the source name will be
+ * specified in `transportSource`.
+ */
+export declare class InputImageRawFrame extends InputImageRawFrame_base {
+    constructor(options: ImageRawFrameOptions);
+    toString(): string;
+}
+declare const InputFileRawFrame_base: typeof SystemFrame & Ctor<FileRawFrame>;
+/**
+ * Raw file input frame.
+ *
+ * A file usually coming from RTVI.
+ */
+export declare class InputFileRawFrame extends InputFileRawFrame_base {
+    constructor(options: FileRawFrameOptions);
+    toString(): string;
+}
+/**
+ * Raw text input frame from transport.
+ *
+ * Text input usually coming from user typing or programmatic text injection
+ * that should be sent to LLM services as input, similar to how
+ * InputAudioRawFrame and InputImageRawFrame represent user audio and video
+ * input.
+ *
+ * Upstream inherits from both `SystemFrame` and `TextFrame`; here it extends
+ * `SystemFrame`, carries `TextFrame`'s fields, and `instanceof TextFrame`
+ * holds through `addVirtualBase`.
+ */
+export declare class InputTextRawFrame extends SystemFrame {
+    text: string;
+    skipTts: boolean | null;
+    includesInterFrameSpaces: boolean;
+    appendToContext: boolean;
+    constructor(options: TextFrameOptions);
+    toString(): string;
+}
+export interface UserAudioRawFrameOptions extends AudioRawFrameOptions {
+    /** Identifier of the user who provided this audio. */
+    userId?: string;
+}
+/**
+ * Raw audio input frame associated with a specific user.
+ *
+ * A chunk of audio, usually coming from an input transport, associated to a user.
+ *
+ * - `userId`: identifier of the user who provided this audio.
+ */
+export declare class UserAudioRawFrame extends InputAudioRawFrame {
+    userId: string;
+    constructor(options: UserAudioRawFrameOptions);
+    toString(): string;
+}
+export interface UserImageRawFrameOptions extends ImageRawFrameOptions {
+    /** Identifier of the user who provided this image. */
+    userId?: string;
+    /** An optional text associated to this image. */
+    text?: string | null;
+    /** Whether the requested image should be appended to the LLM context. */
+    appendToContext?: boolean | null;
+    /** The original image request frame if this is a response. */
+    request?: UserImageRequestFrame | null;
+    /** Whether appending this image should trigger an LLM completion. */
+    runLlm?: boolean | null;
+}
+/**
+ * Raw image input frame associated with a specific user.
+ *
+ * An image associated to a user, potentially in response to an image request.
+ *
+ * - `userId`: identifier of the user who provided this image.
+ * - `text`: an optional text associated to this image.
+ * - `appendToContext`: whether the requested image should be appended to the
+ *   LLM context.
+ * - `request`: the original image request frame if this is a response.
+ * - `runLlm`: whether appending this image should trigger an LLM completion.
+ *   Null (the default) preserves the old unconditional-trigger behavior; only
+ *   an explicit false suppresses it.
+ */
+export declare class UserImageRawFrame extends InputImageRawFrame {
+    userId: string;
+    text: string | null;
+    appendToContext: boolean | null;
+    request: UserImageRequestFrame | null;
+    runLlm: boolean | null;
+    constructor(options: UserImageRawFrameOptions);
+    toString(): string;
+}
+export interface UserFileRawFrameOptions extends FileRawFrameOptions {
+    /** Identifier of the user who provided this file. */
+    userId?: string;
+    /** Text associated to this file. */
+    text?: string;
+    /** Whether the requested file should be appended to the LLM context. */
+    appendToContext?: boolean | null;
+    /** Custom llm-specific options to be used when processing this file. */
+    customOptions?: Record<string, unknown> | null;
+    /** Whether appending this file should trigger an LLM completion. */
+    runLlm?: boolean | null;
+}
+/**
+ * Raw file input frame associated with a specific user.
+ *
+ * A file associated to a user.
+ *
+ * - `userId`: identifier of the user who provided this file.
+ * - `text`: text associated to this file.
+ * - `appendToContext`: whether the requested file should be appended to the
+ *   LLM context.
+ * - `customOptions`: dictionary of custom llm-specific options to be used when
+ *   processing this file, like 'detail' in openAI or 'citations' in Bedrock.
+ * - `runLlm`: whether appending this file should trigger an LLM completion.
+ *   Null (the default) preserves the old unconditional-trigger behavior; only
+ *   an explicit false suppresses it.
+ */
+export declare class UserFileRawFrame extends InputFileRawFrame {
+    userId: string;
+    text: string;
+    appendToContext: boolean | null;
+    customOptions: Record<string, unknown> | null;
+    runLlm: boolean | null;
+    constructor(options: UserFileRawFrameOptions);
+    toString(): string;
+}
+export interface AssistantImageRawFrameOptions extends ImageRawFrameOptions {
+    /** The original image data, usable directly in an LLM context message. */
+    originalData?: Uint8Array | null;
+    /** The MIME type of the original image data. */
+    originalMimeType?: string | null;
+}
+/**
+ * Frame containing an image generated by the assistant.
+ *
+ * Contains both the raw frame for display (superclass functionality) as well
+ * as the original image, which can get used directly in LLM contexts.
+ *
+ * - `originalData`: the original image data, which can get used directly in
+ *   an LLM context message without further encoding.
+ * - `originalMimeType`: the MIME type of the original image data.
+ */
+export declare class AssistantImageRawFrame extends OutputImageRawFrame {
+    originalData: Uint8Array | null;
+    originalMimeType: string | null;
+    constructor(options: AssistantImageRawFrameOptions);
+}
+export interface InputDTMFFrameOptions {
+    /** The DTMF keypad entry that was pressed. */
+    button: KeypadEntry;
+}
+declare const InputDTMFFrame_base: typeof SystemFrame & Ctor<DTMFFrame>;
+/**
+ * DTMF keypress input frame from transport.
+ *
+ * - `button`: the DTMF keypad entry that was pressed.
+ */
+export declare class InputDTMFFrame extends InputDTMFFrame_base {
+    button: KeypadEntry;
+    constructor(options: InputDTMFFrameOptions);
+    toString(): string;
+}
+export interface OutputDTMFUrgentFrameOptions {
+    /** Convenience shortcut for sending a single DTMF keypad entry. */
+    button?: KeypadEntry | null;
+    /** Sequence of one or more DTMF keypad buttons to send. */
+    buttons?: KeypadEntry[] | null;
+}
+declare const OutputDTMFUrgentFrame_base: typeof SystemFrame & Ctor<DTMFFrame>;
+/**
+ * DTMF keypress output frame for immediate sending.
+ *
+ * - `button`: convenience shortcut for sending a single DTMF keypad entry.
+ *   Equivalent to `buttons: [button]`. If both `buttons` and `button` are
+ *   provided, `buttons` takes precedence.
+ * - `buttons`: sequence of one or more DTMF keypad buttons to send. Use
+ *   `fromString()` to build this from a string like `"123#"`.
+ */
+export declare class OutputDTMFUrgentFrame extends OutputDTMFUrgentFrame_base {
+    button: KeypadEntry | null;
+    buttons: KeypadEntry[] | null;
+    constructor(options?: OutputDTMFUrgentFrameOptions);
+    toString(): string;
+    /**
+     * Build an `OutputDTMFUrgentFrame` from a string of DTMF characters.
+     *
+     * @param buttons A string like `"123#"`. Each character must be a valid
+     *   `KeypadEntry` value.
+     * @param options Additional options forwarded to the frame constructor.
+     * @returns A frame of this class with `buttons` populated as a list of `KeypadEntry`.
+     */
+    static fromString<T extends OutputDTMFUrgentFrame>(this: new (options: OutputDTMFUrgentFrameOptions) => T, buttons: string, options?: Omit<OutputDTMFUrgentFrameOptions, "buttons">): T;
+    /**
+     * Return the frame's `buttons` as a dial string. Upstream's `to_string()`;
+     * renamed because `toString()` is the JS `__str__`.
+     *
+     * @returns A string such as `"123#"` formed by concatenating each
+     *   `KeypadEntry` in `buttons`, or an empty string if `buttons` is not set.
+     */
+    toDialString(): string;
+}
+export interface SpeechControlParamsFrameOptions {
+    /** Current VAD parameters. */
+    vadParams?: VADParams | null;
+    /** Current turn-taking analysis parameters. */
+    turnParams?: BaseTurnParams | null;
+}
+/**
+ * Frame for notifying processors of speech control parameter changes.
+ *
+ * This includes parameters for both VAD (Voice Activity Detection) and
+ * turn-taking analysis. It allows downstream processors to adjust their
+ * behavior based on updated interaction control settings.
+ *
+ * - `vadParams`: current VAD parameters.
+ * - `turnParams`: current turn-taking analysis parameters.
+ */
+export declare class SpeechControlParamsFrame extends SystemFrame {
+    vadParams: VADParams | null;
+    turnParams: BaseTurnParams | null;
+    constructor(options?: SpeechControlParamsFrameOptions);
+}
+export interface ServiceMetadataFrameOptions {
+    /** The name of the service broadcasting this metadata. */
+    serviceName: string;
+    /** User turn strategies the service recommends. */
+    userTurnStrategies?: UserTurnStrategies | null;
+}
+/**
+ * Base metadata frame for services.
+ *
+ * Broadcast by services at pipeline start to share service-specific
+ * configuration and performance characteristics with downstream processors.
+ *
+ * - `serviceName`: the name of the service broadcasting this metadata.
+ * - `userTurnStrategies`: user turn strategies the service recommends, e.g.
+ *   `ExternalUserTurnStrategies` for a service that does its own server-side
+ *   end-of-turn detection. The user aggregator applies them unless the user
+ *   passed their own `userTurnStrategies`, which always wins. Null leaves the
+ *   defaults in place.
+ */
+export declare class ServiceMetadataFrame extends SystemFrame {
+    serviceName: string;
+    userTurnStrategies: UserTurnStrategies | null;
+    constructor(options: ServiceMetadataFrameOptions);
+}
+export interface STTMetadataFrameOptions extends ServiceMetadataFrameOptions {
+    /** Time to final segment P99 latency in seconds. */
+    ttfsP99Latency: number;
+}
+/**
+ * Metadata from STT service.
+ *
+ * Broadcast by STT services to inform downstream processors (like turn
+ * strategies) about STT latency characteristics.
+ *
+ * - `ttfsP99Latency`: time to final segment P99 latency in seconds. This is
+ *   the expected time from when speech ends to when the final transcript is
+ *   received, at the 99th percentile.
+ */
+export declare class STTMetadataFrame extends ServiceMetadataFrame {
+    ttfsP99Latency: number;
+    constructor(options: STTMetadataFrameOptions);
+}
+export interface LLMServiceMetadataFrameOptions extends ServiceMetadataFrameOptions {
+    /** Whether the broadcasting service is a realtime (speech-to-speech) LLM service. */
+    isRealtimeService?: boolean;
+}
+/**
+ * Metadata broadcast by an LLM service at pipeline start.
+ *
+ * - `isRealtimeService`: whether the broadcasting service is a realtime
+ *   (speech-to-speech) LLM service.
+ */
+export declare class LLMServiceMetadataFrame extends ServiceMetadataFrame {
+    isRealtimeService: boolean;
+    constructor(options: LLMServiceMetadataFrameOptions);
+}
+export interface ServiceSwitcherRequestMetadataFrameOptions {
+    /** The target service that should re-emit its metadata. */
+    service: FrameProcessor;
+}
+/**
+ * Request a service to re-emit its metadata frames.
+ *
+ * Used by ServiceSwitcher when switching active services to ensure downstream
+ * processors receive updated metadata from the newly active service. Services
+ * that receive this frame should re-push their metadata frame (e.g.,
+ * STTMetadataFrame for STT services).
+ *
+ * - `service`: the target service that should re-emit its metadata.
+ */
+export declare class ServiceSwitcherRequestMetadataFrame extends ControlFrame {
+    service: FrameProcessor;
+    constructor(options: ServiceSwitcherRequestMetadataFrameOptions);
+}
+/**
+ * Base frame for worker frames.
+ *
+ * This is a base class for frames that are handled by the pipeline worker.
+ * This might result in a corresponding frame sent downstream (e.g.
+ * `InterruptionWorkerFrame` / `InterruptionFrame` or `EndWorkerFrame` /
+ * `EndFrame`). Push these frames downstream (the default direction) so frames
+ * queued ahead of them are processed first; pushing them upstream is also
+ * supported.
+ */
+export declare class WorkerFrame extends ControlFrame {
+}
+/**
+ * Base frame for worker system frames.
+ *
+ * This is a base class for system frames that are handled by the pipeline
+ * worker. This might result in a corresponding frame sent downstream (e.g.
+ * `InterruptionWorkerFrame` / `InterruptionFrame` or `CancelWorkerFrame` /
+ * `CancelFrame`). They can be pushed in either direction (downstream is the
+ * default); being system frames, they are processed immediately either way.
+ */
+export declare class WorkerSystemFrame extends SystemFrame {
+}
+export interface EndWorkerFrameOptions {
+    /** Optional reason for pushing an end frame. */
+    reason?: unknown;
+}
+/**
+ * Frame to request graceful pipeline worker closure.
+ *
+ * This is used to notify the pipeline worker that the pipeline should be
+ * closed nicely (flushing all the queued frames) by pushing an EndFrame
+ * downstream. Push this frame downstream (the default direction) so frames
+ * queued ahead of it are flushed before the pipeline ends.
+ *
+ * - `reason`: optional reason for pushing an end frame.
+ */
+export declare class EndWorkerFrame extends WorkerFrame {
+    interruptible: boolean;
+    reason: unknown;
+    constructor(options?: EndWorkerFrameOptions);
+    toString(): string;
+}
+/**
+ * Frame to request pipeline worker stop while keeping processors running.
+ *
+ * This is used to notify the pipeline worker that it should be stopped as
+ * soon as possible (flushing all the queued frames) but that the pipeline
+ * processors should be kept in a running state. Push this frame downstream
+ * (the default direction) so frames queued ahead of it are flushed first.
+ */
+export declare class StopWorkerFrame extends WorkerFrame {
+    interruptible: boolean;
+}
+export interface CancelWorkerFrameOptions {
+    /** Optional reason for pushing a cancel frame. */
+    reason?: unknown;
+}
+/**
+ * Frame to request immediate pipeline worker cancellation.
+ *
+ * This is used to notify the pipeline worker that the pipeline should be
+ * stopped immediately by pushing a CancelFrame downstream. It can be pushed in
+ * either direction; being a system frame, it is processed immediately.
+ *
+ * - `reason`: optional reason for pushing a cancel frame.
+ */
+export declare class CancelWorkerFrame extends WorkerSystemFrame {
+    reason: unknown;
+    constructor(options?: CancelWorkerFrameOptions);
+    toString(): string;
+}
+/**
+ * Frame indicating the pipeline should be interrupted.
+ *
+ * The pipeline worker converts this into an `InterruptionFrame` and sends it
+ * downstream. It can be pushed in either direction; being a system frame, it
+ * is processed immediately.
+ */
+export declare class InterruptionWorkerFrame extends WorkerSystemFrame {
+}
+export interface EndFrameOptions {
+    /** Optional reason for pushing an end frame. */
+    reason?: unknown;
+}
+/**
+ * Frame indicating pipeline has ended and should shut down.
+ *
+ * Indicates that a pipeline has ended and frame processors and pipelines
+ * should be shut down. If the transport receives this frame, it will stop
+ * sending frames to its output channel(s) and close all its threads. Note,
+ * that this is a control frame, which means it will be received in the order
+ * it was sent.
+ *
+ * This frame is uninterruptible so it is not lost when an InterruptionFrame
+ * is processed. Terminal frames must survive interruption to guarantee proper
+ * pipeline shutdown.
+ *
+ * - `reason`: optional reason for pushing an end frame.
+ */
+export declare class EndFrame extends ControlFrame {
+    interruptible: boolean;
+    reason: unknown;
+    constructor(options?: EndFrameOptions);
+    toString(): string;
+}
+/**
+ * Frame indicating pipeline should stop but keep processors running.
+ *
+ * Indicates that a pipeline should be stopped but that the pipeline processors
+ * should be kept in a running state. This is normally queued from the
+ * pipeline task.
+ *
+ * This frame is uninterruptible so it is not lost when an InterruptionFrame
+ * is processed. Terminal frames must survive interruption to guarantee proper
+ * pipeline control.
+ */
+export declare class StopFrame extends ControlFrame {
+    interruptible: boolean;
+}
+export interface PipelineFlushFrameOptions {
+    /** Set by the worker when the probe completes its round-trip. */
+    event?: Event | null;
+    /** Whether the probe is on its second pass downstream. */
+    returning?: boolean;
+    /** Name of the worker that started the flush. */
+    origin?: string | null;
+}
+/**
+ * Probe frame used to flush all in-flight frames from the pipeline.
+ *
+ * Pushed downstream; the pipeline worker's sink bounces it back upstream, the
+ * source turns it around, and the worker sets `event` when it reaches the sink
+ * a second time. Once that fires, every frame queued ahead of the probe has
+ * been processed, along with anything a processor started by pushing
+ * upstream. Useful to wait for the pipeline to drain (e.g. after an
+ * interruption) before injecting a new frame.
+ *
+ * This frame is uninterruptible so the probe survives an InterruptionFrame and
+ * still completes its trip.
+ *
+ * - `event`: set by the worker when the probe completes its round-trip. The
+ *   initiator awaits it to know the pipeline has drained. Carried on the frame
+ *   so concurrent flushes stay isolated (each awaits its own).
+ * - `returning`: whether the probe is on its second pass downstream, after
+ *   having been back up to the source. Work a processor starts by pushing
+ *   upstream — an LLM run triggered by a function call result, say — only
+ *   reaches the sink after that turnaround, so the probe makes the trip twice
+ *   and settles on the second arrival.
+ * - `origin`: name of the worker that started the flush. A probe that crosses
+ *   into another pipeline is answered there, out of sight of whoever is
+ *   waiting, so the answering worker reports progress back to this name.
+ */
+export declare class PipelineFlushFrame extends ControlFrame {
+    interruptible: boolean;
+    event: Event | null;
+    returning: boolean;
+    origin: string | null;
+    constructor(options?: PipelineFlushFrameOptions);
+}
+/**
+ * Frame indicating the bot has connected to the transport service.
+ *
+ * Pushed downstream by SFU transports (Daily, LiveKit, HeyGen, Tavus) when the
+ * bot successfully joins the room. Non-SFU transports do not emit this frame.
+ */
+export declare class BotConnectedFrame extends SystemFrame {
+}
+/**
+ * Frame indicating that a client has connected to the transport.
+ *
+ * Pushed downstream by the input transport when a client (participant)
+ * connects. Used by observers to measure transport readiness timing.
+ */
+export declare class ClientConnectedFrame extends SystemFrame {
+}
+/**
+ * Frame indicating that the output transport is ready.
+ *
+ * Indicates that the output transport is ready and able to receive frames.
+ */
+export declare class OutputTransportReadyFrame extends ControlFrame {
+}
+/**
+ * Frame asking the input transport to start audio input streaming.
+ *
+ * Pushed downstream (e.g. by `RTVIProcessor` once the client is ready) so a
+ * `BaseInputTransport` begins streaming audio from its source. Replaces
+ * calling `BaseInputTransport.startAudioInStreaming()` directly, keeping
+ * cross-processor communication frame-based.
+ */
+export declare class InputTransportStartAudioStreamingFrame extends ControlFrame {
+}
+export interface HeartbeatFrameOptions {
+    /** Timestamp when the heartbeat was generated. */
+    timestamp: number;
+}
+/**
+ * Frame used by pipeline task to monitor pipeline health.
+ *
+ * This frame is used by the pipeline task as a mechanism to know if the
+ * pipeline is running properly.
+ *
+ * - `timestamp`: timestamp when the heartbeat was generated.
+ */
+export declare class HeartbeatFrame extends ControlFrame {
+    timestamp: number;
+    constructor(options: HeartbeatFrameOptions);
+}
+export interface FrameProcessorPauseFrameOptions {
+    /** The frame processor to pause. */
+    processor: FrameProcessor;
+}
+/**
+ * Frame to pause frame processing for a specific processor.
+ *
+ * This frame is used to pause frame processing for the given processor.
+ * Pausing frame processing will keep frames in the internal queue which will
+ * then be processed when frame processing is resumed with
+ * `FrameProcessorResumeFrame`.
+ *
+ * - `processor`: the frame processor to pause.
+ */
+export declare class FrameProcessorPauseFrame extends ControlFrame {
+    processor: FrameProcessor;
+    constructor(options: FrameProcessorPauseFrameOptions);
+}
+export interface FrameProcessorResumeFrameOptions {
+    /** The frame processor to resume. */
+    processor: FrameProcessor;
+}
+/**
+ * Frame to resume frame processing for a specific processor.
+ *
+ * This frame is used to resume frame processing for the given processor if it
+ * was previously paused. After resuming frame processing all queued frames
+ * will be processed in the order received.
+ *
+ * This is a SystemFrame to ensure it bypasses the blocked processing queue
+ * when the processor is paused. Otherwise, the resume frame would get queued
+ * and never processed.
+ *
+ * Note: this frame is now equivalent to FrameProcessorResumeUrgentFrame.
+ *
+ * - `processor`: the frame processor to resume.
+ */
+export declare class FrameProcessorResumeFrame extends SystemFrame {
+    processor: FrameProcessor;
+    constructor(options: FrameProcessorResumeFrameOptions);
+}
+/**
+ * Frame indicating the beginning of an LLM response.
+ *
+ * Used to indicate the beginning of an LLM response. Followed by one or more
+ * TextFrames and a final LLMFullResponseEndFrame.
+ *
+ * - `skipTts`: whether the response should be skipped by the TTS service.
+ */
+export declare class LLMFullResponseStartFrame extends ControlFrame {
+    skipTts: boolean | null;
+}
+/**
+ * Frame indicating the end of an LLM response.
+ *
+ * - `skipTts`: whether the response should be skipped by the TTS service.
+ */
+export declare class LLMFullResponseEndFrame extends ControlFrame {
+    skipTts: boolean | null;
+}
+/**
+ * Frame that forces the LLM assistant aggregator to push its current aggregation to context.
+ *
+ * When received by `LLMAssistantAggregator`, any text that has been
+ * accumulated in the aggregation buffer is immediately committed to the
+ * conversation context as an assistant message, without waiting for an
+ * `LLMFullResponseEndFrame`.
+ */
+export declare class LLMAssistantPushAggregationFrame extends ControlFrame {
+}
+export interface LLMSummarizeContextFrameOptions {
+    /** Optional per-request override for summary generation settings. */
+    config?: LLMContextSummaryConfig | null;
+}
+/**
+ * Frame requesting on-demand context summarization.
+ *
+ * Push this frame into the pipeline to trigger a manual context summarization.
+ *
+ * - `config`: optional per-request override for summary generation settings
+ *   (prompt, token budget, messages to keep). If null, the summarizer's
+ *   default `LLMContextSummaryConfig` is used.
+ */
+export declare class LLMSummarizeContextFrame extends ControlFrame {
+    config: LLMContextSummaryConfig | null;
+    constructor(options?: LLMSummarizeContextFrameOptions);
+}
+export interface LLMContextSummaryRequestFrameOptions {
+    /** Unique identifier to match this request with its response. */
+    requestId: string;
+    /** The full LLM context containing all messages to analyze and summarize. */
+    context: LLMContext;
+    /** Number of recent messages to preserve uncompressed. */
+    minMessagesToKeep: number;
+    /** Maximum token size for the generated summary. */
+    targetContextTokens: number;
+    /** System prompt instructing the LLM how to generate the summary. */
+    summarizationPrompt: string;
+    /** Maximum time in seconds for the LLM to generate a summary. */
+    summarizationTimeout?: number | null;
+}
+/**
+ * Frame requesting context summarization from an LLM service.
+ *
+ * Sent by aggregators to LLM services when conversation context needs to be
+ * compressed. The LLM service generates a summary of older messages while
+ * preserving recent conversation history.
+ *
+ * - `requestId`: unique identifier to match this request with its response.
+ *   Used to handle async responses and avoid race conditions.
+ * - `context`: the full LLM context containing all messages to analyze and
+ *   summarize.
+ * - `minMessagesToKeep`: number of recent messages to preserve uncompressed.
+ *   These messages will not be included in the summary.
+ * - `targetContextTokens`: maximum token size for the generated summary. This
+ *   value is passed directly to the LLM as the max_tokens parameter when
+ *   generating the summary text.
+ * - `summarizationPrompt`: system prompt instructing the LLM how to generate
+ *   the summary.
+ * - `summarizationTimeout`: maximum time in seconds for the LLM to generate a
+ *   summary. When null, a default timeout of 120s is applied.
+ */
+export declare class LLMContextSummaryRequestFrame extends ControlFrame {
+    requestId: string;
+    context: LLMContext;
+    minMessagesToKeep: number;
+    targetContextTokens: number;
+    summarizationPrompt: string;
+    summarizationTimeout: number | null;
+    constructor(options: LLMContextSummaryRequestFrameOptions);
+}
+export interface LLMContextSummaryResultFrameOptions {
+    /** Identifier matching the original request. */
+    requestId: string;
+    /** The formatted summary message ready to be inserted into context. */
+    summary: string;
+    /** Index (0-based) of the last message that was included in the summary. */
+    lastSummarizedIndex: number;
+    /** Error message if summarization failed, null on success. */
+    error?: string | null;
+}
+/**
+ * Frame containing the result of context summarization.
+ *
+ * Sent by LLM services back to aggregators after generating a summary.
+ * Contains the formatted summary message and metadata about what was
+ * summarized.
+ *
+ * - `requestId`: identifier matching the original request. Used to correlate
+ *   async responses.
+ * - `summary`: the formatted summary message ready to be inserted into context.
+ * - `lastSummarizedIndex`: index (0-based) of the last message that was
+ *   included in the summary. Messages after this index are preserved.
+ * - `error`: error message if summarization failed, null on success.
+ */
+export declare class LLMContextSummaryResultFrame extends ControlFrame {
+    interruptible: boolean;
+    requestId: string;
+    summary: string;
+    lastSummarizedIndex: number;
+    error: string | null;
+    constructor(options: LLMContextSummaryResultFrameOptions);
+}
+export interface FunctionCallInProgressFrameOptions {
+    /** Name of the function being executed. */
+    functionName: string;
+    /** Unique identifier for this function call. */
+    toolCallId: string;
+    /** Arguments passed to the function. */
+    arguments: unknown;
+    /** Whether to cancel this call if interrupted. Defaults to false. */
+    cancelOnInterruption?: boolean;
+    /** Identifier shared by all function calls from the same LLM response batch. */
+    groupId?: string | null;
+}
+/**
+ * Frame signaling that a function call is currently executing.
+ *
+ * This is an uninterruptible frame because we always want to update the
+ * context.
+ *
+ * - `functionName`: name of the function being executed.
+ * - `toolCallId`: unique identifier for this function call.
+ * - `arguments`: arguments passed to the function.
+ * - `cancelOnInterruption`: whether to cancel this call if interrupted. When
+ *   false the call is treated as asynchronous: the conversation is not held
+ *   while it runs, and a result that arrives after the conversation has moved
+ *   on is injected via a developer message. A result that arrives before then
+ *   settles in place like a synchronous call's.
+ * - `groupId`: identifier shared by all function calls originating from the
+ *   same LLM response batch. Used to determine when the last call in a group
+ *   completes so the LLM can be triggered exactly once.
+ */
+export declare class FunctionCallInProgressFrame extends ControlFrame {
+    interruptible: boolean;
+    functionName: string;
+    toolCallId: string;
+    arguments: unknown;
+    cancelOnInterruption: boolean;
+    groupId: string | null;
+    constructor(options: FunctionCallInProgressFrameOptions);
+}
+/**
+ * Frame indicating the beginning of a vision model response.
+ *
+ * Used to indicate the beginning of a vision model response. Followed by one
+ * or more VisionTextFrames and a final VisionFullResponseEndFrame.
+ */
+export declare class VisionFullResponseStartFrame extends LLMFullResponseStartFrame {
+}
+/** Frame indicating the end of a Vision model response. */
+export declare class VisionFullResponseEndFrame extends LLMFullResponseEndFrame {
+}
+export interface TTSStartedFrameOptions {
+    /** Unique identifier for this TTS context. */
+    contextId?: string | null;
+    /** Whether the spoken text for this response will be appended to the LLM context. */
+    appendToContext?: boolean;
+}
+/**
+ * Frame indicating the beginning of a TTS response.
+ *
+ * Used to indicate the beginning of a TTS response. Following
+ * TTSAudioRawFrames are part of the TTS response until a TTSStoppedFrame.
+ * These frames can be used for aggregating audio frames in a transport to
+ * optimize the size of frames sent to the session, without needing to control
+ * this in the TTS service.
+ *
+ * - `contextId`: unique identifier for this TTS context.
+ * - `appendToContext`: whether the spoken text for this response will be
+ *   appended to the LLM context. Mirrors the value carried by the response's
+ *   TTSTextFrames.
+ */
+export declare class TTSStartedFrame extends ControlFrame {
+    contextId: string | null;
+    appendToContext: boolean;
+    constructor(options?: TTSStartedFrameOptions);
+}
+export interface TTSStoppedFrameOptions {
+    /** Unique identifier for this TTS context. */
+    contextId?: string | null;
+}
+/**
+ * Frame indicating the end of a TTS response.
+ *
+ * - `contextId`: unique identifier for this TTS context.
+ */
+export declare class TTSStoppedFrame extends ControlFrame {
+    contextId: string | null;
+    constructor(options?: TTSStoppedFrameOptions);
+}
+export interface ServiceUpdateSettingsFrameOptions<TSettings extends ServiceSettings = ServiceSettings> {
+    /** Settings delta object describing the fields to change. */
+    delta?: TSettings | null;
+    /** Optional target service instance. */
+    service?: FrameProcessor | null;
+    /** Whether these settings should reach every service a ServiceSwitcher manages. */
+    reachInactiveServices?: boolean;
+}
+/**
+ * Base frame for updating service settings.
+ *
+ * `TSettings` is covariant upstream so a bare `ServiceUpdateSettingsFrame`
+ * annotation still accepts the subclasses. Gotcha: `delta` is mutable, so
+ * writing through the base type is unsound and goes unreported — treat a
+ * base-typed frame as read-only.
+ *
+ * - `delta`: `ServiceSettings` delta-mode object describing the fields to change.
+ * - `service`: optional target service instance. When provided, only that
+ *   service will apply the settings; other services will forward the frame
+ *   unchanged.
+ * - `reachInactiveServices`: whether these settings should reach every service
+ *   a `ServiceSwitcher` manages, rather than only the active one. Set this for
+ *   provider-neutral settings that must survive a service switch.
+ */
+export declare class ServiceUpdateSettingsFrame<TSettings extends ServiceSettings = ServiceSettings> extends ControlFrame {
+    interruptible: boolean;
+    delta: TSettings | null;
+    service: FrameProcessor | null;
+    reachInactiveServices: boolean;
+    constructor(options?: ServiceUpdateSettingsFrameOptions<TSettings>);
+}
+/** Frame for updating LLM service settings. */
+export declare class LLMUpdateSettingsFrame extends ServiceUpdateSettingsFrame<LLMSettings> {
+}
+/** Frame for updating TTS service settings. */
+export declare class TTSUpdateSettingsFrame extends ServiceUpdateSettingsFrame<TTSSettings> {
+}
+/** Frame for updating STT service settings. */
+export declare class STTUpdateSettingsFrame extends ServiceUpdateSettingsFrame<STTSettings> {
+}
+export interface UserIdleTimeoutUpdateFrameOptions {
+    /** The new idle timeout in seconds. 0 disables idle detection. */
+    timeout: number;
+}
+/**
+ * Frame for updating the user idle timeout at runtime.
+ *
+ * Setting timeout to 0 disables idle detection. Setting a positive value
+ * enables it. Updates apply immediately: a running idle timer restarts with
+ * the new duration, and if the bot is waiting for the user to speak the timer
+ * is armed right away.
+ *
+ * - `timeout`: the new idle timeout in seconds. 0 disables idle detection.
+ */
+export declare class UserIdleTimeoutUpdateFrame extends SystemFrame {
+    timeout: number;
+    constructor(options: UserIdleTimeoutUpdateFrameOptions);
+}
+export interface VADParamsUpdateFrameOptions {
+    /** New VAD parameters to apply. */
+    params: VADParams;
+}
+/**
+ * Frame for updating VAD parameters.
+ *
+ * A control frame containing a request to update VAD params. Intended to be
+ * pushed upstream from RTVI processor.
+ *
+ * - `params`: new VAD parameters to apply.
+ */
+export declare class VADParamsUpdateFrame extends ControlFrame {
+    params: VADParams;
+    constructor(options: VADParamsUpdateFrameOptions);
+}
+/** Base control frame for audio filter operations. */
+export declare class FilterControlFrame extends ControlFrame {
+}
+export interface FilterUpdateSettingsFrameOptions {
+    /** Dictionary of filter setting name to value mappings. */
+    settings: Record<string, unknown>;
+}
+/**
+ * Frame for updating audio filter settings.
+ *
+ * - `settings`: dictionary of filter setting name to value mappings.
+ */
+export declare class FilterUpdateSettingsFrame extends FilterControlFrame {
+    settings: Record<string, unknown>;
+    constructor(options: FilterUpdateSettingsFrameOptions);
+}
+export interface FilterEnableFrameOptions {
+    /** Whether to enable (true) or disable (false) the filter. */
+    enable: boolean;
+}
+/**
+ * Frame for enabling/disabling audio filters at runtime.
+ *
+ * - `enable`: whether to enable (true) or disable (false) the filter.
+ */
+export declare class FilterEnableFrame extends FilterControlFrame {
+    enable: boolean;
+    constructor(options: FilterEnableFrameOptions);
+}
+/** Frame instructing audio buffer processors to start recording. */
+export declare class AudioBufferStartRecordingFrame extends ControlFrame {
+    interruptible: boolean;
+}
+/** Frame instructing audio buffer processors to stop recording and flush. */
+export declare class AudioBufferStopRecordingFrame extends ControlFrame {
+    interruptible: boolean;
+}
+/** Base control frame for audio mixer operations. */
+export declare class MixerControlFrame extends ControlFrame {
+}
+export interface MixerUpdateSettingsFrameOptions {
+    /** Dictionary of mixer setting name to value mappings. */
+    settings: Record<string, unknown>;
+}
+/**
+ * Frame for updating audio mixer settings.
+ *
+ * - `settings`: dictionary of mixer setting name to value mappings.
+ */
+export declare class MixerUpdateSettingsFrame extends MixerControlFrame {
+    settings: Record<string, unknown>;
+    constructor(options: MixerUpdateSettingsFrameOptions);
+}
+export interface MixerEnableFrameOptions {
+    /** Whether to enable (true) or disable (false) the mixer. */
+    enable: boolean;
+}
+/**
+ * Frame for enabling/disabling audio mixer at runtime.
+ *
+ * - `enable`: whether to enable (true) or disable (false) the mixer.
+ */
+export declare class MixerEnableFrame extends MixerControlFrame {
+    enable: boolean;
+    constructor(options: MixerEnableFrameOptions);
+}
+export interface VolumeFrameOptions {
+    /** The volume, as a multiplier on the audio's samples. */
+    volume: number;
+}
+/**
+ * Frame that sets the volume of the output transport's audio.
+ *
+ * The volume holds until the next `VolumeFrame`, and starts at the
+ * transport's `audioOutVolume`. Audio plays at the volume times the gain set
+ * by `VolumeGainFrame`. The frame takes effect in order with the audio before
+ * it, and an interruption doesn't drop it.
+ *
+ * - `volume`: the volume, as a multiplier on the audio's samples: 1.0 leaves
+ *   it unchanged, 0.5 halves it.
+ */
+export declare class VolumeFrame extends ControlFrame {
+    volume: number;
+    interruptible: boolean;
+    constructor(options: VolumeFrameOptions);
+}
+export interface VolumeGainFrameOptions {
+    /** The gain, as a multiplier on the volume. */
+    gain: number;
+}
+/**
+ * Frame that sets a gain on the output transport's volume.
+ *
+ * A gain adjusts the volume for some audio and is reset afterwards, for
+ * example `new VolumeGainFrame({ gain: 0.5 })` before a `TTSSpeakFrame` and
+ * `new VolumeGainFrame({ gain: 1.0 })` after it, which plays that utterance at
+ * half the volume without changing the volume set by `VolumeFrame`. The frame
+ * takes effect in order with the audio before it, and an interruption doesn't
+ * drop it.
+ *
+ * - `gain`: the gain, as a multiplier on the volume: 1.0 leaves it unchanged,
+ *   0.5 halves it.
+ */
+export declare class VolumeGainFrame extends ControlFrame {
+    gain: number;
+    interruptible: boolean;
+    constructor(options: VolumeGainFrameOptions);
+}
+/** A base class for frames that affect ServiceSwitcher behavior. */
+export declare class ServiceSwitcherFrame extends ControlFrame {
+}
+export interface ManuallySwitchServiceFrameOptions {
+    /** The service to switch to. */
+    service: FrameProcessor;
+}
+/**
+ * A frame to request a manual switch in the active service in a ServiceSwitcher.
+ *
+ * Handled by ServiceSwitcherStrategyManual to switch the active service.
+ */
+export declare class ManuallySwitchServiceFrame extends ServiceSwitcherFrame {
+    service: FrameProcessor;
+    constructor(options: ManuallySwitchServiceFrameOptions);
+}
+//# sourceMappingURL=frames.d.ts.map