@pipedog/core 0.0.0 → 0.1.0

package/dist/turns/empty_user_turn.d.ts

@@ -0,0 +1,55 @@
+/** Configuration for recovering from user turns that end without a transcript. */
+export declare const DEFAULT_EMPTY_USER_TURN_INTERRUPTED_PROMPT: string;
+export interface EmptyUserTurnConfigOptions {
+    /**
+     * Developer message for an empty turn that interrupted the bot. `null`
+     * leaves such turns unanswered.
+     */
+    interruptedPrompt?: string | null;
+    /**
+     * Developer message for an empty turn while the bot was idle. `null` (the
+     * default) leaves such turns unanswered.
+     */
+    idlePrompt?: string | null;
+    /**
+     * How many empty turns in a row are answered. Further ones are left
+     * unanswered until the user says something that is transcribed.
+     */
+    maxConsecutiveRecoveries?: number;
+}
+/**
+ * How the user aggregator responds to a user turn with no transcript.
+ *
+ * A user turn can start on voice activity alone and then end with no
+ * transcript: a cough, background noise, or speech the STT could not
+ * recognize. Nothing is written to the context and the LLM does not run.
+ * With this config, the aggregator can append a developer message for such
+ * a turn and run the LLM once.
+ *
+ * Either case may be noise. They differ in what happens if the turn goes
+ * unanswered, so each has its own prompt:
+ *
+ * - Interrupted: the turn started while the bot was thinking, speaking or
+ *   running a function call, and cut it off. Unanswered, the bot stays
+ *   silent mid-response, so by default the LLM runs and the bot asks the
+ *   user to repeat or picks up where it left off. A turn before the bot has
+ *   first finished speaking counts as interrupted too.
+ * - Idle: the bot had finished and was waiting for the user. The
+ *   conversation isn't stuck, and answering what may be noise would be
+ *   intrusive, so by default the turn gets no answer.
+ *
+ * - `interruptedPrompt`: Developer message for an empty turn that interrupted
+ *   the bot. `null` leaves such turns unanswered.
+ * - `idlePrompt`: Developer message for an empty turn while the bot was idle.
+ *   `null` (the default) leaves such turns unanswered.
+ * - `maxConsecutiveRecoveries`: How many empty turns in a row are answered.
+ *   Further ones are left unanswered until the user says something that is
+ *   transcribed.
+ */
+export declare class EmptyUserTurnConfig {
+    interruptedPrompt: string | null;
+    idlePrompt: string | null;
+    maxConsecutiveRecoveries: number;
+    constructor(options?: EmptyUserTurnConfigOptions);
+}
+//# sourceMappingURL=empty_user_turn.d.ts.map

package/dist/turns/empty_user_turn.js

@@ -0,0 +1,53 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/turns/empty_user_turn.py
+/** Configuration for recovering from user turns that end without a transcript. */
+export const DEFAULT_EMPTY_USER_TURN_INTERRUPTED_PROMPT = "The user may have said something while you were responding, but it was not " +
+    "recognized. Your response was cut off there, and the conversation only includes " +
+    "the part they heard, which may be none of it. Briefly ask them to repeat what they said, and " +
+    "repeat any question of yours they may have missed.";
+/**
+ * How the user aggregator responds to a user turn with no transcript.
+ *
+ * A user turn can start on voice activity alone and then end with no
+ * transcript: a cough, background noise, or speech the STT could not
+ * recognize. Nothing is written to the context and the LLM does not run.
+ * With this config, the aggregator can append a developer message for such
+ * a turn and run the LLM once.
+ *
+ * Either case may be noise. They differ in what happens if the turn goes
+ * unanswered, so each has its own prompt:
+ *
+ * - Interrupted: the turn started while the bot was thinking, speaking or
+ *   running a function call, and cut it off. Unanswered, the bot stays
+ *   silent mid-response, so by default the LLM runs and the bot asks the
+ *   user to repeat or picks up where it left off. A turn before the bot has
+ *   first finished speaking counts as interrupted too.
+ * - Idle: the bot had finished and was waiting for the user. The
+ *   conversation isn't stuck, and answering what may be noise would be
+ *   intrusive, so by default the turn gets no answer.
+ *
+ * - `interruptedPrompt`: Developer message for an empty turn that interrupted
+ *   the bot. `null` leaves such turns unanswered.
+ * - `idlePrompt`: Developer message for an empty turn while the bot was idle.
+ *   `null` (the default) leaves such turns unanswered.
+ * - `maxConsecutiveRecoveries`: How many empty turns in a row are answered.
+ *   Further ones are left unanswered until the user says something that is
+ *   transcribed.
+ */
+export class EmptyUserTurnConfig {
+    interruptedPrompt;
+    idlePrompt;
+    maxConsecutiveRecoveries;
+    constructor(options = {}) {
+        this.interruptedPrompt =
+            options.interruptedPrompt === undefined
+                ? DEFAULT_EMPTY_USER_TURN_INTERRUPTED_PROMPT
+                : options.interruptedPrompt;
+        this.idlePrompt = options.idlePrompt ?? null;
+        this.maxConsecutiveRecoveries = options.maxConsecutiveRecoveries ?? 1;
+    }
+}
+//# sourceMappingURL=empty_user_turn.js.map

package/dist/turns/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/turns/index.js

@@ -0,0 +1,8 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/turns/__init__.py
+// Upstream's `__init__.py` is empty: import the package's modules directly.
+export {};
+//# sourceMappingURL=index.js.map

package/dist/turns/speculation_gate.d.ts

@@ -0,0 +1,169 @@
+/** Decision engine holding a speculative bot response until its turn is confirmed. */
+import { type Frame } from "../frames/frames.ts";
+import { FrameDirection } from "../processors/frame_processor.ts";
+import { FrameQueue } from "../utils/frame_queue.ts";
+/** A frame paired with the direction it travels in. */
+export type GatedFrame = [Frame, FrameDirection];
+/**
+ * What the gate is doing with the frames passing through it.
+ *
+ * - `OPEN`: emitting everything.
+ * - `HOLDING`: holding a speculative response until it is confirmed.
+ * - `DROPPING`: discarding the rest of a withdrawn speculative response.
+ */
+export declare const SpeculationState: {
+    readonly OPEN: "open";
+    readonly HOLDING: "holding";
+    readonly DROPPING: "dropping";
+};
+export type SpeculationState = (typeof SpeculationState)[keyof typeof SpeculationState];
+export interface SpeculationGateOptions {
+    /** Label used in log messages, typically the owning service's. */
+    name?: string;
+}
+/**
+ * Decides which frames of a speculative bot response may be emitted, and when.
+ *
+ * A speculative response is generated from an eager end of turn — a
+ * provisional guess that the user has finished talking — so it may answer a
+ * transcript the user never actually completed. This holds everything such a
+ * response produces until the turn is confirmed, then releases it, or discards
+ * it if the guess is withdrawn.
+ *
+ * A host calls `beginSpeculation` when it starts an inference for a turn that
+ * may not have ended, and the response that follows is held from its
+ * LLMFullResponseStartFrame onward. A UserStoppedSpeakingFrame releases it —
+ * the turn it answers has ended — and an EagerEndOfTurnCancelFrame discards
+ * it. Neither names a response: only one speculation is ever in flight, since
+ * producing one takes a whole user turn.
+ *
+ * Whether an inference is still answering an unconfirmed turn is therefore the
+ * gate's to answer, through `isSpeculating`, rather than something a host
+ * tracks alongside it. A host that kept its own copy would have to clear it on
+ * every path that settles a speculation, and the two would disagree on the
+ * paths it missed.
+ *
+ * The gate also tracks whether the turn has ended, because a confirmation can
+ * arrive before the inference it confirms — Pipecat dispatches system frames
+ * ahead of the queued frames they pass — and a response for a turn already
+ * over is not held at all.
+ *
+ * Both of those resolving frames reach the gate ahead of anything queued
+ * behind them, which is what keeps a withdrawal in front of the turn end that
+ * follows it. A withdrawal arriving second would find the response already
+ * released.
+ *
+ * While holding, everything is held in arrival order except system frames,
+ * which are out-of-band throughout Pipecat — and which carry the verdicts the
+ * gate is waiting for, so holding them would deadlock it. That includes
+ * uninterruptible frames (`Frame.interruptible` false), which are ordered like
+ * any other frame; discarding a speculation keeps them and emits them on,
+ * since they can belong to work started before it.
+ *
+ * This decides rather than processes frames: `process` is synchronous and
+ * returns the frames its caller should push, in order. A host can therefore
+ * push from several tasks at once — every state transition completes without
+ * an await for another task to interleave with. LLMService hosts one, gating
+ * every response it produces.
+ *
+ * Holding is unbounded here. Whoever started the speculation bounds it and
+ * withdraws it if it goes unresolved — see EagerUserTurnStopStrategy — so
+ * every way a speculation ends reaches this gate as a frame, and the gate
+ * never has to abandon one on its own.
+ *
+ * @example
+ * for (const [frame, direction] of gate.process(frame, direction)) {
+ *   await this.pushFrame(frame, direction);
+ * }
+ */
+export declare class SpeculationGate {
+    protected _name: string;
+    protected _state: SpeculationState;
+    protected _speculating: boolean;
+    protected _turnEnded: boolean;
+    protected _buffer: FrameQueue<GatedFrame>;
+    /**
+     * Initialize the speculation gate.
+     *
+     * @param options.name Label used in log messages, typically the owning service's.
+     */
+    constructor(options?: SpeculationGateOptions);
+    toString(): string;
+    /** What the gate is currently doing with frames passing through it. */
+    get state(): SpeculationState;
+    /**
+     * Whether the inference in flight answers an unconfirmed turn.
+     *
+     * Set from `beginSpeculation` until the turn settles it, so it covers the
+     * whole inference rather than only the stretch with frames in flight. False
+     * means whatever is generating now answers a turn that has ended, and its
+     * side effects can be let through. Use `state` to ask the narrower question
+     * of whether frames are being held right now.
+     */
+    get isSpeculating(): boolean;
+    /**
+     * Take note of an inference whose turn may not have ended.
+     *
+     * Called when the inference starts rather than when its first response
+     * frame arrives, so a turn confirmed in between is already accounted for by
+     * the time the response shows up.
+     *
+     * @param speculation Whether the inference answers a turn that may still be
+     *   open, rather than an ordinary one against a turn that has ended.
+     */
+    beginSpeculation(speculation: boolean): void;
+    /**
+     * Decide what a frame passing through the gate releases.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction the frame travels in.
+     * @returns The frames to push, in order. Empty while a frame is held or
+     *   dropped; longer than one frame when a verdict releases what was held
+     *   behind it.
+     */
+    process(frame: Frame, direction: FrameDirection): GatedFrame[];
+    /**
+     * Leave the hold.
+     *
+     * The single exit from `HOLDING`. Whether the speculation itself is over is
+     * a separate question — a response superseded by a new one ends its hold
+     * while the inference that replaced it is still pending.
+     *
+     * @param state What the gate does with the frames that follow.
+     */
+    protected _endHold(state: SpeculationState): void;
+    /** Decide what to do with the response opening here. */
+    protected _begin(): GatedFrame[];
+    /**
+     * Release whatever the turn ending confirms.
+     *
+     * @returns The frames the confirmation releases, in arrival order.
+     */
+    protected _release(): GatedFrame[];
+    /**
+     * Discard the response a withdrawal or an interruption voids.
+     *
+     * A withdrawal that arrives before the response it voids needs no memory:
+     * the response is held on arrival, and whatever answers the turn instead
+     * supersedes it — or the bound on the hold runs out if nothing does.
+     *
+     * @returns Whatever the discarded response was holding back that has to be
+     *   delivered anyway.
+     */
+    protected _discard(): GatedFrame[];
+    /**
+     * Drop the held response.
+     *
+     * @param reason Why it is being dropped, for the log line.
+     * @param options.keepDropping Whether the rest of the response may still be
+     *   queued behind us and has to be dropped as it arrives. False when
+     *   something already past it proves there is no tail left.
+     * @returns The held frames that must be delivered anyway, in arrival order.
+     */
+    protected _dropHeld(reason: string, options: {
+        keepDropping: boolean;
+    }): GatedFrame[];
+    /** Take everything the buffer still holds, in the order it arrived. */
+    protected _flush(): GatedFrame[];
+}
+//# sourceMappingURL=speculation_gate.d.ts.map

package/dist/turns/speculation_gate.js

@@ -0,0 +1,294 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/turns/speculation_gate.py
+/** Decision engine holding a speculative bot response until its turn is confirmed. */
+import { EagerEndOfTurnCancelFrame, EndFrame, InterruptionFrame, LLMFullResponseEndFrame, LLMFullResponseStartFrame, SystemFrame, UserStartedSpeakingFrame, UserStoppedSpeakingFrame, } from "../frames/frames.js";
+import { FrameDirection } from "../processors/frame_processor.js";
+import { FrameQueue } from "../utils/frame_queue.js";
+import { logger } from "../utils/logger.js";
+/**
+ * What the gate is doing with the frames passing through it.
+ *
+ * - `OPEN`: emitting everything.
+ * - `HOLDING`: holding a speculative response until it is confirmed.
+ * - `DROPPING`: discarding the rest of a withdrawn speculative response.
+ */
+export const SpeculationState = {
+    OPEN: "open",
+    HOLDING: "holding",
+    DROPPING: "dropping",
+};
+/**
+ * Decides which frames of a speculative bot response may be emitted, and when.
+ *
+ * A speculative response is generated from an eager end of turn — a
+ * provisional guess that the user has finished talking — so it may answer a
+ * transcript the user never actually completed. This holds everything such a
+ * response produces until the turn is confirmed, then releases it, or discards
+ * it if the guess is withdrawn.
+ *
+ * A host calls `beginSpeculation` when it starts an inference for a turn that
+ * may not have ended, and the response that follows is held from its
+ * LLMFullResponseStartFrame onward. A UserStoppedSpeakingFrame releases it —
+ * the turn it answers has ended — and an EagerEndOfTurnCancelFrame discards
+ * it. Neither names a response: only one speculation is ever in flight, since
+ * producing one takes a whole user turn.
+ *
+ * Whether an inference is still answering an unconfirmed turn is therefore the
+ * gate's to answer, through `isSpeculating`, rather than something a host
+ * tracks alongside it. A host that kept its own copy would have to clear it on
+ * every path that settles a speculation, and the two would disagree on the
+ * paths it missed.
+ *
+ * The gate also tracks whether the turn has ended, because a confirmation can
+ * arrive before the inference it confirms — Pipecat dispatches system frames
+ * ahead of the queued frames they pass — and a response for a turn already
+ * over is not held at all.
+ *
+ * Both of those resolving frames reach the gate ahead of anything queued
+ * behind them, which is what keeps a withdrawal in front of the turn end that
+ * follows it. A withdrawal arriving second would find the response already
+ * released.
+ *
+ * While holding, everything is held in arrival order except system frames,
+ * which are out-of-band throughout Pipecat — and which carry the verdicts the
+ * gate is waiting for, so holding them would deadlock it. That includes
+ * uninterruptible frames (`Frame.interruptible` false), which are ordered like
+ * any other frame; discarding a speculation keeps them and emits them on,
+ * since they can belong to work started before it.
+ *
+ * This decides rather than processes frames: `process` is synchronous and
+ * returns the frames its caller should push, in order. A host can therefore
+ * push from several tasks at once — every state transition completes without
+ * an await for another task to interleave with. LLMService hosts one, gating
+ * every response it produces.
+ *
+ * Holding is unbounded here. Whoever started the speculation bounds it and
+ * withdraws it if it goes unresolved — see EagerUserTurnStopStrategy — so
+ * every way a speculation ends reaches this gate as a frame, and the gate
+ * never has to abandon one on its own.
+ *
+ * @example
+ * for (const [frame, direction] of gate.process(frame, direction)) {
+ *   await this.pushFrame(frame, direction);
+ * }
+ */
+export class SpeculationGate {
+    _name;
+    _state = SpeculationState.OPEN;
+    // Whether the inference in flight answers a turn that has not been
+    // confirmed. Set when the inference starts, cleared when the turn settles it
+    // either way — so it outlives any one response frame.
+    _speculating = false;
+    // Whether the turn ended since it was last seen to start. A speculation
+    // registered while this is set answers a turn that is already over, so it is
+    // not held. Starts false, so a gate that never sees turn frames holds rather
+    // than speaks — the strategy's bound then recovers it.
+    _turnEnded = false;
+    _buffer = new FrameQueue((item) => item[0]);
+    /**
+     * Initialize the speculation gate.
+     *
+     * @param options.name Label used in log messages, typically the owning service's.
+     */
+    constructor(options = {}) {
+        this._name = options.name ?? "SpeculationGate";
+    }
+    toString() {
+        return this._name;
+    }
+    /** What the gate is currently doing with frames passing through it. */
+    get state() {
+        return this._state;
+    }
+    /**
+     * Whether the inference in flight answers an unconfirmed turn.
+     *
+     * Set from `beginSpeculation` until the turn settles it, so it covers the
+     * whole inference rather than only the stretch with frames in flight. False
+     * means whatever is generating now answers a turn that has ended, and its
+     * side effects can be let through. Use `state` to ask the narrower question
+     * of whether frames are being held right now.
+     */
+    get isSpeculating() {
+        return this._speculating;
+    }
+    /**
+     * Take note of an inference whose turn may not have ended.
+     *
+     * Called when the inference starts rather than when its first response
+     * frame arrives, so a turn confirmed in between is already accounted for by
+     * the time the response shows up.
+     *
+     * @param speculation Whether the inference answers a turn that may still be
+     *   open, rather than an ordinary one against a turn that has ended.
+     */
+    beginSpeculation(speculation) {
+        // A turn that ended before the inference reached us leaves nothing to
+        // hold for: the response answers a turn that is already over.
+        this._speculating = speculation && !this._turnEnded;
+    }
+    /**
+     * Decide what a frame passing through the gate releases.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction the frame travels in.
+     * @returns The frames to push, in order. Empty while a frame is held or
+     *   dropped; longer than one frame when a verdict releases what was held
+     *   behind it.
+     */
+    process(frame, direction) {
+        if (direction !== FrameDirection.DOWNSTREAM) {
+            return [[frame, direction]];
+        }
+        if (frame instanceof SystemFrame) {
+            // Emitted before the verdict is applied, so a released response still
+            // follows the frame that ended the turn it answers.
+            let emitted = [[frame, direction]];
+            if (frame instanceof EagerEndOfTurnCancelFrame || frame instanceof InterruptionFrame) {
+                emitted = emitted.concat(this._discard());
+            }
+            else if (frame instanceof UserStoppedSpeakingFrame) {
+                emitted = emitted.concat(this._release());
+            }
+            else if (frame instanceof UserStartedSpeakingFrame) {
+                // A turn is open again, so an inference started from here on answers
+                // something that may not have ended.
+                this._turnEnded = false;
+            }
+            return emitted;
+        }
+        if (frame instanceof EndFrame) {
+            // Uninterruptible, and the runner awaits it: holding it hangs shutdown.
+            // Discarding first delivers whatever is held that has to outlive the
+            // speculation, ahead of it.
+            return [...this._discard(), [frame, direction]];
+        }
+        const emitted = [];
+        if (frame instanceof LLMFullResponseStartFrame) {
+            emitted.push(...this._begin());
+        }
+        if (this._state === SpeculationState.HOLDING) {
+            // Held in arrival order, uninterruptible frames included: they are
+            // ordered like any other, and the buffer preserves them when the
+            // speculation around them is discarded.
+            this._buffer.putNowait([frame, direction]);
+        }
+        else if (this._state === SpeculationState.DROPPING) {
+            if (!frame.interruptible) {
+                // Not part of the response being dropped, and nothing is being held
+                // back, so emitting it keeps it in order.
+                emitted.push([frame, direction]);
+            }
+            else if (frame instanceof LLMFullResponseEndFrame) {
+                this._state = SpeculationState.OPEN;
+            }
+        }
+        else {
+            emitted.push([frame, direction]);
+        }
+        return emitted;
+    }
+    /**
+     * Leave the hold.
+     *
+     * The single exit from `HOLDING`. Whether the speculation itself is over is
+     * a separate question — a response superseded by a new one ends its hold
+     * while the inference that replaced it is still pending.
+     *
+     * @param state What the gate does with the frames that follow.
+     */
+    _endHold(state) {
+        this._state = state;
+    }
+    /** Decide what to do with the response opening here. */
+    _begin() {
+        const emitted = [];
+        if (this._state !== SpeculationState.OPEN) {
+            // A new response supersedes the one we were holding or dropping. A
+            // withdrawn response may never send its end frame, since its generation
+            // was cancelled mid-flight, and an unconfirmed one is void once
+            // something else starts answering. Nothing of it can still be queued
+            // behind this frame, so there is no tail left to drop.
+            emitted.push(...this._dropHeld("superseded by a new response", { keepDropping: false }));
+        }
+        // Whether this response is speculative was settled when its inference
+        // started, so a turn confirmed since then already cleared it.
+        if (!this._speculating) {
+            return emitted;
+        }
+        this._state = SpeculationState.HOLDING;
+        return emitted;
+    }
+    /**
+     * Release whatever the turn ending confirms.
+     *
+     * @returns The frames the confirmation releases, in arrival order.
+     */
+    _release() {
+        // Remembered so an inference that arrives after this is not held: the turn
+        // it answers is already over, and nothing follows to release it.
+        this._turnEnded = true;
+        // Nothing this inference still produces is speculative either — including
+        // a tool call it has yet to reach.
+        this._speculating = false;
+        if (this._state !== SpeculationState.HOLDING) {
+            return [];
+        }
+        logger.debug(`${this}: releasing speculative response (${this._buffer.qsize()} frames)`);
+        this._endHold(SpeculationState.OPEN);
+        return this._flush();
+    }
+    /**
+     * Discard the response a withdrawal or an interruption voids.
+     *
+     * A withdrawal that arrives before the response it voids needs no memory:
+     * the response is held on arrival, and whatever answers the turn instead
+     * supersedes it — or the bound on the hold runs out if nothing does.
+     *
+     * @returns Whatever the discarded response was holding back that has to be
+     *   delivered anyway.
+     */
+    _discard() {
+        // The speculation is void, so nothing the inference still produces
+        // answers a turn worth holding for.
+        this._speculating = false;
+        return this._dropHeld("withdrawn", { keepDropping: true });
+    }
+    /**
+     * Drop the held response.
+     *
+     * @param reason Why it is being dropped, for the log line.
+     * @param options.keepDropping Whether the rest of the response may still be
+     *   queued behind us and has to be dropped as it arrives. False when
+     *   something already past it proves there is no tail left.
+     * @returns The held frames that must be delivered anyway, in arrival order.
+     */
+    _dropHeld(reason, options) {
+        if (this._state !== SpeculationState.HOLDING) {
+            this._state = SpeculationState.OPEN;
+            return [];
+        }
+        logger.debug(`${this}: discarding speculative response (${this._buffer.qsize()} frames, ${reason})`);
+        // A response that already ended has no tail left to drop.
+        const complete = this._buffer.hasFrame(LLMFullResponseEndFrame);
+        // Drops the speculative response and keeps anything that must always be
+        // delivered, which is then emitted rather than discarded with it.
+        this._buffer.reset();
+        this._endHold(options.keepDropping && !complete ? SpeculationState.DROPPING : SpeculationState.OPEN);
+        return this._flush();
+    }
+    /** Take everything the buffer still holds, in the order it arrived. */
+    _flush() {
+        const emitted = [];
+        while (!this._buffer.empty()) {
+            const [frame, direction] = this._buffer.getNowait();
+            this._buffer.taskDone();
+            emitted.push([frame, direction]);
+        }
+        return emitted;
+    }
+}
+//# sourceMappingURL=speculation_gate.js.map

package/dist/turns/types.d.ts

@@ -0,0 +1,33 @@
+/** Shared types for user turn strategy frame processing. */
+/**
+ * Result of processing a frame in a user turn strategy.
+ *
+ * Controls whether the strategy loop in the controller continues to the
+ * next strategy or stops early.
+ *
+ * - CONTINUE: Continue to the next strategy in the loop.
+ * - STOP: Stop evaluating further strategies for this frame.
+ */
+export declare const ProcessFrameResult: {
+    readonly CONTINUE: "continue";
+    readonly STOP: "stop";
+};
+export type ProcessFrameResult = (typeof ProcessFrameResult)[keyof typeof ProcessFrameResult];
+export interface UserTurnSpeculationOptions {
+    /** The user turn text the inference was run against. */
+    text: string;
+}
+/**
+ * A speculative inference a stop strategy has in flight.
+ *
+ * Produced from an eager end of turn: the turn is not over yet, so the
+ * inference runs against a provisional context and its response is held back
+ * until the turn is confirmed.
+ *
+ * - `text`: The user turn text the inference was run against.
+ */
+export declare class UserTurnSpeculation {
+    text: string;
+    constructor(options: UserTurnSpeculationOptions);
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/turns/types.js

@@ -0,0 +1,35 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/turns/types.py
+/** Shared types for user turn strategy frame processing. */
+/**
+ * Result of processing a frame in a user turn strategy.
+ *
+ * Controls whether the strategy loop in the controller continues to the
+ * next strategy or stops early.
+ *
+ * - CONTINUE: Continue to the next strategy in the loop.
+ * - STOP: Stop evaluating further strategies for this frame.
+ */
+export const ProcessFrameResult = {
+    CONTINUE: "continue",
+    STOP: "stop",
+};
+/**
+ * A speculative inference a stop strategy has in flight.
+ *
+ * Produced from an eager end of turn: the turn is not over yet, so the
+ * inference runs against a provisional context and its response is held back
+ * until the turn is confirmed.
+ *
+ * - `text`: The user turn text the inference was run against.
+ */
+export class UserTurnSpeculation {
+    text;
+    constructor(options) {
+        this.text = options.text;
+    }
+}
+//# sourceMappingURL=types.js.map