supervoxtral 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

{supervoxtral-0.1.1.dist-info → supervoxtral-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supervoxtral
-Version: 0.1.1
+Version: 0.1.3
 Summary: CLI/GUI audio recorder and transcription client using Mistral Voxtral (chat with audio and transcription).
 License: MIT
 License-File: LICENSE

{supervoxtral-0.1.1.dist-info → supervoxtral-0.1.3.dist-info}/RECORD

@@ -1,18 +1,18 @@
 svx/__init__.py,sha256=qPEe5u3PT8yOQN4MiOLj_Bd18HqcRb6fxnPDfdMUP7w,742
-svx/cli.py,sha256=8CHNw0ySKJb3ToG_65sPl2QbvSSoKxp1Jm1zRQJvjUI,8925
+svx/cli.py,sha256=FMDdOSwTncgMxBj_H2BAYcuCtDNX9wEelbqm4ddo0O0,9132
 svx/core/__init__.py,sha256=mhzXuIXo3kUzjWme0Bxhe4TQZQELlyEiG_89LUAPC7M,2856
 svx/core/audio.py,sha256=r0m5T1uzdsJ1j9YXgQ5clv15dvMwZBp_bk2aLpjnrkc,7684
 svx/core/clipboard.py,sha256=IFtiN2SnYKQIu0WXx0hCK8syvDXanBpm1Jr2a8X7y9s,3692
 svx/core/config.py,sha256=irODbQBOosIdWANaj1Mju4NfdvPiqTkV0gWmoTNjZRM,14569
-svx/core/pipeline.py,sha256=YdhkwwXC_50rUHaiwHJCrKGp4gwT93s1IAmvvYeCUfY,10243
+svx/core/pipeline.py,sha256=nqvCgK5Pbyx18mfACrN_mIDt546Bh7fKA6MF4XG1hxM,10637
 svx/core/prompt.py,sha256=z-TFVQjHr4mWYXWYLRjCIChg4dMvG4GGJYcIy5QQwJY,5099
 svx/core/storage.py,sha256=5_xKYEpvDhaixRxmSTBlyX_jt8ssjHwHzX9VodcrtJw,3213
 svx/providers/__init__.py,sha256=SzlSWpZSUIptbSrAnGfi0d0NX4hYTpT0ObWpYyskDdA,2634
 svx/providers/base.py,sha256=YoiI8KWVRGISh7dx9XXPr1Q1a7ZDu8vfeJFlPbcKr20,2695
 svx/providers/mistral.py,sha256=vrBatNZg0zGNkJ5Qfnfz6ZwP6QtBgIt9sT_w59zkSO0,6636
-svx/ui/qt_app.py,sha256=_cEhISVJcudDAsZrq9J1AZf_xPFvnp59s7gPipTpj2A,16509
-supervoxtral-0.1.1.dist-info/METADATA,sha256=rjFsXX6EeW8dUHdKcfCrBE-y4IHAXJ7F9yb-D9V-f3I,753
-supervoxtral-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-supervoxtral-0.1.1.dist-info/entry_points.txt,sha256=phJhRy3VkYHC6AR_tUB5CypHzG0ePRR9sB13HWE1vEg,36
-supervoxtral-0.1.1.dist-info/licenses/LICENSE,sha256=fCEBKmC4i-1WZAwoKjKWegfDd8qNsG8ECB7JyqoswyQ,1064
-supervoxtral-0.1.1.dist-info/RECORD,,
+svx/ui/qt_app.py,sha256=0XoAk-6vCJguYq1ZVZA5zm-00442HOds_ibDHoDz-J0,18466
+supervoxtral-0.1.3.dist-info/METADATA,sha256=SpB9BeL_dbolMTM6UydjskMHHy_gnA4QJ1RfZI-Q3kE,753
+supervoxtral-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+supervoxtral-0.1.3.dist-info/entry_points.txt,sha256=phJhRy3VkYHC6AR_tUB5CypHzG0ePRR9sB13HWE1vEg,36
+supervoxtral-0.1.3.dist-info/licenses/LICENSE,sha256=fCEBKmC4i-1WZAwoKjKWegfDd8qNsG8ECB7JyqoswyQ,1064
+supervoxtral-0.1.3.dist-info/RECORD,,

svx/cli.py

@@ -191,6 +191,11 @@ def record(
         user_prompt = None
         user_prompt_file = None
 
+    if gui and transcribe:
+        console.print("[yellow]Warning: --transcribe has no effect in GUI mode.[/yellow]")
+        console.print("[yellow]Use the 'Transcribe' or 'Prompt' buttons in the interface.[/yellow]")
+        transcribe = False
+
     # If GUI requested, launch GUI with the resolved parameters and exit.
     if gui:
         from svx.ui.qt_app import run_gui
@@ -202,7 +207,6 @@ def record(
             user_prompt_file=user_prompt_file,
             save_all=save_all,
             outfile_prefix=outfile_prefix,
-            transcribe_mode=transcribe,
         )
         return
 

svx/core/pipeline.py

@@ -50,6 +50,60 @@ class RecordingPipeline:
             self.progress_callback(msg)
         logging.info(msg)
 
+    def record(self, stop_event: threading.Event | None = None) -> tuple[Path, float]:
+        """
+        Record audio and return wav_path, duration.
+
+        Returns:
+            tuple[Path, float]: wav_path, duration.
+        """
+        # Resolve parameters
+        _provider = self.cfg.defaults.provider
+        audio_format = self.cfg.defaults.format
+        model = self.cfg.defaults.model
+        _original_model = model
+        _language = self.cfg.defaults.language
+        rate = self.cfg.defaults.rate
+        channels = self.cfg.defaults.channels
+        device = self.cfg.defaults.device
+        base = self.outfile_prefix or f"rec_{timestamp()}"
+        keep_audio = self.save_all or self.cfg.defaults.keep_audio_files
+
+        # Validation (fail fast)
+        if channels not in (1, 2):
+            raise ValueError("channels must be 1 or 2")
+        if rate <= 0:
+            raise ValueError("rate must be > 0")
+        if audio_format not in {"wav", "mp3", "opus"}:
+            raise ValueError("format must be one of wav|mp3|opus")
+
+        stop_for_recording = stop_event or threading.Event()
+
+        self._status("Recording...")
+        if keep_audio:
+            self.cfg.recordings_dir.mkdir(parents=True, exist_ok=True)
+            wav_path = self.cfg.recordings_dir / f"{base}.wav"
+            duration = record_wav(
+                wav_path,
+                samplerate=rate,
+                channels=channels,
+                device=device,
+                stop_event=stop_for_recording,
+            )
+        else:
+            # Use mktemp for temp wav_path
+            wav_path = Path(tempfile.mktemp(suffix=".wav"))
+            duration = record_wav(
+                wav_path,
+                samplerate=rate,
+                channels=channels,
+                device=device,
+                stop_event=stop_for_recording,
+            )
+
+        self._status("Recording completed.")
+        return wav_path, duration
+
     def _setup_save_all(self) -> None:
         """Apply save_all overrides: set keeps to True, create dirs, add file logging."""
         if not self.save_all:
@@ -78,183 +132,155 @@ class RecordingPipeline:
             root_logger.addHandler(file_handler)
             logging.info("File logging enabled for this run")
 
-    def run(self, stop_event: threading.Event | None = None) -> dict[str, Any]:
+    def process(
+        self, wav_path: Path, duration: float, transcribe_mode: bool, user_prompt: str | None = None
+    ) -> dict[str, Any]:
         """
-        Execute the full pipeline.
+        Process recorded audio: convert if needed, transcribe, save, copy.
 
         Args:
-            stop_event: Optional event to signal recording stop (e.g., for GUI).
+            wav_path: Path to the recorded WAV file.
+            duration: Recording duration in seconds.
+            transcribe_mode: Whether to use pure transcription mode.
+            user_prompt: User prompt to use (None for transcribe_mode).
 
         Returns:
             Dict with 'text' (str), 'raw' (dict), 'duration' (float),
             'paths' (dict of Path or None).
-
-        Raises:
-            Exception: On recording, conversion, or transcription errors.
         """
-        self._setup_save_all()
-
         # Resolve parameters
         provider = self.cfg.defaults.provider
         audio_format = self.cfg.defaults.format
         model = self.cfg.defaults.model
         original_model = model
-        if self.transcribe_mode:
+        if transcribe_mode:
             model = "voxtral-mini-latest"
             if original_model != "voxtral-mini-latest":
                 logging.warning(
-                    "Mode Transcribe : modèle override de '%s' vers 'voxtral-mini-latest' "
-                    "(optimisé pour la transcription).",
+                    "Transcribe mode: model override from '%s' to 'voxtral-mini-latest'\n"
+                    "(optimized for transcription).",
                     original_model,
                 )
         language = self.cfg.defaults.language
-        rate = self.cfg.defaults.rate
-        channels = self.cfg.defaults.channels
-        device = self.cfg.defaults.device
-        base = self.outfile_prefix or f"rec_{timestamp()}"
+        if wav_path.stem.endswith(".wav"):
+            base = wav_path.stem.replace(".wav", "")
+        else:
+            base = wav_path.stem
+        keep_transcript = self.save_all or self.cfg.defaults.keep_transcript_files
+        copy_to_clip = self.cfg.defaults.copy
+
+        # Resolve user prompt if not provided
+        final_user_prompt = None
+        if not transcribe_mode:
+            if user_prompt is None:
+                final_user_prompt = self.cfg.resolve_prompt(self.user_prompt, self.user_prompt_file)
+            else:
+                final_user_prompt = user_prompt
+            self._status("Transcribe mode not activated: using prompt.")
+        else:
+            self._status("Transcribe mode activated: no prompt used.")
+
+        paths: dict[str, Path | None] = {"wav": wav_path}
+
+        # Convert if needed
+        to_send_path = wav_path
+        _converted = False
+        if audio_format in {"mp3", "opus"}:
+            self._status("Converting...")
+            to_send_path = convert_audio(wav_path, audio_format)
+            logging.info("Converted %s -> %s", wav_path, to_send_path)
+            paths["converted"] = to_send_path
+            _converted = True
+
+        # Transcribe
+        self._status("Transcribing...")
+        prov = get_provider(provider, cfg=self.cfg)
+        result = prov.transcribe(
+            to_send_path,
+            user_prompt=final_user_prompt,
+            model=model,
+            language=language,
+            transcribe_mode=transcribe_mode,
+        )
+        text = result["text"]
+        raw = result["raw"]
+
+        # Save if keeping transcripts
+        if keep_transcript:
+            self.cfg.transcripts_dir.mkdir(parents=True, exist_ok=True)
+            txt_path, json_path = save_transcript(
+                self.cfg.transcripts_dir, base, provider, text, raw
+            )
+            paths["txt"] = txt_path
+            paths["json"] = json_path
+        else:
+            paths["txt"] = None
+            paths["json"] = None
+
+        # Copy to clipboard
+        if copy_to_clip:
+            try:
+                copy_to_clipboard(text)
+                logging.info("Copied transcription to clipboard")
+            except Exception as e:
+                logging.warning("Failed to copy to clipboard: %s", e)
+
+        logging.info("Processing finished (%.2fs)", duration)
+        return {
+            "text": text,
+            "raw": raw,
+            "duration": duration,
+            "paths": paths,
+        }
+
+    def clean(self, wav_path: Path, paths: dict[str, Path | None], keep_audio: bool) -> None:
+        """
+        Clean up temporary files.
+
+        Args:
+            wav_path: The original WAV path.
+            paths: The paths dict from process().
+            keep_audio: Whether to keep audio files (if True, no deletion).
+        """
+        if not keep_audio and wav_path.exists():
+            wav_path.unlink()
+            logging.info("Deleted temp WAV: %s", wav_path)
+
+        if "converted" in paths and paths["converted"] and paths["converted"] != wav_path:
+            if paths["converted"].exists():
+                paths["converted"].unlink()
+                logging.info("Deleted temp converted: %s", paths["converted"])
+
+        self._status("Cleanup completed.")
+
+    def run(self, stop_event: threading.Event | None = None) -> dict[str, Any]:
+        """
+        Execute the full pipeline.
+
+        Args:
+            stop_event: Optional event to signal recording stop (e.g., for GUI).
+
+        Returns:
+            Dict with 'text' (str), 'raw' (dict), 'duration' (float),
+            'paths' (dict of Path or None).
+
+        Raises:
+            Exception: On recording, conversion, or transcription errors.
+        """
+        self._setup_save_all()
+
+        wav_path, duration = self.record(stop_event)
+        keep_audio = self.save_all or self.cfg.defaults.keep_audio_files
+
         if self.transcribe_mode:
             final_user_prompt = None
             self._status("Mode Transcribe activated: no prompt used.")
         else:
             final_user_prompt = self.cfg.resolve_prompt(self.user_prompt, self.user_prompt_file)
-        keep_audio = self.cfg.defaults.keep_audio_files
-        keep_transcript = self.cfg.defaults.keep_transcript_files
-        copy_to_clip = self.cfg.defaults.copy
 
-        # Validation (fail fast)
-        if channels not in (1, 2):
-            raise ValueError("channels must be 1 or 2")
-        if rate <= 0:
-            raise ValueError("rate must be > 0")
-        if audio_format not in {"wav", "mp3", "opus"}:  # noqa: E501
-            raise ValueError("format must be one of wav|mp3|opus")
+        result = self.process(wav_path, duration, self.transcribe_mode, final_user_prompt)
 
-        paths: dict[str, Path | None] = {}
-        stop_for_recording = stop_event or threading.Event()
+        self.clean(wav_path, result["paths"], keep_audio=keep_audio)
 
-        try:
-            self._status("Recording...")
-            if keep_audio:
-                self.cfg.recordings_dir.mkdir(parents=True, exist_ok=True)
-                wav_path = self.cfg.recordings_dir / f"{base}.wav"
-                duration = record_wav(
-                    wav_path,
-                    samplerate=rate,
-                    channels=channels,
-                    device=device,
-                    stop_event=stop_for_recording,
-                )
-                to_send_path = wav_path
-                paths["wav"] = wav_path
-            else:
-                with tempfile.TemporaryDirectory() as tmpdir:
-                    tmp_path = Path(tmpdir)
-                    wav_path = tmp_path / f"{base}.wav"
-                    duration = record_wav(
-                        wav_path,
-                        samplerate=rate,
-                        channels=channels,
-                        device=device,
-                        stop_event=stop_for_recording,
-                    )
-                    to_send_path = wav_path
-
-                    # Convert if needed
-                    if audio_format in {"mp3", "opus"}:
-                        self._status("Converting...")
-                        to_send_path = convert_audio(wav_path, audio_format)
-                        logging.info("Converted %s -> %s", wav_path, to_send_path)
-
-                    # Transcribe
-                    self._status("Transcribing...")
-                    prov = get_provider(provider, cfg=self.cfg)
-                    result = prov.transcribe(
-                        to_send_path,
-                        user_prompt=final_user_prompt,
-                        model=model,
-                        language=language,
-                        transcribe_mode=self.transcribe_mode,
-                    )
-                    text = result["text"]
-                    raw = result["raw"]
-
-                    # Save if keeping transcripts
-                    if keep_transcript:
-                        self.cfg.transcripts_dir.mkdir(parents=True, exist_ok=True)
-                        txt_path, json_path = save_transcript(
-                            self.cfg.transcripts_dir, base, provider, text, raw
-                        )
-                        paths["txt"] = txt_path
-                        paths["json"] = json_path
-                    else:
-                        paths["txt"] = None
-                        paths["json"] = None
-
-                    # Copy to clipboard
-                    if copy_to_clip:
-                        try:
-                            copy_to_clipboard(text)
-                            logging.info("Copied transcription to clipboard")
-                        except Exception as e:
-                            logging.warning("Failed to copy to clipboard: %s", e)
-
-                    logging.info("Pipeline finished (%.2fs)", duration)
-                    return {
-                        "text": text,
-                        "raw": raw,
-                        "duration": duration,
-                        "paths": paths,
-                    }
-
-            # For keep_audio=True: continue outside tempdir
-            # Convert if needed
-            if audio_format in {"mp3", "opus"}:
-                self._status("Converting...")
-                to_send_path = convert_audio(wav_path, audio_format)
-                logging.info("Converted %s -> %s", wav_path, to_send_path)
-                paths["converted"] = to_send_path
-
-            # Transcribe
-            self._status("Transcribing...")
-            prov = get_provider(provider, cfg=self.cfg)
-            result = prov.transcribe(
-                to_send_path,
-                user_prompt=final_user_prompt,
-                model=model,
-                language=language,
-                transcribe_mode=self.transcribe_mode,
-            )
-            text = result["text"]
-            raw = result["raw"]
-
-            # Save if keeping transcripts
-            if keep_transcript:
-                self.cfg.transcripts_dir.mkdir(parents=True, exist_ok=True)
-                txt_path, json_path = save_transcript(
-                    self.cfg.transcripts_dir, base, provider, text, raw
-                )
-                paths["txt"] = txt_path
-                paths["json"] = json_path
-            else:
-                paths["txt"] = None
-                paths["json"] = None
-
-            # Copy to clipboard
-            if copy_to_clip:
-                try:
-                    copy_to_clipboard(text)
-                    logging.info("Copied transcription to clipboard")
-                except Exception as e:
-                    logging.warning("Failed to copy to clipboard: %s", e)
-
-            logging.info("Pipeline finished (%.2fs)", duration)
-            return {
-                "text": text,
-                "raw": raw,
-                "duration": duration,
-                "paths": paths,
-            }
-
-        except Exception:
-            logging.exception("Pipeline failed")
-            raise
+        logging.info("Pipeline finished (%.2fs)", duration)
+        return result

svx/ui/qt_app.py

@@ -19,12 +19,14 @@ from __future__ import annotations
 
 import logging
 import threading
+import time
 from pathlib import Path
 
 from PySide6.QtCore import QObject, QPoint, Qt, QTimer, Signal
 from PySide6.QtGui import QAction, QFont, QFontDatabase, QKeySequence
 from PySide6.QtWidgets import (
     QApplication,
+    QHBoxLayout,
     QLabel,
     QMessageBox,
     QPushButton,
@@ -63,20 +65,32 @@ QLabel#info_label {
 
 /* Stop button */
 QPushButton {
-    background-color: #1f6feb;
+    background-color: #1e40af;
     color: #ffffff;
     border: none;
-    border-radius: 6px;
-    padding: 8px 14px;
+    border-radius: 2px;
+    padding: 4px 8px;
     margin: 6px;
-    min-width: 80px;
+    min-width: 60px;
 }
 QPushButton:disabled {
-    background-color: #274a7a;
-    color: #9fb8e6;
+    background-color: #374151;
+    color: #9ca3af;
 }
 QPushButton:hover {
-    background-color: #2a78ff;
+    background-color: #1d4ed8;
+}
+
+/* Cancel button */
+QPushButton#cancel_btn {
+    background-color: #b91c1c;
+}
+QPushButton#cancel_btn:hover {
+    background-color: #ef4444;
+}
+QPushButton#cancel_btn:disabled {
+    background-color: #4b5563;
+    color: #9ca3af;
 }
 
 /* Small window border effect (subtle) */
@@ -189,12 +203,12 @@ class RecorderWorker(QObject):
         status (str): human-readable status updates for the UI.
         done (str): emitted with the final transcription text on success.
         error (str): emitted with an error message on failure.
-    Supports transcribe_mode for pure transcription without prompt.
     """
 
     status = Signal(str)
     done = Signal(str)
     error = Signal(str)
+    canceled = Signal()
 
     def __init__(
         self,
@@ -203,7 +217,6 @@ class RecorderWorker(QObject):
         user_prompt_file: Path | None = None,
         save_all: bool = False,
         outfile_prefix: str | None = None,
-        transcribe_mode: bool = False,
     ) -> None:
         super().__init__()
         self.cfg = cfg
@@ -211,13 +224,21 @@ class RecorderWorker(QObject):
         self.user_prompt_file = user_prompt_file
         self.save_all = save_all
         self.outfile_prefix = outfile_prefix
-        self.transcribe_mode = transcribe_mode
+        self.mode: str | None = None
+        self.cancel_requested: bool = False
         self._stop_event = threading.Event()
 
+    def set_mode(self, mode: str) -> None:
+        self.mode = mode
+
     def stop(self) -> None:
         """Request the recording to stop."""
         self._stop_event.set()
 
+    def cancel(self) -> None:
+        self.cancel_requested = True
+        self._stop_event.set()
+
     def _resolve_user_prompt(self) -> str:
         """
         Determine the final user prompt using the shared resolver.
@@ -227,14 +248,12 @@ class RecorderWorker(QObject):
     def run(self) -> None:
         """
         Execute the pipeline:
-        - record_wav (until stop)
-        - optional convert (mp3/opus)
-        - provider.transcribe
-        - save_transcript
-        - copy_to_clipboard
-        - optionally delete audio files
-        Supports transcribe_mode for pure transcription without prompt.
+        - record (until stop)
+        - wait for mode
+        - process
+        - clean
         """
+
         try:
             pipeline = RecordingPipeline(
                 cfg=self.cfg,
@@ -242,10 +261,24 @@ class RecorderWorker(QObject):
                 user_prompt_file=self.user_prompt_file,
                 save_all=self.save_all,
                 outfile_prefix=self.outfile_prefix,
-                transcribe_mode=self.transcribe_mode,
                 progress_callback=self.status.emit,
             )
-            result = pipeline.run(stop_event=self._stop_event)
+            self.status.emit("Recording in progress...")
+            wav_path, duration = pipeline.record(self._stop_event)
+            self.status.emit("Recording finished.")
+            if self.cancel_requested:
+                keep_audio = self.save_all or self.cfg.defaults.keep_audio_files
+                pipeline.clean(wav_path, {"wav": wav_path}, keep_audio)
+                self.canceled.emit()
+                return
+            self.status.emit("Processing in progress...")
+            while self.mode is None:
+                time.sleep(0.05)
+            transcribe_mode = self.mode == "transcribe"
+            user_prompt = None if transcribe_mode else self._resolve_user_prompt()
+            result = pipeline.process(wav_path, duration, transcribe_mode, user_prompt)
+            keep_audio = self.save_all or self.cfg.defaults.keep_audio_files
+            pipeline.clean(wav_path, result["paths"], keep_audio)
             self.done.emit(result["text"])
         except Exception as e:
             logging.exception("Pipeline failed")
@@ -254,13 +287,12 @@ class RecorderWorker(QObject):
 
 class RecorderWindow(QWidget):
     """
-    Frameless always-on-top window with a single Stop button.
+    Frameless always-on-top window with Transcribe and Prompt buttons.
 
     Launching this window will immediately start the recording in a background thread.
 
     Window can be dragged by clicking anywhere on the widget background.
-    Pressing Esc triggers Stop.
-    Supports transcribe_mode for pure transcription without prompt.
+    Pressing Esc triggers Prompt mode.
     """
 
     def __init__(
@@ -270,7 +302,6 @@ class RecorderWindow(QWidget):
         user_prompt_file: Path | None = None,
         save_all: bool = False,
         outfile_prefix: str | None = None,
-        transcribe_mode: bool = False,
     ) -> None:
         super().__init__()
 
@@ -279,7 +310,16 @@ class RecorderWindow(QWidget):
         self.user_prompt_file = user_prompt_file
         self.save_all = save_all
         self.outfile_prefix = outfile_prefix
-        self.transcribe_mode = transcribe_mode
+
+        # Background worker (create early for signal connections)
+        self._worker = RecorderWorker(
+            cfg=self.cfg,
+            user_prompt=user_prompt,
+            user_prompt_file=user_prompt_file,
+            save_all=save_all,
+            outfile_prefix=outfile_prefix,
+        )
+        self._thread = threading.Thread(target=self._worker.run, daemon=True)
 
         # Environment and prompt files
 
@@ -313,14 +353,9 @@ class RecorderWindow(QWidget):
             "</span>"
         )
         format_html = f"<span style='color:#ffa657'>{self.cfg.defaults.format}</span>"
-        if self.transcribe_mode:
-            mode_html = "<span style='color:#ff7b72'>Transcribe</span>"
-        else:
-            mode_html = "<span style='color:#7ee787'>Completion</span>"
         parts = [
             prov_model_html,
             format_html,
-            mode_html,
         ]
         if self.cfg.defaults.language:
             lang_html = f"<span style='color:#c9b4ff'>{self.cfg.defaults.language}</span>"
@@ -337,34 +372,42 @@ class RecorderWindow(QWidget):
         self._info_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
         layout.addWidget(self._info_label)
 
-        self._status_label = QLabel("Recording... Press Stop to finish")
+        self._status_label = QLabel("Recording in progress...")
         self._status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
         layout.addWidget(self._status_label)
 
-        self._stop_btn = QPushButton("Stop")
-        self._stop_btn.clicked.connect(self._on_stop_clicked)
-        layout.addWidget(self._stop_btn, 0, Qt.AlignmentFlag.AlignCenter)
+        # Buttons layout
+        button_layout = QHBoxLayout()
+        button_layout.addStretch()
+        self._transcribe_btn = QPushButton("Transcribe")
+        self._transcribe_btn.setToolTip("Stop and transcribe without prompt")
+        self._transcribe_btn.clicked.connect(lambda: self._on_button_clicked("transcribe"))
+        button_layout.addWidget(self._transcribe_btn)
+        self._prompt_btn = QPushButton("Prompt")
+        self._prompt_btn.setToolTip("Stop and transcribe with prompt")
+        self._prompt_btn.clicked.connect(lambda: self._on_button_clicked("prompt"))
+        button_layout.addWidget(self._prompt_btn)
+        self._cancel_btn = QPushButton("Cancel")
+        self._cancel_btn.setObjectName("cancel_btn")
+        self._cancel_btn.setToolTip("Stop recording and quit without processing")
+        self._cancel_btn.clicked.connect(self._on_cancel_clicked)
+        button_layout.addWidget(self._cancel_btn)
+        button_layout.addStretch()
+        button_widget = QWidget()
+        button_widget.setLayout(button_layout)
+        layout.addWidget(button_widget, 0, Qt.AlignmentFlag.AlignCenter)
 
         # Keyboard shortcut: Esc to stop
         stop_action = QAction(self)
         stop_action.setShortcut(QKeySequence.StandardKey.Cancel)  # Esc
-        stop_action.triggered.connect(self._on_stop_clicked)
+        stop_action.triggered.connect(lambda: self._worker.cancel())
         self.addAction(stop_action)
 
-        # Background worker
-        self._worker = RecorderWorker(
-            cfg=self.cfg,
-            user_prompt=user_prompt,
-            user_prompt_file=user_prompt_file,
-            save_all=save_all,
-            outfile_prefix=outfile_prefix,
-        )
-        self._thread = threading.Thread(target=self._worker.run, daemon=True)
-
         # Signals wiring
         self._worker.status.connect(self._on_status)
         self._worker.done.connect(self._on_done)
         self._worker.error.connect(self._on_error)
+        self._worker.canceled.connect(self._close_soon)
 
         # Apply stylesheet to the application for consistent appearance
         app = QApplication.instance()
@@ -410,14 +453,24 @@ class RecorderWindow(QWidget):
 
     def closeEvent(self, event) -> None:  # type: ignore[override]
         # Attempt to stop recording if the user closes the window via window controls.
-        self._worker.stop()
+        self._worker.cancel()
         super().closeEvent(event)
 
-    def _on_stop_clicked(self) -> None:
-        self._stop_btn.setEnabled(False)
-        self._status_label.setText("Stopping...")
+    def _on_button_clicked(self, mode: str) -> None:
+        self._transcribe_btn.setEnabled(False)
+        self._prompt_btn.setEnabled(False)
+        self._cancel_btn.setEnabled(False)
+        self._status_label.setText("Stopping and processing...")
+        self._worker.set_mode(mode)
         self._worker.stop()
 
+    def _on_cancel_clicked(self) -> None:
+        self._transcribe_btn.setEnabled(False)
+        self._prompt_btn.setEnabled(False)
+        self._cancel_btn.setEnabled(False)
+        self._status_label.setText("Canceling...")
+        self._worker.cancel()
+
     # --- Drag handling for frameless window ---
     def mousePressEvent(self, event) -> None:  # type: ignore[override]
         if event.button() == Qt.MouseButton.LeftButton:
@@ -447,7 +500,7 @@ class RecorderWindow(QWidget):
     def keyPressEvent(self, event) -> None:  # type: ignore[override]
         # Qt.Key_Escape is a safety stop
         if event.key() == Qt.Key.Key_Escape:
-            self._on_stop_clicked()
+            self._worker.cancel()
         else:
             super().keyPressEvent(event)
 
@@ -458,14 +511,12 @@ def run_gui(
     user_prompt_file: Path | None = None,
     save_all: bool = False,
     outfile_prefix: str | None = None,
-    transcribe_mode: bool = False,
     log_level: str = "INFO",
 ) -> None:
     if cfg is None:
         cfg = Config.load(log_level=log_level)
     """
     Launch the PySide6 app with the minimal recorder window.
-    Supports transcribe_mode for pure transcription without prompt.
     """
     config.setup_environment(log_level=log_level)
 
@@ -485,7 +536,6 @@ def run_gui(
         user_prompt_file=user_prompt_file,
         save_all=save_all,
         outfile_prefix=outfile_prefix,
-        transcribe_mode=transcribe_mode,
     )
     window.show()
     app.exec()