@pipedog/core 0.0.0 → 0.1.0

package/dist/turns/user_mute/mute_until_first_bot_complete_user_mute_strategy.js

@@ -0,0 +1,76 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/turns/user_mute/mute_until_first_bot_complete_user_mute_strategy.py
+/** User mute strategy that mutes the user until the bot completes its first speech. */
+import { BotStartedSpeakingFrame, BotStoppedSpeakingFrame, ErrorFrame, } from "../../frames/frames.js";
+import { logger } from "../../utils/logger.js";
+import { BaseUserMuteStrategy } from "./base_user_mute_strategy.js";
+/**
+ * User mute strategy that mutes the user until the bot completes its first speech.
+ *
+ * This strategy mutes user frames immediately from the start of the
+ * interaction, even if the bot has not started speaking yet. User input
+ * remains muted until the bot finishes its first speaking turn.
+ *
+ * After the bot completes its initial speech, all subsequent user frames are
+ * allowed to pass through without muting.
+ *
+ * Use this strategy when the bot must fully control the beginning of the
+ * interaction and deliver its first response without any user interruption.
+ *
+ * The mute is also released if the bot's first speaking turn fails before
+ * producing any audio, so that a failed opening leaves the user able to speak.
+ */
+export class MuteUntilFirstBotCompleteUserMuteStrategy extends BaseUserMuteStrategy {
+    _botStartedSpeaking = false;
+    _firstSpeechHandled = false;
+    /** Initialize the mute-until-first-bot-complete user mute strategy. */
+    constructor() {
+        super();
+    }
+    /**
+     * Process an incoming frame.
+     *
+     * @param frame The frame to be processed.
+     * @returns Whether the strategy is muted.
+     */
+    async processFrame(frame) {
+        await super.processFrame(frame);
+        if (frame instanceof BotStartedSpeakingFrame) {
+            this._botStartedSpeaking = true;
+        }
+        else if (frame instanceof BotStoppedSpeakingFrame) {
+            await this._handleBotStoppedSpeaking(frame);
+        }
+        else if (frame instanceof ErrorFrame) {
+            await this._handleError(frame);
+        }
+        return !this._firstSpeechHandled;
+    }
+    async _handleBotStoppedSpeaking(_frame) {
+        if (!this._firstSpeechHandled) {
+            this._firstSpeechHandled = true;
+        }
+    }
+    /**
+     * Release the mute when the first speaking turn fails before any audio.
+     *
+     * No audio means no `BotStoppedSpeakingFrame`, and no later one to wait
+     * for either, since a muted user can never prompt another turn. Only
+     * errors before the bot starts speaking count: after that the transport
+     * ends the turn on its own once the audio dries up.
+     */
+    async _handleError(frame) {
+        if (this._botStartedSpeaking) {
+            return;
+        }
+        if (!this._firstSpeechHandled) {
+            logger.warning(`${this}: releasing the user mute without the bot having completed its first ` +
+                `speech, after an error from ${frame.processor}: ${frame.error}`);
+            this._firstSpeechHandled = true;
+        }
+    }
+}
+//# sourceMappingURL=mute_until_first_bot_complete_user_mute_strategy.js.map

package/dist/turns/user_start/base_user_turn_start_strategy.d.ts

@@ -0,0 +1,135 @@
+/** Base turn start strategy for determining when the user starts speaking. */
+import type { Frame } from "../../frames/frames.ts";
+import { FrameDirection, type FrameProcessorSetup } from "../../processors/frame_processor.ts";
+import { BaseObject, type BaseObjectOptions } from "../../utils/base_object.ts";
+import type { ProcessFrameResult } from "../types.ts";
+export interface UserTurnStartedParamsOptions {
+    /** Whether the user aggregator should broadcast an interruption for this turn. */
+    enableInterruptions: boolean;
+    /**
+     * Whether to emit `UserStartedSpeakingFrame` for this turn. False when the
+     * turn was already announced elsewhere — by a shared `UserTurnProcessor`,
+     * or by a service that emits turn frames rather than proposing them.
+     */
+    enableUserSpeakingFrames: boolean;
+}
+/**
+ * Parameters emitted when a user turn starts.
+ *
+ * These parameters are passed to the `on_user_turn_started` event and provide
+ * contextual information about how the user turn should be handled by the user
+ * aggregator.
+ *
+ * - `enableUserSpeakingFrames`: Whether to emit `UserStartedSpeakingFrame` for
+ *   this turn. False when the turn was already announced elsewhere — by a
+ *   shared `UserTurnProcessor`, or by a service that emits turn frames rather
+ *   than proposing them.
+ */
+export declare class UserTurnStartedParams {
+    enableInterruptions: boolean;
+    enableUserSpeakingFrames: boolean;
+    constructor(options: UserTurnStartedParamsOptions);
+}
+export interface BaseUserTurnStartStrategyOptions extends BaseObjectOptions {
+    /**
+     * If true, the user aggregator will emit an interruption frame when the user
+     * turn starts.
+     */
+    enableInterruptions?: boolean;
+}
+export interface TriggerUserTurnStartedOptions {
+    /**
+     * Whether to broadcast an interruption for this turn, overriding the
+     * strategy's configured setting. Pass false when something else in the
+     * pipeline has already broadcast one.
+     */
+    enableInterruptions?: boolean | null;
+    /**
+     * Whether to emit `UserStartedSpeakingFrame` for this turn. Pass false when
+     * something else in the pipeline has already emitted it.
+     */
+    enableUserSpeakingFrames?: boolean | null;
+}
+/**
+ * Base class for strategies that determine when a user starts speaking.
+ *
+ * Subclasses should implement logic to detect the start of a user's turn.
+ * This could be based on voice activity, number of words spoken, or other
+ * heuristics.
+ *
+ * Events triggered by user turn start strategies:
+ *
+ *   - `on_push_frame`: Indicates the strategy wants to push a frame.
+ *   - `on_broadcast_frame`: Indicates the strategy wants to broadcast a frame.
+ *   - `on_user_turn_started`: Signals that a user turn has started.
+ *
+ * Porting note: the deprecated `enable_user_speaking_frames` constructor
+ * argument and the deprecated `reset()` hook are not ported.
+ */
+export declare class BaseUserTurnStartStrategy extends BaseObject {
+    protected _enableInterruptions: boolean;
+    protected _enableUserSpeakingFrames: boolean;
+    constructor(options?: BaseUserTurnStartStrategyOptions);
+    /**
+     * Whether this strategy resolves proposals into turn starts.
+     *
+     * A `ProposedUserStartedSpeakingFrame` is a request for a decision, so a
+     * strategy that acts on one consumes it: the frame stops travelling, and no
+     * resolver further along decides the same turn a second time. Override to
+     * true in a strategy that handles that frame.
+     */
+    get resolvesProposedTurnStartFrames(): boolean;
+    /**
+     * Set up the strategy.
+     *
+     * @param setup Configuration object containing setup parameters.
+     */
+    setup(setup: FrameProcessorSetup): Promise<void>;
+    /** Cleanup the strategy. */
+    cleanup(): Promise<void>;
+    /**
+     * Notify the strategy that a user turn has started.
+     *
+     * The controller calls this on every start strategy when a turn begins.
+     * Override to run, for example, logic to reset state and prepare for the
+     * next detection.
+     */
+    handleUserTurnStarted(): Promise<void>;
+    /**
+     * Notify the strategy that the user turn has stopped.
+     *
+     * The controller calls this on every start strategy when a turn ends.
+     * Override if the strategy needs to act on turn end (likely uncommon).
+     */
+    handleUserTurnStopped(): Promise<void>;
+    /**
+     * Process an incoming frame.
+     *
+     * Subclasses should override this to implement logic that decides whether
+     * the user turn has started.
+     *
+     * @param frame The frame to be processed.
+     * @returns A ProcessFrameResult indicating the outcome, or null (treated as
+     *   CONTINUE for backward compatibility).
+     */
+    processFrame(_frame: Frame): Promise<ProcessFrameResult | null>;
+    /**
+     * Emit on_push_frame to push a frame using the user aggregator.
+     *
+     * @param frame The frame to be pushed.
+     * @param direction What direction the frame should be pushed to.
+     */
+    pushFrame(frame: Frame, direction?: FrameDirection): Promise<void>;
+    /**
+     * Emit on_broadcast_frame to broadcast a frame using the user aggregator.
+     *
+     * @param frameCls The class of the frame to be broadcasted.
+     * @param options Options to be passed to the frame's constructor.
+     */
+    broadcastFrame<O>(frameCls: new (options: O) => Frame, options?: O): Promise<void>;
+    /** Trigger the `on_user_turn_started` event. */
+    triggerUserTurnStarted(options?: TriggerUserTurnStartedOptions): Promise<void>;
+    /** Trigger the `on_reset_aggregation` event. */
+    triggerResetAggregation(): Promise<void>;
+}
+//# sourceMappingURL=base_user_turn_start_strategy.d.ts.map

package/dist/turns/user_start/base_user_turn_start_strategy.js

@@ -0,0 +1,134 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/turns/user_start/base_user_turn_start_strategy.py
+import { FrameDirection } from "../../processors/frame_processor.js";
+import { BaseObject } from "../../utils/base_object.js";
+/**
+ * Parameters emitted when a user turn starts.
+ *
+ * These parameters are passed to the `on_user_turn_started` event and provide
+ * contextual information about how the user turn should be handled by the user
+ * aggregator.
+ *
+ * - `enableUserSpeakingFrames`: Whether to emit `UserStartedSpeakingFrame` for
+ *   this turn. False when the turn was already announced elsewhere — by a
+ *   shared `UserTurnProcessor`, or by a service that emits turn frames rather
+ *   than proposing them.
+ */
+export class UserTurnStartedParams {
+    enableInterruptions;
+    enableUserSpeakingFrames;
+    constructor(options) {
+        this.enableInterruptions = options.enableInterruptions;
+        this.enableUserSpeakingFrames = options.enableUserSpeakingFrames;
+    }
+}
+/**
+ * Base class for strategies that determine when a user starts speaking.
+ *
+ * Subclasses should implement logic to detect the start of a user's turn.
+ * This could be based on voice activity, number of words spoken, or other
+ * heuristics.
+ *
+ * Events triggered by user turn start strategies:
+ *
+ *   - `on_push_frame`: Indicates the strategy wants to push a frame.
+ *   - `on_broadcast_frame`: Indicates the strategy wants to broadcast a frame.
+ *   - `on_user_turn_started`: Signals that a user turn has started.
+ *
+ * Porting note: the deprecated `enable_user_speaking_frames` constructor
+ * argument and the deprecated `reset()` hook are not ported.
+ */
+export class BaseUserTurnStartStrategy extends BaseObject {
+    _enableInterruptions;
+    _enableUserSpeakingFrames = true;
+    constructor(options = {}) {
+        super(options);
+        this._enableInterruptions = options.enableInterruptions ?? true;
+        this._registerEventHandler("on_push_frame", true);
+        this._registerEventHandler("on_broadcast_frame", true);
+        this._registerEventHandler("on_user_turn_started", true);
+        this._registerEventHandler("on_reset_aggregation", true);
+    }
+    /**
+     * Whether this strategy resolves proposals into turn starts.
+     *
+     * A `ProposedUserStartedSpeakingFrame` is a request for a decision, so a
+     * strategy that acts on one consumes it: the frame stops travelling, and no
+     * resolver further along decides the same turn a second time. Override to
+     * true in a strategy that handles that frame.
+     */
+    get resolvesProposedTurnStartFrames() {
+        return false;
+    }
+    /**
+     * Set up the strategy.
+     *
+     * @param setup Configuration object containing setup parameters.
+     */
+    async setup(setup) {
+        await super.setup(setup.taskManager);
+    }
+    /** Cleanup the strategy. */
+    async cleanup() { }
+    /**
+     * Notify the strategy that a user turn has started.
+     *
+     * The controller calls this on every start strategy when a turn begins.
+     * Override to run, for example, logic to reset state and prepare for the
+     * next detection.
+     */
+    async handleUserTurnStarted() { }
+    /**
+     * Notify the strategy that the user turn has stopped.
+     *
+     * The controller calls this on every start strategy when a turn ends.
+     * Override if the strategy needs to act on turn end (likely uncommon).
+     */
+    async handleUserTurnStopped() { }
+    /**
+     * Process an incoming frame.
+     *
+     * Subclasses should override this to implement logic that decides whether
+     * the user turn has started.
+     *
+     * @param frame The frame to be processed.
+     * @returns A ProcessFrameResult indicating the outcome, or null (treated as
+     *   CONTINUE for backward compatibility).
+     */
+    async processFrame(_frame) {
+        return null;
+    }
+    /**
+     * Emit on_push_frame to push a frame using the user aggregator.
+     *
+     * @param frame The frame to be pushed.
+     * @param direction What direction the frame should be pushed to.
+     */
+    async pushFrame(frame, direction = FrameDirection.DOWNSTREAM) {
+        await this._callEventHandler("on_push_frame", frame, direction);
+    }
+    /**
+     * Emit on_broadcast_frame to broadcast a frame using the user aggregator.
+     *
+     * @param frameCls The class of the frame to be broadcasted.
+     * @param options Options to be passed to the frame's constructor.
+     */
+    async broadcastFrame(frameCls, options) {
+        await this._callEventHandler("on_broadcast_frame", frameCls, options);
+    }
+    /** Trigger the `on_user_turn_started` event. */
+    async triggerUserTurnStarted(options = {}) {
+        await this._callEventHandler("on_user_turn_started", new UserTurnStartedParams({
+            enableInterruptions: options.enableInterruptions ?? this._enableInterruptions,
+            enableUserSpeakingFrames: options.enableUserSpeakingFrames ?? this._enableUserSpeakingFrames,
+        }));
+    }
+    /** Trigger the `on_reset_aggregation` event. */
+    async triggerResetAggregation() {
+        await this._callEventHandler("on_reset_aggregation");
+    }
+}
+//# sourceMappingURL=base_user_turn_start_strategy.js.map

package/dist/turns/user_start/external_user_turn_start_strategy.d.ts

@@ -0,0 +1,45 @@
+/** User turn start strategy driven by another component in the pipeline. */
+import { type Frame } from "../../frames/frames.ts";
+import { ProcessFrameResult } from "../types.ts";
+import { BaseUserTurnStartStrategy, type BaseUserTurnStartStrategyOptions } from "./base_user_turn_start_strategy.ts";
+export interface ExternalUserTurnStartStrategyOptions extends BaseUserTurnStartStrategyOptions {
+    /**
+     * If true, broadcast an interruption when a proposal opens a turn. Ignored
+     * on the adopt path, where the emitter has already broadcast one.
+     */
+    enableInterruptions?: boolean;
+}
+/**
+ * User turn start strategy driven by another component in the pipeline.
+ *
+ * Rather than detecting the start of a turn itself, this strategy takes its
+ * cue from another processor. It understands two signals, which differ in how
+ * much the emitter has already done:
+ *
+ * - `ProposedUserStartedSpeakingFrame` — a service with its own turn detection
+ *   proposing a turn boundary. This strategy makes the decision, emitting the
+ *   `UserStartedSpeakingFrame` and broadcasting the interruption itself.
+ *   Subclass it to adjust when, or whether, a proposal opens a turn.
+ *
+ * - `UserStartedSpeakingFrame` — the turn was already decided and announced
+ *   elsewhere, typically by a shared `UserTurnProcessor` fanning turns out to
+ *   several aggregators. This strategy adopts that decision and emits nothing,
+ *   so the turn isn't announced twice.
+ *
+ * A service that emits turn frames directly lands on the adopt path and keeps
+ * working, but it owns the interruption logic itself. Emitting proposals
+ * instead hands that job back to the pipeline.
+ */
+export declare class ExternalUserTurnStartStrategy extends BaseUserTurnStartStrategy {
+    constructor(options?: ExternalUserTurnStartStrategyOptions);
+    /** Whether this strategy resolves proposals into turn starts. */
+    get resolvesProposedTurnStartFrames(): boolean;
+    /**
+     * Process an incoming frame to detect user turn start.
+     *
+     * @param frame The frame to be analyzed.
+     * @returns STOP if the turn started, CONTINUE otherwise.
+     */
+    processFrame(frame: Frame): Promise<ProcessFrameResult>;
+}
+//# sourceMappingURL=external_user_turn_start_strategy.d.ts.map

package/dist/turns/user_start/external_user_turn_start_strategy.js

@@ -0,0 +1,64 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/turns/user_start/external_user_turn_start_strategy.py
+/** User turn start strategy driven by another component in the pipeline. */
+import { ProposedUserStartedSpeakingFrame, UserStartedSpeakingFrame, } from "../../frames/frames.js";
+import { logger } from "../../utils/logger.js";
+import { ProcessFrameResult } from "../types.js";
+import { BaseUserTurnStartStrategy, } from "./base_user_turn_start_strategy.js";
+/**
+ * User turn start strategy driven by another component in the pipeline.
+ *
+ * Rather than detecting the start of a turn itself, this strategy takes its
+ * cue from another processor. It understands two signals, which differ in how
+ * much the emitter has already done:
+ *
+ * - `ProposedUserStartedSpeakingFrame` — a service with its own turn detection
+ *   proposing a turn boundary. This strategy makes the decision, emitting the
+ *   `UserStartedSpeakingFrame` and broadcasting the interruption itself.
+ *   Subclass it to adjust when, or whether, a proposal opens a turn.
+ *
+ * - `UserStartedSpeakingFrame` — the turn was already decided and announced
+ *   elsewhere, typically by a shared `UserTurnProcessor` fanning turns out to
+ *   several aggregators. This strategy adopts that decision and emits nothing,
+ *   so the turn isn't announced twice.
+ *
+ * A service that emits turn frames directly lands on the adopt path and keeps
+ * working, but it owns the interruption logic itself. Emitting proposals
+ * instead hands that job back to the pipeline.
+ */
+export class ExternalUserTurnStartStrategy extends BaseUserTurnStartStrategy {
+    constructor(options = {}) {
+        super({ ...options, enableInterruptions: options.enableInterruptions ?? true });
+    }
+    /** Whether this strategy resolves proposals into turn starts. */
+    get resolvesProposedTurnStartFrames() {
+        return true;
+    }
+    /**
+     * Process an incoming frame to detect user turn start.
+     *
+     * @param frame The frame to be analyzed.
+     * @returns STOP if the turn started, CONTINUE otherwise.
+     */
+    async processFrame(frame) {
+        if (frame instanceof ProposedUserStartedSpeakingFrame) {
+            logger.debug(`${this}: resolving a proposed user turn start`);
+            await this.triggerUserTurnStarted();
+            return ProcessFrameResult.STOP;
+        }
+        if (frame instanceof UserStartedSpeakingFrame) {
+            // Already announced elsewhere — adopt the decision without repeating it.
+            logger.debug(`${this}: adopting a user turn start decided elsewhere`);
+            await this.triggerUserTurnStarted({
+                enableInterruptions: false,
+                enableUserSpeakingFrames: false,
+            });
+            return ProcessFrameResult.STOP;
+        }
+        return ProcessFrameResult.CONTINUE;
+    }
+}
+//# sourceMappingURL=external_user_turn_start_strategy.js.map

package/dist/turns/user_start/index.d.ts

@@ -0,0 +1,8 @@
+export { BaseUserTurnStartStrategy, UserTurnStartedParams, } from "./base_user_turn_start_strategy.ts";
+export { ExternalUserTurnStartStrategy } from "./external_user_turn_start_strategy.ts";
+export { KrispVivaIPUserTurnStartStrategy } from "./krisp_viva_ip_user_turn_start_strategy.ts";
+export { MinWordsUserTurnStartStrategy } from "./min_words_user_turn_start_strategy.ts";
+export { TranscriptionUserTurnStartStrategy } from "./transcription_user_turn_start_strategy.ts";
+export { VADUserTurnStartStrategy } from "./vad_user_turn_start_strategy.ts";
+export { WakePhraseUserTurnStartStrategy } from "./wake_phrase_user_turn_start_strategy.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/turns/user_start/index.js

@@ -0,0 +1,16 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/turns/user_start/__init__.py
+// Upstream imports KrispVivaIPUserTurnStartStrategy inside a try/except and
+// sets it to None when krisp_audio is not installed. Here the module is always
+// importable; its Krisp runtime is injected (see its own module).
+export { BaseUserTurnStartStrategy, UserTurnStartedParams, } from "./base_user_turn_start_strategy.js";
+export { ExternalUserTurnStartStrategy } from "./external_user_turn_start_strategy.js";
+export { KrispVivaIPUserTurnStartStrategy } from "./krisp_viva_ip_user_turn_start_strategy.js";
+export { MinWordsUserTurnStartStrategy } from "./min_words_user_turn_start_strategy.js";
+export { TranscriptionUserTurnStartStrategy } from "./transcription_user_turn_start_strategy.js";
+export { VADUserTurnStartStrategy } from "./vad_user_turn_start_strategy.js";
+export { WakePhraseUserTurnStartStrategy } from "./wake_phrase_user_turn_start_strategy.js";
+//# sourceMappingURL=index.js.map

package/dist/turns/user_start/krisp_viva_ip_user_turn_start_strategy.d.ts

@@ -0,0 +1,133 @@
+import { BotStoppedSpeakingFrame, type Frame, InputAudioRawFrame, VADUserStartedSpeakingFrame, VADUserStoppedSpeakingFrame } from "../../frames/frames.ts";
+import { ProcessFrameResult } from "../types.ts";
+import { BaseUserTurnStartStrategy, type BaseUserTurnStartStrategyOptions } from "./base_user_turn_start_strategy.ts";
+/** A Krisp IP session (`krisp_audio.IpFloat`): one probability per audio frame. */
+export interface KrispIpSession {
+    /**
+     * Feed one frame of float32 samples in [-1, 1).
+     *
+     * @param frame Exactly `samplesPerFrame` samples.
+     * @param speechActive The per-frame VAD input.
+     * @returns The probability that the speech is a genuine interruption.
+     */
+    process(frame: Float32Array, speechActive: boolean): number;
+}
+export interface KrispVivaIPUserTurnStartStrategyOptions extends BaseUserTurnStartStrategyOptions {
+    /**
+     * Path to the Krisp VIVA IP model file (.kef). If null, uses the
+     * KRISP_VIVA_IP_MODEL_PATH environment variable.
+     */
+    modelPath?: string | null;
+    /**
+     * IP probability threshold (0.0 to 1.0). When the model's output exceeds
+     * this value, the speech is classified as a genuine interruption.
+     */
+    threshold?: number;
+    /**
+     * Frame duration in milliseconds for IP processing.
+     * Supported values: 10, 15, 20, 30, 32.
+     */
+    frameDurationMs?: number;
+    /**
+     * Krisp SDK API key. If empty, falls back to the KRISP_VIVA_API_KEY
+     * environment variable.
+     */
+    apiKey?: string;
+}
+/**
+ * User turn start strategy using Krisp VIVA Interruption Prediction.
+ *
+ * When VAD detects user speech, this strategy feeds audio frames into
+ * the Krisp VIVA IP model. The model outputs a probability indicating
+ * whether the speech is a genuine interruption (as opposed to a
+ * backchannel). A user turn is triggered only when this probability
+ * exceeds the configured threshold.
+ *
+ * This strategy is designed to work alongside other start strategies
+ * (e.g. `TranscriptionUserTurnStartStrategy` as a fallback) via the
+ * strategy list in `UserTurnStrategies`.
+ *
+ * @example
+ * const strategies = new UserTurnStrategies({
+ *   start: [
+ *     new KrispVivaIPUserTurnStartStrategy({
+ *       modelPath: "/path/to/ip_model.kef",
+ *       threshold: 0.5,
+ *     }),
+ *     new TranscriptionUserTurnStartStrategy(),
+ *   ],
+ * });
+ */
+export declare class KrispVivaIPUserTurnStartStrategy extends BaseUserTurnStartStrategy {
+    protected _threshold: number;
+    protected _frameDurationMs: number;
+    protected _apiKey: string;
+    protected _modelPath: string;
+    protected _sdkAcquired: boolean;
+    protected _ipSession: KrispIpSession | null;
+    protected _samplesPerFrame: number | null;
+    protected _sampleRate: number | null;
+    protected _speechActive: boolean;
+    protected _audioBuffer: Uint8Array;
+    protected _decisionMade: boolean;
+    constructor(options?: KrispVivaIPUserTurnStartStrategyOptions);
+    /** Release Krisp SDK resources. */
+    cleanup(): Promise<void>;
+    /**
+     * Create a Krisp IP session for the given sample rate.
+     *
+     * STUB: needs the Krisp SDK (`krisp_audio.IpFloat.create`), which has no JS
+     * equivalent yet. Override to supply a session.
+     */
+    protected _createIpSession(sampleRate: number): KrispIpSession;
+    /**
+     * Create or re-create the IP session when sample rate changes.
+     *
+     * @param sampleRate Audio sample rate in Hz.
+     */
+    protected _ensureSession(sampleRate: number): void;
+    /** Reset speech tracking state for the next candidate interruption. */
+    protected _resetState(): void;
+    /** Ready the strategy for a new user turn. */
+    handleUserTurnStarted(): Promise<void>;
+    /**
+     * Process a frame to detect genuine user interruptions.
+     *
+     * On `VADUserStartedSpeakingFrame`, begins collecting audio.
+     * On `InputAudioRawFrame`, feeds audio through the IP model and
+     * triggers a user turn if the interruption probability exceeds the
+     * threshold.
+     * On `VADUserStoppedSpeakingFrame` or `BotStoppedSpeakingFrame`,
+     * resets the candidate state.
+     *
+     * @param frame The incoming frame.
+     * @returns STOP if a genuine interruption was detected, CONTINUE otherwise.
+     */
+    processFrame(frame: Frame): Promise<ProcessFrameResult>;
+    /**
+     * Begin collecting audio for interruption classification.
+     *
+     * @returns Always CONTINUE; the decision is deferred until enough audio is processed.
+     */
+    protected _handleVadStarted(_frame: VADUserStartedSpeakingFrame): Promise<ProcessFrameResult>;
+    /**
+     * Feed audio to the IP model and check for genuine interruption.
+     *
+     * Every frame is passed to the IP model regardless of speech state so
+     * that the model maintains continuous internal state (matching the
+     * standalone Krisp SDK behaviour). `_speechActive` is forwarded as
+     * the per-frame VAD input to the model and also gates the threshold
+     * evaluation.
+     *
+     * @param frame Raw audio input frame.
+     * @returns STOP if the model detects a genuine interruption, CONTINUE otherwise.
+     */
+    protected _handleAudio(frame: InputAudioRawFrame): Promise<ProcessFrameResult>;
+    /**
+     * Reset state when the candidate interruption window ends.
+     *
+     * @returns Always CONTINUE.
+     */
+    protected _handleReset(_frame: VADUserStoppedSpeakingFrame | BotStoppedSpeakingFrame): Promise<ProcessFrameResult>;
+}
+//# sourceMappingURL=krisp_viva_ip_user_turn_start_strategy.d.ts.map