RealTimeSTT 1.0.4__tar.gz → 1.1.0__tar.gz

{realtimestt-1.0.4 → realtimestt-1.1.0}/MANIFEST.in

@@ -9,7 +9,10 @@ prune roadmap
 prune test-model-cache
 prune test-results
 prune docs_private
+prune docs/handoffs
 prune tests_private
 global-exclude *Kopie*.py
 global-exclude *.bak
 global-exclude *.tmp
+global-exclude *.log
+global-exclude *.jsonl

{realtimestt-1.0.4 → realtimestt-1.1.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: realtimestt
-Version: 1.0.4
+Version: 1.1.0
 Summary: A fast Voice Activity Detection and Transcription System
-Home-page: https://github.com/KoljaB/RealTimeSTT
+Home-page: https://github.com/KoljaB/RealtimeSTT
 Author: Kolja Beigel
 Author-email: kolja.beigel@web.de
 License: MIT
 Keywords: real-time,audio,transcription,speech-to-text,voice-activity-detection,VAD,real-time-transcription,ambient-noise-detection,microphone-input,faster_whisper,speech-recognition,voice-assistants,audio-processing,buffered-transcription,pyaudio,ambient-noise-level,voice-deactivity
-Requires-Python: >=3.11
+Requires-Python: >=3.11,<3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: PyAudio==0.2.14
@@ -27,6 +27,12 @@ Provides-Extra: whisper-cpp
 Requires-Dist: pywhispercpp; extra == "whisper-cpp"
 Provides-Extra: whispercpp
 Requires-Dist: pywhispercpp; extra == "whispercpp"
+Provides-Extra: transcribe-cpp
+Requires-Dist: transcribe-cpp==0.2.1; extra == "transcribe-cpp"
+Provides-Extra: transcribecpp
+Requires-Dist: transcribe-cpp==0.2.1; extra == "transcribecpp"
+Provides-Extra: parakeet-transcribe-cpp
+Requires-Dist: transcribe-cpp==0.2.1; extra == "parakeet-transcribe-cpp"
 Provides-Extra: openai-whisper
 Requires-Dist: openai-whisper; extra == "openai-whisper"
 Provides-Extra: sherpa-onnx
@@ -120,6 +126,7 @@ Requires-Dist: silero-vad[onnx-cpu]>=6.2.1; python_version >= "3.8" and extra ==
 Provides-Extra: all
 Requires-Dist: faster-whisper==1.2.1; extra == "all"
 Requires-Dist: pywhispercpp; extra == "all"
+Requires-Dist: transcribe-cpp==0.2.1; extra == "all"
 Requires-Dist: openai-whisper; extra == "all"
 Requires-Dist: sherpa-onnx==1.13.4; extra == "all"
 Requires-Dist: fastapi<1,>=0.115; extra == "all"
@@ -179,6 +186,7 @@ Available extras include:
 
 - faster-whisper: default CTranslate2 Whisper backend
 - whisper-cpp: whisper.cpp backend through pywhispercpp
+- transcribe-cpp: first-party transcribe.cpp Python binding; add the matching CUDA provider separately
 - openai-whisper: original OpenAI Whisper Python backend
 - sherpa-onnx: sherpa-onnx CPU backends
 - server/production-server: versioned FastAPI HTTP and WebSocket ASR server
@@ -319,7 +327,8 @@ See the [Kroko-ONNX engine guide](docs/engines/kroko-onnx.md),
 
 ## Install
 
-Use Python 3.11 or newer for the current pinned dependency set.
+The current CI matrix covers Python 3.11 and 3.12. Python 3.13 and newer are
+not release targets until dependency and CI gates are available.
 
 ```bash
 pip install "RealtimeSTT[faster-whisper]"

{realtimestt-1.0.4 → realtimestt-1.1.0}/README.md

@@ -72,7 +72,8 @@ See the [Kroko-ONNX engine guide](docs/engines/kroko-onnx.md),
 
 ## Install
 
-Use Python 3.11 or newer for the current pinned dependency set.
+The current CI matrix covers Python 3.11 and 3.12. Python 3.13 and newer are
+not release targets until dependency and CI gates are available.
 
 ```bash
 pip install "RealtimeSTT[faster-whisper]"

{realtimestt-1.0.4 → realtimestt-1.1.0}/RELEASE_NOTES.md

@@ -1,5 +1,54 @@
 # Release Notes
 
+## 1.1.0 - 2026-08-27
+
+This stable release promotes the externally validated `1.1.0rc1` candidate.
+See [the release-readiness checklist](docs/release-1.1.0-readiness.md) for the
+required evidence gates and supported platform boundaries.
+
+### Added
+
+- Added correlated Preview `resume` handling for the versioned production
+  WebSocket API, including an ordered acknowledgement barrier and explicit
+  candidate/audio provenance fields.
+- Added an opt-in authenticated late full-turn correction operation for
+  Preview-only deployments, bounded by a configurable maximum audio duration.
+- Added recorder Preview/tail transcription support with package-level result
+  types and the documented dual-realtime merge contracts.
+
+### Changed
+
+- Preview-only production turns retain the complete logical-turn audio for model
+  input; live text remains diagnostic and is never substituted for Preview or
+  Final output.
+- Empty Preview results use one bounded silence-padding retry, while Final
+  remains authoritative whenever Final ASR is enabled.
+- Preview admission is now bounded and coalesced: one native dispatch lane
+  retains only the latest pending snapshot while an older inference is active.
+- Unexpected live-lane exits now produce structured, observable degraded events
+  while preserving the authoritative-final fallback path.
+- Raw-PCM responses propagate provider-reported language and finite language
+  probability metadata when the selected provider supplies it.
+- Realtime punctuation splitting commits the frame boundary atomically, and the
+  local Preview worker rejects new speculative requests once its bounded queue
+  is full.
+- Release packaging checks now validate the requested version, inspect archive
+  names/content for private material, and install both wheel and sdist from
+  outside the source checkout.
+
+### Release boundaries
+
+- The documented Nemotron-live/Parakeet-final profile targets Linux x86-64 with
+  the pinned sherpa-onnx runtime. Native Windows remains a development target
+  for this pair; use another authoritative final engine there unless the
+  cumulative-recovery behavior is independently validated.
+- Model weights remain external artifacts. Users must review and accept the
+  exact model/runtime licenses before downloading or redistributing them.
+- The final source tree must pass supported CI, Linux real-model acceptance,
+  and isolated wheel and sdist installation before stable publication.
+- `1.1.0` supersedes the `1.1.0rc1` prerelease; stable installations should pin
+  `RealtimeSTT==1.1.0` when an exact version is required.
+
 ## 1.0.4 - 2026-08-21
 
 ### Fixed
@@ -86,8 +135,8 @@
   streaming WebSocket APIs. Non-loopback binds require bearer authentication
   and TLS. The server includes bounded queues and sessions, backpressure,
   limits, structured errors, warmup, and graceful resource cleanup.
-- Added a reproducible same-host A/B benchmark harness for the AgentTalk/raw
-  PCM16 contract and release CI for unit, distribution, and isolated wheel
+- Added a reproducible same-host A/B benchmark harness for the raw PCM16 client
+  contract and release CI for unit, distribution, and isolated wheel
   installation checks.
 
 ### Changed

{realtimestt-1.0.4 → realtimestt-1.1.0}/RealtimeSTT/__init__.py

@@ -16,6 +16,8 @@ __all__ = [
     "TranscriptionEngineError",
     "TranscriptionInfo",
     "TranscriptionResult",
+    "PreviewTranscriptionResult",
+    "RealtimeTranscriptionMergeResult",
     "UnsupportedTranscriptionEngineError",
 ]
 
@@ -65,6 +67,14 @@ def __getattr__(name):
         from .engines import TranscriptionResult
 
         return TranscriptionResult
+    if name == "PreviewTranscriptionResult":
+        from .core.preview_transcription import PreviewTranscriptionResult
+
+        return PreviewTranscriptionResult
+    if name == "RealtimeTranscriptionMergeResult":
+        from .core.realtime_merge import RealtimeTranscriptionMergeResult
+
+        return RealtimeTranscriptionMergeResult
     if name == "UnsupportedTranscriptionEngineError":
         from .engines import UnsupportedTranscriptionEngineError
 

{realtimestt-1.0.4 → realtimestt-1.1.0}/RealtimeSTT/audio_recorder.py

@@ -32,6 +32,10 @@ from .core.recording_buffers import (
     flush_buffered_audio as flush_recorder_buffered_audio,
     has_pending_recordings as recorder_has_pending_recordings,
 )
+from .core.tail_transcription import (
+    MIN_LIVE_WORDS_FOR_FUZZY_REPAIR,
+    PREVIEW_TRANSCRIPTION_TAIL_SECONDS,
+)
 from .core.shutdown import shutdown_recorder
 from .core.text_formatting import format_number
 from .core.transcription_api import (
@@ -206,6 +210,29 @@ class AudioToTextRecorder:
                  deactivity_silence_confirmation_duration: float = (
                      DEACTIVITY_SILENCE_CONFIRMATION_DURATION
                  ),
+                 # Speculative Preview transcription parameters
+                 enable_preview_transcription: bool = False,
+                 preview_model_type: Optional[str] = None,
+                 preview_transcription_engine: Optional[str] = None,
+                 preview_transcription_engine_options: Optional[dict] = None,
+                 preview_transcription_tail_seconds: float = (
+                     PREVIEW_TRANSCRIPTION_TAIL_SECONDS
+                 ),
+                 on_preview_transcription_finished=None,
+                 preview_transcription_executor: Optional[Callable] = None,
+                 preview_transcription_min_live_words_for_fuzzy_repair: int = (
+                     MIN_LIVE_WORDS_FOR_FUZZY_REPAIR
+                 ),
+                 # Optional second, lower-latency realtime transcription lane
+                 ultrafast_realtime_model_type: Optional[str] = None,
+                 ultrafast_realtime_transcription_engine: Optional[str] = None,
+                 ultrafast_realtime_transcription_engine_options: Optional[
+                     dict
+                 ] = None,
+                 on_ultrafast_transcription_update=None,
+                 on_merged_realtime_transcription_update=None,
+                 on_realtime_transcription_merge_update=None,
+                 ultrafast_realtime_max_tail_words: int = 5,
                  ):
         """
         Initializes an audio recorder and  transcription
@@ -315,6 +342,54 @@ class AudioToTextRecorder:
             recordings. Use "sentence" for the supported `. ? !` mode.
         - realtime_batch_size (int, default=16): Batch size for the real-time
             transcription model.
+        - ultrafast_realtime_model_type (str, default=None): Optional second
+            streaming realtime model. Its text may only append a bounded,
+            safely anchored suffix to the authoritative realtime model text.
+        - ultrafast_realtime_transcription_engine (str, default=None): Backend
+            for the ultrafast lane. If omitted, the realtime backend is used.
+            The backend must support streaming sessions.
+        - ultrafast_realtime_transcription_engine_options (dict,
+            default=None): Backend-specific ultrafast options. If omitted,
+            realtime engine options are reused.
+        - on_ultrafast_transcription_update (callable, default=None): Receives
+            the raw ultrafast text independently of the central callbacks.
+        - on_merged_realtime_transcription_update (callable, default=None):
+            Receives the complete sticky merged text only when it changes.
+        - on_realtime_transcription_merge_update (callable, default=None):
+            Receives every structured RealtimeTranscriptionMergeResult,
+            including held/no-anchor transitions.
+        - ultrafast_realtime_max_tail_words (int, default=5): Maximum number
+            of words the ultrafast model may append after a safe anchor. Lower
+            this value to reduce the speculative error radius.
+
+        Speculative Preview transcription:
+        - enable_preview_transcription (bool, default=False): Runs an
+            independent low-latency Preview transcription at confirmed VAD
+            silence. Preview is intended for speculative consumers such as an
+            early LLM response and is not authoritative Final ASR.
+        - preview_model_type (str, default=None): Model used for Preview. If
+            omitted while Preview is enabled, the loaded main model is reused
+            when the Preview engine and options also match; otherwise an
+            independent Preview model is initialized.
+        - preview_transcription_engine (str, default=None): Backend used for
+            Preview. If omitted, the main transcription backend is used.
+        - preview_transcription_engine_options (dict, default=None): Optional
+            backend-specific Preview options. If omitted, main-engine options
+            are reused and allow the loaded main model to be shared.
+        - preview_transcription_tail_seconds (float, default=3.0): Amount of
+            recent active speech sent to Preview ASR.
+        - preview_transcription_min_live_words_for_fuzzy_repair (int,
+            default=3): Minimum Live words required before constrained fuzzy
+            repair is allowed. Exact anchors remain available for shorter
+            Live text; values below the 3-word anchor length cannot lower the
+            matcher further.
+        - on_preview_transcription_finished (callable, default=None): Callback
+            receiving a PreviewTranscriptionResult. The result includes the
+            speculative text, Live boundary snapshot, tail text, alignment
+            status, and recording id.
+        - preview_transcription_executor (callable, default=None): Optional
+            external Preview ASR executor. It is called only with the bounded
+            Preview tail; it never receives or triggers the full Final audio.
 
         Voice activity and turn detection:
         - silero_sensitivity (float, default=SILERO_SENSITIVITY): Sensitivity
@@ -623,6 +698,37 @@ class AudioToTextRecorder:
             deactivity_silence_confirmation_duration=(
                 deactivity_silence_confirmation_duration
             ),
+            enable_preview_transcription=enable_preview_transcription,
+            preview_model_type=preview_model_type,
+            preview_transcription_engine=preview_transcription_engine,
+            preview_transcription_engine_options=(
+                preview_transcription_engine_options
+            ),
+            preview_transcription_tail_seconds=preview_transcription_tail_seconds,
+            preview_transcription_min_live_words_for_fuzzy_repair=(
+                preview_transcription_min_live_words_for_fuzzy_repair
+            ),
+            on_preview_transcription_finished=on_preview_transcription_finished,
+            preview_transcription_executor=preview_transcription_executor,
+            ultrafast_realtime_model_type=ultrafast_realtime_model_type,
+            ultrafast_realtime_transcription_engine=(
+                ultrafast_realtime_transcription_engine
+            ),
+            ultrafast_realtime_transcription_engine_options=(
+                ultrafast_realtime_transcription_engine_options
+            ),
+            on_ultrafast_transcription_update=(
+                on_ultrafast_transcription_update
+            ),
+            on_merged_realtime_transcription_update=(
+                on_merged_realtime_transcription_update
+            ),
+            on_realtime_transcription_merge_update=(
+                on_realtime_transcription_merge_update
+            ),
+            ultrafast_realtime_max_tail_words=(
+                ultrafast_realtime_max_tail_words
+            ),
         )
 
         initialize_recorder(

{realtimestt-1.0.4 → realtimestt-1.1.0}/RealtimeSTT/core/initialization.py

@@ -19,6 +19,8 @@ from .realtime import (
     run_realtime_worker,
 )
 from .realtime_text_stabilizer import RealtimeTextStabilizer
+from .realtime_merge import StickyRealtimeTranscriptionMerger
+from .preview_transcription import start_preview_transcription_worker
 from .recording import run_recording_worker
 from ..transcription_engines import (
     TranscriptionEngineConfig,
@@ -29,7 +31,10 @@ from .safepipe import SafePipe
 from .wakeword import OPENWAKEWORD_BACKENDS, setup_wakeword_detection
 from .audio_input_worker import run_audio_data_worker
 from .runtime import read_stdout_pipe, start_recorder_worker
-from .transcription import run_transcription_worker
+from .transcription import (
+    SharedFinalModelExecutor,
+    run_transcription_worker,
+)
 from .voice_activity import warmup_voice_activity_detectors
 
 
@@ -63,6 +68,7 @@ def initialize_recorder(
     _initialize_transcription_runtime(recorder, recorder_cls)
     _start_audio_reader(recorder, recorder_cls)
     _initialize_realtime_transcription_model(recorder)
+    _initialize_preview_transcription_model(recorder)
     _initialize_wakeword_detection(
         recorder,
         normalized_wakeword_backend,
@@ -175,6 +181,69 @@ def _assign_initial_attributes(recorder, init_args, normalize_wakeword_backend):
     recorder.on_realtime_text_stabilization_update = (
         init_args["on_realtime_text_stabilization_update"]
     )
+    recorder.ultrafast_realtime_model_type = init_args[
+        "ultrafast_realtime_model_type"
+    ]
+    recorder.ultrafast_realtime_transcription_engine = (
+        init_args["ultrafast_realtime_transcription_engine"]
+        or recorder.realtime_transcription_engine
+    )
+    recorder.ultrafast_realtime_transcription_engine_options = (
+        init_args["ultrafast_realtime_transcription_engine_options"]
+        if init_args["ultrafast_realtime_transcription_engine_options"]
+        is not None
+        else recorder.realtime_transcription_engine_options
+    )
+    recorder.ultrafast_realtime_transcription_model = None
+    recorder._ultrafast_uses_realtime_model = False
+    recorder.on_ultrafast_transcription_update = init_args[
+        "on_ultrafast_transcription_update"
+    ]
+    recorder.on_merged_realtime_transcription_update = init_args[
+        "on_merged_realtime_transcription_update"
+    ]
+    recorder.on_realtime_transcription_merge_update = init_args[
+        "on_realtime_transcription_merge_update"
+    ]
+    recorder.ultrafast_realtime_max_tail_words = int(
+        init_args["ultrafast_realtime_max_tail_words"]
+    )
+
+    recorder.enable_preview_transcription = bool(
+        init_args["enable_preview_transcription"]
+    )
+    recorder.preview_model_type = (
+        init_args["preview_model_type"] or init_args["model"]
+    )
+    recorder.preview_transcription_engine = (
+        init_args["preview_transcription_engine"]
+        or init_args["transcription_engine"]
+    )
+    recorder.preview_transcription_engine_options = (
+        init_args["preview_transcription_engine_options"]
+        if init_args["preview_transcription_engine_options"] is not None
+        else recorder.transcription_engine_options
+    )
+    recorder.preview_transcription_tail_seconds = float(
+        init_args["preview_transcription_tail_seconds"]
+    )
+    recorder.preview_transcription_min_live_words_for_fuzzy_repair = int(
+        init_args["preview_transcription_min_live_words_for_fuzzy_repair"]
+    )
+    recorder.on_preview_transcription_finished = (
+        init_args["on_preview_transcription_finished"]
+    )
+    recorder.preview_transcription_executor = (
+        init_args["preview_transcription_executor"]
+    )
+    recorder._uses_external_preview_transcription_executor = (
+        recorder.preview_transcription_executor is not None
+    )
+    recorder.preview_transcription_uses_main_model = False
+    recorder._preview_uses_main_model = False
+    recorder._preview_uses_shared_final_worker = False
+    recorder.preview_transcription_model = None
+    recorder.preview_transcription_worker = None
     recorder.realtime_punctuation_split_marks = (
         _normalize_realtime_punctuation_split_marks(
             init_args["realtime_punctuation_split_marks"]
@@ -225,8 +294,20 @@ def _assign_initial_attributes(recorder, init_args, normalize_wakeword_backend):
     recorder.realtime_stabilized_text = ""
     recorder.realtime_stabilized_safetext = ""
     recorder.realtime_text_stabilizer = RealtimeTextStabilizer()
+    recorder.realtime_transcription_merger = StickyRealtimeTranscriptionMerger(
+        max_ultrafast_tail_words=(
+            recorder.ultrafast_realtime_max_tail_words
+        )
+    )
+    recorder.realtime_transcription_merger.reset(0)
     recorder.realtime_recording_id = 0
     recorder.realtime_observation_sequence = 0
+    recorder.ultrafast_realtime_observation_sequence = 0
+    recorder.ultrafast_realtime_transcription_text = ""
+    recorder.merged_realtime_transcription_text = ""
+    recorder.last_ultrafast_transcription = ""
+    recorder.last_merged_realtime_transcription = ""
+    recorder.last_realtime_transcription_merge_result = None
     recorder.realtime_text_stabilization_event = None
     recorder.realtime_stabilization_accepted_count = 0
     recorder.realtime_stabilization_outlier_count = 0
@@ -255,6 +336,16 @@ def _assign_initial_attributes(recorder, init_args, normalize_wakeword_backend):
     recorder.last_transcription_bytes = None
     recorder.last_transcription_bytes_b64 = None
     recorder.last_transcription_metadata = None
+    recorder.active_speech_tail_buffer = bytearray()
+    recorder._current_transcription_live_text = None
+    recorder._current_transcription_tail_audio = None
+    recorder._preview_transcription_submitted = False
+    recorder._pending_vad_live_text = None
+    recorder.preview_transcription_queue = None
+    recorder.preview_transcription_stop_event = None
+    recorder.preview_transcription_thread = None
+    recorder.last_preview_transcription = ""
+    recorder.last_preview_transcription_result = None
     recorder.last_preroll_selection = None
     recorder._pending_preroll_selection = None
     recorder.initial_prompt = init_args["initial_prompt"]
@@ -398,12 +489,16 @@ def _initialize_transcription_runtime(recorder, recorder_cls):
     recorder.stdout_thread = None
     recorder.parent_transcription_pipe = None
     recorder.parent_stdout_pipe = None
+    recorder.shared_preview_transcription_result_queue = None
     child_transcription_pipe = None
     child_stdout_pipe = None
 
     if not recorder._uses_external_transcription_executor:
         recorder.parent_transcription_pipe, child_transcription_pipe = SafePipe()
         recorder.parent_stdout_pipe, child_stdout_pipe = SafePipe()
+        if _should_share_preview_model(recorder):
+            recorder.shared_preview_transcription_result_queue = mp.Queue()
+            recorder._preview_uses_shared_final_worker = True
 
     recorder.device = "cuda" if recorder.device == "cuda" and torch.cuda.is_available() else "cpu"
 
@@ -432,10 +527,72 @@ def _initialize_transcription_runtime(recorder, recorder_cls):
                 recorder.batch_size,
                 recorder.faster_whisper_vad_filter,
                 recorder.normalize_audio,
+                recorder.shared_preview_transcription_result_queue,
             )
         )
 
 
+def _values_equal(left, right):
+    """Compares optional engine settings without assuming scalar values."""
+
+    if left is right:
+        return True
+    try:
+        result = left == right
+    except Exception:
+        return False
+    return result if isinstance(result, bool) else False
+
+
+def _should_share_preview_model(recorder):
+    """Returns whether Preview can use the loaded Final model safely."""
+
+    return bool(
+        getattr(recorder, "enable_preview_transcription", False)
+        and not getattr(
+            recorder,
+            "_uses_external_preview_transcription_executor",
+            False,
+        )
+        and recorder.preview_model_type == recorder.main_model_type
+        and recorder.preview_transcription_engine
+        == recorder.transcription_engine
+        and _values_equal(
+            recorder.preview_transcription_engine_options,
+            recorder.transcription_engine_options,
+        )
+    )
+
+
+def _should_share_ultrafast_realtime_model(recorder):
+    """Returns whether both realtime lanes can share one loaded model."""
+
+    return bool(
+        getattr(recorder, "ultrafast_realtime_model_type", None)
+        and getattr(recorder, "realtime_transcription_model", None) is not None
+        and recorder.ultrafast_realtime_model_type
+        == recorder.realtime_model_type
+        and recorder.ultrafast_realtime_transcription_engine
+        == recorder.realtime_transcription_engine
+        and _values_equal(
+            recorder.ultrafast_realtime_transcription_engine_options,
+            recorder.realtime_transcription_engine_options,
+        )
+    )
+
+
+def _require_streaming_realtime_model(model, lane_name):
+    """Rejects an optional lane that cannot maintain streaming sessions."""
+
+    if not getattr(model, "supports_streaming", False) or not hasattr(
+        model,
+        "create_streaming_session",
+    ):
+        raise ValueError(
+            f"{lane_name} realtime model must support streaming sessions"
+        )
+
+
 def _start_audio_reader(recorder, recorder_cls):
     """
     Starts the background audio reader process.
@@ -515,6 +672,143 @@ def _initialize_realtime_transcription_model(recorder):
             f"{recorder.realtime_transcription_engine} realtime speech to text transcription model initialized successfully"
         )
 
+    if not (
+        recorder.enable_realtime_transcription
+        and recorder.ultrafast_realtime_model_type
+    ):
+        return
+
+    try:
+        if _should_share_ultrafast_realtime_model(recorder):
+            recorder.ultrafast_realtime_transcription_model = (
+                recorder.realtime_transcription_model
+            )
+            recorder._ultrafast_uses_realtime_model = True
+        else:
+            logger.info(
+                "Initializing %s ultrafast realtime transcription model %s",
+                recorder.ultrafast_realtime_transcription_engine,
+                recorder.ultrafast_realtime_model_type,
+            )
+            recorder.ultrafast_realtime_transcription_model = (
+                create_transcription_engine(
+                    recorder.ultrafast_realtime_transcription_engine,
+                    TranscriptionEngineConfig(
+                        model=recorder.ultrafast_realtime_model_type,
+                        download_root=recorder.download_root,
+                        compute_type=recorder.compute_type,
+                        gpu_device_index=recorder.gpu_device_index,
+                        device=recorder.device,
+                        beam_size=recorder.beam_size_realtime,
+                        initial_prompt=recorder.initial_prompt_realtime,
+                        suppress_tokens=recorder.suppress_tokens,
+                        batch_size=recorder.realtime_batch_size,
+                        vad_filter=recorder.faster_whisper_vad_filter,
+                        normalize_audio=recorder.normalize_audio,
+                        engine_options=(
+                            recorder.ultrafast_realtime_transcription_engine_options
+                        ),
+                    ),
+                )
+            )
+
+        _require_streaming_realtime_model(
+            recorder.ultrafast_realtime_transcription_model,
+            "ultrafast",
+        )
+
+        if not recorder._ultrafast_uses_realtime_model:
+            current_dir = os.path.dirname(
+                os.path.dirname(os.path.realpath(__file__))
+            )
+            warmup_audio_path = os.path.join(
+                current_dir,
+                "assets",
+                "warmup_audio.wav",
+            )
+            warmup_audio_data, _ = sf.read(
+                warmup_audio_path,
+                dtype="float32",
+            )
+            recorder.ultrafast_realtime_transcription_model.warmup(
+                warmup_audio_data
+            )
+    except Exception as error:
+        logger.exception(
+            "Error initializing ultrafast realtime transcription model: %s",
+            error,
+        )
+        raise
+
+    logger.debug("Ultrafast realtime transcription model initialized")
+
+
+def _initialize_preview_transcription_model(recorder):
+    """
+    Initializes the optional independent speculative Preview model.
+    """
+
+    if not recorder.enable_preview_transcription:
+        return
+
+    recorder._preview_uses_main_model = _should_share_preview_model(recorder)
+    if recorder._preview_uses_main_model:
+        recorder.preview_transcription_uses_main_model = True
+        if recorder._uses_external_transcription_executor:
+            recorder.preview_transcription_executor = (
+                recorder.transcription_executor
+            )
+        else:
+            recorder.preview_transcription_executor = SharedFinalModelExecutor(
+                recorder
+            )
+        recorder._uses_external_preview_transcription_executor = True
+        start_preview_transcription_worker(recorder)
+        return
+
+    if not recorder._uses_external_preview_transcription_executor:
+        try:
+            logger.info(
+                f"Initializing {recorder.preview_transcription_engine} preview "
+                f"transcription model {recorder.preview_model_type}, "
+                f"device: {recorder.device}, compute type: {recorder.compute_type}, "
+                f"download root: {recorder.download_root}"
+            )
+            recorder.preview_transcription_model = create_transcription_engine(
+                recorder.preview_transcription_engine,
+                TranscriptionEngineConfig(
+                    model=recorder.preview_model_type,
+                    download_root=recorder.download_root,
+                    compute_type=recorder.compute_type,
+                    gpu_device_index=recorder.gpu_device_index,
+                    device=recorder.device,
+                    beam_size=recorder.beam_size_realtime,
+                    initial_prompt=recorder.initial_prompt,
+                    suppress_tokens=recorder.suppress_tokens,
+                    batch_size=0,
+                    vad_filter=recorder.faster_whisper_vad_filter,
+                    normalize_audio=recorder.normalize_audio,
+                    engine_options=recorder.preview_transcription_engine_options,
+                ),
+            )
+
+            current_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+            warmup_audio_path = os.path.join(
+                current_dir,
+                "assets",
+                "warmup_audio.wav",
+            )
+            warmup_audio_data, _ = sf.read(warmup_audio_path, dtype="float32")
+            recorder.preview_transcription_model.warmup(warmup_audio_data)
+        except Exception as error:
+            logger.exception(
+                "Error initializing preview transcription model: %s",
+                error,
+            )
+            raise
+
+    start_preview_transcription_worker(recorder)
+
 
 def _initialize_wakeword_detection(
     recorder,