agent-cli 0.98.1__tar.gz → 0.98.3__tar.gz

{agent_cli-0.98.1 → agent_cli-0.98.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-cli
-Version: 0.98.1
+Version: 0.98.3
 Summary: A suite of AI-powered command-line tools for text correction, audio transcription, and voice assistance.
 Project-URL: Homepage, https://github.com/basnijholt/agent-cli
 Author-email: Bas Nijholt <bas@nijho.lt>

{agent_cli-0.98.1 → agent_cli-0.98.3}/agent_cli/server/cli.py

@@ -351,7 +351,7 @@ def whisper_cmd(  # noqa: C901, PLR0912, PLR0915
             "--device",
             "-d",
             help=(
-                "Compute device: `auto` (detect GPU), `cuda`, `cuda:0`, `cpu`. "
+                "Compute device: `auto` (detect GPU), `cuda`, `cuda:0`, `mps`, `cpu`. "
                 "MLX backend always uses Apple Silicon"
             ),
         ),

{agent_cli-0.98.1 → agent_cli-0.98.3}/agent_cli/server/whisper/backends/nemo.py

@@ -6,6 +6,8 @@ import asyncio
 import inspect
 import io
 import logging
+import os
+import sys
 import tempfile
 import time
 import wave
@@ -89,18 +91,35 @@ _state = _SubprocessState()
 
 def _resolve_device(device: str) -> str:
     """Resolve the runtime device for NeMo inference."""
+    if device in {"auto", "mps"} and sys.platform == "darwin":
+        os.environ.setdefault("PYTORCH_ENABLE_MPS_FALLBACK", "1")
+
     import torch  # noqa: PLC0415
 
     if device == "auto":
-        return "cuda" if torch.cuda.is_available() else "cpu"
+        if torch.cuda.is_available():
+            return "cuda"
+        if _mps_available(torch):
+            return "mps"
+        return "cpu"
 
     if device.startswith("cuda") and not torch.cuda.is_available():
         msg = f"CUDA device requested ({device}) but CUDA is not available"
         raise RuntimeError(msg)
 
+    if device == "mps" and not _mps_available(torch):
+        msg = "MPS device requested (mps) but MPS is not available"
+        raise RuntimeError(msg)
+
     return device
 
 
+def _mps_available(torch: Any) -> bool:
+    """Return True when PyTorch exposes an available MPS backend."""
+    mps = getattr(getattr(torch, "backends", None), "mps", None)
+    return bool(mps is not None and mps.is_available())
+
+
 def _extract_text(hypothesis: Any) -> str:
     """Extract a transcript string from a NeMo hypothesis-like object."""
     if isinstance(hypothesis, str):

{agent_cli-0.98.1 → agent_cli-0.98.3}/docs/commands/server/whisper.md

@@ -112,7 +112,7 @@ agent-cli server whisper \
 |--------|---------|-------------|
 | `--model, -m` | - | Whisper model(s) to load. Common models: `tiny`, `base`, `small`, `medium`, `large-v3`, `distil-large-v3`, `parakeet-tdt-0.6b-v3`, `parakeet-unified-en-0.6b` (NeMo backend). Can specify multiple for different accuracy/speed tradeoffs. Default: `large-v3` (`parakeet-unified-en-0.6b` with `--backend nemo`) |
 | `--default-model` | - | Model to use when client doesn't specify one. Must be in the `--model` list |
-| `--device, -d` | `auto` | Compute device: `auto` (detect GPU), `cuda`, `cuda:0`, `cpu`. MLX backend always uses Apple Silicon |
+| `--device, -d` | `auto` | Compute device: `auto` (detect GPU), `cuda`, `cuda:0`, `mps`, `cpu`. MLX backend always uses Apple Silicon |
 | `--compute-type` | `auto` | Precision for faster-whisper: `auto`, `float16`, `int8`, `int8_float16`. Lower precision = faster + less VRAM |
 | `--cache-dir` | - | Custom directory for downloaded models (default: HuggingFace cache) |
 | `--default-language` | - | Fallback language code for requests that omit `language`. Required for models that do not support language auto-detection (for example Cohere Transcribe). |
@@ -269,6 +269,13 @@ pip install "agent-cli[mlx-whisper]"
 
 The server will automatically detect and use the MLX backend when available.
 
+For NeMo/Parakeet models on Apple Silicon, `--device auto` uses PyTorch MPS when
+available. You can also request it explicitly:
+
+```bash
+agent-cli server whisper --backend nemo --model parakeet-unified-en-0.6b --device mps
+```
+
 ### HuggingFace Transformers
 
 For loading models in safetensors format (instead of CTranslate2 `.bin` files):

{agent_cli-0.98.1 → agent_cli-0.98.3}/macos/AgentCLI/Sources/AgentCLI/ConfigurableHotkeyController.swift

@@ -3,6 +3,70 @@ import Carbon.HIToolbox
 import Foundation
 import KeyboardShortcuts
 
+enum HoldToTranscribeStopDecision: Equatable {
+    case none
+    case deferUntilStartCompletes
+    case stopNow
+}
+
+struct HoldToTranscribeKeyState {
+    private enum State {
+        case idle
+        case startPending(releaseRequested: Bool)
+        case recording
+    }
+
+    private var state: State = .idle
+
+    var isStartPendingOrRecording: Bool {
+        switch state {
+        case .idle:
+            return false
+        case .startPending, .recording:
+            return true
+        }
+    }
+
+    mutating func requestStart() -> Bool {
+        guard case .idle = state else { return false }
+        state = .startPending(releaseRequested: false)
+        return true
+    }
+
+    mutating func releaseKey() -> HoldToTranscribeStopDecision {
+        switch state {
+        case .idle:
+            return .none
+        case .startPending:
+            state = .startPending(releaseRequested: true)
+            return .deferUntilStartCompletes
+        case .recording:
+            state = .idle
+            return .stopNow
+        }
+    }
+
+    mutating func completeStart(started: Bool) -> HoldToTranscribeStopDecision {
+        guard case let .startPending(releaseRequested) = state else { return .none }
+        guard started else {
+            state = .idle
+            return .none
+        }
+
+        if releaseRequested {
+            state = .idle
+            return .stopNow
+        }
+
+        state = .recording
+        return .none
+    }
+
+    mutating func reset() {
+        state = .idle
+    }
+}
+
 final class ConfigurableHotkeyController {
     static let shared = ConfigurableHotkeyController()
 
@@ -12,7 +76,7 @@ final class ConfigurableHotkeyController {
     private var runLoopSource: CFRunLoopSource?
     private var functionKeyIsDown = false
     private var suppressNextFunctionKeyRelease = false
-    private var holdToTranscribeIsRecording = false
+    private var holdToTranscribeKeyState = HoldToTranscribeKeyState()
     private var pendingHoldToTranscribeWorkItem: DispatchWorkItem?
     private let holdToTranscribeDelay: TimeInterval = 0.16
 
@@ -52,9 +116,7 @@ final class ConfigurableHotkeyController {
                   !self.usesFunctionShortcut(shortcut) else {
                 return
             }
-            Task { @MainActor in
-                _ = runner.beginHoldToTranscribe()
-            }
+            self.requestHoldToTranscribeStart(preferredRunner: runner)
         }
         KeyboardShortcuts.onKeyUp(for: .holdToTranscribe) {
             guard !ShortcutRecordingState.shared.isRecording,
@@ -62,7 +124,7 @@ final class ConfigurableHotkeyController {
                   !self.usesFunctionShortcut(shortcut) else {
                 return
             }
-            Task { @MainActor in runner.endHoldToTranscribe() }
+            self.releaseHoldToTranscribeKey()
         }
     }
 
@@ -120,7 +182,7 @@ final class ConfigurableHotkeyController {
         runLoopSource = nil
         functionKeyIsDown = false
         suppressNextFunctionKeyRelease = false
-        holdToTranscribeIsRecording = false
+        holdToTranscribeKeyState.reset()
     }
 
     func resumeFunctionAwareHotkeysAfterAccessibilityReset(runner: AgentCommandRunner) {
@@ -169,7 +231,7 @@ final class ConfigurableHotkeyController {
             cancelPendingHoldToTranscribe()
             suppressNextFunctionKeyRelease = usesFunctionShortcut(shortcut)
 
-            if !isAutorepeat(event) && !holdToTranscribeIsRecording {
+            if !isAutorepeat(event) && !holdToTranscribeKeyState.isStartPendingOrRecording {
                 Task { @MainActor in
                     self.runner?.run(.toggleTranscription)
                 }
@@ -190,25 +252,14 @@ final class ConfigurableHotkeyController {
         }
 
         if type == .keyDown {
-            if !isAutorepeat(event) && !holdToTranscribeIsRecording {
-                Task { @MainActor in
-                    guard let runner = self.runner else { return }
-                    if runner.beginHoldToTranscribe() {
-                        self.holdToTranscribeIsRecording = true
-                    }
-                }
+            if !isAutorepeat(event) {
+                requestHoldToTranscribeStart()
             }
             return true
         }
 
         if type == .keyUp {
-            if holdToTranscribeIsRecording {
-                holdToTranscribeIsRecording = false
-                Task { @MainActor in
-                    guard let runner = self.runner else { return }
-                    runner.endHoldToTranscribe()
-                }
-            }
+            releaseHoldToTranscribeKey()
             return true
         }
 
@@ -238,17 +289,7 @@ final class ConfigurableHotkeyController {
             return true
         }
 
-        if holdToTranscribeIsRecording {
-            holdToTranscribeIsRecording = false
-            Task { @MainActor in
-                guard let runner = self.runner else { return }
-                runner.endHoldToTranscribe()
-            }
-        } else {
-            Task { @MainActor in
-                _ = self.runner?.stopTranscriptionFromFunctionKeyIfNeeded()
-            }
-        }
+        releaseHoldToTranscribeKey(stopExistingFunctionRecordingIfIdle: true)
 
         return true
     }
@@ -264,16 +305,7 @@ final class ConfigurableHotkeyController {
             }
 
             self.pendingHoldToTranscribeWorkItem = nil
-            Task { @MainActor in
-                if self.runner?.stopTranscriptionFromFunctionKeyIfNeeded() == true {
-                    return
-                }
-
-                guard let runner = self.runner else { return }
-                if runner.beginHoldToTranscribe() {
-                    self.holdToTranscribeIsRecording = true
-                }
-            }
+            self.requestHoldToTranscribeStart(stopExistingFunctionRecordingFirst: true)
         }
 
         pendingHoldToTranscribeWorkItem = workItem
@@ -287,6 +319,57 @@ final class ConfigurableHotkeyController {
         pendingHoldToTranscribeWorkItem = nil
     }
 
+    private func requestHoldToTranscribeStart(
+        preferredRunner: AgentCommandRunner? = nil,
+        stopExistingFunctionRecordingFirst: Bool = false
+    ) {
+        guard holdToTranscribeKeyState.requestStart() else { return }
+        Task { @MainActor in
+            if stopExistingFunctionRecordingFirst,
+               self.runner?.stopTranscriptionFromFunctionKeyIfNeeded() == true {
+                _ = self.holdToTranscribeKeyState.completeStart(started: false)
+                return
+            }
+
+            guard let runner = preferredRunner ?? self.runner else {
+                _ = self.holdToTranscribeKeyState.completeStart(started: false)
+                return
+            }
+            self.finishHoldToTranscribeStart(runner: runner)
+        }
+    }
+
+    @MainActor
+    private func finishHoldToTranscribeStart(runner: AgentCommandRunner) {
+        let started = runner.beginHoldToTranscribe()
+        let action = holdToTranscribeKeyState.completeStart(started: started)
+        if action == .stopNow {
+            runner.endHoldToTranscribe()
+        }
+    }
+
+    private func releaseHoldToTranscribeKey(stopExistingFunctionRecordingIfIdle: Bool = false) {
+        switch holdToTranscribeKeyState.releaseKey() {
+        case .stopNow:
+            stopHoldToTranscribe()
+        case .none:
+            if stopExistingFunctionRecordingIfIdle {
+                Task { @MainActor in
+                    _ = self.runner?.stopTranscriptionFromFunctionKeyIfNeeded()
+                }
+            }
+        case .deferUntilStartCompletes:
+            break
+        }
+    }
+
+    private func stopHoldToTranscribe() {
+        Task { @MainActor in
+            guard let runner = self.runner else { return }
+            runner.endHoldToTranscribe()
+        }
+    }
+
     private func shortcutMatches(type: CGEventType, event: CGEvent, shortcut: KeyboardShortcuts.Shortcut) -> Bool {
         guard type == .keyDown || type == .keyUp else {
             return false

agent_cli-0.98.3/macos/AgentCLI/Tests/AgentCLITests/ConfigurableHotkeyControllerTests.swift

@@ -0,0 +1,36 @@
+#if canImport(XCTest)
+import XCTest
+@testable import AgentCLI
+
+final class ConfigurableHotkeyControllerTests: XCTestCase {
+    func testReleaseBeforeHoldStartCompletesStopsAfterSuccessfulStart() {
+        var state = HoldToTranscribeKeyState()
+
+        XCTAssertTrue(state.requestStart())
+        XCTAssertEqual(state.releaseKey(), .deferUntilStartCompletes)
+
+        XCTAssertEqual(state.completeStart(started: true), .stopNow)
+        XCTAssertFalse(state.isStartPendingOrRecording)
+    }
+
+    func testReleaseAfterHoldStartStopsImmediately() {
+        var state = HoldToTranscribeKeyState()
+
+        XCTAssertTrue(state.requestStart())
+        XCTAssertEqual(state.completeStart(started: true), .none)
+
+        XCTAssertEqual(state.releaseKey(), .stopNow)
+        XCTAssertFalse(state.isStartPendingOrRecording)
+    }
+
+    func testFailedHoldStartAfterReleaseClearsPendingStateWithoutStop() {
+        var state = HoldToTranscribeKeyState()
+
+        XCTAssertTrue(state.requestStart())
+        XCTAssertEqual(state.releaseKey(), .deferUntilStartCompletes)
+
+        XCTAssertEqual(state.completeStart(started: false), .none)
+        XCTAssertFalse(state.isStartPendingOrRecording)
+    }
+}
+#endif

{agent_cli-0.98.1 → agent_cli-0.98.3}/macos/appcast.xml

@@ -4,6 +4,21 @@
         <title>Agent CLI Updates</title>
         <link>https://github.com/basnijholt/agent-cli</link>
         <description>Signed Agent CLI macOS app updates.</description>
+        <item>
+            <title>0.98.1</title>
+            <pubDate>Thu, 04 Jun 2026 16:50:48 +0000</pubDate>
+            <link>https://github.com/basnijholt/agent-cli</link>
+            <sparkle:version>189</sparkle:version>
+            <sparkle:shortVersionString>0.98.1</sparkle:shortVersionString>
+            <sparkle:minimumSystemVersion>13.0</sparkle:minimumSystemVersion>
+            <sparkle:hardwareRequirements>arm64</sparkle:hardwareRequirements>
+            <description sparkle:format="markdown"><![CDATA[## What’s Changed
+
+* Add macOS transcription TTL setting (#578) @basnijholt
+
+]]></description>
+            <enclosure url="https://github.com/basnijholt/agent-cli/releases/download/v0.98.1/AgentCLI.zip" length="22896191" type="application/octet-stream" sparkle:edSignature="4g9PD/is1i4Htq5eM2TfAUjxEaXSb7xJJDjnliSfX5TQfqeLLsItUcaCLbhpXaOKqzq0YByVg5SLSpqHK08vAw=="/>
+        </item>
         <item>
             <title>0.98.0</title>
             <pubDate>Thu, 04 Jun 2026 16:25:34 +0000</pubDate>
@@ -154,23 +169,5 @@
 ]]></description>
             <enclosure url="https://github.com/basnijholt/agent-cli/releases/download/v0.96.6/AgentCLI.zip" length="22742441" type="application/octet-stream" sparkle:edSignature="DriNk09uSrq9l20Pu7S+y34r4LvO+rfTHGOm1gsPDOd94FQZXqgDZxbVYYfTGgJ6eWSb0l3ljQokW6VQhJ97DQ=="/>
         </item>
-        <item>
-            <title>0.96.5</title>
-            <pubDate>Fri, 29 May 2026 16:40:33 +0000</pubDate>
-            <link>https://github.com/basnijholt/agent-cli</link>
-            <sparkle:version>179</sparkle:version>
-            <sparkle:shortVersionString>0.96.5</sparkle:shortVersionString>
-            <sparkle:minimumSystemVersion>13.0</sparkle:minimumSystemVersion>
-            <sparkle:hardwareRequirements>arm64</sparkle:hardwareRequirements>
-            <description sparkle:format="markdown"><![CDATA[## What’s Changed
-
-* Fix bare Fn shortcut detection on macOS (#554) @marcellaholm
-* Fix macOS setup menu bar icon (#555) @marcellaholm
-* Use purr for recording release sound (#556) @basnijholt
-* Boost quiet waveform levels (#553) @basnijholt
-
-]]></description>
-            <enclosure url="https://github.com/basnijholt/agent-cli/releases/download/v0.96.5/AgentCLI.zip" length="22738995" type="application/octet-stream" sparkle:edSignature="Jf0aoWxUGvOR6idZhELnlGf61IHrf8Kw92tcH5Xk4wC8chn3mO3OgeE+8+P2orbHC0VhszHgjMNzsGN3bZPwCg=="/>
-        </item>
     </channel>
 </rss>

{agent_cli-0.98.1 → agent_cli-0.98.3}/tests/test_nemo_backend.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import io
+import os
 import sys
 import wave
 from concurrent.futures import ThreadPoolExecutor
@@ -47,16 +48,27 @@ def _install_mock_nemo(
     monkeypatch.setitem(sys.modules, "nemo.collections.asr", asr_module)
 
 
-def _install_mock_torch(monkeypatch: pytest.MonkeyPatch, *, cuda_available: bool) -> None:
-    """Install a minimal mock torch module exposing cuda.is_available()."""
+def _install_mock_torch(
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    cuda_available: bool,
+    mps_available: bool = False,
+) -> None:
+    """Install a minimal mock torch module exposing device availability."""
 
     class _Cuda:
         @staticmethod
         def is_available() -> bool:
             return cuda_available
 
+    class _Mps:
+        @staticmethod
+        def is_available() -> bool:
+            return mps_available
+
     torch_module: Any = ModuleType("torch")
     torch_module.cuda = _Cuda()
+    torch_module.backends = SimpleNamespace(mps=_Mps())
     monkeypatch.setitem(sys.modules, "torch", torch_module)
 
 
@@ -207,15 +219,27 @@ def test_resolve_device_auto_uses_cuda_when_available(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     """Ensure auto device selection prefers CUDA when available."""
-    _install_mock_torch(monkeypatch, cuda_available=True)
+    _install_mock_torch(monkeypatch, cuda_available=True, mps_available=True)
     assert backend._resolve_device("auto") == "cuda"
 
 
+def test_resolve_device_auto_uses_mps_when_cuda_unavailable(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Ensure auto device selection uses Apple GPU when CUDA is unavailable."""
+    monkeypatch.delenv("PYTORCH_ENABLE_MPS_FALLBACK", raising=False)
+    monkeypatch.setattr(backend.sys, "platform", "darwin")
+    _install_mock_torch(monkeypatch, cuda_available=False, mps_available=True)
+
+    assert backend._resolve_device("auto") == "mps"
+    assert os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] == "1"
+
+
 def test_resolve_device_auto_falls_back_to_cpu(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     """Ensure auto device selection falls back to CPU."""
-    _install_mock_torch(monkeypatch, cuda_available=False)
+    _install_mock_torch(monkeypatch, cuda_available=False, mps_available=False)
     assert backend._resolve_device("auto") == "cpu"
 
 
@@ -229,6 +253,16 @@ def test_resolve_device_explicit_cuda_requires_available_cuda(
         backend._resolve_device("cuda:0")
 
 
+def test_resolve_device_explicit_mps_requires_available_mps(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Ensure explicit MPS requests fail fast when MPS is unavailable."""
+    _install_mock_torch(monkeypatch, cuda_available=False, mps_available=False)
+
+    with pytest.raises(RuntimeError, match="MPS device requested"):
+        backend._resolve_device("mps")
+
+
 def test_resolve_device_preserves_explicit_cpu(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None: