base_user_turn_start_strategy

Base turn start strategy for determining when the user starts speaking.

class pipecat.turns.user_start.base_user_turn_start_strategy.UserTurnStartedParams(enable_interruptions: bool, enable_user_speaking_frames: bool)

Bases: object

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.

Parameters:

enable_user_speaking_frames – Whether the user aggregator should emit frames indicating user speaking state (e.g., user started speaking) during the bot’s turn. This is typically enabled by default, but may be disabled when another component (such as an STT service) is already responsible for generating user speaking frames.

enable_interruptions: bool

enable_user_speaking_frames: bool

class pipecat.turns.user_start.base_user_turn_start_strategy.BaseUserTurnStartStrategy(*, enable_interruptions: bool = True, enable_user_speaking_frames: bool = True, **kwargs)

Bases: BaseObject

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.

__init__(*, enable_interruptions: bool = True, enable_user_speaking_frames: bool = True, **kwargs)

Initialize the base user turn start strategy.

Parameters:

• enable_interruptions – If True, the user aggregator will emit an interruption frame when the user turn starts.

• enable_user_speaking_frames – If True, the user aggregator will emit frames indicating when the user starts speaking, as well as interruption frames. This is enabled by default, but you may want to disable it if another component (e.g., an STT service) is already generating these frames.

• **kwargs – Additional keyword arguments.

property task_manager: BaseTaskManager

Returns the configured task manager.

async setup(task_manager: BaseTaskManager)

Initialize the strategy with the given task manager.

Parameters:

task_manager – The task manager to be associated with this instance.

async cleanup()

Cleanup the strategy.

async reset()

Reset the strategy to its initial state.

async process_frame(frame: Frame) → ProcessFrameResult | None

Process an incoming frame.

Subclasses should override this to implement logic that decides whether the user turn has started.

Parameters:

frame – The frame to be processed.

Returns:

A ProcessFrameResult indicating the outcome, or None (treated as CONTINUE for backward compatibility).

async push_frame(frame: Frame, direction: FrameDirection = FrameDirection.DOWNSTREAM)

Emit on_push_frame to push a frame using the user aggreagtor.

Parameters:

• frame – The frame to be pushed.

• direction – What direction the frame should be pushed to.

async broadcast_frame(frame_cls: type[Frame], **kwargs)

Emit on_broadcast_frame to broadcast a frame using the user aggreagtor.

Parameters:

• frame_cls – The class of the frame to be broadcasted.

• **kwargs – Keyword arguments to be passed to the frame’s constructor.

async trigger_user_turn_started()

Trigger the on_user_turn_started event.

async trigger_reset_aggregation()

Trigger the on_reset_aggregation event.