unslothai/unsloth · warning · SttUnavailableError

The local transcription runtime is being updated. Try dictat

Error message

The local transcription runtime is being updated. Try dictation again shortly.

What it means

Raised by SttMtmdSidecar._raise_if_update_in_progress() as SttUnavailableError when the llama.cpp runtime tree the dictation sidecar's executable lives in is being swapped by update_maintenance(). The _update_in_progress flag is published before the update waits on startup locks, so any load() call that checks it (before or inside _start_lock) is refused for the duration of the binary replacement.

Source

Thrown at studio/backend/core/inference/stt_mtmd_sidecar.py:760

        if process is not None and process.poll() is None:
            try:
                process.terminate()
            except Exception:
                pass
        return True

    def wait_for_load_to_settle(self) -> None:
        """Block until a cancelled startup has been reaped and its VRAM freed.

        load() holds _start_lock across startup and its cleanup, so taking it
        is the wait.
        """
        with self._start_lock:
            pass

    def _raise_if_update_in_progress(self) -> None:
        if self._update_in_progress:
            raise SttUnavailableError(
                "The local transcription runtime is being updated. Try dictation again shortly."
            )

    @contextmanager
    def update_maintenance(self) -> Iterator[bool]:
        """Block new loads while the llama.cpp tree this binary lives in is
        replaced. The chat backend coordinates its own server; this sidecar runs
        the same executable, so on Windows a live one blocks the swap.

        The guard is published before waiting for the locks, so a load already
        past its own check still cannot start a process against a half-swapped
        tree. Yields whether a warm server had to be unloaded.
        """
        self._update_in_progress = True
        try:
            with self._start_lock, self._lock:
                model_was_active = self._process_alive()
                self._release_locked()

View on GitHub (pinned to 203007d190)

Solutions

Wait for the update to finish (it typically takes seconds) and retry the load/dictation request.
If it persists, check that no update_maintenance() block is stuck holding _update_in_progress (e.g. a hung updater) and restart the studio backend.
Ensure only one update coordinator runs at a time so the maintenance window stays short.

Defensive patterns

Strategy: retry

Validate before calling

```python
if sidecar._update_in_progress:
    return "runtime updating", 503  # back off and retry shortly
```

Try / catch

```python
try:
    sidecar.load(model_id)
except SttUnavailableError as exc:
    if "being updated" in str(exc):
        backoff_and_retry(delay=2.0)  # maintenance window is short
    raise
```

Prevention

Surface a 'runtime updating' state in the UI and disable the dictation button during update_maintenance().
Coordinate updates through a single owner so the maintenance window is short.
Retry with backoff once or twice before showing an error.

When it happens

Trigger: Calling load() or a transcription that triggers load() while an `with sidecar.update_maintenance():` block is active, i.e. the studio backend is replacing the llama.cpp binaries (notably on Windows, where a live llama-server process locks the executable).

Common situations: A runtime self-update kicked off while the user started dictation; two studio components (chat backend and STT sidecar share the same llama-server executable) racing one update; retrying dictation immediately after an update prompt.

Related errors

AI-assisted analysis of unslothai/unsloth@203007d190 (2026-08-15). Data as JSON: /api/errors/92849dd52b5ee44a. Report an issue: GitHub.