python-voiceio 0.3.11__tar.gz → 0.3.13__tar.gz

{python_voiceio-0.3.11/python_voiceio.egg-info → python_voiceio-0.3.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.3.11
+Version: 0.3.13
 Summary: Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.3.11 → python_voiceio-0.3.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-voiceio"
-version = "0.3.11"
+version = "0.3.13"
 description = "Speak → text, locally, instantly."
 readme = "README.md"
 license = "MIT"

{python_voiceio-0.3.11 → python_voiceio-0.3.13/python_voiceio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.3.11
+Version: 0.3.13
 Summary: Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.3.11 → python_voiceio-0.3.13}/python_voiceio.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ python_voiceio.egg-info/top_level.txt
 tests/test_app_wiring.py
 tests/test_autocorrect.py
 tests/test_backend_probes.py
+tests/test_cli.py
 tests/test_clipboard_read.py
 tests/test_commands.py
 tests/test_config.py

{python_voiceio-0.3.11 → python_voiceio-0.3.13}/tests/test_app_wiring.py

@@ -76,7 +76,7 @@ class TestHotkeyDebounce:
     """Verify that duplicate hotkey events are properly debounced."""
 
     def test_rapid_duplicate_ignored(self):
-        """Two on_hotkey calls within 0.3s should only trigger once."""
+        """Two on_hotkey calls within the debounce window should only trigger once."""
         vio, _, _ = _make_vio()
 
         vio.on_hotkey()

{python_voiceio-0.3.11 → python_voiceio-0.3.13}/tests/test_autocorrect.py

@@ -5,6 +5,7 @@ import json
 from unittest.mock import MagicMock, patch
 
 from voiceio.autocorrect import (
+    _REVIEW_BATCH_SIZE,
     ReviewResult,
     SuspiciousWord,
     _find_similar_common,
@@ -12,6 +13,8 @@ from voiceio.autocorrect import (
     _parse_review_response,
     cluster_variants,
     find_suspicious_words,
+    rank_review_items,
+    rank_review_score,
     review_suspicious,
 )
 from voiceio.config import AutocorrectConfig, Config, LLMConfig
@@ -220,6 +223,53 @@ def test_parse_flat_array_fallback():
     assert result.ask_user[0]["wrong"] == "foo"
 
 
+def test_parse_ask_user_keeps_empty_right_with_reason():
+    """ask_user items must survive even when LLM has no clean correction."""
+    response = json.dumps({
+        "auto_fix": [],
+        "ask_user": [
+            {"wrong": "tridle", "right": "", "reason": "unclear"},
+            {"wrong": "kaiki", "right": "kaiki", "reason": "uncertain"},
+        ],
+        "vocabulary": [],
+    })
+    result = _parse_review_response(response)
+    assert len(result.ask_user) == 2
+    assert result.ask_user[0]["wrong"] == "tridle"
+    assert result.ask_user[0]["reason"] == "unclear"
+    # right == wrong gets normalized to empty string (no useful suggestion)
+    assert result.ask_user[1]["wrong"] == "kaiki"
+    assert result.ask_user[1]["right"] == ""
+    assert result.ask_user[1]["reason"] == "uncertain"
+
+
+def test_parse_ask_user_drops_empty_wrong():
+    """ask_user items with no `wrong` are still useless and get dropped."""
+    response = json.dumps({
+        "auto_fix": [],
+        "ask_user": [{"wrong": "", "right": "something", "reason": "noise"}],
+        "vocabulary": [],
+    })
+    result = _parse_review_response(response)
+    assert result.ask_user == []
+
+
+def test_parse_auto_fix_still_strict():
+    """auto_fix bucket still requires `right != wrong` — case-only change dropped."""
+    response = json.dumps({
+        "auto_fix": [
+            {"wrong": "hello", "right": "Hello"},        # case-only → drop
+            {"wrong": "olamma", "right": "Ollama"},       # legit → keep
+            {"wrong": "foo", "right": "", "reason": "?"}, # missing right → drop
+        ],
+        "ask_user": [],
+        "vocabulary": [],
+    })
+    result = _parse_review_response(response)
+    assert len(result.auto_fix) == 1
+    assert result.auto_fix[0]["wrong"] == "olamma"
+
+
 def test_parse_partial_buckets():
     """Missing buckets should default to empty."""
     response = json.dumps({"auto_fix": [{"wrong": "a", "right": "b"}]})
@@ -262,3 +312,163 @@ def test_review_api_failure_falls_back(mock_chat):
     words = [SuspiciousWord(word="foo", count=1)]
     result = review_suspicious(cfg, words)
     assert result == ReviewResult()
+
+
+@patch("voiceio.llm_api.chat")
+def test_review_batches_large_input(mock_chat):
+    """Large suspicious lists are split across multiple chat() calls."""
+    n = _REVIEW_BATCH_SIZE * 3 + 7  # forces 4 batches
+    words = [SuspiciousWord(word=f"word{i}", count=1) for i in range(n)]
+    # Each call returns a unique vocab entry so we can verify all batches ran.
+    call_counter = {"i": 0}
+
+    def fake_chat(*_a, **_kw):
+        call_counter["i"] += 1
+        return json.dumps({
+            "auto_fix": [], "ask_user": [],
+            "vocabulary": [f"batch{call_counter['i']}"],
+        })
+
+    mock_chat.side_effect = fake_chat
+    cfg = Config(autocorrect=AutocorrectConfig(api_key="test-key"))
+    result = review_suspicious(cfg, words)
+
+    assert mock_chat.call_count == 4
+    # Batches run in parallel — order is non-deterministic, so compare as set.
+    assert set(result.vocabulary) == {"batch1", "batch2", "batch3", "batch4"}
+
+
+@patch("voiceio.llm_api.chat")
+def test_review_progress_callback(mock_chat):
+    """on_progress is invoked once per batch and tops out at the total."""
+    # Vocab keeps the result non-empty so review_suspicious doesn't fall back.
+    mock_chat.return_value = json.dumps(
+        {"auto_fix": [], "ask_user": [], "vocabulary": ["x"]},
+    )
+    n = _REVIEW_BATCH_SIZE * 2 + 5
+    words = [SuspiciousWord(word=f"w{i}", count=1) for i in range(n)]
+    cfg = Config(autocorrect=AutocorrectConfig(api_key="test-key"))
+
+    progress: list[tuple[int, int]] = []
+    review_suspicious(cfg, words, on_progress=lambda d, t: progress.append((d, t)))
+
+    # Three batches → three progress calls. Order may vary (parallel),
+    # but the final call must report `total = n` and totals must be
+    # monotonically non-decreasing.
+    assert len(progress) == 3
+    assert all(t == n for _, t in progress)
+    assert progress[-1][0] == n
+    assert all(progress[i][0] <= progress[i + 1][0] for i in range(len(progress) - 1))
+
+
+@patch("voiceio.autocorrect._REVIEW_OVERALL_TIMEOUT_PER_BATCH", 0.2)
+@patch("voiceio.autocorrect._REVIEW_MAX_WORKERS", 2)
+@patch("voiceio.llm_api.chat")
+def test_review_overall_timeout_returns_partial(mock_chat):
+    """A hung batch beyond the overall deadline doesn't stall the whole review."""
+    import time as _t
+
+    good_response = json.dumps({
+        "auto_fix": [], "ask_user": [],
+        "vocabulary": ["fast"],
+    })
+    call_count = {"i": 0}
+
+    def slow_or_fast(*_a, **_kw):
+        call_count["i"] += 1
+        # First call returns immediately; second one hangs past the overall budget.
+        if call_count["i"] == 1:
+            return good_response
+        _t.sleep(5.0)
+        return good_response
+
+    mock_chat.side_effect = slow_or_fast
+    n = _REVIEW_BATCH_SIZE * 2  # forces 2 batches
+    words = [SuspiciousWord(word=f"w{i}", count=1) for i in range(n)]
+    cfg = Config(autocorrect=AutocorrectConfig(api_key="test-key"))
+
+    started = _t.monotonic()
+    result = review_suspicious(cfg, words)
+    elapsed = _t.monotonic() - started
+
+    # Fast batch landed; slow batch was abandoned.
+    assert result.vocabulary == ["fast"]
+    # Overall budget is rounds(1) * 0.2 * 2 = 0.4s — must terminate well below 5s.
+    assert elapsed < 2.0
+
+
+@patch("voiceio.llm_api.chat")
+def test_review_partial_batch_failure_keeps_others(mock_chat):
+    """One failed batch doesn't lose results from successful batches."""
+    good = json.dumps({
+        "auto_fix": [{"wrong": "olamma", "right": "Ollama"}],
+        "ask_user": [], "vocabulary": [],
+    })
+    mock_chat.side_effect = [good, None, good]
+    n = _REVIEW_BATCH_SIZE * 2 + 1
+    words = [SuspiciousWord(word=f"w{i}", count=1) for i in range(n)]
+    cfg = Config(autocorrect=AutocorrectConfig(api_key="test-key"))
+
+    result = review_suspicious(cfg, words)
+    # Two successful batches × one auto_fix each
+    assert len(result.auto_fix) == 2
+
+
+# ── ranking tests ─────────────────────────────────────────────────────────
+
+
+def test_rank_score_llm_suggestion_dominates():
+    """An LLM-suggested correction outranks anything without one."""
+    sw = SuspiciousWord(word="foo", count=50, similar_common=["food"])
+    item_with = {"wrong": "bar", "right": "barn"}
+    item_without = {"wrong": "foo", "right": ""}
+    assert rank_review_score(item_with, None) > rank_review_score(item_without, sw)
+
+
+def test_rank_score_similar_common_boosts():
+    """Words near a real dictionary word score higher than isolated ones."""
+    sw_near = SuspiciousWord(word="wordal", count=5, similar_common=["wordle", "word"])
+    sw_alone = SuspiciousWord(word="wordal", count=5, similar_common=[])
+    item = {"wrong": "wordal", "right": ""}
+    assert rank_review_score(item, sw_near) > rank_review_score(item, sw_alone)
+
+
+def test_rank_score_short_acronym_demoted():
+    """Short all-lowercase ASCII words with no similar common get pushed down."""
+    sw_acronym = SuspiciousWord(word="yaml", count=10, similar_common=[])
+    sw_typo = SuspiciousWord(word="wordal", count=10, similar_common=["wordle"])
+    item_a = {"wrong": "yaml", "right": ""}
+    item_t = {"wrong": "wordal", "right": ""}
+    assert rank_review_score(item_t, sw_typo) > rank_review_score(item_a, sw_acronym)
+
+
+def test_rank_review_items_orders_correctly():
+    """rank_review_items: LLM-suggested first, acronyms last."""
+    sw_by_word = {
+        "yaml":   SuspiciousWord(word="yaml", count=10, similar_common=[]),
+        "wordal": SuspiciousWord(word="wordal", count=8, similar_common=["wordle"]),
+        "ctas":   SuspiciousWord(word="ctas", count=14, similar_common=[]),
+        "tarnsl": SuspiciousWord(word="tarnsl", count=2, similar_common=["transl", "trans"]),
+    }
+    items = [
+        {"wrong": "yaml",   "right": ""},
+        {"wrong": "wordal", "right": ""},
+        {"wrong": "ctas",   "right": ""},
+        {"wrong": "tarnsl", "right": "transl"},  # has LLM suggestion
+    ]
+    ranked = rank_review_items(items, sw_by_word)
+    order = [it["wrong"] for it in ranked]
+    # LLM-suggested first; then word with similar_common; acronyms last.
+    assert order[0] == "tarnsl"
+    assert order[1] == "wordal"
+    assert set(order[2:]) == {"yaml", "ctas"}
+
+
+def test_rank_review_items_handles_missing_metadata():
+    """Items without a SuspiciousWord entry still rank (lower)."""
+    items = [
+        {"wrong": "foo", "right": ""},
+        {"wrong": "bar", "right": "baz"},
+    ]
+    ranked = rank_review_items(items, {})
+    assert ranked[0]["wrong"] == "bar"

python_voiceio-0.3.13/tests/test_cli.py

@@ -0,0 +1,264 @@
+"""Tests for CLI helpers in voiceio.cli."""
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from voiceio.autocorrect import SuspiciousWord
+from voiceio.cli import _offer_cluster_apply, _save_api_key
+
+
+@pytest.fixture
+def patch_config_path(monkeypatch, tmp_path):
+    """Redirect voiceio.config.CONFIG_PATH to a temp file."""
+    config_path = tmp_path / "config.toml"
+    monkeypatch.setattr("voiceio.config.CONFIG_PATH", config_path)
+    return config_path
+
+
+def test_save_api_key_empty_config_openrouter(patch_config_path):
+    """Saving to a fresh config writes a new [autocorrect] block."""
+    cfg = MagicMock()
+    _save_api_key(cfg, "sk-or-v1-abc123")
+
+    content = patch_config_path.read_text(encoding="utf-8")
+    assert "[autocorrect]" in content
+    assert 'api_key = "sk-or-v1-abc123"' in content
+    assert 'base_url = "https://openrouter.ai/api/v1"' in content
+    assert "moonshotai/kimi-k2-0905" in content
+
+
+def test_save_api_key_detects_anthropic(patch_config_path):
+    """sk-ant- prefix routes to Anthropic provider."""
+    _save_api_key(MagicMock(), "sk-ant-api03-xyz")
+
+    content = patch_config_path.read_text(encoding="utf-8")
+    assert 'api_key = "sk-ant-api03-xyz"' in content
+    assert "api.anthropic.com" in content
+
+
+def test_save_api_key_detects_openai(patch_config_path):
+    """sk-proj- prefix routes to OpenAI provider."""
+    _save_api_key(MagicMock(), "sk-proj-foo")
+
+    content = patch_config_path.read_text(encoding="utf-8")
+    assert 'api_key = "sk-proj-foo"' in content
+    assert "api.openai.com" in content
+
+
+def test_save_api_key_replaces_existing_in_autocorrect(patch_config_path):
+    """Existing api_key under [autocorrect] is overwritten, not duplicated."""
+    patch_config_path.write_text(
+        '[autocorrect]\n'
+        'api_key = "old-key"\n'
+        'base_url = "https://example.com/v1"\n'
+        'model = "old-model"\n',
+        encoding="utf-8",
+    )
+    _save_api_key(MagicMock(), "sk-or-v1-new")
+
+    content = patch_config_path.read_text(encoding="utf-8")
+    assert content.count("api_key") == 1
+    assert 'api_key = "sk-or-v1-new"' in content
+    assert "old-key" not in content
+    assert "old-model" not in content
+
+
+def test_save_api_key_replaces_commented_field(patch_config_path):
+    """A commented-out api_key line gets replaced."""
+    patch_config_path.write_text(
+        '[autocorrect]\n'
+        '# api_key = ""\n'
+        '# base_url = ""\n'
+        '# model = ""\n',
+        encoding="utf-8",
+    )
+    _save_api_key(MagicMock(), "sk-or-v1-new")
+
+    content = patch_config_path.read_text(encoding="utf-8")
+    assert 'api_key = "sk-or-v1-new"' in content
+    assert "# api_key" not in content
+
+
+def test_save_api_key_preserves_other_sections(patch_config_path):
+    """Sections other than [autocorrect] are untouched."""
+    patch_config_path.write_text(
+        '[model]\n'
+        'language = "en"\n'
+        '\n'
+        '[autocorrect]\n'
+        'api_key = "old"\n'
+        '\n'
+        '[tts]\n'
+        'engine = "piper"\n',
+        encoding="utf-8",
+    )
+    _save_api_key(MagicMock(), "sk-or-v1-new")
+
+    content = patch_config_path.read_text(encoding="utf-8")
+    assert '[model]' in content
+    assert 'language = "en"' in content
+    assert '[tts]' in content
+    assert 'engine = "piper"' in content
+    assert 'api_key = "sk-or-v1-new"' in content
+
+
+def test_save_api_key_appends_section_when_missing(patch_config_path):
+    """If [autocorrect] doesn't exist yet, it's appended."""
+    patch_config_path.write_text(
+        '[model]\n'
+        'language = "en"\n',
+        encoding="utf-8",
+    )
+    _save_api_key(MagicMock(), "sk-or-v1-fresh")
+
+    content = patch_config_path.read_text(encoding="utf-8")
+    assert '[model]' in content
+    assert '[autocorrect]' in content
+    assert 'api_key = "sk-or-v1-fresh"' in content
+
+
+def test_save_api_key_creates_parent_dir(monkeypatch, tmp_path):
+    """Parent directory is created if missing."""
+    nested = tmp_path / "deep" / "nested" / "config.toml"
+    monkeypatch.setattr("voiceio.config.CONFIG_PATH", nested)
+
+    _save_api_key(MagicMock(), "sk-or-v1-abc")
+
+    assert nested.exists()
+    assert 'api_key = "sk-or-v1-abc"' in nested.read_text(encoding="utf-8")
+
+
+# ── _offer_cluster_apply ──────────────────────────────────────────────────
+
+
+def _rl_prompt(s):  # passthrough — strip ANSI is done by readline IRL
+    return s
+
+
+def test_cluster_apply_no_close_variants_returns_zero(monkeypatch):
+    """No remaining items within Levenshtein 2 → no prompt, no extra fixes."""
+    cd = MagicMock()
+    to_review = [
+        {"wrong": "pnit", "right": ""},
+        {"wrong": "completely_different", "right": ""},
+    ]
+    sw_by_word = {
+        "pnit": SuspiciousWord(word="pnit", count=6),
+        "completely_different": SuspiciousWord(word="completely_different", count=1),
+    }
+    # Should not call input() at all
+    monkeypatch.setattr("builtins.input", lambda *_a, **_k: pytest.fail("prompted"))
+    n = _offer_cluster_apply(
+        cd, "pnit", "peanut", to_review, current_i=1,
+        sw_by_word=sw_by_word, rl_prompt=_rl_prompt,
+    )
+    assert n == 0
+    assert cd.add.call_count == 0
+    assert len(to_review) == 2
+
+
+def test_cluster_apply_yes_applies_to_all_close_variants(monkeypatch):
+    """Y reply applies the same correction to every Levenshtein-≤2 remaining item."""
+    cd = MagicMock()
+    to_review = [
+        {"wrong": "pnit", "right": ""},      # current (already corrected)
+        {"wrong": "pnat", "right": "PNET"},  # close — should be batch-fixed
+        {"wrong": "pnut", "right": "PNET"},  # close — should be batch-fixed
+        {"wrong": "yaml", "right": ""},      # not close — left alone
+        {"wrong": "pinat", "right": "PNET"}, # close (distance 2) — batch-fixed
+    ]
+    sw_by_word = {
+        w["wrong"]: SuspiciousWord(word=w["wrong"], count=2) for w in to_review
+    }
+    monkeypatch.setattr("builtins.input", lambda *_a, **_k: "y")
+
+    n = _offer_cluster_apply(
+        cd, "pnit", "peanut", to_review, current_i=1,
+        sw_by_word=sw_by_word, rl_prompt=_rl_prompt,
+    )
+    assert n == 3
+    added = {call.args for call in cd.add.call_args_list}
+    assert added == {("pnat", "peanut"), ("pnut", "peanut"), ("pinat", "peanut")}
+    # yaml stays in to_review; the three variants are removed
+    assert [it["wrong"] for it in to_review] == ["pnit", "yaml"]
+
+
+def test_cluster_apply_no_reply_skips(monkeypatch):
+    """Replying 'n' applies nothing and leaves to_review intact."""
+    cd = MagicMock()
+    to_review = [
+        {"wrong": "pnit", "right": ""},
+        {"wrong": "pnat", "right": ""},
+        {"wrong": "pnut", "right": ""},
+    ]
+    sw_by_word = {
+        w["wrong"]: SuspiciousWord(word=w["wrong"], count=2) for w in to_review
+    }
+    monkeypatch.setattr("builtins.input", lambda *_a, **_k: "n")
+
+    n = _offer_cluster_apply(
+        cd, "pnit", "peanut", to_review, current_i=1,
+        sw_by_word=sw_by_word, rl_prompt=_rl_prompt,
+    )
+    assert n == 0
+    assert cd.add.call_count == 0
+    assert len(to_review) == 3
+
+
+def test_cluster_apply_default_yes_on_empty_input(monkeypatch):
+    """Empty input (just Enter) is treated as Yes."""
+    cd = MagicMock()
+    to_review = [
+        {"wrong": "pnit", "right": ""},
+        {"wrong": "pnat", "right": ""},
+    ]
+    sw_by_word = {w["wrong"]: SuspiciousWord(word=w["wrong"], count=2) for w in to_review}
+    monkeypatch.setattr("builtins.input", lambda *_a, **_k: "")
+    n = _offer_cluster_apply(
+        cd, "pnit", "peanut", to_review, current_i=1,
+        sw_by_word=sw_by_word, rl_prompt=_rl_prompt,
+    )
+    assert n == 1
+    cd.add.assert_called_once_with("pnat", "peanut")
+
+
+def test_cluster_apply_skips_already_reviewed_indices(monkeypatch):
+    """Items at indices < current_i (already reviewed) are not touched."""
+    cd = MagicMock()
+    to_review = [
+        {"wrong": "pnut", "right": ""},   # already reviewed (index 0)
+        {"wrong": "pnit", "right": ""},   # current
+        {"wrong": "pnat", "right": ""},   # remaining — eligible
+    ]
+    sw_by_word = {w["wrong"]: SuspiciousWord(word=w["wrong"], count=2) for w in to_review}
+    monkeypatch.setattr("builtins.input", lambda *_a, **_k: "y")
+    n = _offer_cluster_apply(
+        cd, "pnit", "peanut", to_review, current_i=2,  # skip past current word too
+        sw_by_word=sw_by_word, rl_prompt=_rl_prompt,
+    )
+    # Only pnat (at index 2) is eligible — pnut is at index 0 (< current_i).
+    assert n == 1
+    cd.add.assert_called_once_with("pnat", "peanut")
+
+
+def test_cluster_apply_eof_aborts_safely(monkeypatch):
+    """Ctrl-D / EOF on the prompt does not crash and applies nothing."""
+    cd = MagicMock()
+    to_review = [
+        {"wrong": "pnit", "right": ""},
+        {"wrong": "pnat", "right": ""},
+    ]
+    sw_by_word = {w["wrong"]: SuspiciousWord(word=w["wrong"], count=2) for w in to_review}
+
+    def raise_eof(*_a, **_k):
+        raise EOFError
+
+    monkeypatch.setattr("builtins.input", raise_eof)
+    n = _offer_cluster_apply(
+        cd, "pnit", "peanut", to_review, current_i=1,
+        sw_by_word=sw_by_word, rl_prompt=_rl_prompt,
+    )
+    assert n == 0
+    assert cd.add.call_count == 0

{python_voiceio-0.3.11 → python_voiceio-0.3.13}/tests/test_llm_api.py

@@ -95,6 +95,50 @@ def test_chat_malformed_response(mock_urlopen):
     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 ────────────────────────────────────────────────────────
 
 
@@ -157,7 +201,7 @@ def test_check_api_key_anthropic(mock_urlopen):
 def test_detect_openrouter():
     base_url, model = detect_provider("sk-or-abc123")
     assert "openrouter" in base_url
-    assert "claude" in model
+    assert "kimi" in model
 
 
 def test_detect_anthropic():

{python_voiceio-0.3.11 → python_voiceio-0.3.13}/tests/test_postprocess.py

@@ -1,7 +1,7 @@
 """Tests for text post-processing (punctuation, capitalization)."""
 from __future__ import annotations
 
-from voiceio.postprocess import cleanup
+from voiceio.postprocess import apply_pipeline, cleanup
 from voiceio.streaming import _word_match_len
 
 
@@ -105,3 +105,50 @@ class TestWordMatchCompatibility:
         raw = ["testing,", "testing,", "hello"]
         cleaned = ["Testing,", "testing", "hello"]
         assert _word_match_len(raw, cleaned) == 3
+
+
+class TestVoiceInputPrefix:
+    """The prefix marker is prepended only when configured + text is non-empty."""
+
+    def test_disabled_by_default(self):
+        text, abort = apply_pipeline("hello world", final=True)
+        assert text == "hello world"
+        assert abort is False
+
+    def test_applied_when_set_final(self):
+        text, abort = apply_pipeline(
+            "hello world", voice_input_prefix="[voice]", final=True,
+        )
+        assert text == "[voice] hello world"
+        assert abort is False
+
+    def test_applied_during_streaming(self):
+        # Streaming passes (final=False) must also carry the prefix so the
+        # marker appears from the first chunk, not only at the very end.
+        text, _ = apply_pipeline(
+            "partial", voice_input_prefix="[voice]", final=False,
+        )
+        assert text == "[voice] partial"
+
+    def test_not_applied_to_empty_text(self):
+        text, abort = apply_pipeline(
+            "", voice_input_prefix="[voice]", final=True,
+        )
+        assert text == ""
+        assert abort is False
+
+    def test_custom_prefix(self):
+        text, _ = apply_pipeline(
+            "ok", voice_input_prefix="[v]", final=True,
+        )
+        assert text == "[v] ok"
+
+    def test_with_cleanup_chain(self):
+        # Cleanup capitalizes, then prefix is prepended verbatim.
+        text, _ = apply_pipeline(
+            "hello world",
+            do_cleanup=True,
+            voice_input_prefix="[voice]",
+            final=True,
+        )
+        assert text == "[voice] Hello world"

python_voiceio-0.3.13/voiceio/__init__.py

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