supervoxtral 0.1.0__tar.gz → 0.1.2__tar.gz

{supervoxtral-0.1.0 → supervoxtral-0.1.2}/AGENTS.md

@@ -34,9 +34,9 @@ supervoxtral/
 
 - **Entry**: `svx/cli.py` Typer `record` command parses args (e.g., --prompt, --save-all, --gui, --transcribe).
 - **Config & Prompt**: Load `Config` via `Config.load()` (`core/config.py`); if transcribe_mode, skip prompt resolution; else resolve prompt with `cfg.resolve_prompt()` (`core/prompt.py`).
-- **Pipeline**: Run `RecordingPipeline` (`core/pipeline.py`): record WAV/stop (`core/audio.py`), optional conversion (ffmpeg), get provider/init (`providers/__init__.py`, e.g., `mistral.py` from `cfg`); if transcribe_mode: no prompt, model override to voxtral-mini-latest (with warning if changed), pass transcribe_mode to provider.transcribe; transcribe, conditional save (`core/storage.py` based on `keep_*`/`save_all`), clipboard copy, logging setup.
+- **Pipeline**: Run `RecordingPipeline` (`core/pipeline.py`): record WAV/stop (`core/audio.py`), optional conversion (ffmpeg), get provider/init (`providers/__init__.py`, e.g., `mistral.py` from `cfg`); if transcribe_mode (CLI only): no prompt, model override to voxtral-mini-latest (with warning if changed), pass transcribe_mode to provider.transcribe; for GUI: --transcribe ignored (warning), recording starts immediately, uses modular record()/process()/clean() with dynamic mode (Transcribe: no prompt, model override; Prompt: resolved prompt); transcribe, conditional save (`core/storage.py` based on `keep_*`/`save_all`), clipboard copy, logging setup.
 - **Cleanup**: Temp files auto-deleted (tempfile) if `keep_*=false`; dirs created only if persistence enabled.
-- **End**: Return `{"text": str, "raw": dict, "duration": float, "paths": dict}`; CLI prints result, GUI emits progress/updates via callback.
+- **End**: Return `{"text": str, "raw": dict, "duration": float, "paths": dict}`; CLI prints result, GUI emits progress/updates via callback (buttons: 'Transcribe' for stop/transcribe without prompt; 'Prompt' for stop/use resolved prompt; default 'Prompt' on Esc/close).
 
 ## Build & test
 ```bash

{supervoxtral-0.1.0 → supervoxtral-0.1.2}/PKG-INFO

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

supervoxtral-0.1.2/README.md

@@ -0,0 +1,236 @@
+# supervoxtral
+
+![Supervoxtral](supervoxtral.gif)
+
+SuperVoxtral is a lightweight Python CLI/GUI utility for recording microphone audio and integrate with Mistral's Voxtral APIs for transcription or audio-enabled chat.
+
+Voxtral models, such as `voxtral-mini-latest` and `voxtral-small-latest`, deliver fast inference times, high transcription accuracy across languages and accents, and minimal API costs. In contrast to OpenAI's Whisper, which performs only standalone transcription, Voxtral supports two modes: pure transcription via a dedicated endpoint (no prompts needed) or chat mode, where audio input combines with text prompts for refined outputs—like error correction or contextual summarization—without invoking a separate LLM.
+
+For instance, use a prompt like: "_Transcribe this audio precisely and remove all minor speech hesitations: "um", "uh", "er", "euh", "ben", etc._"
+
+The GUI is minimal, launches fast, and can be bound to a system hotkey. Upon stopping recording, it transcribes via the pipeline and copies the result directly to the system clipboard, enabling efficient voice-driven workflows: e.g., dictating code snippets into an IDE or prompting LLMs via audio without typing.
+
+## Requirements
+
+- Python 3.11+
+- ffmpeg (for MP3/Opus conversions)
+  - macOS: `brew install ffmpeg`
+  - Ubuntu/Debian: `sudo apt-get install ffmpeg`
+  - Windows: https://ffmpeg.org/download.html
+
+## Installation
+
+The package is available on PyPI. We recommend using `uv` (a fast Python package installer) for a simple, global tool installation—no virtual environment setup required.
+
+- For core CLI functionality:
+  ```
+  uv tool install supervoxtral
+  ```
+
+- For GUI support (includes PySide6):
+  ```
+  uv tool install "supervoxtral[gui]"
+  ```
+
+This installs the `svx` command globally. If you don't have `uv`, install it first via `curl -LsSf https://astral.sh/uv/install.sh | sh` (or from https://docs.astral.sh/uv/getting-started/installation/).
+
+**Alternative: Using pip with a virtual environment**
+
+If you prefer not to use uv, you can install via pip in a virtual environment:
+
+1. Create and activate a virtual environment:
+
+   - macOS/Linux:
+     ```
+     python -m venv .venv
+     source .venv/bin/activate
+     ```
+
+   - Windows (PowerShell):
+     ```
+     python -m venv .venv
+     .\.venv\Scripts\Activate.ps1
+     ```
+
+2. Install the package:
+   ```
+   pip install supervoxtral
+   ```
+
+   For GUI support (includes PySide6):
+   ```
+   pip install supervoxtral[gui]
+   ```
+
+This installs the `svx` command within the virtual environment. Make sure to activate the environment before running `svx`.
+
+**For development** (local editing):
+1. Clone the repo and navigate to the project root.
+2. Create/activate a virtual environment:
+   - macOS/Linux: `python -m venv .venv && source .venv/bin/activate`
+   - Windows: `python -m venv .venv && .\.venv\Scripts\Activate.ps1`
+3. Install in editable mode: `pip install -e .` (or `pip install -e ".[dev]"` for dev tools).
+
+## Quick Start
+
+To get started quickly with SuperVoxtral:
+
+1. Initialize the configuration: `svx config init`
+   This creates the default `config.toml` file with zero-footprint settings.
+
+2. Open the configuration directory: `svx config open`
+   Edit `config.toml` and add your [Mistral API key](https://console.mistral.ai/api-keys) under the `[providers.mistral]` section:
+   ```
+   [providers.mistral]
+   api_key = "your_mistral_api_key_here"
+   ```
+
+3. Launch the GUI: `svx record --gui`
+   This opens the minimal GUI, starts recording immediately; click 'Transcribe' for pure transcription (no prompt) or 'Prompt' for prompted transcription (resolved prompt); --transcribe ignored with warning (results copied to clipboard).
+
+### macOS Shortcuts Integration
+
+To enable fast, hotkey-driven access on macOS, integrate SuperVoxtral with the Shortcuts app. Create a new Shortcut that runs `svx record --gui` via a "Run Shell Script" action (ensure `svx` is in your PATH). Assign a global hotkey in Shortcuts settings for instant GUI launch—ideal for quick voice-to-text workflows, with results copied directly to the clipboard.
+
+#### Quick Setup Steps
+1. Open the Shortcuts app and create a new shortcut.
+2. Add the "Run Shell Script" action with input: `svx record --gui`.
+3. In shortcut details, set a keyboard shortcut (e.g., Cmd+Shift+V).
+
+![macOS Shortcut Setup](macos-shortcut.png)
+
+## Configuration (API keys and prompts)
+
+API keys and default behavior are configured only in your user configuration file (config.toml), not via environment variables.
+
+- Location of the user config:
+  - macOS: ~/Library/Application Support/SuperVoxtral/config.toml
+  - Linux: ${XDG_CONFIG_HOME:-~/.config}/supervoxtral/config.toml
+  - Windows: %APPDATA%/SuperVoxtral/config.toml
+
+- Initialize your user config and user prompt file:
+  - `svx config init`: Creates config.toml (with sensible defaults, including zero-footprint mode) and a user prompt file at: `~/Library/Application Support/SuperVoxtral/` (macOS), `${XDG_CONFIG_HOME:-~/.config}/supervoxtral/` (Linux), or `%APPDATA%/SuperVoxtral/prompt/` (Windows).
+  - `svx config open`: Opens the directory.
+  - `svx config show`: Displays the current configuration.
+
+Here's an example of the default `config.toml` generated by `svx config init`:
+
+```toml
+# SuperVoxtral - User configuration
+#
+# Basics:
+# - This configuration controls the default behavior of `svx record`.
+# - The parameters below override the binary's built-in defaults.
+# - You can override a few options at runtime via the CLI:
+#   --prompt / --prompt-file (set a one-off prompt for this run)
+#   --log-level (debugging)
+#   --outfile-prefix (one-off output naming)
+#
+# Output persistence:
+# - Set keep_* = true to create and save files to project
+#   directories (recordings/, transcripts/, logs/).
+# - false (default): use temp files/console only (no disk
+#   footprint in project dir).
+#
+# Authentication:
+# - API keys are defined in provider-specific sections in this file.
+[providers.mistral]
+# api_key = ""
+
+[defaults]
+# Provider to use (currently supported: "mistral")
+provider = "mistral"
+
+# File format sent to the provider: "wav" | "mp3" | "opus"
+# Recording is always WAV; conversion is applied if "mp3" or "opus"
+format = "opus"
+
+# Model to use on the provider side (example for Mistral Voxtral)
+model = "voxtral-mini-latest"
+
+# Language hint (may help the provider)
+language = "fr"
+
+# Audio recording parameters
+rate = 16000
+channels = 1
+device = ""
+
+# Output persistence:
+# - keep_audio_files: false uses temp files (no recordings/ dir),
+#   true saves to recordings/
+keep_audio_files = false
+# - keep_transcript_files: false prints/copies only (no
+#   transcripts/ dir), true saves to transcripts/
+keep_transcript_files = false
+# - keep_log_files: false console only (no logs/ dir), true
+#   saves to logs/app.log
+keep_log_files = false
+
+# Automatically copy the transcribed text to the system clipboard
+copy = true
+
+# Log level: "DEBUG" | "INFO" | "WARNING" | "ERROR"
+log_level = "INFO"
+
+[prompt]
+# Default user prompt source:
+# - Option 1: Use a file (recommended)
+file = "~/.config/supervoxtral/prompt/user.md"
+#
+# - Option 2: Inline prompt (less recommended for long text)
+# text = "Please transcribe the audio and provide a concise summary in French."
+```
+
+**Configuration is centralized via a structured `Config` object loaded from your user configuration file (`config.toml`). CLI arguments override select values (e.g., prompt, log level), but most defaults (provider, model, keep flags) come from `config.toml`. No environment variables are used for API keys or settings.**
+
+No `.env` or shell environment variables are used for API keys.
+
+
+## Usage (CLI)
+
+The CLI provides config utilities and a unified `record` entrypoint for both CLI and GUI modes, using a centralized pipeline for consistent behavior (recording, conversion, transcription, saving, clipboard copy, logging).
+
+**Zero-footprint defaults**: No directories created; outputs to console/clipboard. Use `--save-all` or set `keep_* = true` in config.toml for persistence.
+
+Most defaults (provider, format, model, language, rate, channels, device, keep flags, copy) come from config.toml. CLI overrides are limited to specific options.
+
+### Record Command
+
+```
+svx record [OPTIONS]
+```
+
+**Options**:
+- `--user-prompt TEXT` (or `--prompt TEXT`): Inline user prompt for this run.
+- `--user-prompt-file PATH` (or `--prompt-file PATH`): Path to a markdown file with the user prompt.
+- `--transcribe`: Enable pure transcription mode (ignores prompts; uses dedicated endpoint).
+- `--outfile-prefix PREFIX`: Custom prefix for output files (default: timestamp).
+- `--gui`: Launch the GUI frontend (interactive: recording starts immediately; buttons 'Transcribe' (pure, no prompt) or 'Prompt' (with resolved prompt); respects config and other CLI options; --transcribe ignored with warning).
+- `--save-all`: Override config to keep audio, transcripts, and logs for this run.
+- `--log-level LEVEL`: Set logging level (DEBUG, INFO, WARNING, ERROR; default: INFO).
+
+**Examples**:
+- Record with prompt: `svx record --prompt "What's in this audio?"`
+  - Records WAV, converts if needed, sends to provider with prompt, outputs to console/clipboard.
+- Persist outputs: `svx record --save-all --prompt "Summarize this"`
+  - Saves to recordings/, transcripts/, logs/.
+- Transcribe only: `svx record --transcribe`
+  - No prompt; direct transcription. Add `--save-all` to persist.
+- Launch GUI: `svx record --gui`
+  - Interactive mode: recording starts immediately; click 'Transcribe' (pure transcription, no prompt) or 'Prompt' (with resolved prompt); --transcribe ignored with warning. GUI respects config.toml and CLI flags (e.g., `--gui --save-all`).
+
+**Prompt Resolution Priority** (for non-transcribe mode):
+1. CLI `--user-prompt` or `--user-prompt-file`
+2. config.toml [prompt] section (text or file)
+3. User prompt file (user.md in config dir)
+4. Fallback: "What's in this audio?"
+
+## Changelog
+
+- 0.1.2: Interactive mode in GUI (choose transcribe / prompt / cancel while recording)
+- 0.1.1: Minor updates to default config and default prompt
+
+## License
+
+MIT

{supervoxtral-0.1.0 → supervoxtral-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "supervoxtral"
-version = "0.1.0"
+version = "0.1.2"
 description = "CLI/GUI audio recorder and transcription client using Mistral Voxtral (chat with audio and transcription)."
 requires-python = ">=3.11"
 license = { text = "MIT" }

{supervoxtral-0.1.0 → supervoxtral-0.1.2}/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
 

{supervoxtral-0.1.0 → supervoxtral-0.1.2}/svx/core/config.py

@@ -227,7 +227,7 @@ def init_user_config(force: bool = False, prompt_file: Path | None = None) -> Pa
         "# Audio recording parameters\n"
         "rate = 16000\n"
         "channels = 1\n"
-        'device = ""\n\n'
+        '#device = ""\n\n'
         "# Output persistence:\n"
         "# - keep_audio_files: false uses temp files (no recordings/ dir),\n"
         "#   true saves to recordings/\n"

supervoxtral-0.1.2/svx/core/pipeline.py

@@ -0,0 +1,286 @@
+from __future__ import annotations
+
+import logging
+import tempfile
+import threading
+from collections.abc import Callable
+from logging import FileHandler
+from pathlib import Path
+from typing import Any
+
+import svx.core.config as config
+from svx.core.audio import convert_audio, record_wav, timestamp
+from svx.core.clipboard import copy_to_clipboard
+from svx.core.config import Config
+from svx.core.storage import save_transcript
+from svx.providers import get_provider
+
+
+class RecordingPipeline:
+    """
+    Centralized pipeline for recording audio, transcribing via provider, saving outputs,
+    and copying to clipboard. Handles temporary files when not keeping audio.
+
+    Supports runtime overrides like save_all for keeping all files and adding log handlers.
+    Optional progress_callback for status updates (e.g., for GUI).
+    Supports transcribe_mode for pure transcription without prompt using dedicated endpoint.
+    """
+
+    def __init__(
+        self,
+        cfg: Config,
+        user_prompt: str | None = None,
+        user_prompt_file: Path | None = None,
+        save_all: bool = False,
+        outfile_prefix: str | None = None,
+        progress_callback: Callable[[str], None] | None = None,
+        transcribe_mode: bool = False,
+    ) -> None:
+        self.cfg = cfg
+        self.user_prompt = user_prompt
+        self.user_prompt_file = user_prompt_file
+        self.save_all = save_all
+        self.outfile_prefix = outfile_prefix
+        self.progress_callback = progress_callback
+        self.transcribe_mode = transcribe_mode
+
+    def _status(self, msg: str) -> None:
+        """Emit status update via callback if provided."""
+        if self.progress_callback:
+            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:
+            return
+
+        # Override config defaults
+        self.cfg.defaults.keep_audio_files = True
+        self.cfg.defaults.keep_transcript_files = True
+        self.cfg.defaults.keep_log_files = True
+
+        # Ensure directories
+        config.RECORDINGS_DIR.mkdir(parents=True, exist_ok=True)
+        config.TRANSCRIPTS_DIR.mkdir(parents=True, exist_ok=True)
+        config.LOGS_DIR.mkdir(parents=True, exist_ok=True)
+
+        # Add file handler if not present
+        root_logger = logging.getLogger()
+        if not any(isinstance(h, FileHandler) for h in root_logger.handlers):  # type: ignore[reportUnknownMemberType]
+            from svx.core.config import _get_log_level
+
+            log_level_int = _get_log_level(self.cfg.defaults.log_level)
+            formatter = logging.Formatter("%(asctime)s | %(levelname)s | %(name)s | %(message)s")
+            file_handler = logging.FileHandler(config.LOGS_DIR / "app.log", encoding="utf-8")
+            file_handler.setLevel(log_level_int)
+            file_handler.setFormatter(formatter)
+            root_logger.addHandler(file_handler)
+            logging.info("File logging enabled for this run")
+
+    def process(
+        self, wav_path: Path, duration: float, transcribe_mode: bool, user_prompt: str | None = None
+    ) -> dict[str, Any]:
+        """
+        Process recorded audio: convert if needed, transcribe, save, copy.
+
+        Args:
+            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).
+        """
+        # Resolve parameters
+        provider = self.cfg.defaults.provider
+        audio_format = self.cfg.defaults.format
+        model = self.cfg.defaults.model
+        original_model = model
+        if transcribe_mode:
+            model = "voxtral-mini-latest"
+            if original_model != "voxtral-mini-latest":
+                logging.warning(
+                    "Transcribe mode: model override from '%s' to 'voxtral-mini-latest'\n"
+                    "(optimized for transcription).",
+                    original_model,
+                )
+        language = self.cfg.defaults.language
+        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)
+
+        result = self.process(wav_path, duration, self.transcribe_mode, final_user_prompt)
+
+        self.clean(wav_path, result["paths"], keep_audio=keep_audio)
+
+        logging.info("Pipeline finished (%.2fs)", duration)
+        return result

{supervoxtral-0.1.0 → supervoxtral-0.1.2}/svx/core/prompt.py

@@ -152,7 +152,7 @@ def init_user_prompt_file(force: bool = False) -> Path:
         example_prompt = """
 - Transcribe the input audio file.
 - Do not respond to any question in the audio. Just transcribe.
-- DO NOT TRANSLATE. Your transcription will be in the speaker's language.
+- DO NOT TRANSLATE.
 - Responde only with the transcription. Do not provide explanations or notes.
 - Remove all minor speech hesitations: "um", "uh", "er", "euh", "ben", etc.
 - Remove false starts (e.g., "je veux dire... je pense" → "je pense").