@pipedog/core 0.0.0 → 0.1.0

package/dist/turns/user_idle_controller.d.ts

@@ -0,0 +1,94 @@
+/** This module defines a controller for managing user idle detection. */
+import { type Task } from "@pipedog/asyncio";
+import { type Frame } from "../frames/frames.ts";
+import type { FrameProcessorSetup } from "../processors/frame_processor.ts";
+import { BaseObject } from "../utils/base_object.ts";
+export interface UserIdleControllerOptions {
+    /**
+     * Timeout in seconds before considering the user idle. 0 disables idle
+     * detection.
+     */
+    userIdleTimeout?: number;
+}
+/**
+ * Controller for managing user idle detection.
+ *
+ * This class monitors user activity and triggers an event when the user has
+ * been idle (not speaking) for a configured timeout period after the bot
+ * finishes speaking. The timer starts when BotStoppedSpeakingFrame is received
+ * and is cancelled when someone starts speaking again
+ * (UserStartedSpeakingFrame or BotStartedSpeakingFrame).
+ *
+ * The timer is suppressed while a user turn is in progress to avoid false
+ * triggers during interruptions (where BotStoppedSpeakingFrame arrives while
+ * the user is still speaking).
+ *
+ * A UserIdleTimeoutUpdateFrame applies immediately: it restarts a running
+ * timer with the new duration and, while waiting for the user to speak, arms
+ * the timer even if idle detection was previously disabled.
+ *
+ * Event handlers available:
+ *
+ * - on_user_turn_idle: Emitted when the user has been idle for the timeout period.
+ *
+ * @example
+ * controller.eventHandler("on_user_turn_idle", async (controller) => {
+ *   // Handle user idle - send reminder, prompt, etc.
+ * });
+ */
+export declare class UserIdleController extends BaseObject {
+    protected _userIdleTimeout: number;
+    protected _waitingForUser: boolean;
+    protected _botSpeaking: boolean;
+    protected _userTurnInProgress: boolean;
+    protected _functionCallsInProgress: number;
+    protected _idleTimerTask: Task<unknown> | null;
+    constructor(options?: UserIdleControllerOptions);
+    /**
+     * Whether the bot has finished responding and is waiting for the user.
+     *
+     * False while the bot is thinking, speaking or running a function call,
+     * and during a user turn.
+     */
+    get waitingForUser(): boolean;
+    /** Whether function calls have started and not finished. */
+    get functionCallsInProgress(): boolean;
+    /**
+     * Set up the controller.
+     *
+     * @param setup Configuration object containing setup parameters.
+     */
+    setup(setup: FrameProcessorSetup): Promise<void>;
+    /**
+     * Stop the idle timer.
+     *
+     * Called at session end so it can't report idleness that only means the
+     * session is over.
+     */
+    stop(): Promise<void>;
+    /** Cleanup the controller. */
+    cleanup(): Promise<void>;
+    /**
+     * Process an incoming frame to track user activity state.
+     *
+     * @param frame The frame to be processed.
+     */
+    processFrame(frame: Frame): Promise<void>;
+    /**
+     * Start waiting for the user after a turn the bot will not answer.
+     *
+     * The timer normally starts when the bot stops speaking. A user turn that
+     * ends with nothing for the bot to answer (e.g. no transcript) cancels the
+     * timer without the bot speaking again afterwards, so the caller re-arms it
+     * here. Does nothing while the bot is speaking, a user turn is in progress,
+     * or function calls are pending.
+     */
+    waitForUser(): Promise<void>;
+    /** Start (or restart) the idle timer. */
+    protected _startIdleTimer(): Promise<void>;
+    /** Cancel the idle timer if running. */
+    protected _cancelIdleTimer(): Promise<void>;
+    /** Sleep for the timeout duration then fire the idle event. */
+    protected _idleTimerExpired(): Promise<void>;
+}
+//# sourceMappingURL=user_idle_controller.d.ts.map

package/dist/turns/user_idle_controller.js

@@ -0,0 +1,187 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/turns/user_idle_controller.py
+/** This module defines a controller for managing user idle detection. */
+import { sleep } from "@pipedog/asyncio";
+import { BotStartedSpeakingFrame, BotStoppedSpeakingFrame, FunctionCallCancelFrame, FunctionCallResultFrame, FunctionCallsStartedFrame, UserIdleTimeoutUpdateFrame, UserStartedSpeakingFrame, UserStoppedSpeakingFrame, } from "../frames/frames.js";
+import { BaseObject } from "../utils/base_object.js";
+/**
+ * Controller for managing user idle detection.
+ *
+ * This class monitors user activity and triggers an event when the user has
+ * been idle (not speaking) for a configured timeout period after the bot
+ * finishes speaking. The timer starts when BotStoppedSpeakingFrame is received
+ * and is cancelled when someone starts speaking again
+ * (UserStartedSpeakingFrame or BotStartedSpeakingFrame).
+ *
+ * The timer is suppressed while a user turn is in progress to avoid false
+ * triggers during interruptions (where BotStoppedSpeakingFrame arrives while
+ * the user is still speaking).
+ *
+ * A UserIdleTimeoutUpdateFrame applies immediately: it restarts a running
+ * timer with the new duration and, while waiting for the user to speak, arms
+ * the timer even if idle detection was previously disabled.
+ *
+ * Event handlers available:
+ *
+ * - on_user_turn_idle: Emitted when the user has been idle for the timeout period.
+ *
+ * @example
+ * controller.eventHandler("on_user_turn_idle", async (controller) => {
+ *   // Handle user idle - send reminder, prompt, etc.
+ * });
+ */
+export class UserIdleController extends BaseObject {
+    _userIdleTimeout;
+    _waitingForUser = false;
+    _botSpeaking = false;
+    _userTurnInProgress = false;
+    _functionCallsInProgress = 0;
+    _idleTimerTask = null;
+    constructor(options = {}) {
+        super();
+        this._userIdleTimeout = options.userIdleTimeout ?? 0;
+        this._registerEventHandler("on_user_turn_idle", true);
+    }
+    /**
+     * Whether the bot has finished responding and is waiting for the user.
+     *
+     * False while the bot is thinking, speaking or running a function call,
+     * and during a user turn.
+     */
+    get waitingForUser() {
+        return this._waitingForUser;
+    }
+    /** Whether function calls have started and not finished. */
+    get functionCallsInProgress() {
+        return this._functionCallsInProgress > 0;
+    }
+    /**
+     * Set up the controller.
+     *
+     * @param setup Configuration object containing setup parameters.
+     */
+    async setup(setup) {
+        await super.setup(setup.taskManager);
+    }
+    /**
+     * Stop the idle timer.
+     *
+     * Called at session end so it can't report idleness that only means the
+     * session is over.
+     */
+    async stop() {
+        await this._cancelIdleTimer();
+    }
+    /** Cleanup the controller. */
+    async cleanup() {
+        await super.cleanup();
+        await this.stop();
+    }
+    /**
+     * Process an incoming frame to track user activity state.
+     *
+     * @param frame The frame to be processed.
+     */
+    async processFrame(frame) {
+        if (frame instanceof UserIdleTimeoutUpdateFrame) {
+            this._userIdleTimeout = frame.timeout;
+            if (this._userIdleTimeout <= 0) {
+                await this._cancelIdleTimer();
+            }
+            else if (this._waitingForUser) {
+                // Apply the new timeout now: restart a running timer with the new
+                // duration, or arm one if idle detection was previously disabled.
+                await this._startIdleTimer();
+            }
+            return;
+        }
+        if (frame instanceof BotStoppedSpeakingFrame) {
+            this._botSpeaking = false;
+            // Only start the timer if the user isn't mid-turn and no function
+            // calls are pending.
+            //
+            // Interruption case: the frame order is UserStartedSpeaking →
+            // BotStoppedSpeaking → (user keeps talking) → UserStoppedSpeaking.
+            // Without the user-turn guard the timer would start while the user is
+            // still speaking.
+            //
+            // Function call case: normally FunctionCallsStarted arrives after
+            // BotStoppedSpeaking and cancels the timer directly. But a race
+            // condition can cause FunctionCallsStarted to arrive before
+            // BotStoppedSpeaking when pushing a TTSSpeakFrame in the
+            // on_function_calls_started event handler, so the counter guard
+            // prevents the timer from starting while a function call is in
+            // progress.
+            if (!this._userTurnInProgress && this._functionCallsInProgress === 0) {
+                // Track the waiting-for-user window even when the timeout is
+                // currently <= 0 (no timer), so a later timeout update can arm the
+                // timer without waiting for the next bot turn.
+                this._waitingForUser = true;
+                await this._startIdleTimer();
+            }
+        }
+        else if (frame instanceof BotStartedSpeakingFrame) {
+            this._botSpeaking = true;
+            this._waitingForUser = false;
+            await this._cancelIdleTimer();
+        }
+        else if (frame instanceof UserStartedSpeakingFrame) {
+            this._waitingForUser = false;
+            this._userTurnInProgress = true;
+            await this._cancelIdleTimer();
+        }
+        else if (frame instanceof UserStoppedSpeakingFrame) {
+            this._userTurnInProgress = false;
+        }
+        else if (frame instanceof FunctionCallsStartedFrame) {
+            this._waitingForUser = false;
+            this._functionCallsInProgress += frame.functionCalls.length;
+            await this._cancelIdleTimer();
+        }
+        else if (frame instanceof FunctionCallResultFrame ||
+            frame instanceof FunctionCallCancelFrame) {
+            this._functionCallsInProgress = Math.max(0, this._functionCallsInProgress - 1);
+        }
+    }
+    /**
+     * Start waiting for the user after a turn the bot will not answer.
+     *
+     * The timer normally starts when the bot stops speaking. A user turn that
+     * ends with nothing for the bot to answer (e.g. no transcript) cancels the
+     * timer without the bot speaking again afterwards, so the caller re-arms it
+     * here. Does nothing while the bot is speaking, a user turn is in progress,
+     * or function calls are pending.
+     */
+    async waitForUser() {
+        if (this._botSpeaking || this._userTurnInProgress)
+            return;
+        if (this._functionCallsInProgress > 0)
+            return;
+        this._waitingForUser = true;
+        await this._startIdleTimer();
+    }
+    /** Start (or restart) the idle timer. */
+    async _startIdleTimer() {
+        if (this._userIdleTimeout <= 0)
+            return;
+        await this._cancelIdleTimer();
+        this._idleTimerTask = this.createTask(() => this._idleTimerExpired(), "_idleTimerExpired");
+    }
+    /** Cancel the idle timer if running. */
+    async _cancelIdleTimer() {
+        if (this._idleTimerTask) {
+            await this.cancelTask(this._idleTimerTask);
+            this._idleTimerTask = null;
+        }
+    }
+    /** Sleep for the timeout duration then fire the idle event. */
+    async _idleTimerExpired() {
+        await sleep(this._userIdleTimeout);
+        this._idleTimerTask = null;
+        await this._callEventHandler("on_user_turn_idle");
+    }
+}
+//# sourceMappingURL=user_idle_controller.js.map

package/dist/turns/user_mute/always_user_mute_strategy.d.ts

@@ -0,0 +1,15 @@
+/** User mute strategy that always mutes the user while the bot is speaking. */
+import { type Frame } from "../../frames/frames.ts";
+import { BaseUserMuteStrategy } from "./base_user_mute_strategy.ts";
+/** User mute strategy that always mutes the user while the bot is speaking. */
+export declare class AlwaysUserMuteStrategy extends BaseUserMuteStrategy {
+    protected _botSpeaking: boolean;
+    /**
+     * Process an incoming frame.
+     *
+     * @param frame The frame to be processed.
+     * @returns Whether the strategy is muted.
+     */
+    processFrame(frame: Frame): Promise<boolean>;
+}
+//# sourceMappingURL=always_user_mute_strategy.d.ts.map

package/dist/turns/user_mute/always_user_mute_strategy.js

@@ -0,0 +1,29 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/turns/user_mute/always_user_mute_strategy.py
+/** User mute strategy that always mutes the user while the bot is speaking. */
+import { BotStartedSpeakingFrame, BotStoppedSpeakingFrame, } from "../../frames/frames.js";
+import { BaseUserMuteStrategy } from "./base_user_mute_strategy.js";
+/** User mute strategy that always mutes the user while the bot is speaking. */
+export class AlwaysUserMuteStrategy extends BaseUserMuteStrategy {
+    _botSpeaking = false;
+    /**
+     * 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._botSpeaking = true;
+        }
+        else if (frame instanceof BotStoppedSpeakingFrame) {
+            this._botSpeaking = false;
+        }
+        return this._botSpeaking;
+    }
+}
+//# sourceMappingURL=always_user_mute_strategy.js.map

package/dist/turns/user_mute/base_user_mute_strategy.d.ts

@@ -0,0 +1,39 @@
+/** Base strategy for deciding whether user frames should be muted. */
+import type { Frame } from "../../frames/frames.ts";
+import type { FrameProcessorSetup } from "../../processors/frame_processor.ts";
+import { BaseObject, type BaseObjectOptions } from "../../utils/base_object.ts";
+export interface BaseUserMuteStrategyOptions extends BaseObjectOptions {
+}
+/**
+ * Base class for strategies that decide whether user frames should be muted.
+ *
+ * A user mute strategy determines whether incoming user frames should be
+ * suppressed based on the *current system state*.
+ *
+ * Typical heuristics include:
+ * - The bot is currently speaking, so user should be muted
+ * - A function call or tool execution is in progress
+ * - The system is otherwise not ready to accept user input
+ *
+ * The strategy is evaluated per frame and returns a boolean indicating whether
+ * the user should be muted.
+ */
+export declare class BaseUserMuteStrategy extends BaseObject {
+    constructor(options?: BaseUserMuteStrategyOptions);
+    /**
+     * Set up the strategy.
+     *
+     * @param setup Configuration object containing setup parameters.
+     */
+    setup(setup: FrameProcessorSetup): Promise<void>;
+    /** Cleanup the strategy. */
+    cleanup(): Promise<void>;
+    /**
+     * Process an incoming frame.
+     *
+     * @param frame The frame to be processed.
+     * @returns Whether the strategy is muted.
+     */
+    processFrame(_frame: Frame): Promise<boolean>;
+}
+//# sourceMappingURL=base_user_mute_strategy.d.ts.map

package/dist/turns/user_mute/base_user_mute_strategy.js

@@ -0,0 +1,45 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/turns/user_mute/base_user_mute_strategy.py
+import { BaseObject } from "../../utils/base_object.js";
+/**
+ * Base class for strategies that decide whether user frames should be muted.
+ *
+ * A user mute strategy determines whether incoming user frames should be
+ * suppressed based on the *current system state*.
+ *
+ * Typical heuristics include:
+ * - The bot is currently speaking, so user should be muted
+ * - A function call or tool execution is in progress
+ * - The system is otherwise not ready to accept user input
+ *
+ * The strategy is evaluated per frame and returns a boolean indicating whether
+ * the user should be muted.
+ */
+export class BaseUserMuteStrategy extends BaseObject {
+    constructor(options = {}) {
+        super(options);
+    }
+    /**
+     * Set up the strategy.
+     *
+     * @param setup Configuration object containing setup parameters.
+     */
+    async setup(setup) {
+        await super.setup(setup.taskManager);
+    }
+    /** Cleanup the strategy. */
+    async cleanup() { }
+    /**
+     * Process an incoming frame.
+     *
+     * @param frame The frame to be processed.
+     * @returns Whether the strategy is muted.
+     */
+    async processFrame(_frame) {
+        return false;
+    }
+}
+//# sourceMappingURL=base_user_mute_strategy.js.map

package/dist/turns/user_mute/first_speech_user_mute_strategy.d.ts

@@ -0,0 +1,28 @@
+/** User mute strategy that mutes the user only during the bot’s first speech. */
+import { BotStartedSpeakingFrame, BotStoppedSpeakingFrame, type Frame } from "../../frames/frames.ts";
+import { BaseUserMuteStrategy } from "./base_user_mute_strategy.ts";
+/**
+ * User mute strategy that mutes the user only during the bot’s first speech.
+ *
+ * This strategy allows user input before the bot starts speaking. Once the bot
+ * begins its first speaking turn, user frames are muted until the bot finishes
+ * that speech. After the bot completes its first speaking turn, user input is
+ * no longer muted by this strategy.
+ *
+ * Use this strategy when early user input is acceptable, but interruptions
+ * during the bot’s initial response should be prevented.
+ */
+export declare class FirstSpeechUserMuteStrategy extends BaseUserMuteStrategy {
+    protected _botSpeaking: boolean;
+    protected _firstSpeechHandled: boolean;
+    /**
+     * Process an incoming frame.
+     *
+     * @param frame The frame to be processed.
+     * @returns Whether the strategy is muted.
+     */
+    processFrame(frame: Frame): Promise<boolean>;
+    protected _handleBotStartedSpeaking(_frame: BotStartedSpeakingFrame): Promise<void>;
+    protected _handleBotStoppedSpeaking(_frame: BotStoppedSpeakingFrame): Promise<void>;
+}
+//# sourceMappingURL=first_speech_user_mute_strategy.d.ts.map

package/dist/turns/user_mute/first_speech_user_mute_strategy.js

@@ -0,0 +1,52 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/turns/user_mute/first_speech_user_mute_strategy.py
+/** User mute strategy that mutes the user only during the bot’s first speech. */
+import { BotStartedSpeakingFrame, BotStoppedSpeakingFrame, } from "../../frames/frames.js";
+import { BaseUserMuteStrategy } from "./base_user_mute_strategy.js";
+/**
+ * User mute strategy that mutes the user only during the bot’s first speech.
+ *
+ * This strategy allows user input before the bot starts speaking. Once the bot
+ * begins its first speaking turn, user frames are muted until the bot finishes
+ * that speech. After the bot completes its first speaking turn, user input is
+ * no longer muted by this strategy.
+ *
+ * Use this strategy when early user input is acceptable, but interruptions
+ * during the bot’s initial response should be prevented.
+ */
+export class FirstSpeechUserMuteStrategy extends BaseUserMuteStrategy {
+    _botSpeaking = false;
+    _firstSpeechHandled = false;
+    /**
+     * 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) {
+            await this._handleBotStartedSpeaking(frame);
+        }
+        else if (frame instanceof BotStoppedSpeakingFrame) {
+            await this._handleBotStoppedSpeaking(frame);
+        }
+        if (this._botSpeaking && !this._firstSpeechHandled) {
+            return true;
+        }
+        return false;
+    }
+    async _handleBotStartedSpeaking(_frame) {
+        this._botSpeaking = true;
+    }
+    async _handleBotStoppedSpeaking(_frame) {
+        this._botSpeaking = false;
+        if (!this._firstSpeechHandled) {
+            this._firstSpeechHandled = true;
+        }
+    }
+}
+//# sourceMappingURL=first_speech_user_mute_strategy.js.map

package/dist/turns/user_mute/function_call_user_mute_strategy.d.ts

@@ -0,0 +1,25 @@
+/** User mute strategy that mutes the user while a function call is executing. */
+import { type Frame, FunctionCallsStartedFrame } from "../../frames/frames.ts";
+import { BaseUserMuteStrategy } from "./base_user_mute_strategy.ts";
+/**
+ * User mute strategy that mutes the user while a function call is executing.
+ *
+ * This strategy ensures that user input does not interfere with ongoing
+ * function execution. While a function call is active, all user frames are
+ * muted. Once the function call completes or is canceled, user input is
+ * allowed again.
+ */
+export declare class FunctionCallUserMuteStrategy extends BaseUserMuteStrategy {
+    protected _functionCallInProgress: Set<string>;
+    /** Initialize the function call user mute strategy. */
+    constructor();
+    /**
+     * Process an incoming frame.
+     *
+     * @param frame The frame to be processed.
+     * @returns Whether the strategy is muted.
+     */
+    processFrame(frame: Frame): Promise<boolean>;
+    protected _handleFunctionCallsStarted(frame: FunctionCallsStartedFrame): Promise<void>;
+}
+//# sourceMappingURL=function_call_user_mute_strategy.d.ts.map

package/dist/turns/user_mute/function_call_user_mute_strategy.js

@@ -0,0 +1,50 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/turns/user_mute/function_call_user_mute_strategy.py
+/** User mute strategy that mutes the user while a function call is executing. */
+import { FunctionCallCancelFrame, FunctionCallResultFrame, FunctionCallsStartedFrame, } from "../../frames/frames.js";
+import { BaseUserMuteStrategy } from "./base_user_mute_strategy.js";
+/**
+ * User mute strategy that mutes the user while a function call is executing.
+ *
+ * This strategy ensures that user input does not interfere with ongoing
+ * function execution. While a function call is active, all user frames are
+ * muted. Once the function call completes or is canceled, user input is
+ * allowed again.
+ */
+export class FunctionCallUserMuteStrategy extends BaseUserMuteStrategy {
+    _functionCallInProgress = new Set();
+    /** Initialize the function call 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 FunctionCallsStartedFrame) {
+            await this._handleFunctionCallsStarted(frame);
+        }
+        else if (frame instanceof FunctionCallCancelFrame ||
+            frame instanceof FunctionCallResultFrame) {
+            // Untracked ids reach here: a built-in cancel tool is excluded from
+            // FunctionCallsStartedFrame yet still emits a result, async tools
+            // emit a result frame per intermediate update, and a bus bridge can
+            // re-deliver a result another worker already handled.
+            this._functionCallInProgress.delete(frame.toolCallId);
+        }
+        return this._functionCallInProgress.size > 0;
+    }
+    async _handleFunctionCallsStarted(frame) {
+        for (const f of frame.functionCalls) {
+            this._functionCallInProgress.add(f.toolCallId);
+        }
+    }
+}
+//# sourceMappingURL=function_call_user_mute_strategy.js.map

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

@@ -0,0 +1,6 @@
+export { AlwaysUserMuteStrategy } from "./always_user_mute_strategy.ts";
+export { BaseUserMuteStrategy } from "./base_user_mute_strategy.ts";
+export { FirstSpeechUserMuteStrategy } from "./first_speech_user_mute_strategy.ts";
+export { FunctionCallUserMuteStrategy } from "./function_call_user_mute_strategy.ts";
+export { MuteUntilFirstBotCompleteUserMuteStrategy } from "./mute_until_first_bot_complete_user_mute_strategy.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/turns/user_mute/index.js

@@ -0,0 +1,11 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/turns/user_mute/__init__.py
+export { AlwaysUserMuteStrategy } from "./always_user_mute_strategy.js";
+export { BaseUserMuteStrategy } from "./base_user_mute_strategy.js";
+export { FirstSpeechUserMuteStrategy } from "./first_speech_user_mute_strategy.js";
+export { FunctionCallUserMuteStrategy } from "./function_call_user_mute_strategy.js";
+export { MuteUntilFirstBotCompleteUserMuteStrategy } from "./mute_until_first_bot_complete_user_mute_strategy.js";
+//# sourceMappingURL=index.js.map

package/dist/turns/user_mute/mute_until_first_bot_complete_user_mute_strategy.d.ts

@@ -0,0 +1,43 @@
+/** User mute strategy that mutes the user until the bot completes its first speech. */
+import { BotStoppedSpeakingFrame, ErrorFrame, type Frame } from "../../frames/frames.ts";
+import { BaseUserMuteStrategy } from "./base_user_mute_strategy.ts";
+/**
+ * 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 declare class MuteUntilFirstBotCompleteUserMuteStrategy extends BaseUserMuteStrategy {
+    protected _botStartedSpeaking: boolean;
+    protected _firstSpeechHandled: boolean;
+    /** Initialize the mute-until-first-bot-complete user mute strategy. */
+    constructor();
+    /**
+     * Process an incoming frame.
+     *
+     * @param frame The frame to be processed.
+     * @returns Whether the strategy is muted.
+     */
+    processFrame(frame: Frame): Promise<boolean>;
+    protected _handleBotStoppedSpeaking(_frame: BotStoppedSpeakingFrame): Promise<void>;
+    /**
+     * 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.
+     */
+    protected _handleError(frame: ErrorFrame): Promise<void>;
+}
+//# sourceMappingURL=mute_until_first_bot_complete_user_mute_strategy.d.ts.map