@pipedog/core 0.0.0 → 0.1.0

package/dist/transports/video_in_sampler.d.ts

@@ -0,0 +1,157 @@
+import type { UserImageRequestFrame } from "../frames/frames.ts";
+/**
+ * How early a frame may arrive and still count as due, at most half an
+ * interval. It covers jitter in the incoming stream, which is about the same at
+ * any framerate.
+ */
+export declare const JITTER_TOLERANCE_SECS = 0.05;
+/**
+ * The sampler framerate for a `captureParticipantVideo()` call's arguments.
+ *
+ * A sampler passes on only the frames that answer image requests at a
+ * framerate of `0`, which is how `onRequestOnly` is applied.
+ *
+ * Porting note: upstream warns that `framerate=0` is deprecated in favour of
+ * `on_request_only=True`; the deprecation warning is not ported (`method` is
+ * kept so callers have the same signature).
+ */
+export declare function _captureFramerate(framerate: number | null, onRequestOnly: boolean, _method: string): number | null;
+/**
+ * Decides which frames of one incoming video source a transport passes on.
+ *
+ * A user's camera or screen share sends frames at its own rate, often 15-30
+ * per second, while a bot usually wants fewer: a vision bot may want one a
+ * second, or only a frame when it asks for one. An input transport keeps one
+ * sampler per video source and calls `sample()` for every frame that arrives;
+ * the sampler says whether to pass that frame on or drop it.
+ *
+ * The framerate decides which frames are passed on:
+ *
+ * - `null`: every frame.
+ * - `0`: only frames that answer an image request.
+ * - `N > 0`: `N` frames per second, on the schedule described below.
+ *
+ * Whatever the framerate, an image request queued with `addRequest()` is
+ * answered by the next frame that arrives, which is passed on with the
+ * request.
+ *
+ * For `N > 0`, frames are due on a fixed schedule, one interval (`1 / N`
+ * seconds) apart:
+ *
+ * - **On schedule.** A frame is due once its scheduled time comes, or up to a
+ *   tolerance before it, since frames never arrive exactly on time. The next
+ *   frame is scheduled one interval after this frame's *scheduled* time, not
+ *   its arrival time, so the rate doesn't drift. A frame arriving late moves
+ *   the schedule to its arrival, so a stream slower than the framerate passes
+ *   every frame rather than falling further and further behind.
+ * - **Fresh start.** The first frame, a frame that answers a request, and the
+ *   first frame after a stall (more than an interval past its scheduled time)
+ *   start a new schedule from their arrival. After a stall this passes on one
+ *   frame instead of a burst catching up on the missed ones.
+ *
+ * The tolerance is the smaller of `JITTER_TOLERANCE_SECS` and half an
+ * interval. At low framerates the next frame after any frame is therefore
+ * close to a full interval later; at framerates near the stream's own rate it
+ * covers the stream's jitter, so every frame passes.
+ */
+export declare class _VideoInSampler {
+    protected _framerate: number | null;
+    protected _nextTime: number;
+    protected _requests: UserImageRequestFrame[];
+    /**
+     * Initialize the sampler.
+     *
+     * @param framerate Frames per second to pass on. `0` passes on frames only
+     *   to answer requests, and `null` passes on every frame.
+     */
+    constructor(framerate: number | null);
+    /** The frames per second this sampler passes on. */
+    get framerate(): number | null;
+    set framerate(framerate: number | null);
+    /**
+     * Queue an image request for the next frame to answer.
+     *
+     * @param request The image request to answer.
+     */
+    addRequest(request: UserImageRequestFrame): void;
+    /**
+     * Remove and return the image requests waiting for a frame.
+     *
+     * @returns The waiting requests, oldest first.
+     */
+    takeRequests(): UserImageRequestFrame[];
+    /**
+     * Decide whether to pass on the frame that just arrived.
+     *
+     * @returns A tuple of `[due, request]`: `due` is whether to pass the frame
+     *   on, and `request` is the `UserImageRequestFrame` it answers, or `null`.
+     */
+    sample(): [boolean, UserImageRequestFrame | null];
+}
+/** An input transport's video samplers, by participant and video source. */
+export declare class _VideoInSamplers {
+    #private;
+    protected _samplers: Map<string, [string, string, _VideoInSampler]>;
+    /**
+     * Start sampling a source, or change its framerate.
+     *
+     * Changing the framerate keeps the source's sampler, so image requests
+     * already waiting on it are still answered.
+     *
+     * @param participantId The participant whose video this is.
+     * @param videoSource The video source, e.g. `"camera"` or `"screenVideo"`.
+     * @param framerate Frames per second to pass on. `0` passes on frames only
+     *   to answer requests, and `null` passes on every frame.
+     */
+    capture(participantId: string, videoSource: string, framerate: number | null): void;
+    /**
+     * Whether a source is being sampled.
+     *
+     * @param participantId The participant whose video this is.
+     * @param videoSource The video source.
+     * @returns Whether `capture()` was called for the source.
+     */
+    isCapturing(participantId: string, videoSource: string): boolean;
+    /**
+     * Queue an image request for the next frame of a source to answer.
+     *
+     * @param participantId The participant whose video is requested.
+     * @param videoSource The video source requested.
+     * @param request The image request to answer.
+     * @returns Whether the request was queued; `false` if the source isn't being
+     *   sampled, so nothing would answer it.
+     */
+    addRequest(participantId: string, videoSource: string, request: UserImageRequestFrame): boolean;
+    /**
+     * Decide whether to pass on the frame that just arrived from a source.
+     *
+     * @param participantId The participant the frame came from.
+     * @param videoSource The video source the frame came from.
+     * @returns A tuple of `[due, request]`, as from `_VideoInSampler.sample()`.
+     *   A frame from a source that isn't being sampled is never due.
+     */
+    sample(participantId: string, videoSource: string): [boolean, UserImageRequestFrame | null];
+    /**
+     * Remove and return image requests waiting for a frame, keeping the samplers.
+     *
+     * @param participantId The participant whose requests to take.
+     * @param videoSource The video source whose requests to take, or `null` for
+     *   all of the participant's sources.
+     * @returns The waiting requests.
+     */
+    takeRequests(participantId: string, videoSource?: string | null): UserImageRequestFrame[];
+    /**
+     * Stop sampling every video source of a participant.
+     *
+     * @param participantId The participant to forget, e.g. one who left.
+     * @returns The image requests that were waiting on the participant's video.
+     */
+    removeParticipant(participantId: string): UserImageRequestFrame[];
+    /**
+     * Stop sampling every video source.
+     *
+     * @returns The image requests that were waiting on any of them.
+     */
+    clear(): UserImageRequestFrame[];
+}
+//# sourceMappingURL=video_in_sampler.d.ts.map

package/dist/transports/video_in_sampler.js

@@ -0,0 +1,258 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/transports/video_in_sampler.py
+var _a;
+/** Selection of the incoming video frames an input transport passes on. */
+import { time } from "@pipedog/asyncio";
+/**
+ * How early a frame may arrive and still count as due, at most half an
+ * interval. It covers jitter in the incoming stream, which is about the same at
+ * any framerate.
+ */
+export const JITTER_TOLERANCE_SECS = 0.05;
+/**
+ * The sampler framerate for a `captureParticipantVideo()` call's arguments.
+ *
+ * A sampler passes on only the frames that answer image requests at a
+ * framerate of `0`, which is how `onRequestOnly` is applied.
+ *
+ * Porting note: upstream warns that `framerate=0` is deprecated in favour of
+ * `on_request_only=True`; the deprecation warning is not ported (`method` is
+ * kept so callers have the same signature).
+ */
+export function _captureFramerate(framerate, onRequestOnly, _method) {
+    if (onRequestOnly)
+        return 0;
+    return framerate;
+}
+/**
+ * Decides which frames of one incoming video source a transport passes on.
+ *
+ * A user's camera or screen share sends frames at its own rate, often 15-30
+ * per second, while a bot usually wants fewer: a vision bot may want one a
+ * second, or only a frame when it asks for one. An input transport keeps one
+ * sampler per video source and calls `sample()` for every frame that arrives;
+ * the sampler says whether to pass that frame on or drop it.
+ *
+ * The framerate decides which frames are passed on:
+ *
+ * - `null`: every frame.
+ * - `0`: only frames that answer an image request.
+ * - `N > 0`: `N` frames per second, on the schedule described below.
+ *
+ * Whatever the framerate, an image request queued with `addRequest()` is
+ * answered by the next frame that arrives, which is passed on with the
+ * request.
+ *
+ * For `N > 0`, frames are due on a fixed schedule, one interval (`1 / N`
+ * seconds) apart:
+ *
+ * - **On schedule.** A frame is due once its scheduled time comes, or up to a
+ *   tolerance before it, since frames never arrive exactly on time. The next
+ *   frame is scheduled one interval after this frame's *scheduled* time, not
+ *   its arrival time, so the rate doesn't drift. A frame arriving late moves
+ *   the schedule to its arrival, so a stream slower than the framerate passes
+ *   every frame rather than falling further and further behind.
+ * - **Fresh start.** The first frame, a frame that answers a request, and the
+ *   first frame after a stall (more than an interval past its scheduled time)
+ *   start a new schedule from their arrival. After a stall this passes on one
+ *   frame instead of a burst catching up on the missed ones.
+ *
+ * The tolerance is the smaller of `JITTER_TOLERANCE_SECS` and half an
+ * interval. At low framerates the next frame after any frame is therefore
+ * close to a full interval later; at framerates near the stream's own rate it
+ * covers the stream's jitter, so every frame passes.
+ */
+export class _VideoInSampler {
+    _framerate;
+    // When the next frame is due. Zero before the first frame, which then
+    // counts as arriving after a stall and starts the schedule.
+    _nextTime = 0.0;
+    _requests = [];
+    /**
+     * Initialize the sampler.
+     *
+     * @param framerate Frames per second to pass on. `0` passes on frames only
+     *   to answer requests, and `null` passes on every frame.
+     */
+    constructor(framerate) {
+        this._framerate = framerate;
+    }
+    /** The frames per second this sampler passes on. */
+    get framerate() {
+        return this._framerate;
+    }
+    set framerate(framerate) {
+        this._framerate = framerate;
+    }
+    /**
+     * Queue an image request for the next frame to answer.
+     *
+     * @param request The image request to answer.
+     */
+    addRequest(request) {
+        this._requests.push(request);
+    }
+    /**
+     * Remove and return the image requests waiting for a frame.
+     *
+     * @returns The waiting requests, oldest first.
+     */
+    takeRequests() {
+        const requests = this._requests;
+        this._requests = [];
+        return requests;
+    }
+    /**
+     * Decide whether to pass on the frame that just arrived.
+     *
+     * @returns A tuple of `[due, request]`: `due` is whether to pass the frame
+     *   on, and `request` is the `UserImageRequestFrame` it answers, or `null`.
+     */
+    sample() {
+        // A waiting request is always answered by this frame.
+        const request = this._requests.length > 0 ? (this._requests.shift() ?? null) : null;
+        if (this._framerate === null)
+            return [true, request];
+        if (this._framerate === 0)
+            return [request !== null, request];
+        const now = time();
+        const interval = 1 / this._framerate;
+        const tolerance = Math.min(JITTER_TOLERANCE_SECS, interval / 2);
+        if (request === null && now < this._nextTime - tolerance) {
+            // Too early: the next frame isn't due yet.
+            return [false, null];
+        }
+        if (request || now - this._nextTime > interval) {
+            // Fresh start (a request, the first frame, or a stall): the next frame
+            // is due one interval from now.
+            this._nextTime = now + interval;
+        }
+        else {
+            // On schedule: one interval after this frame's scheduled time, or after
+            // its arrival if it came late.
+            this._nextTime = Math.max(this._nextTime, now - tolerance) + interval;
+        }
+        return [true, request];
+    }
+}
+/** An input transport's video samplers, by participant and video source. */
+export class _VideoInSamplers {
+    // Python keys a dict by the (participant_id, video_source) tuple. A Map keeps
+    // the same insertion order; the entry carries both parts of the key.
+    _samplers = new Map();
+    static #key(participantId, videoSource) {
+        return JSON.stringify([participantId, videoSource]);
+    }
+    #get(participantId, videoSource) {
+        return this._samplers.get(_a.#key(participantId, videoSource))?.[2];
+    }
+    /**
+     * Start sampling a source, or change its framerate.
+     *
+     * Changing the framerate keeps the source's sampler, so image requests
+     * already waiting on it are still answered.
+     *
+     * @param participantId The participant whose video this is.
+     * @param videoSource The video source, e.g. `"camera"` or `"screenVideo"`.
+     * @param framerate Frames per second to pass on. `0` passes on frames only
+     *   to answer requests, and `null` passes on every frame.
+     */
+    capture(participantId, videoSource, framerate) {
+        const sampler = this.#get(participantId, videoSource);
+        if (sampler) {
+            sampler.framerate = framerate;
+        }
+        else {
+            this._samplers.set(_a.#key(participantId, videoSource), [
+                participantId,
+                videoSource,
+                new _VideoInSampler(framerate),
+            ]);
+        }
+    }
+    /**
+     * Whether a source is being sampled.
+     *
+     * @param participantId The participant whose video this is.
+     * @param videoSource The video source.
+     * @returns Whether `capture()` was called for the source.
+     */
+    isCapturing(participantId, videoSource) {
+        return this._samplers.has(_a.#key(participantId, videoSource));
+    }
+    /**
+     * Queue an image request for the next frame of a source to answer.
+     *
+     * @param participantId The participant whose video is requested.
+     * @param videoSource The video source requested.
+     * @param request The image request to answer.
+     * @returns Whether the request was queued; `false` if the source isn't being
+     *   sampled, so nothing would answer it.
+     */
+    addRequest(participantId, videoSource, request) {
+        const sampler = this.#get(participantId, videoSource);
+        if (sampler)
+            sampler.addRequest(request);
+        return sampler !== undefined;
+    }
+    /**
+     * Decide whether to pass on the frame that just arrived from a source.
+     *
+     * @param participantId The participant the frame came from.
+     * @param videoSource The video source the frame came from.
+     * @returns A tuple of `[due, request]`, as from `_VideoInSampler.sample()`.
+     *   A frame from a source that isn't being sampled is never due.
+     */
+    sample(participantId, videoSource) {
+        const sampler = this.#get(participantId, videoSource);
+        return sampler ? sampler.sample() : [false, null];
+    }
+    /**
+     * Remove and return image requests waiting for a frame, keeping the samplers.
+     *
+     * @param participantId The participant whose requests to take.
+     * @param videoSource The video source whose requests to take, or `null` for
+     *   all of the participant's sources.
+     * @returns The waiting requests.
+     */
+    takeRequests(participantId, videoSource = null) {
+        const requests = [];
+        for (const [participant, source, sampler] of this._samplers.values()) {
+            if (participant === participantId && (videoSource === null || videoSource === source)) {
+                requests.push(...sampler.takeRequests());
+            }
+        }
+        return requests;
+    }
+    /**
+     * Stop sampling every video source of a participant.
+     *
+     * @param participantId The participant to forget, e.g. one who left.
+     * @returns The image requests that were waiting on the participant's video.
+     */
+    removeParticipant(participantId) {
+        const requests = this.takeRequests(participantId);
+        for (const [key, [participant]] of [...this._samplers]) {
+            if (participant === participantId)
+                this._samplers.delete(key);
+        }
+        return requests;
+    }
+    /**
+     * Stop sampling every video source.
+     *
+     * @returns The image requests that were waiting on any of them.
+     */
+    clear() {
+        const requests = [];
+        for (const [, , sampler] of this._samplers.values())
+            requests.push(...sampler.takeRequests());
+        this._samplers.clear();
+        return requests;
+    }
+}
+_a = _VideoInSamplers;
+//# sourceMappingURL=video_in_sampler.js.map

package/dist/transports/vonage/index.d.ts

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

package/dist/transports/vonage/index.js

@@ -0,0 +1,9 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/transports/vonage/__init__.py
+// Upstream's __init__.py is empty: it only marks the package. The provider
+// modules themselves live in their own packages (see porting/manifest.json).
+export {};
+//# sourceMappingURL=index.js.map

package/dist/transports/websocket/index.d.ts

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

package/dist/transports/websocket/index.js

@@ -0,0 +1,9 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/transports/websocket/__init__.py
+// Upstream's __init__.py is empty: it only marks the package. The provider
+// modules themselves live in their own packages (see porting/manifest.json).
+export {};
+//# sourceMappingURL=index.js.map

package/dist/transports/whatsapp/index.d.ts

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

package/dist/transports/whatsapp/index.js

@@ -0,0 +1,9 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/transports/whatsapp/__init__.py
+// Upstream's __init__.py is empty: it only marks the package. The provider
+// modules themselves live in their own packages (see porting/manifest.json).
+export {};
+//# sourceMappingURL=index.js.map

package/dist/turns/eager_end_of_turn_mixin.d.ts

@@ -0,0 +1,70 @@
+import type { Language } from "../transcriptions/language.ts";
+import { type Ctor } from "../utils/mixin.ts";
+import type { EagerMatchPolicy } from "./user_stop/index.ts";
+import { type UserTurnStrategies } from "./user_turn_strategies.ts";
+/** Options read by EagerEndOfTurnSTTServiceMixin from the constructor options. */
+export interface EagerEndOfTurnSTTServiceMixinOptions {
+    /**
+     * Whether to answer a predicted end of turn ahead of the committed one.
+     * Off by default: it spends an inference on every prediction, including the
+     * ones the service withdraws.
+     */
+    enableEagerEndOfTurn?: boolean;
+    /**
+     * Decides whether the committed transcript is close enough to the predicted
+     * one to keep the speculative response. Only consulted while eager end of
+     * turn is on. See EagerUserTurnStrategies.
+     */
+    eagerMatchPolicy?: EagerMatchPolicy | null;
+}
+/** Members added by EagerEndOfTurnSTTServiceMixin. */
+export interface EagerEndOfTurnSTTServiceMixin {
+    _enableEagerEndOfTurn: boolean;
+    _eagerMatchPolicy: EagerMatchPolicy | null;
+    _eagerEndOfTurnPending: boolean;
+    /** Whether predicted ends of turn are answered ahead of committed ones. */
+    readonly eagerEndOfTurnEnabled: boolean;
+    /** Whether a prediction is awaiting a committed end of turn. */
+    readonly eagerEndOfTurnPending: boolean;
+    recommendedUserTurnStrategies(options: {
+        enableInterruptions: boolean;
+    }): UserTurnStrategies;
+    _pushEagerEndOfTurn(transcript: string, options: {
+        userId: string;
+        language?: Language | null;
+        result?: unknown;
+    }): Promise<void>;
+    _cancelEagerEndOfTurn(): Promise<void>;
+    _clearEagerEndOfTurn(): void;
+}
+/**
+ * Adds eager end-of-turn signalling to an STT service that predicts one.
+ *
+ * Some services report that a turn has probably ended before committing to it,
+ * and withdraw the prediction if the user turns out to be mid-sentence. A
+ * response can be generated during that gap — see EagerUserTurnStopStrategy,
+ * which acts on the frames pushed here. At most one prediction is outstanding
+ * at a time, so the frames need not name which one they mean.
+ *
+ * A service drives the prediction through its own three lifecycle points:
+ *
+ * @example
+ * // the service predicts the turn has ended
+ * await this._pushEagerEndOfTurn(transcript, { userId: ..., language: ... });
+ *
+ * // the user resumed speaking, so the prediction is void
+ * await this._cancelEagerEndOfTurn();
+ *
+ * // the turn was committed, so the prediction is resolved
+ * this._clearEagerEndOfTurn();
+ *
+ * All three are safe to call when no prediction is outstanding, and all three
+ * are inert while `enableEagerEndOfTurn` is off, so a service can call them
+ * wherever its protocol reports a prediction without guarding each one.
+ *
+ * The base must be a FrameProcessor (upstream's mixin subclasses it).
+ * Upstream: `class XSTTService(EagerEndOfTurnSTTServiceMixin, STTService)`
+ * → `class XSTTService extends EagerEndOfTurnSTTServiceMixin(STTService)`.
+ */
+export declare const EagerEndOfTurnSTTServiceMixin: import("../utils/mixin.ts").Mixin<<B extends Ctor>(base: B) => B & Ctor<EagerEndOfTurnSTTServiceMixin>, EagerEndOfTurnSTTServiceMixin>;
+//# sourceMappingURL=eager_end_of_turn_mixin.d.ts.map

package/dist/turns/eager_end_of_turn_mixin.js

@@ -0,0 +1,122 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/turns/eager_end_of_turn_mixin.py
+/** Mixin for STT services that predict the end of a turn before committing to it. */
+import { EagerEndOfTurnCancelFrame, EagerTranscriptionFrame } from "../frames/frames.js";
+import { logger } from "../utils/logger.js";
+import { defineMixin } from "../utils/mixin.js";
+import { timeNowIso8601 } from "../utils/time.js";
+import { EagerUserTurnStrategies, ExternalUserTurnStrategies, } from "./user_turn_strategies.js";
+/**
+ * Adds eager end-of-turn signalling to an STT service that predicts one.
+ *
+ * Some services report that a turn has probably ended before committing to it,
+ * and withdraw the prediction if the user turns out to be mid-sentence. A
+ * response can be generated during that gap — see EagerUserTurnStopStrategy,
+ * which acts on the frames pushed here. At most one prediction is outstanding
+ * at a time, so the frames need not name which one they mean.
+ *
+ * A service drives the prediction through its own three lifecycle points:
+ *
+ * @example
+ * // the service predicts the turn has ended
+ * await this._pushEagerEndOfTurn(transcript, { userId: ..., language: ... });
+ *
+ * // the user resumed speaking, so the prediction is void
+ * await this._cancelEagerEndOfTurn();
+ *
+ * // the turn was committed, so the prediction is resolved
+ * this._clearEagerEndOfTurn();
+ *
+ * All three are safe to call when no prediction is outstanding, and all three
+ * are inert while `enableEagerEndOfTurn` is off, so a service can call them
+ * wherever its protocol reports a prediction without guarding each one.
+ *
+ * The base must be a FrameProcessor (upstream's mixin subclasses it).
+ * Upstream: `class XSTTService(EagerEndOfTurnSTTServiceMixin, STTService)`
+ * → `class XSTTService extends EagerEndOfTurnSTTServiceMixin(STTService)`.
+ */
+export const EagerEndOfTurnSTTServiceMixin = defineMixin("EagerEndOfTurnSTTServiceMixin", (Base) => {
+    const FrameProcessorBase = Base;
+    class EagerEndOfTurnSTTServiceMixinImpl extends FrameProcessorBase {
+        _enableEagerEndOfTurn;
+        _eagerMatchPolicy;
+        _eagerEndOfTurnPending = false;
+        constructor(...args) {
+            super(...args);
+            const options = (args[0] ?? {});
+            this._enableEagerEndOfTurn = options.enableEagerEndOfTurn ?? false;
+            this._eagerMatchPolicy = options.eagerMatchPolicy ?? null;
+        }
+        get eagerEndOfTurnEnabled() {
+            return this._enableEagerEndOfTurn;
+        }
+        get eagerEndOfTurnPending() {
+            return this._eagerEndOfTurnPending;
+        }
+        /**
+         * Build the turn strategies this service recommends.
+         *
+         * Both recommendations leave turn detection to the service. The eager one
+         * additionally answers a predicted end of turn, which only makes sense for
+         * a service configured to report one.
+         *
+         * @param options.enableInterruptions Whether a proposal starting a turn
+         *   should interrupt the bot.
+         * @returns Strategies for the caller's `STTMetadataFrame`.
+         */
+        recommendedUserTurnStrategies(options) {
+            if (!this._enableEagerEndOfTurn) {
+                return new ExternalUserTurnStrategies({
+                    enableInterruptions: options.enableInterruptions,
+                });
+            }
+            return new EagerUserTurnStrategies({
+                matchPolicy: this._eagerMatchPolicy,
+                enableInterruptions: options.enableInterruptions,
+            });
+        }
+        /**
+         * Report that the turn has probably ended.
+         *
+         * @param transcript What the service heard for the turn so far.
+         * @param options.userId Identifier for the user who spoke.
+         * @param options.language Detected or specified language of the speech.
+         * @param options.result Raw result from the STT service.
+         */
+        async _pushEagerEndOfTurn(transcript, options) {
+            if (!this._enableEagerEndOfTurn)
+                return;
+            this._eagerEndOfTurnPending = true;
+            logger.trace(`${this}: eager end of turn: [${transcript}]`);
+            await this.pushFrame(new EagerTranscriptionFrame({
+                text: transcript,
+                userId: options.userId,
+                timestamp: timeNowIso8601(),
+                language: options.language ?? null,
+                result: options.result ?? null,
+            }));
+        }
+        /** Withdraw the prediction. */
+        async _cancelEagerEndOfTurn() {
+            if (!this._eagerEndOfTurnPending)
+                return;
+            logger.trace(`${this}: eager end of turn withdrawn`);
+            this._eagerEndOfTurnPending = false;
+            await this.pushFrame(new EagerEndOfTurnCancelFrame());
+        }
+        /**
+         * Resolve the prediction without withdrawing it.
+         *
+         * Called when the turn is committed: whatever was generated from the
+         * prediction is settled by the committed transcript, not by this.
+         */
+        _clearEagerEndOfTurn() {
+            this._eagerEndOfTurnPending = false;
+        }
+    }
+    return EagerEndOfTurnSTTServiceMixinImpl;
+});
+//# sourceMappingURL=eager_end_of_turn_mixin.js.map