@elizaos/plugin-local-inference 2.0.0-beta.1 → 2.0.11-beta.7

package/src/services/voice/voice-settings.ts

@@ -0,0 +1,172 @@
+/**
+ * Voice settings — the user-facing knobs the runtime + UI consume to
+ * decide local vs cloud, model quality, RAM cap, and quant downgrade.
+ *
+ * R9 §5 spells out the five knobs:
+ *
+ *   1. `voice.forceLocal` / `voice.forceCloud` / `voice.autoSwap` — backend
+ *      mode (auto by default).
+ *   2. `voice.modelQualityPreset` — `"max" | "balanced" | "minimal"`.
+ *   3. `voice.maxRamMB` — hard cap on the allocator's total budget.
+ *   4. `voice.allowQuantDowngrade` — auto-pick smaller quants if RAM tight.
+ *
+ * This module is the env-var resolver + the canonical default table. The
+ * dashboard's Settings panel writes the same fields to `messages.voice.*`
+ * config; I10 wires the persistent store. For now (I9 scope), the resolver
+ * reads env + an optional `Partial<VoiceSettings>` overlay so tests can
+ * lock in deterministic behaviour.
+ *
+ * There is no central `settings.ts` to extend in `plugins/plugin-local-
+ * inference/src/services/` today (R9 §1 path inventory confirms it).
+ * Keeping this file in `voice/` makes its surface area obvious.
+ */
+
+import type { DeviceTier } from "../device-tier";
+
+export type VoiceBackendMode = "auto" | "force-local" | "force-cloud";
+export type VoiceModelQualityPreset = "max" | "balanced" | "minimal";
+
+export interface VoiceSettings {
+	/** Backend selection mode. `auto` consults the device tier. */
+	backendMode: VoiceBackendMode;
+	/** When `backendMode === "auto"`, allow the runtime to swap between
+	 *  cloud and local in mid-session to keep latency bounded. */
+	autoSwap: boolean;
+	/** Quality vs RAM tradeoff. Maps to a quant ladder for the LM + voice
+	 *  stack — see `qualityPresetQuantizationRanking()`. */
+	modelQualityPreset: VoiceModelQualityPreset;
+	/** Hard cap on the allocator's total budget, in MB. 0 / null = use the
+	 *  tier's natural total. */
+	maxRamMb: number | null;
+	/** When true (default), an OOM-pending reservation may pick a smaller
+	 *  quant variant instead of refusing. When false, `reserve()` throws. */
+	allowQuantDowngrade: boolean;
+	/** Continuous local recording on mobile when on battery. Off by default. */
+	continuousLocalRecordingOnBattery: boolean;
+}
+
+const DEFAULT_VOICE_SETTINGS: VoiceSettings = {
+	backendMode: "auto",
+	autoSwap: true,
+	modelQualityPreset: "balanced",
+	maxRamMb: null,
+	allowQuantDowngrade: true,
+	continuousLocalRecordingOnBattery: false,
+};
+
+function parseBackendMode(value: string | undefined): VoiceBackendMode | null {
+	if (!value) return null;
+	const v = value.trim().toLowerCase();
+	if (v === "auto") return "auto";
+	if (v === "force-local" || v === "local") return "force-local";
+	if (v === "force-cloud" || v === "cloud") return "force-cloud";
+	return null;
+}
+
+function parseQualityPreset(
+	value: string | undefined,
+): VoiceModelQualityPreset | null {
+	if (!value) return null;
+	const v = value.trim().toLowerCase();
+	if (v === "max") return "max";
+	if (v === "balanced") return "balanced";
+	if (v === "minimal" || v === "efficient" || v === "min") return "minimal";
+	return null;
+}
+
+function parseBool(value: string | undefined): boolean | null {
+	if (!value) return null;
+	const v = value.trim().toLowerCase();
+	if (v === "1" || v === "true" || v === "yes" || v === "on") return true;
+	if (v === "0" || v === "false" || v === "no" || v === "off") return false;
+	return null;
+}
+
+function parseNumberMb(value: string | undefined): number | null {
+	if (!value) return null;
+	const n = Number.parseInt(value, 10);
+	if (!Number.isFinite(n) || n <= 0) return null;
+	return n;
+}
+
+/**
+ * Resolve voice settings from environment + an optional overlay.
+ * Env wins over defaults; overlay wins over env (so tests / UI can lock
+ * specific fields). All fields are required in the returned settings.
+ *
+ * Env knobs (canonical ELIZA_* prefix; ELIZA_* aliases honored upstream):
+ *
+ *   - `ELIZA_VOICE_BACKEND_MODE`        → backendMode
+ *   - `ELIZA_VOICE_AUTO_SWAP`           → autoSwap
+ *   - `ELIZA_VOICE_QUALITY_PRESET`      → modelQualityPreset
+ *   - `ELIZA_VOICE_MAX_RAM_MB`          → maxRamMb
+ *   - `ELIZA_VOICE_ALLOW_QUANT_DOWNGRADE` → allowQuantDowngrade
+ *   - `ELIZA_VOICE_CONTINUOUS_ON_BATTERY` → continuousLocalRecordingOnBattery
+ */
+export function resolveVoiceSettings(
+	overlay: Partial<VoiceSettings> = {},
+	env: NodeJS.ProcessEnv = process.env,
+): VoiceSettings {
+	const fromEnv: Partial<VoiceSettings> = {};
+	const backendMode = parseBackendMode(env.ELIZA_VOICE_BACKEND_MODE);
+	if (backendMode) fromEnv.backendMode = backendMode;
+	const autoSwap = parseBool(env.ELIZA_VOICE_AUTO_SWAP);
+	if (autoSwap !== null) fromEnv.autoSwap = autoSwap;
+	const preset = parseQualityPreset(env.ELIZA_VOICE_QUALITY_PRESET);
+	if (preset) fromEnv.modelQualityPreset = preset;
+	const maxRamMb = parseNumberMb(env.ELIZA_VOICE_MAX_RAM_MB);
+	if (maxRamMb !== null) fromEnv.maxRamMb = maxRamMb;
+	const allowQuantDowngrade = parseBool(env.ELIZA_VOICE_ALLOW_QUANT_DOWNGRADE);
+	if (allowQuantDowngrade !== null)
+		fromEnv.allowQuantDowngrade = allowQuantDowngrade;
+	const continuousBattery = parseBool(env.ELIZA_VOICE_CONTINUOUS_ON_BATTERY);
+	if (continuousBattery !== null)
+		fromEnv.continuousLocalRecordingOnBattery = continuousBattery;
+
+	return { ...DEFAULT_VOICE_SETTINGS, ...fromEnv, ...overlay };
+}
+
+/**
+ * Default backend mode given the user's settings + the device tier. R9 §5:
+ *
+ *   - `force-local` overrides the mobile-cloud-default;
+ *   - `force-cloud` overrides the desktop-local-default;
+ *   - `auto` consults the tier (MAX/GOOD → local; OKAY/POOR → cloud).
+ *
+ * Returns the resolved mode the runtime should *act on*, taking the tier
+ * into account.
+ */
+export function effectiveBackendMode(
+	settings: VoiceSettings,
+	tier: DeviceTier,
+): "local" | "cloud" {
+	if (settings.backendMode === "force-local") return "local";
+	if (settings.backendMode === "force-cloud") return "cloud";
+	// auto
+	if (tier === "MAX" || tier === "GOOD") return "local";
+	return "cloud";
+}
+
+/**
+ * Ordered quant ladder per quality preset. Most-preferred first. Loaders
+ * pick the most-preferred variant that fits the budget; `allowQuantDowngrade`
+ * controls whether they slide down the ladder when the top choice doesn't
+ * fit.
+ *
+ * Names match the catalog ids in `recommendation.ts:textQuantizationMatrix`
+ * + the voice stack's documented variants.
+ */
+export function qualityPresetQuantizationRanking(
+	preset: VoiceModelQualityPreset,
+): ReadonlyArray<string> {
+	switch (preset) {
+		case "max":
+			return ["Q8_0", "Q6_K", "Q5_K_M", "Q4_K_M", "Q3_K_M"];
+		case "balanced":
+			return ["Q4_K_M", "Q5_K_M", "Q6_K", "Q3_K_M", "Q8_0"];
+		case "minimal":
+			return ["Q3_K_M", "Q4_K_M", "Q5_K_M", "Q6_K"];
+	}
+}
+
+export { DEFAULT_VOICE_SETTINGS };

package/src/services/voice/voice-state-machine.d.ts

@@ -0,0 +1,364 @@
+/**
+ * Voice state machine — explicit state-machine wrapper that drives the
+ * optimistic-rollback path the C1 checkpoint enables.
+ *
+ * This is the thin layer the brief calls for: the existing
+ * `OptimisticRollbackController` already covers the pre-draft / draft-response
+ * path; this module adds the SPEAKING state and the barge-in restore path on
+ * top, exposed as a single state-machine surface (`getState`, `dispatch`)
+ * that the voice loop drives from VAD events + scheduler events.
+ *
+ *   IDLE
+ *     │ speech-start
+ *     ▼
+ *   LISTENING ────────────── speech-pause ────────────▶ PAUSE_TENTATIVE
+ *     ▲                                                       │
+ *     │ speech-active (within 2× hangover)                    │
+ *     │ ──── discard C1 ──────────────────────────────────────┤
+ *     │                                                       │
+ *     │                                                       │ speech-end
+ *     │                                                       ▼
+ *     │                                                  SPEAKING
+ *     │                                                       │
+ *     │ ◀──── restore C1, re-enter LISTENING ───── barge-in ──┘
+ *
+ * Key transitions (all wired to a `CheckpointManagerLike`):
+ *
+ *   - `speech-pause` (LISTENING → PAUSE_TENTATIVE)
+ *       Save checkpoint named "pre-draft" (C1). Kick the drafter on the
+ *       current partial transcript via the caller-supplied `startDrafter`.
+ *
+ *   - `speech-active` within 2× hangover (PAUSE_TENTATIVE → LISTENING)
+ *       Discard C1. Abort the speculative drafter. No rollback is required
+ *       because the drafter's KV writes were speculative against a snapshot
+ *       we never committed.
+ *
+ *   - `speech-end` (PAUSE_TENTATIVE → SPEAKING)
+ *       Commit the ASR final. The drafter's output is promoted: callers
+ *       wire the verifier on top via `onCommit`. **Retain** C1 — a barge-in
+ *       while the agent is speaking must roll the KV cache back to the
+ *       pre-draft point so the next user turn doesn't see the agent's own
+ *       half-spoken response in the prompt.
+ *
+ *   - `barge-in` (SPEAKING → LISTENING)
+ *       Restore C1. Hand the new user speech to the next LISTENING turn.
+ *       The same C1 may be restored multiple times — useful when two
+ *       consecutive barge-ins land before the next checkpoint is taken
+ *       (the test suite covers this).
+ *
+ * No fallback sludge: a checkpoint failure surfaces via `onError`. The
+ * state machine never silently downgrades to a non-checkpointed path —
+ * callers turn the feature off via the constructor option.
+ */
+import type { CheckpointHandle, CheckpointManagerLike } from "./checkpoint-manager";
+import type { ContextPartial } from "./eager-context-builder";
+import { type EotClassifier } from "./eot-classifier";
+import type { OptimisticGenerationPolicy } from "./optimistic-policy";
+import { type PrefillOptimisticOptions, type PrefillOptimisticResult } from "./prefill-client";
+/** Public state. Closed union — exhaustive switches catch new variants. */
+export type VoiceState = "IDLE" | "LISTENING" | "PAUSE_TENTATIVE" | "SPEAKING";
+/**
+ * Events that drive the state machine. Wall-clock timestamps are caller-
+ * supplied so the machine is testable without a fake clock.
+ */
+export type VoiceStateEvent = {
+    type: "speech-start";
+    timestampMs: number;
+} | {
+    type: "speech-pause";
+    timestampMs: number;
+    partialTranscript: string;
+} | {
+    type: "speech-active";
+    timestampMs: number;
+} | {
+    type: "speech-end";
+    timestampMs: number;
+    finalTranscript: string;
+} | {
+    type: "barge-in";
+    timestampMs: number;
+}
+/**
+ * Tier-3 — streamed partial transcript chunk from the ASR. When an
+ * `eotClassifier` is configured the machine will run `checkEot()` and may
+ * transition to PAUSE_TENTATIVE early or commit immediately depending on
+ * the returned probability and the elapsed silence since the last speech
+ * audio frame (provided by the caller via `silenceSinceMs`).
+ */
+ | {
+    type: "partial-transcript";
+    timestampMs: number;
+    text: string;
+    /** Milliseconds of silence elapsed since the last speech audio frame. */
+    silenceSinceMs: number;
+};
+/**
+ * Reason a speculative drafter handle was aborted by the state machine.
+ *
+ *   - `resumed` — `speech-active` re-entered LISTENING; the draft was
+ *                 speculative against a transcript that turned out to be
+ *                 still provisional.
+ *   - `barge-in` — the user interrupted while the agent was speaking; the
+ *                  draft's downstream TTS has already been hard-stopped.
+ *   - `shutdown` — `dispose()` was called.
+ */
+export type DrafterAbortReason = "resumed" | "barge-in" | "shutdown";
+/**
+ * Handle returned by `startDrafter`. The state machine calls `abort()`
+ * (idempotent) when the draft must be cancelled.
+ */
+export interface DrafterHandle {
+    abort(reason: DrafterAbortReason): void;
+}
+/**
+ * Caller-supplied drafter starter. Receives the partial transcript at the
+ * `speech-pause` instant and a turn id. Must return synchronously; the
+ * draft itself runs in the background until the state machine calls
+ * `abort()` or the draft completes (which is observed via `onCommit`).
+ */
+export type StartDrafterFn = (args: {
+    partialTranscript: string;
+    turnId: string;
+    /** Aborted when the drafter must be cancelled. */
+    signal: AbortSignal;
+}) => DrafterHandle;
+export interface VoiceStateMachineEvents {
+    /** State transition occurred. Called AFTER the new state is set. */
+    onStateChange?(prev: VoiceState, next: VoiceState, turnId: string): void;
+    /** Speculative drafter was started on `speech-pause`. */
+    onDrafterStart?(turnId: string, partialTranscript: string): void;
+    /** Speculative drafter was aborted (resumed / barge-in / shutdown). */
+    onDrafterAbort?(turnId: string, reason: DrafterAbortReason): void;
+    /**
+     * `speech-end` reached SPEAKING. The verifier should now run on top of
+     * the speculative drafter output against the final transcript.
+     *
+     * `prefillResult` is present when the C7 optimistic prefill completed
+     * before `speech-end` arrived. The verifier can resume generation from
+     * `prefillResult.checkpointHandle` to skip one full prefill RTT.
+     */
+    onCommit?(turnId: string, finalTranscript: string, prefillResult?: PrefillOptimisticResult): void;
+    /**
+     * A barge-in restored C1. The voice loop should drop any in-flight TTS
+     * (separate concern owned by the barge-in controller) and begin a new
+     * LISTENING turn with the new user audio.
+     */
+    onRollback?(turnId: string, restoredFrom: CheckpointHandle): void;
+    /**
+     * Surfaced when `CheckpointManager.{save,restore,discard}` rejects.
+     * The state machine continues — checkpoint failures must not break the
+     * voice loop — but the operator can flip the feature flag off in
+     * response.
+     */
+    onError?(op: "save" | "restore" | "discard", error: unknown, turnId: string): void;
+    /**
+     * Fired when the Tier-3 EOT classifier scores a partial transcript.
+     * Useful for telemetry and debugging — P values are emitted before the
+     * state machine decides whether to act on them.
+     */
+    onEotScore?(turnId: string, text: string, pDone: number): void;
+    /**
+     * Fired when the C7 optimistic prefill completes (either successfully or
+     * with an error). On success `result` is set; on error `error` is set.
+     * The state machine never blocks on the prefill result — it resolves or
+     * rejects in the background while PAUSE_TENTATIVE is active.
+     */
+    onPrefill?(turnId: string, result: PrefillOptimisticResult | null, error: unknown | null): void;
+}
+export interface VoiceStateMachineOptions {
+    /** Slot identifier for the conversation pinning. */
+    slotId: string;
+    /**
+     * Whether to actually call into the `CheckpointManager`. When `false`,
+     * the state machine still transitions through the same states but
+     * never saves/restores. Default `true` — callers turn the feature off
+     * here when upstream `--ctx-checkpoints` is unavailable.
+     */
+    enableCheckpoints?: boolean;
+    /**
+     * VAD pause hangover (ms). The rollback window is `2 × hangoverMs`. If
+     * a `speech-active` arrives later than this after a `speech-pause`, the
+     * machine treats the pause as a real speech-end equivalent (it commits
+     * instead of discarding).
+     */
+    pauseHangoverMs?: number;
+    checkpointManager: CheckpointManagerLike;
+    /** Drafter starter — see `StartDrafterFn`. */
+    startDrafter: StartDrafterFn;
+    /** Events sink. */
+    events?: VoiceStateMachineEvents;
+    /**
+     * Tier-3 semantic EOT classifier. When provided, partial transcripts are
+     * scored on each `partial-transcript` dispatch:
+     *
+     *   P ≥ 0.9 AND silence ≥ 50 ms  → commit immediately (skip remaining hangover)
+     *   P ≥ 0.6 AND silence ≥ 20 ms  → enter PAUSE_TENTATIVE early (start drafter)
+     *   P < 0.4                        → extend hangover by 50 ms (user is mid-clause)
+     *
+     * When absent the machine behaves as before (tiers 1 + 2 only).
+     */
+    eotClassifier?: EotClassifier;
+    /**
+     * C7 — optimistic prefill configuration. When provided the machine fires
+     * `prefillOptimistic` on `PAUSE_TENTATIVE` entry (fire-and-forget) so the
+     * KV cache is pre-warmed with the partial transcript by the time ASR
+     * finalizes. The prefill result is passed to `onCommit` via `prefillResult`.
+     *
+     * Omit to disable the prefill path entirely.
+     */
+    prefillConfig?: {
+        /** Base URL of the llama-server (`http://host:port`). */
+        baseUrl: string;
+        /** `CheckpointManager` options forwarded to `prefillOptimistic`. */
+        checkpointOptions?: Omit<PrefillOptimisticOptions, "checkpointManager">;
+        /**
+         * Optional deterministic context from `EagerContextBuilder` (C3).
+         * When supplied, the prefill `/completion` call includes the system
+         * prompt + conversation history so the KV cache is maximally warm.
+         */
+        getContext?: () => ContextPartial | null;
+    };
+    /**
+     * W3-9 / F1 — optional optimistic-generation policy. When provided, the
+     * machine consults `policy.shouldStartOptimisticLm(eotProb)` at the
+     * `firePrefill` site before kicking off the speculative prefill. When
+     * the policy says no (e.g. on battery, or below the configured EOT
+     * threshold) `firePrefill` is a no-op and `handleSpeechEnd` falls back
+     * to a regular (non-prefilled) verifier pass. Omit to keep the prior
+     * behaviour (fire on every PAUSE_TENTATIVE entry regardless of EOT
+     * probability).
+     */
+    optimisticPolicy?: OptimisticGenerationPolicy;
+}
+/**
+ * Explicit state-machine implementation. Stateful (state + active
+ * checkpoint + drafter handle); methods are NOT thread-safe — call them
+ * from a single event loop.
+ */
+export declare class VoiceStateMachine {
+    private readonly slotId;
+    private readonly enabled;
+    private readonly pauseHangoverMs;
+    private readonly mgr;
+    private readonly startDrafterFn;
+    private readonly events;
+    /** Tier-3 semantic EOT classifier. Optional — omit for tiers 1+2 only. */
+    private readonly eotClassifier;
+    private state;
+    private turnCounter;
+    /** Most recent C1 handle. Retained across `speech-end` until barge-in or next IDLE. */
+    private checkpoint;
+    private activeDraft;
+    private pauseTimestampMs;
+    private disposed;
+    /**
+     * Accumulated hangover extension from EOT mid-clause detections (ms).
+     * Reset on each new turn (speech-start). Added to the effective hangover
+     * so that consecutive mid-clause detections stack.
+     */
+    private eotHangoverExtensionMs;
+    /**
+     * C7 — in-flight prefill promise. Set on PAUSE_TENTATIVE entry; awaited
+     * (or discarded) on SPEECH_END / SPEECH_ACTIVE_REBOUND. Fire-and-forget
+     * from the perspective of the state machine — the result is surfaced via
+     * `onPrefill` and `onCommit(prefillResult)`.
+     */
+    private prefillPromise;
+    private readonly prefillConfig;
+    /** W3-9 / F1 — optimistic-generation policy gate for `firePrefill`. */
+    private readonly optimisticPolicy;
+    /**
+     * Most recently observed EOT probability from the Tier-3 classifier.
+     * Used as the `eotProb` argument to `prefillOptimistic` when PAUSE_TENTATIVE
+     * is entered. Starts at 0.5 (uncertain). Updated on each `partial-transcript`
+     * event when an EOT classifier is wired.
+     */
+    private latestEotProb;
+    constructor(opts: VoiceStateMachineOptions);
+    /** Current state — read-only view for tests / telemetry. */
+    getState(): VoiceState;
+    /** Internal turn id for the current turn. Stable across pause/active. */
+    getTurnId(): string;
+    /**
+     * Active checkpoint handle, if any. Exposed for tests; production code
+     * should use `onCommit` / `onRollback` events instead.
+     */
+    getActiveCheckpoint(): CheckpointHandle | null;
+    /**
+     * Accumulated EOT hangover extension (ms). The `VadDetector` (Tier 2)
+     * should add this to its effective pause hangover so mid-clause pauses
+     * are not committed prematurely. Resets to 0 on each `speech-start`.
+     */
+    getEotHangoverExtensionMs(): number;
+    /**
+     * Drive the machine. Returns a promise that resolves after any async
+     * checkpoint work for this event finishes (await it in tests for
+     * deterministic assertions). Callers in production may ignore the
+     * returned promise — events fire synchronously regardless.
+     */
+    dispatch(event: VoiceStateEvent): Promise<void>;
+    /**
+     * Tear down: abort any in-flight drafter, discard the live checkpoint.
+     * Safe to call multiple times. After `dispose` the machine ignores
+     * further events.
+     */
+    dispose(): Promise<void>;
+    private handleSpeechStart;
+    private handleSpeechPause;
+    private handleSpeechActive;
+    private handleSpeechEnd;
+    private handleBargeIn;
+    /**
+     * Handle a partial transcript chunk from streaming ASR.
+     *
+     * When an `eotClassifier` is configured, scores the text and applies:
+     *
+     *   P ≥ EOT_COMMIT_THRESHOLD  AND silence ≥ EOT_COMMIT_SILENCE_MS
+     *     → behave as `speech-end` (commit immediately, skip remaining hangover)
+     *
+     *   P ≥ EOT_TENTATIVE_THRESHOLD AND silence ≥ EOT_TENTATIVE_SILENCE_MS
+     *     AND state is LISTENING
+     *     → behave as `speech-pause` (enter PAUSE_TENTATIVE, start drafter)
+     *
+     *   P < EOT_MID_CLAUSE_THRESHOLD
+     *     → accumulate EOT_HANGOVER_EXTENSION_MS into the hangover extension
+     *       (the VadDetector reads this via `getEotHangoverExtensionMs()`)
+     *
+     * No-ops when `eotClassifier` is not set, or when the machine is not in
+     * LISTENING or PAUSE_TENTATIVE.
+     */
+    private handlePartialTranscript;
+    /**
+     * Score the partial transcript with the Tier-3 EOT classifier.
+     * Returns 0.5 when no classifier is configured (uncertain — let tiers 1+2 decide).
+     */
+    private checkEot;
+    /**
+     * C7 — fire the optimistic prefill in the background and store the
+     * promise so `handleSpeechEnd` can await it. The machine never awaits
+     * here — it stays in PAUSE_TENTATIVE whether or not the prefill has
+     * finished. On `SPEECH_ACTIVE_REBOUND` the promise is discarded; on
+     * `SPEECH_END` it is awaited (or its cached result used) and passed
+     * through `onCommit(prefillResult)`.
+     *
+     * W3-9 / F1 — when an `optimisticPolicy` is configured, this is gated on
+     * `policy.shouldStartOptimisticLm(eotProb)`. The policy folds the
+     * device's power source (plugged-in / battery / unknown), the user's
+     * explicit override, and the EOT threshold into a single decision; when
+     * it returns false the prefill is suppressed and `handleSpeechEnd`
+     * runs a regular (non-prefilled) verifier pass.
+     */
+    private firePrefill;
+    private startSpeculativeDrafter;
+    private abortActiveDraft;
+    private setState;
+    /**
+     * Returns `this.state` as the wider `VoiceState` union. Used in
+     * post-`await` re-checks where the entry-guard narrowing would
+     * otherwise convince TS the state can't have changed (it doesn't track
+     * mutations through `setState`).
+     */
+    private currentState;
+}
+//# sourceMappingURL=voice-state-machine.d.ts.map

package/src/services/voice/voice-state-machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voice-state-machine.d.ts","sourceRoot":"","sources":["voice-state-machine.ts"],"names":[],"mappings":"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"}