python-voiceio 0.6.0__tar.gz → 0.7.0__tar.gz

{python_voiceio-0.6.0/python_voiceio.egg-info → python_voiceio-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.6.0
+Version: 0.7.0
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.6.0 → python_voiceio-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-voiceio"
-version = "0.6.0"
+version = "0.7.0"
 description = "Voice dictation for Linux. Speak → text, locally, instantly."
 readme = "README.md"
 license = "MIT"

{python_voiceio-0.6.0 → python_voiceio-0.7.0/python_voiceio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.6.0
+Version: 0.7.0
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

python_voiceio-0.7.0/tests/test_llm_api.py

@@ -0,0 +1,261 @@
+"""Tests for voiceio.llm_api — OpenAI-compatible chat completions client."""
+from __future__ import annotations
+
+import http.client
+import json
+import urllib.error
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from voiceio import llm_api
+from voiceio.config import AutocorrectConfig
+from voiceio.llm_api import chat, check_api_key, detect_provider, resolve_api_key
+
+
+@pytest.fixture(autouse=True)
+def _clear_pool():
+    """Keep-alive pool is process-global state — isolate every test."""
+    llm_api._CONN_POOL.clear()
+    yield
+    llm_api._CONN_POOL.clear()
+
+
+def _fake_conn(data: dict | None, status: int = 200) -> MagicMock:
+    """A mock http.client connection returning one JSON response."""
+    resp = MagicMock()
+    resp.status = status
+    resp.reason = "OK" if status == 200 else "ERR"
+    resp.read.return_value = json.dumps(data or {}).encode()
+    resp.getheaders.return_value = []
+    conn = MagicMock()
+    conn.getresponse.return_value = resp
+    return conn
+
+
+def _request_kwargs(conn: MagicMock) -> tuple[str, dict, dict]:
+    """(path, headers, parsed body) of the single request made on conn."""
+    args, kwargs = conn.request.call_args
+    return args[1], kwargs["headers"], json.loads(kwargs["body"])
+
+
+def _cfg(**kwargs) -> AutocorrectConfig:
+    defaults = {"api_key": "test-key", "model": "test-model"}
+    defaults.update(kwargs)
+    return AutocorrectConfig(**defaults)
+
+
+# ── resolve_api_key ──────────────────────────────────────────────────────
+
+
+def test_resolve_from_config():
+    cfg = _cfg(api_key="sk-from-config")
+    assert resolve_api_key(cfg) == "sk-from-config"
+
+
+@patch.dict("os.environ", {"OPENROUTER_API_KEY": "sk-from-env"}, clear=False)
+def test_resolve_from_env():
+    cfg = _cfg(api_key="")
+    assert resolve_api_key(cfg) == "sk-from-env"
+
+
+@patch.dict("os.environ", {}, clear=True)
+def test_resolve_empty():
+    cfg = _cfg(api_key="")
+    assert resolve_api_key(cfg) == ""
+
+
+# ── chat ─────────────────────────────────────────────────────────────────
+
+
+def test_chat_success():
+    conn = _fake_conn({"choices": [{"message": {"content": "Fixed text."}}]})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        result = chat(_cfg(), "system prompt", "user message")
+    assert result == "Fixed text."
+
+    path, headers, body = _request_kwargs(conn)
+    assert path == "/v1/chat/completions" or path.endswith("/chat/completions")
+    assert headers["Authorization"] == "Bearer test-key"
+    assert headers["Content-Type"] == "application/json"
+    assert body["model"] == "test-model"
+    assert body["messages"][0]["role"] == "system"
+    assert body["messages"][1]["role"] == "user"
+
+
+def test_chat_timeout():
+    conn = MagicMock()
+    conn.request.side_effect = OSError("timed out")
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") is None
+
+
+def test_chat_http_401():
+    conn = _fake_conn({"error": "invalid key"}, status=401)
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") is None
+
+
+def test_chat_no_api_key():
+    cfg = _cfg(api_key="")
+    with patch.dict("os.environ", {}, clear=True):
+        assert chat(cfg, "sys", "msg") is None
+
+
+def test_chat_malformed_response():
+    conn = _fake_conn({"unexpected": "format"})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") is None
+
+
+def test_chat_null_content_returns_none():
+    """Thinking models (Kimi K2.6 etc.) can return content=None — must not crash."""
+    conn = _fake_conn({"choices": [{"message": {"content": None}}]})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") is None
+
+
+def test_chat_falls_back_to_reasoning_field():
+    """When content is null but reasoning is present, use reasoning text."""
+    conn = _fake_conn({
+        "choices": [{"message": {"content": None, "reasoning": "the answer"}}],
+    })
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") == "the answer"
+
+
+def test_chat_falls_back_to_reasoning_content_field():
+    """Some providers expose `reasoning_content` instead of `reasoning`."""
+    conn = _fake_conn({
+        "choices": [{"message": {
+            "content": None,
+            "reasoning_content": "thought-through answer",
+        }}],
+    })
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") == "thought-through answer"
+
+
+def test_chat_anthropic_null_content_array():
+    """Anthropic native API: content=null shouldn't crash."""
+    conn = _fake_conn({"content": None})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        cfg = _cfg(base_url="https://api.anthropic.com/v1")
+        assert chat(cfg, "sys", "msg") is None
+
+
+# ── check_api_key ────────────────────────────────────────────────────────
+
+
+def test_check_valid_key():
+    conn = _fake_conn({"choices": [{"message": {"content": ""}}]})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert check_api_key(_cfg(), "sk-valid") is True
+
+
+def test_check_invalid_key():
+    conn = _fake_conn({"error": "unauthorized"}, status=401)
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert check_api_key(_cfg(), "sk-invalid") is False
+
+
+def test_check_empty_key():
+    cfg = _cfg(api_key="")
+    with patch.dict("os.environ", {}, clear=True):
+        assert check_api_key(cfg) is False
+
+
+# ── Anthropic native API ────────────────────────────────────────────────
+
+
+def test_chat_anthropic_native():
+    conn = _fake_conn({"content": [{"type": "text", "text": "Fixed text."}]})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        cfg = _cfg(base_url="https://api.anthropic.com/v1")
+        result = chat(cfg, "system prompt", "user message")
+    assert result == "Fixed text."
+
+    path, headers, body = _request_kwargs(conn)
+    assert path.endswith("/messages")
+    assert headers["x-api-key"] == "test-key"
+    assert headers["anthropic-version"] == "2023-06-01"
+    assert "Authorization" not in headers
+    assert body["system"] == "system prompt"
+    assert body["messages"] == [{"role": "user", "content": "user message"}]
+
+
+def test_check_api_key_anthropic():
+    conn = _fake_conn({"content": [{"type": "text", "text": ""}]})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        cfg = _cfg(base_url="https://api.anthropic.com/v1")
+        assert check_api_key(cfg, "sk-ant-test") is True
+    path, _, _ = _request_kwargs(conn)
+    assert path.endswith("/messages")
+
+
+# ── detect_provider ─────────────────────────────────────────────────────
+
+
+def test_detect_openrouter():
+    base_url, model = detect_provider("sk-or-abc123")
+    assert "openrouter" in base_url
+    assert "kimi" in model
+
+
+def test_detect_anthropic():
+    base_url, model = detect_provider("sk-ant-abc123")
+    assert "anthropic.com" in base_url
+    assert "claude" in model
+
+
+def test_detect_openai():
+    base_url, model = detect_provider("sk-proj-abc123")
+    assert "openai.com" in base_url
+
+
+def test_detect_unknown_defaults_openrouter():
+    base_url, _ = detect_provider("unknown-key-format")
+    assert "openrouter" in base_url
+
+
+# ── keep-alive connection pool ───────────────────────────────────────────
+
+
+def test_post_json_reuses_connection():
+    conn = _fake_conn({"ok": 1})
+    with patch("http.client.HTTPSConnection", return_value=conn) as cls:
+        r1 = llm_api._post_json("https://api.example.com/v1/x", {}, {}, 5)
+        r2 = llm_api._post_json("https://api.example.com/v1/x", {}, {}, 5)
+    assert r1 == {"ok": 1} and r2 == {"ok": 1}
+    cls.assert_called_once()  # second call reused the pooled connection
+    assert conn.request.call_count == 2
+
+
+def test_post_json_retries_stale_pooled_connection():
+    stale = MagicMock()
+    stale.sock = None
+    stale.request.side_effect = http.client.BadStatusLine("")  # server closed it
+    llm_api._CONN_POOL["https://api.example.com"] = stale
+    fresh = _fake_conn({"ok": 2})
+    with patch("http.client.HTTPSConnection", return_value=fresh):
+        r = llm_api._post_json("https://api.example.com/v1/x", {}, {}, 5)
+    assert r == {"ok": 2}
+    stale.close.assert_called_once()
+
+
+def test_post_json_fresh_connection_error_propagates():
+    conn = MagicMock()
+    conn.request.side_effect = OSError("connection refused")
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        with pytest.raises(OSError):
+            llm_api._post_json("https://api.example.com/v1/x", {}, {}, 5)
+
+
+def test_post_json_http_error_compatible():
+    conn = _fake_conn({"error": "bad key"}, status=401)
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        with pytest.raises(urllib.error.HTTPError) as exc:
+            llm_api._post_json("https://api.example.com/v1/x", {}, {}, 5)
+    assert exc.value.code == 401
+    assert b"bad key" in exc.value.read()
+    assert not llm_api._CONN_POOL  # error connections are not pooled

{python_voiceio-0.6.0 → python_voiceio-0.7.0}/tests/test_streaming.py

@@ -867,3 +867,84 @@ class TestDecodeFailureSafety:
             np.full(int(SR * 2.5), 0.005, dtype=np.float32), _silent(0.5),
         ])
         assert _tail_ends_in_silence(with_pause, SR)
+
+
+class TestFreezeCalibration:
+    def test_hot_noise_floor_pause_is_silence(self):
+        """Real-mic calibration: noise floor ~0.3x of tail RMS IS a pause."""
+        from voiceio.streaming import _tail_ends_in_silence
+        speech = np.full(int(SR * 2.5), 0.12, dtype=np.float32)
+        pause = np.full(int(SR * 0.5), 0.03, dtype=np.float32)  # noise floor
+        assert _tail_ends_in_silence(np.concatenate([speech, pause]), SR)
+
+    def test_speech_level_window_is_not_silence(self):
+        from voiceio.streaming import _tail_ends_in_silence
+        tail = np.full(SR * 3, 0.12, dtype=np.float32)
+        assert not _tail_ends_in_silence(tail, SR)
+
+
+class TestDecodeBackpressure:
+    def _make_session(self):
+        recorder = MagicMock()
+        recorder.sample_rate = SR
+        transcriber = MagicMock()
+        transcriber.last_segments = []
+        s = StreamingSession(
+            transcriber=transcriber,
+            typer=MagicMock(spec=TyperBackend),
+            recorder=recorder,
+        )
+        return s, transcriber, recorder
+
+    def test_interim_skipped_while_behind(self):
+        """No new interim until new audio >= duration of the last decode."""
+        s, tr, rec = self._make_session()
+        s._last_decode_end = SR * 10
+        s._last_decode_secs = 8.0  # last decode took 8s (contended CPU)
+        rec.get_audio_so_far.return_value = _loud(13)  # only 3s new audio
+        s._transcribe_and_apply()
+        tr.transcribe.assert_not_called()
+
+    def test_interim_runs_once_caught_up(self):
+        s, tr, rec = self._make_session()
+        s._last_decode_end = SR * 10
+        s._last_decode_secs = 8.0
+        rec.get_audio_so_far.return_value = _loud(19)  # 9s new audio > 8s
+        tr.transcribe.return_value = "hello"
+        s._transcribe_and_apply()
+        tr.transcribe.assert_called_once()
+        assert s._last_decode_end == SR * 19
+
+    def test_final_never_skipped_by_backpressure(self):
+        s, tr, rec = self._make_session()
+        s._last_decode_end = SR * 10
+        s._last_decode_secs = 60.0
+        s._final_audio = _loud(11)
+        tr.transcribe.return_value = "hello"
+        s._transcribe_and_apply(min_seconds=0.5, final=True)
+        tr.transcribe.assert_called_once()
+
+
+class TestStaleInterimAfterStop:
+    def test_interim_completing_after_stop_is_discarded(self):
+        """A slow interim decode finishing post-stop must not touch the display."""
+        recorder = MagicMock()
+        recorder.sample_rate = SR
+        transcriber = MagicMock()
+        transcriber.last_segments = []
+        s = StreamingSession(
+            transcriber=transcriber,
+            typer=MagicMock(spec=StreamingTyper),
+            recorder=recorder,
+        )
+        s._typed_text = "Okay."
+        recorder.get_audio_so_far.return_value = _loud(8)
+
+        def slow_then_stopped(audio, final=False, context=None):
+            s._stop_event.set()  # stop pressed while decode in flight
+            return "Okay, two things. One, is it"
+
+        transcriber.transcribe.side_effect = slow_then_stopped
+        s._transcribe_and_apply()
+        s._typer.update_preedit.assert_not_called()
+        assert s._typed_text == "Okay."  # display state untouched

python_voiceio-0.7.0/voiceio/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.7.0"

{python_voiceio-0.6.0 → python_voiceio-0.7.0}/voiceio/config.py

@@ -147,7 +147,12 @@ class PostCorrectConfig:
     model can be overridden here; empty falls back to the autocorrect model.
     """
     enabled: bool = False
-    model: str = ""              # empty = use [autocorrect].model
+    # Latency-critical (blocks the commit): default to a fast cheap model.
+    # Bake-off on the real correction prompt: gemini-2.5-flash-lite 0.44s
+    # with fixes identical to kimi-k2's 2.0s. OpenRouter model id — on a
+    # custom base_url set a model your endpoint serves (empty = use
+    # [autocorrect].model).
+    model: str = "google/gemini-2.5-flash-lite"
     timeout_secs: float = 8.0
     min_words: int = 4           # skip utterances shorter than this
 

{python_voiceio-0.6.0 → python_voiceio-0.7.0}/voiceio/llm_api.py

@@ -5,16 +5,73 @@ local Ollama (via /v1/chat/completions), etc. Zero dependencies beyond stdlib.
 """
 from __future__ import annotations
 
+import http.client
+import io
 import json
 import logging
 import os
+import threading
 import urllib.error
-import urllib.request
+from urllib.parse import urlsplit
 
 from voiceio.config import AutocorrectConfig
 
 log = logging.getLogger(__name__)
 
+# Keep-alive connection pool: a fresh TLS handshake costs ~0.2-0.5s per call,
+# which lands directly on postcorrect's stop-to-commit latency. Connections
+# are checked OUT for the duration of a request and returned only on clean
+# completion, so a deadline-abandoned postcorrect thread can never share a
+# socket with a later call.
+_POOL_LOCK = threading.Lock()
+_CONN_POOL: dict[str, http.client.HTTPConnection] = {}
+
+
+def _post_json(url: str, headers: dict, body: dict, timeout: float) -> dict:
+    """POST JSON over a pooled keep-alive connection; return the parsed reply.
+
+    A stale pooled connection (server closed it while idle) gets one retry on
+    a fresh one. Non-2xx raises urllib.error.HTTPError so callers keep their
+    existing status-code handling.
+    """
+    parts = urlsplit(url)
+    pool_key = f"{parts.scheme}://{parts.netloc}"
+    path = parts.path or "/"
+    payload = json.dumps(body).encode()
+
+    for attempt in (1, 2):
+        with _POOL_LOCK:
+            conn = _CONN_POOL.pop(pool_key, None)
+        pooled = conn is not None
+        if conn is None:
+            cls = (http.client.HTTPSConnection if parts.scheme == "https"
+                   else http.client.HTTPConnection)
+            conn = cls(parts.hostname, parts.port, timeout=timeout)
+        elif conn.sock is not None:
+            conn.sock.settimeout(timeout)
+        try:
+            conn.request("POST", path, body=payload, headers=headers)
+            resp = conn.getresponse()
+            data = resp.read()
+        except (http.client.HTTPException, OSError):
+            conn.close()
+            if not pooled or attempt == 2:
+                raise
+            continue  # stale keep-alive — retry once on a fresh connection
+        if resp.status // 100 != 2:
+            conn.close()
+            raise urllib.error.HTTPError(
+                url, resp.status, resp.reason, dict(resp.getheaders()),
+                io.BytesIO(data),
+            )
+        with _POOL_LOCK:
+            if pool_key in _CONN_POOL:
+                conn.close()  # keep at most one idle connection per host
+            else:
+                _CONN_POOL[pool_key] = conn
+        return json.loads(data)
+    raise AssertionError("unreachable")
+
 
 _LOCAL_HOSTS = ("localhost", "127.0.0.1", "0.0.0.0", "[::1]", "::1")
 _consent_warned = False
@@ -94,11 +151,7 @@ def _anthropic_request(
         "anthropic-version": "2023-06-01",
     }
 
-    req = urllib.request.Request(
-        url, data=json.dumps(body).encode(), headers=headers, method="POST",
-    )
-    with urllib.request.urlopen(req, timeout=timeout) as resp:
-        data = json.loads(resp.read())
+    data = _post_json(url, headers, body, timeout)
     # Anthropic returns content as a list of blocks; some thinking models
     # may also include `thinking` blocks which we ignore.
     blocks = data.get("content") or []
@@ -137,11 +190,7 @@ def _openai_request(
         "Authorization": f"Bearer {api_key}",
     }
 
-    req = urllib.request.Request(
-        url, data=json.dumps(body).encode(), headers=headers, method="POST",
-    )
-    with urllib.request.urlopen(req, timeout=timeout) as resp:
-        data = json.loads(resp.read())
+    data = _post_json(url, headers, body, timeout)
     # Be defensive: thinking models (Kimi K2.6, GPT reasoning, etc.) can
     # return content=None when the answer is in `reasoning` / `reasoning_content`
     # instead. Also some malformed responses lack `choices` entirely.

{python_voiceio-0.6.0 → python_voiceio-0.7.0}/voiceio/streaming.py

@@ -32,7 +32,10 @@ _FREEZE_SILENCE_WINDOW_SECS = 0.3
 # and the decode path normalizes audio anyway, so an absolute threshold
 # would read a quiet mic's speech as silence (mid-word cuts) and a hot
 # noise floor as speech (freeze never fires).
-_FREEZE_SILENCE_RATIO = 0.15
+# Calibrated on real recordings: between-words noise floor sits at
+# ~0.27-0.38 of overall tail RMS, speech windows at >=0.9. 0.6 separates
+# both with margin; 0.15 never fired on a mic with a normal noise floor.
+_FREEZE_SILENCE_RATIO = 0.6
 _FREEZE_SILENCE_FLOOR = 1e-4  # digital silence is always quiet
 # Whisper conditions on ~224 prompt tokens; more frozen context is wasted.
 _FREEZE_CONTEXT_CHARS = 400
@@ -158,6 +161,12 @@ class StreamingSession:
         self._frozen_samples = 0
         self._frozen_raw = ""
         self._frozen_segments: list[dict] = []
+        # Decode backpressure: when the CPU is contended, decodes slow down
+        # and 1s-tick interim passes would queue back-to-back, each covering
+        # a longer tail — a starvation spiral. Require at least as much NEW
+        # audio as the last decode took before starting another interim.
+        self._last_decode_end = 0     # samples covered by the last decode
+        self._last_decode_secs = 0.0  # how long that decode took
         # Raw (pre-pipeline) text + confidence of the final pass, for history
         self.raw_final_text: str | None = None
         self.final_latency: dict = {}
@@ -294,6 +303,9 @@ class StreamingSession:
         tail = audio[self._frozen_samples:]
         if not final and len(tail) < self._sample_rate * min_seconds:
             return  # not enough new audio since the last freeze
+        grown_secs = (len(audio) - self._last_decode_end) / self._sample_rate
+        if not final and grown_secs < max(min_seconds, self._last_decode_secs):
+            return  # backpressure: don't decode faster than we can keep up
 
         # Freeze when the tail has grown long AND ends at a speech pause
         # (never cut mid-word). The freeze pass gets beam search because its
@@ -333,6 +345,8 @@ class StreamingSession:
                 return
             tail_segments = list(getattr(self._transcriber, "last_segments", []))
         t_transcribe = time.monotonic() - t0
+        self._last_decode_end = len(audio)
+        self._last_decode_secs = t_transcribe
 
         self.trace.append({
             "t": round(time.monotonic() - self._t0, 2),
@@ -353,6 +367,13 @@ class StreamingSession:
             )
         raw = self._frozen_raw if freeze else _join_text(self._frozen_raw, tail_text)
 
+        # A slow interim decode can complete AFTER the user pressed stop
+        # (observed: 29s under CPU contention). Applying it would overwrite
+        # the preedit with stale partial text moments before the final
+        # commit rewrites it again — discard it. Freeze bookkeeping above
+        # is kept: it is beam-quality and shrinks the final tail.
+        if not final and self._stop_event.is_set():
+            return
         # An interim pass that decoded nothing must not touch the display:
         # rewriting to frozen-only text would visibly delete the un-frozen
         # words the previous pass just showed (transient decoder flake).

python_voiceio-0.6.0/tests/test_llm_api.py

@@ -1,220 +0,0 @@
-"""Tests for voiceio.llm_api — OpenAI-compatible chat completions client."""
-from __future__ import annotations
-
-import json
-import urllib.error
-from unittest.mock import MagicMock, patch
-
-from voiceio.config import AutocorrectConfig
-from voiceio.llm_api import chat, check_api_key, detect_provider, resolve_api_key
-
-
-def _mock_response(data: dict) -> MagicMock:
-    resp = MagicMock()
-    resp.read.return_value = json.dumps(data).encode()
-    resp.__enter__ = lambda s: s
-    resp.__exit__ = MagicMock(return_value=False)
-    return resp
-
-
-def _cfg(**kwargs) -> AutocorrectConfig:
-    defaults = {"api_key": "test-key", "model": "test-model"}
-    defaults.update(kwargs)
-    return AutocorrectConfig(**defaults)
-
-
-# ── resolve_api_key ──────────────────────────────────────────────────────
-
-
-def test_resolve_from_config():
-    cfg = _cfg(api_key="sk-from-config")
-    assert resolve_api_key(cfg) == "sk-from-config"
-
-
-@patch.dict("os.environ", {"OPENROUTER_API_KEY": "sk-from-env"}, clear=False)
-def test_resolve_from_env():
-    cfg = _cfg(api_key="")
-    assert resolve_api_key(cfg) == "sk-from-env"
-
-
-@patch.dict("os.environ", {}, clear=True)
-def test_resolve_empty():
-    cfg = _cfg(api_key="")
-    assert resolve_api_key(cfg) == ""
-
-
-# ── chat ─────────────────────────────────────────────────────────────────
-
-
-@patch("urllib.request.urlopen")
-def test_chat_success(mock_urlopen):
-    mock_urlopen.return_value = _mock_response({
-        "choices": [{"message": {"content": "Fixed text."}}]
-    })
-    cfg = _cfg()
-    result = chat(cfg, "system prompt", "user message")
-    assert result == "Fixed text."
-
-    # Verify request format
-    call_args = mock_urlopen.call_args
-    req = call_args[0][0]
-    assert req.get_header("Authorization") == "Bearer test-key"
-    assert req.get_header("Content-type") == "application/json"
-    body = json.loads(req.data)
-    assert body["model"] == "test-model"
-    assert body["messages"][0]["role"] == "system"
-    assert body["messages"][1]["role"] == "user"
-
-
-@patch("urllib.request.urlopen")
-def test_chat_timeout(mock_urlopen):
-    mock_urlopen.side_effect = urllib.error.URLError("timed out")
-    cfg = _cfg()
-    assert chat(cfg, "sys", "msg") is None
-
-
-@patch("urllib.request.urlopen")
-def test_chat_http_401(mock_urlopen):
-    err = urllib.error.HTTPError("url", 401, "Unauthorized", {}, None)
-    err.read = lambda: b"invalid key"
-    mock_urlopen.side_effect = err
-    cfg = _cfg()
-    assert chat(cfg, "sys", "msg") is None
-
-
-def test_chat_no_api_key():
-    cfg = _cfg(api_key="")
-    with patch.dict("os.environ", {}, clear=True):
-        assert chat(cfg, "sys", "msg") is None
-
-
-@patch("urllib.request.urlopen")
-def test_chat_malformed_response(mock_urlopen):
-    mock_urlopen.return_value = _mock_response({"unexpected": "format"})
-    cfg = _cfg()
-    assert chat(cfg, "sys", "msg") is None
-
-
-@patch("urllib.request.urlopen")
-def test_chat_null_content_returns_none(mock_urlopen):
-    """Thinking models (Kimi K2.6 etc.) can return content=None — must not crash."""
-    mock_urlopen.return_value = _mock_response({
-        "choices": [{"message": {"content": None}}],
-    })
-    cfg = _cfg()
-    assert chat(cfg, "sys", "msg") is None
-
-
-@patch("urllib.request.urlopen")
-def test_chat_falls_back_to_reasoning_field(mock_urlopen):
-    """When content is null but reasoning is present, use reasoning text."""
-    mock_urlopen.return_value = _mock_response({
-        "choices": [{"message": {
-            "content": None,
-            "reasoning": "the answer",
-        }}],
-    })
-    cfg = _cfg()
-    assert chat(cfg, "sys", "msg") == "the answer"
-
-
-@patch("urllib.request.urlopen")
-def test_chat_falls_back_to_reasoning_content_field(mock_urlopen):
-    """Some providers expose `reasoning_content` instead of `reasoning`."""
-    mock_urlopen.return_value = _mock_response({
-        "choices": [{"message": {
-            "content": None,
-            "reasoning_content": "thought-through answer",
-        }}],
-    })
-    cfg = _cfg()
-    assert chat(cfg, "sys", "msg") == "thought-through answer"
-
-
-@patch("urllib.request.urlopen")
-def test_chat_anthropic_null_content_array(mock_urlopen):
-    """Anthropic native API: content=null shouldn't crash."""
-    mock_urlopen.return_value = _mock_response({"content": None})
-    cfg = _cfg(base_url="https://api.anthropic.com/v1")
-    assert chat(cfg, "sys", "msg") is None
-
-
-# ── check_api_key ────────────────────────────────────────────────────────
-
-
-@patch("urllib.request.urlopen")
-def test_check_valid_key(mock_urlopen):
-    mock_urlopen.return_value = _mock_response({"choices": [{"message": {"content": ""}}]})
-    cfg = _cfg()
-    assert check_api_key(cfg, "sk-valid") is True
-
-
-@patch("urllib.request.urlopen")
-def test_check_invalid_key(mock_urlopen):
-    mock_urlopen.side_effect = urllib.error.HTTPError("url", 401, "Unauthorized", {}, None)
-    cfg = _cfg()
-    assert check_api_key(cfg, "sk-invalid") is False
-
-
-def test_check_empty_key():
-    cfg = _cfg(api_key="")
-    with patch.dict("os.environ", {}, clear=True):
-        assert check_api_key(cfg) is False
-
-
-# ── Anthropic native API ────────────────────────────────────────────────
-
-
-@patch("urllib.request.urlopen")
-def test_chat_anthropic_native(mock_urlopen):
-    mock_urlopen.return_value = _mock_response({
-        "content": [{"type": "text", "text": "Fixed text."}]
-    })
-    cfg = _cfg(base_url="https://api.anthropic.com/v1")
-    result = chat(cfg, "system prompt", "user message")
-    assert result == "Fixed text."
-
-    req = mock_urlopen.call_args[0][0]
-    assert req.get_header("X-api-key") == "test-key"
-    assert req.get_header("Anthropic-version") == "2023-06-01"
-    assert "Authorization" not in dict(req.header_items())
-    body = json.loads(req.data)
-    assert body["system"] == "system prompt"
-    assert body["messages"] == [{"role": "user", "content": "user message"}]
-    assert "/messages" in req.full_url
-
-
-@patch("urllib.request.urlopen")
-def test_check_api_key_anthropic(mock_urlopen):
-    mock_urlopen.return_value = _mock_response({
-        "content": [{"type": "text", "text": ""}]
-    })
-    cfg = _cfg(base_url="https://api.anthropic.com/v1")
-    assert check_api_key(cfg, "sk-ant-test") is True
-    req = mock_urlopen.call_args[0][0]
-    assert "/messages" in req.full_url
-
-
-# ── detect_provider ─────────────────────────────────────────────────────
-
-
-def test_detect_openrouter():
-    base_url, model = detect_provider("sk-or-abc123")
-    assert "openrouter" in base_url
-    assert "kimi" in model
-
-
-def test_detect_anthropic():
-    base_url, model = detect_provider("sk-ant-abc123")
-    assert "anthropic.com" in base_url
-    assert "claude" in model
-
-
-def test_detect_openai():
-    base_url, model = detect_provider("sk-proj-abc123")
-    assert "openai.com" in base_url
-
-
-def test_detect_unknown_defaults_openrouter():
-    base_url, _ = detect_provider("unknown-key-format")
-    assert "openrouter" in base_url

python_voiceio-0.6.0/voiceio/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.6.0"