@pipedog/core 0.0.0 → 0.2.0

package/dist/services/settings.js

@@ -0,0 +1,437 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/services/settings.py
+import { logger } from "../utils/logger.js";
+import { isGiven, NOT_GIVEN } from "../utils/types.js";
+// In a settings object `NOT_GIVEN` means "this field was not included in the
+// delta": distinct from `null`, which is a valid stored value typically meaning
+// "this service doesn't support this field". Every delta field defaults to it so
+// deltas stay sparse and `applyUpdate` can skip untouched fields. It must
+// never appear in a store-mode object — see `validateComplete()`.
+/** Convert a snake_case key to camelCase (`voice_id` → `voiceId`). */
+function snakeToCamel(key) {
+    return key.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+/**
+ * Python `==` for settings values: structural equality for arrays, plain
+ * objects and class instances (dataclasses compare field by field).
+ */
+export function settingsValuesEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a === "number" && typeof b === "number")
+        return a === b;
+    if (a === null || b === null || typeof a !== "object" || typeof b !== "object")
+        return false;
+    if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
+        return false;
+    if (Array.isArray(a)) {
+        const bb = b;
+        return a.length === bb.length && a.every((v, i) => settingsValuesEqual(v, bb[i]));
+    }
+    if (a instanceof Map) {
+        const bb = b;
+        if (a.size !== bb.size)
+            return false;
+        for (const [k, v] of a) {
+            if (!bb.has(k) || !settingsValuesEqual(v, bb.get(k)))
+                return false;
+        }
+        return true;
+    }
+    if (a instanceof Set) {
+        const bb = b;
+        return a.size === bb.size && [...a].every((v) => bb.has(v));
+    }
+    if (ArrayBuffer.isView(a)) {
+        const aa = a;
+        const bb = b;
+        if (aa.length !== bb.length)
+            return false;
+        for (let i = 0; i < aa.length; i++)
+            if (aa[i] !== bb[i])
+                return false;
+        return true;
+    }
+    if (a instanceof Date)
+        return a.getTime() === b.getTime();
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    if (ka.length !== kb.length)
+        return false;
+    const ra = a;
+    const rb = b;
+    return ka.every((k) => Object.hasOwn(rb, k) && settingsValuesEqual(ra[k], rb[k]));
+}
+/** `copy.deepcopy` for settings values. Keeps prototypes and the `NOT_GIVEN` singleton. */
+function deepCopy(value, memo = new Map()) {
+    if (value === null || typeof value !== "object")
+        return value;
+    if (value === NOT_GIVEN)
+        return value;
+    if (memo.has(value))
+        return memo.get(value);
+    if (Array.isArray(value)) {
+        const out = [];
+        memo.set(value, out);
+        for (const v of value)
+            out.push(deepCopy(v, memo));
+        return out;
+    }
+    if (value instanceof Map) {
+        const out = new Map();
+        memo.set(value, out);
+        for (const [k, v] of value)
+            out.set(deepCopy(k, memo), deepCopy(v, memo));
+        return out;
+    }
+    if (value instanceof Set) {
+        const out = new Set();
+        memo.set(value, out);
+        for (const v of value)
+            out.add(deepCopy(v, memo));
+        return out;
+    }
+    if (value instanceof Date)
+        return new Date(value.getTime());
+    if (ArrayBuffer.isView(value)) {
+        return value.slice();
+    }
+    const out = Object.create(Object.getPrototypeOf(value));
+    memo.set(value, out);
+    for (const key of Object.keys(value)) {
+        out[key] = deepCopy(value[key], memo);
+    }
+    return out;
+}
+/**
+ * Base class for runtime-updatable service settings.
+ *
+ * These settings capture the subset of a service's configuration that can be
+ * changed **while the pipeline is running** (e.g. switching the model or
+ * changing the voice). They are *not* meant to capture every constructor
+ * parameter — only those that support live updates via
+ * `*UpdateSettingsFrame`.
+ *
+ * Every AI service type (LLM, TTS, STT) extends this with its own fields.
+ * Each instance operates in one of two modes (see module docs):
+ *
+ * - **Store mode** (`this._settings`): holds the full current state. Every
+ *   field must be a real value — `NOT_GIVEN` is never valid. Use `null` for
+ *   inherited fields the service doesn't support. Enforced at runtime by
+ *   `validateComplete()`.
+ * - **Delta mode** (`*UpdateSettingsFrame`): a sparse update. Only fields the
+ *   caller wants to change are set; all others stay at the default
+ *   `NOT_GIVEN` and are skipped by `applyUpdate()`.
+ *
+ * - `model`: the model identifier used by the service. Set to `null` in
+ *   store mode if the service has no model concept.
+ * - `extra`: overflow dict for service-specific keys that don't map to a
+ *   declared field.
+ */
+export class ServiceSettings {
+    // -- common fields -------------------------------------------------------
+    /**
+     * AI model identifier (e.g. `"gpt-4o"`, `"eleven_flash_v2_5"`).
+     *
+     * Defaults to `NOT_GIVEN` for delta mode. In store mode, set to a model
+     * string or `null` if the service has no model concept.
+     */
+    model = NOT_GIVEN;
+    /** Catch-all for service-specific keys that have no declared field. */
+    extra = {};
+    // -- class-level configuration -------------------------------------------
+    /**
+     * Map of alternative key names to canonical field names.
+     *
+     * For example `{ voice_id: "voice" }` lets callers use either spelling.
+     * Subclasses should override this as needed.
+     */
+    static _aliases = {};
+    constructor(options = {}) {
+        if (options.extra !== undefined)
+            this.extra = options.extra;
+        this._assignOptions(options);
+    }
+    /**
+     * Copy the given options onto the declared fields of this object. A key
+     * that is `undefined` leaves its field at `NOT_GIVEN`. Settings subclasses
+     * that declare fields call this at the end of their constructor (see the
+     * module docs).
+     */
+    _assignOptions(options) {
+        const self = this;
+        for (const [key, value] of Object.entries(options)) {
+            if (key === "extra" || value === undefined)
+                continue;
+            if (Object.hasOwn(this, key))
+                self[key] = value;
+        }
+    }
+    /** Names of the declared fields (`dataclasses.fields()`), without `extra`. */
+    _fieldNames() {
+        return Object.keys(this).filter((name) => name !== "extra");
+    }
+    // -- public API ----------------------------------------------------------
+    /**
+     * Return a dict of only the fields that are not `NOT_GIVEN`.
+     *
+     * Primarily useful for delta-mode objects to inspect which fields were set.
+     * For a store-mode object this returns all declared fields (since none
+     * should be `NOT_GIVEN`).
+     *
+     * Skips the `extra` field itself but merges its entries into the returned
+     * dict at the top level.
+     *
+     * @returns Dictionary mapping field names to their provided values.
+     */
+    givenFields() {
+        const result = {};
+        const self = this;
+        for (const name of this._fieldNames()) {
+            const val = self[name];
+            if (isGiven(val))
+                result[name] = val;
+        }
+        Object.assign(result, this.extra);
+        return result;
+    }
+    /**
+     * Merge a delta-mode object into this store-mode object.
+     *
+     * Only fields in `delta` that are **given** (i.e. not `NOT_GIVEN`) are
+     * considered. A field is "changed" if its new value differs from the
+     * current value.
+     *
+     * The `extra` dicts are merged: keys present in the delta overwrite keys in
+     * the target.
+     *
+     * @param delta A delta-mode settings object of the same type.
+     * @returns A dict mapping each changed field name to its **pre-update**
+     *   value. Use `Object.keys(changed)` for the set of names, or index with
+     *   `changed.field` to inspect the old value.
+     *
+     * @example
+     * // store-mode object (all fields given)
+     * const current = new TTSSettings({ voice: "alice", language: "en" });
+     * // delta-mode object (only voice is set)
+     * const delta = new TTSSettings({ voice: "bob" });
+     * const changed = current.applyUpdate(delta);
+     * // changed == { voice: "alice" }
+     * // current.voice == "bob", current.language == "en"
+     */
+    applyUpdate(delta) {
+        const changed = {};
+        const self = this;
+        const other = delta;
+        for (const name of this._fieldNames()) {
+            const newVal = Object.hasOwn(other, name) ? other[name] : NOT_GIVEN;
+            if (!isGiven(newVal))
+                continue;
+            const oldVal = self[name];
+            if (!settingsValuesEqual(oldVal, newVal)) {
+                self[name] = newVal;
+                changed[name] = oldVal;
+            }
+        }
+        // Merge extra
+        for (const [key, newVal] of Object.entries(delta.extra)) {
+            const oldVal = Object.hasOwn(this.extra, key) ? this.extra[key] : NOT_GIVEN;
+            if (!settingsValuesEqual(oldVal, newVal)) {
+                this.extra[key] = newVal;
+                changed[key] = oldVal;
+            }
+        }
+        return changed;
+    }
+    /**
+     * Build a **delta-mode** settings object from a plain dictionary.
+     *
+     * The returned object is a delta: only the keys present in `settings` are
+     * set; all other fields remain `NOT_GIVEN`.
+     *
+     * Keys are matched to fields by name. Keys listed in `_aliases` are
+     * translated to their canonical name first. A snake_case key also matches
+     * its camelCase field (`system_instruction` → `systemInstruction`), so dicts
+     * written with upstream's spelling keep working. Any remaining
+     * unrecognized keys are placed into `extra`.
+     *
+     * @param settings A dictionary of setting names to values.
+     * @returns A new delta-mode settings instance.
+     *
+     * @example
+     * const delta = TTSSettings.fromMapping({ voice_id: "alice", speed: 1.2 });
+     * // delta.voice == "alice"  (via alias)
+     * // delta.language is NOT_GIVEN  (not in the dict)
+     * // delta.extra == { speed: 1.2 }
+     */
+    static fromMapping(settings) {
+        const cls = ServiceSettings;
+        const fieldNames = new Set(new cls()._fieldNames());
+        const kwargs = {};
+        const extra = {};
+        for (const [key, value] of Object.entries(settings)) {
+            // Resolve aliases first
+            const canonical = cls._aliases[key] ?? key;
+            if (fieldNames.has(canonical)) {
+                kwargs[canonical] = value;
+            }
+            else if (fieldNames.has(snakeToCamel(canonical))) {
+                kwargs[snakeToCamel(canonical)] = value;
+            }
+            else {
+                extra[key] = value;
+            }
+        }
+        const instance = new cls(kwargs);
+        instance.extra = extra;
+        return instance;
+    }
+    /**
+     * Check that this is a valid store-mode object (no `NOT_GIVEN` fields).
+     *
+     * Called automatically by `AIService.start()` to catch fields that a service
+     * forgot to initialize in its constructor. Can also be called manually after
+     * constructing a store-mode settings object.
+     *
+     * Logs an error naming every uninitialized field. Failure to initialize all
+     * fields may or may not cause runtime issues — it depends on whether and how
+     * the service actually reads the field — but it indicates a deviation from
+     * expectations and should be fixed.
+     */
+    validateComplete() {
+        const self = this;
+        const missing = this._fieldNames().filter((name) => !isGiven(self[name]));
+        if (missing.length > 0) {
+            const names = missing.join(", ");
+            logger.error(`${this.constructor.name}: the following fields are NOT_GIVEN: ${names}. ` +
+                "All settings fields should be initialized in the service's " +
+                "constructor (use null for unsupported fields).");
+        }
+    }
+    /**
+     * Return a deep copy of this settings instance.
+     *
+     * @returns A new settings object with the same field values.
+     */
+    copy() {
+        return deepCopy(this);
+    }
+}
+/**
+ * Runtime-updatable settings for image generation services.
+ *
+ * Used in both store and delta mode — see `ServiceSettings`.
+ *
+ * - `model`: image generation model identifier.
+ */
+export class ImageGenSettings extends ServiceSettings {
+}
+/**
+ * Runtime-updatable settings for vision services.
+ *
+ * Used in both store and delta mode — see `ServiceSettings`.
+ *
+ * - `model`: vision model identifier.
+ */
+export class VisionSettings extends ServiceSettings {
+}
+/**
+ * Runtime-updatable settings for LLM services.
+ *
+ * Used in both store and delta mode — see `ServiceSettings`.
+ *
+ * These fields are common across LLM providers. Not every provider supports
+ * every field; in store mode, set unsupported fields to `null` (e.g. a
+ * service that doesn't support `seed` should initialize it as `seed: null`).
+ *
+ * - `model`: LLM model identifier.
+ * - `systemInstruction`: system instruction/prompt for the model.
+ * - `temperature`: sampling temperature.
+ * - `maxTokens`: maximum tokens to generate.
+ * - `topP`: nucleus sampling probability.
+ * - `topK`: top-k sampling parameter.
+ * - `frequencyPenalty`: frequency penalty.
+ * - `presencePenalty`: presence penalty.
+ * - `seed`: random seed for reproducibility.
+ * - `filterIncompleteUserTurns`: enable LLM-based turn completion detection.
+ *   Set by `LLMTurnCompletionUserTurnStopStrategy` over an
+ *   `LLMUpdateSettingsFrame`; application code configures it through
+ *   `FilterIncompleteUserTurnStrategies` instead.
+ * - `userTurnCompletionConfig`: configuration for turn completion behavior
+ *   when `filterIncompleteUserTurns` is enabled. Set by the user turn
+ *   strategy, like `filterIncompleteUserTurns`.
+ * - `useProviderThinkingDefault`: whether a model with no thinking configured
+ *   runs at its provider's default. Defaults to false.
+ */
+export class LLMSettings extends ServiceSettings {
+    systemInstruction = NOT_GIVEN;
+    temperature = NOT_GIVEN;
+    maxTokens = NOT_GIVEN;
+    topP = NOT_GIVEN;
+    topK = NOT_GIVEN;
+    frequencyPenalty = NOT_GIVEN;
+    presencePenalty = NOT_GIVEN;
+    seed = NOT_GIVEN;
+    // Upstream deprecates setting these from application code (1.7.0), but the
+    // user turn strategy still drives turn completion through them.
+    filterIncompleteUserTurns = NOT_GIVEN;
+    userTurnCompletionConfig = NOT_GIVEN;
+    useProviderThinkingDefault = NOT_GIVEN;
+    constructor(options = {}) {
+        super(options);
+        this._assignOptions(options);
+    }
+}
+/**
+ * Runtime-updatable settings for TTS services.
+ *
+ * Used in both store and delta mode — see `ServiceSettings`.
+ *
+ * In store mode, set unsupported fields to `null` (e.g. `language: null` if
+ * the service doesn't expose a language setting).
+ *
+ * - `model`: TTS model identifier.
+ * - `voice`: voice identifier or name.
+ * - `language`: language for speech synthesis. The union type reflects the
+ *   *input* side: callers may pass a `Language` value or a raw string in a
+ *   delta. However, the **stored** value (in store mode) is always a
+ *   service-specific string or `null` — `TTSService._updateSettings` converts
+ *   `Language` values via `languageToServiceLanguage()` before writing, and
+ *   constructors do the same at construction time.
+ */
+export class TTSSettings extends ServiceSettings {
+    voice = NOT_GIVEN;
+    language = NOT_GIVEN;
+    static _aliases = { voice_id: "voice", voiceId: "voice" };
+    constructor(options = {}) {
+        super(options);
+        this._assignOptions(options);
+    }
+}
+/**
+ * Runtime-updatable settings for STT services.
+ *
+ * Used in both store and delta mode — see `ServiceSettings`.
+ *
+ * In store mode, set unsupported fields to `null` (e.g. `language: null` if
+ * the service auto-detects language).
+ *
+ * - `model`: STT model identifier.
+ * - `language`: language for speech recognition. The union type reflects the
+ *   *input* side: callers may pass a `Language` value or a raw string in a
+ *   delta. However, the **stored** value (in store mode) is always a
+ *   service-specific string or `null` — `STTService._updateSettings` converts
+ *   `Language` values via `languageToServiceLanguage()` before writing, and
+ *   constructors do the same at construction time.
+ */
+export class STTSettings extends ServiceSettings {
+    language = NOT_GIVEN;
+    constructor(options = {}) {
+        super(options);
+        this._assignOptions(options);
+    }
+}
+//# sourceMappingURL=settings.js.map

package/dist/services/simli/index.d.ts

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

package/dist/services/simli/index.js

@@ -0,0 +1,7 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/services/simli/__init__.py
+export {};
+//# sourceMappingURL=index.js.map

package/dist/services/smallest/index.d.ts

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

package/dist/services/smallest/index.js

@@ -0,0 +1,7 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/services/smallest/__init__.py
+export {};
+//# sourceMappingURL=index.js.map

package/dist/services/soniox/index.d.ts

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

package/dist/services/soniox/index.js

@@ -0,0 +1,7 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/services/soniox/__init__.py
+export {};
+//# sourceMappingURL=index.js.map

package/dist/services/speechify/index.d.ts

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

package/dist/services/speechify/index.js

@@ -0,0 +1,7 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/services/speechify/__init__.py
+export {};
+//# sourceMappingURL=index.js.map

package/dist/services/speechmatics/index.d.ts

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

package/dist/services/speechmatics/index.js

@@ -0,0 +1,7 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/services/speechmatics/__init__.py
+export {};
+//# sourceMappingURL=index.js.map

package/dist/services/stt_latency.d.ts

@@ -0,0 +1,62 @@
+/**
+ * STT service latency defaults.
+ *
+ * This module contains P99 time-to-final-segment (TTFS) latency values for
+ * STT services. TTFS measures the time from when speech ends to when the
+ * final transcript is received.
+ *
+ * These values are used by turn stop strategies to optimize timing. Each STT
+ * service publishes its latency via STTMetadataFrame at pipeline start.
+ *
+ * All built-in values were measured with `VADParams.stopSecs=0.2`, the
+ * recommended default. If you change `stopSecs`, re-run the benchmark with
+ * your VAD settings and pass the measured value to your STT service
+ * constructor.
+ *
+ * To measure latency for your specific deployment (region, network
+ * conditions, self-hosted instances), use the STT benchmark tool:
+ * https://github.com/pipecat-ai/stt-benchmark
+ *
+ * Run the TTFS benchmark for your service and configuration, then pass the
+ * measured value to your STT service constructor:
+ *
+ * @example
+ * const stt = new DeepgramSTTService({ apiKey: "...", ttfsP99Latency: 0.45 });
+ *
+ * Turn-based STT services (e.g. `CartesiaTurnsSTTService`,
+ * `DeepgramFluxSTTService`) have no meaningful TTFS metric — the server
+ * defines the turn boundary directly, so there is no separate "speech end →
+ * final transcript" interval to measure. Those services override the
+ * `STTService.supportsTtfs` property to return false rather than supplying a
+ * constant here.
+ */
+export declare const DEFAULT_TTFS_P99: number;
+export declare const ASSEMBLYAI_TTFS_P99: number;
+export declare const ASSEMBLYAI_SYNC_TTFS_P99: number;
+export declare const AWS_TRANSCRIBE_TTFS_P99: number;
+export declare const AZURE_TTFS_P99: number;
+export declare const CARTESIA_TTFS_P99: number;
+export declare const DEEPGRAM_TTFS_P99: number;
+export declare const DEEPGRAM_SAGEMAKER_TTFS_P99: number;
+export declare const ELEVENLABS_TTFS_P99: number;
+export declare const ELEVENLABS_REALTIME_TTFS_P99: number;
+export declare const FAL_TTFS_P99: number;
+export declare const GEMINI_TTFS_P99: number;
+export declare const GLADIA_TTFS_P99: number;
+export declare const GOOGLE_TTFS_P99: number;
+export declare const GRADIUM_TTFS_P99: number;
+export declare const GROQ_TTFS_P99: number;
+export declare const META_TTFS_P99: number;
+export declare const MISTRAL_TTFS_P99: number;
+export declare const OPENAI_TTFS_P99: number;
+export declare const OPENAI_REALTIME_TTFS_P99: number;
+export declare const SARVAM_TTFS_P99: number;
+export declare const SARVAM_REALTIME_TTFS_P99: number;
+export declare const SMALLEST_TTFS_P99: number;
+export declare const SONIOX_TTFS_P99: number;
+export declare const SPEECHMATICS_TTFS_P99: number;
+export declare const XAI_TTFS_P99: number;
+export declare const TOGETHER_TTFS_P99: number;
+export declare const NVIDIA_TTFS_P99: number;
+export declare const WHISPER_TTFS_P99: number;
+//# sourceMappingURL=stt_latency.d.ts.map

package/dist/services/stt_latency.js

@@ -0,0 +1,71 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/services/stt_latency.py
+/**
+ * STT service latency defaults.
+ *
+ * This module contains P99 time-to-final-segment (TTFS) latency values for
+ * STT services. TTFS measures the time from when speech ends to when the
+ * final transcript is received.
+ *
+ * These values are used by turn stop strategies to optimize timing. Each STT
+ * service publishes its latency via STTMetadataFrame at pipeline start.
+ *
+ * All built-in values were measured with `VADParams.stopSecs=0.2`, the
+ * recommended default. If you change `stopSecs`, re-run the benchmark with
+ * your VAD settings and pass the measured value to your STT service
+ * constructor.
+ *
+ * To measure latency for your specific deployment (region, network
+ * conditions, self-hosted instances), use the STT benchmark tool:
+ * https://github.com/pipecat-ai/stt-benchmark
+ *
+ * Run the TTFS benchmark for your service and configuration, then pass the
+ * measured value to your STT service constructor:
+ *
+ * @example
+ * const stt = new DeepgramSTTService({ apiKey: "...", ttfsP99Latency: 0.45 });
+ *
+ * Turn-based STT services (e.g. `CartesiaTurnsSTTService`,
+ * `DeepgramFluxSTTService`) have no meaningful TTFS metric — the server
+ * defines the turn boundary directly, so there is no separate "speech end →
+ * final transcript" interval to measure. Those services override the
+ * `STTService.supportsTtfs` property to return false rather than supplying a
+ * constant here.
+ */
+// Conservative fallback for services without measured values
+export const DEFAULT_TTFS_P99 = 1.0;
+// Measured P99 TTFS latency values (in seconds)
+export const ASSEMBLYAI_TTFS_P99 = 0.42;
+export const ASSEMBLYAI_SYNC_TTFS_P99 = 0.65;
+export const AWS_TRANSCRIBE_TTFS_P99 = 1.9;
+export const AZURE_TTFS_P99 = 1.8;
+export const CARTESIA_TTFS_P99 = 0.81;
+export const DEEPGRAM_TTFS_P99 = 0.35;
+export const DEEPGRAM_SAGEMAKER_TTFS_P99 = 0.35;
+export const ELEVENLABS_TTFS_P99 = 2.01;
+export const ELEVENLABS_REALTIME_TTFS_P99 = 0.41;
+export const FAL_TTFS_P99 = 2.07;
+export const GEMINI_TTFS_P99 = 0.6;
+export const GLADIA_TTFS_P99 = 1.49;
+export const GOOGLE_TTFS_P99 = 1.57;
+export const GRADIUM_TTFS_P99 = 0.62;
+export const GROQ_TTFS_P99 = 1.54;
+export const META_TTFS_P99 = 1.92;
+export const MISTRAL_TTFS_P99 = 1.89;
+export const OPENAI_TTFS_P99 = 2.01;
+export const OPENAI_REALTIME_TTFS_P99 = 1.66;
+export const SARVAM_TTFS_P99 = 1.17;
+// Provisional until benchmarked against the realtime endpoint.
+export const SARVAM_REALTIME_TTFS_P99 = 1.0;
+export const SMALLEST_TTFS_P99 = 1.59;
+export const SONIOX_TTFS_P99 = 0.35;
+export const SPEECHMATICS_TTFS_P99 = 0.74;
+export const XAI_TTFS_P99 = 2.14;
+export const TOGETHER_TTFS_P99 = 1.0;
+// These services run locally and should be replaced with measured values
+export const NVIDIA_TTFS_P99 = DEFAULT_TTFS_P99;
+export const WHISPER_TTFS_P99 = DEFAULT_TTFS_P99;
+//# sourceMappingURL=stt_latency.js.map