PayPerTranscript 0.2.8__tar.gz → 0.3.0__tar.gz

{paypertranscript-0.2.8 → paypertranscript-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PayPerTranscript
-Version: 0.2.8
+Version: 0.3.0
 Summary: Open-Source Voice-to-Text mit Pay-per-Use Pricing
 Author: PayPerTranscript Contributors
 License-Expression: MIT

{paypertranscript-0.2.8 → paypertranscript-0.3.0}/PayPerTranscript.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PayPerTranscript
-Version: 0.2.8
+Version: 0.3.0
 Summary: Open-Source Voice-to-Text mit Pay-per-Use Pricing
 Author: PayPerTranscript Contributors
 License-Expression: MIT

{paypertranscript-0.2.8 → paypertranscript-0.3.0}/paypertranscript/__init__.py

@@ -1,3 +1,3 @@
 """PayPerTranscript - Voice-to-Text mit Pay-per-Use Pricing."""
 
-__version__ = "0.2.8"
+__version__ = "0.3.0"

{paypertranscript-0.2.8 → paypertranscript-0.3.0}/paypertranscript/core/config.py

@@ -33,6 +33,7 @@ DEFAULT_CONFIG: dict[str, Any] = {
         "provider": "groq",
         "stt_model": "whisper-large-v3-turbo",
         "llm_model": "openai/gpt-oss-20b",
+        "llm_temperature": 1.0,
     },
     "words": {
         "misspelled_words": [],
@@ -87,6 +88,7 @@ _SCHEMA: dict[str, type | tuple[type, ...]] = {
     "api.provider": str,
     "api.stt_model": str,
     "api.llm_model": str,
+    "api.llm_temperature": (int, float),
     "words.misspelled_words": list,
     "formatting.window_mappings": dict,
     "formatting.categories": dict,

{paypertranscript-0.2.8 → paypertranscript-0.3.0}/paypertranscript/core/cost_tracker.py

@@ -6,12 +6,18 @@ Keine I/O, keine Seiteneffekte - einfach testbar.
 
 from dataclasses import dataclass
 
-# STT/LLM API-Preise (Stand: 2026-02)
+# STT API-Preise (Stand: 2026-02)
 STT_PRICE_PER_HOUR_USD = 0.04
 STT_MIN_BILLED_SECONDS = 10  # API-seitiges Minimum-Billing
 
-LLM_INPUT_PRICE_PER_M_TOKENS = 0.075   # USD per million input tokens
-LLM_OUTPUT_PRICE_PER_M_TOKENS = 0.30   # USD per million output tokens
+# LLM-Preise pro Modell: (Input USD/M Tokens, Output USD/M Tokens)
+LLM_PRICES: dict[str, tuple[float, float]] = {
+    "openai/gpt-oss-20b": (0.075, 0.30),
+    "openai/gpt-oss-120b": (0.15, 0.60),
+    "moonshotai/kimi-k2-instruct-0905": (1.00, 3.00),
+}
+
+_DEFAULT_LLM_PRICES = (0.075, 0.30)  # Fallback
 
 
 @dataclass(frozen=True)
@@ -41,19 +47,22 @@ def calculate_stt_cost(audio_duration_seconds: float) -> tuple[float, float]:
     return billed, cost
 
 
-def calculate_llm_cost(input_tokens: int, output_tokens: int) -> float:
+def calculate_llm_cost(
+    input_tokens: int, output_tokens: int, model: str = "",
+) -> float:
     """Berechnet LLM-Kosten.
 
     Args:
         input_tokens: Anzahl Input-Tokens.
         output_tokens: Anzahl Output-Tokens.
+        model: LLM-Modellname fuer modellspezifische Preise.
 
     Returns:
         Kosten in USD.
     """
+    input_price, output_price = LLM_PRICES.get(model, _DEFAULT_LLM_PRICES)
     return (
-        input_tokens * LLM_INPUT_PRICE_PER_M_TOKENS
-        + output_tokens * LLM_OUTPUT_PRICE_PER_M_TOKENS
+        input_tokens * input_price + output_tokens * output_price
     ) / 1_000_000
 
 
@@ -61,6 +70,7 @@ def calculate_total_cost(
     audio_duration_seconds: float,
     llm_input_tokens: int = 0,
     llm_output_tokens: int = 0,
+    llm_model: str = "",
 ) -> CostResult:
     """Berechnet Gesamtkosten einer Transkription.
 
@@ -68,12 +78,13 @@ def calculate_total_cost(
         audio_duration_seconds: Audio-Dauer in Sekunden.
         llm_input_tokens: LLM Input-Tokens (0 wenn kein LLM).
         llm_output_tokens: LLM Output-Tokens (0 wenn kein LLM).
+        llm_model: LLM-Modellname fuer modellspezifische Preise.
 
     Returns:
         CostResult mit allen Kosten-Details.
     """
     billed, stt_cost = calculate_stt_cost(audio_duration_seconds)
-    llm_cost = calculate_llm_cost(llm_input_tokens, llm_output_tokens)
+    llm_cost = calculate_llm_cost(llm_input_tokens, llm_output_tokens, llm_model)
     return CostResult(
         audio_duration_seconds=audio_duration_seconds,
         billed_seconds=billed,

{paypertranscript-0.2.8 → paypertranscript-0.3.0}/paypertranscript/core/hotkey.py

@@ -54,6 +54,11 @@ _MODIFIER_GROUPS: dict[str, set[keyboard.Key]] = {
     "cmd": {keyboard.Key.cmd, keyboard.Key.cmd_l, keyboard.Key.cmd_r},
 }
 
+# Alle Modifier-Keys (flach) fuer Exakt-Match-Pruefung
+_ALL_MODIFIER_KEYS: set[keyboard.Key] = set()
+for _grp in _MODIFIER_GROUPS.values():
+    _ALL_MODIFIER_KEYS |= _grp
+
 # Alt-Keys fuer Menu-Bar-Workaround (Windows aktiviert Menueleiste bei bare Alt-Release)
 _ALT_KEYS: set[keyboard.Key] = {keyboard.Key.alt_l, keyboard.Key.alt_r}
 
@@ -149,18 +154,33 @@ class HotkeyListener:
         target_keys: list[keyboard.Key | keyboard.KeyCode],
         modifier_groups: list[set[keyboard.Key]],
     ) -> bool:
-        """Prüft ob eine Tastenkombination aktuell gedrückt ist."""
+        """Prüft ob eine Tastenkombination aktuell gedrückt ist.
+
+        Exaktes Modifier-Matching: es muessen genau die konfigurierten Modifier
+        gedrueckt sein, keine zusaetzlichen. Damit wird verhindert, dass z.B.
+        Ctrl+Win auch durch Ctrl+Shift+Alt+F9 ausgeloest wird.
+        """
         if not target_keys:
             return False
 
+        # Sammle welche Modifier-Gruppen zum Hotkey gehoeren
+        required_modifier_keys: set[keyboard.Key] = set()
+
         for i, target_key in enumerate(target_keys):
             # Für Modifier: prüfe ob *irgendein* Key aus der Gruppe gedrückt ist
             if i < len(modifier_groups) and modifier_groups[i]:
                 if not (modifier_groups[i] & self._pressed_keys):
                     return False
+                required_modifier_keys |= modifier_groups[i]
             else:
                 if target_key not in self._pressed_keys:
                     return False
+
+        # Pruefe ob Extra-Modifier gedrueckt sind, die nicht zum Hotkey gehoeren
+        extra_modifiers = (self._pressed_keys & _ALL_MODIFIER_KEYS) - required_modifier_keys
+        if extra_modifiers:
+            return False
+
         return True
 
     def _combo_uses_alt(self, target_keys: list[keyboard.Key | keyboard.KeyCode]) -> bool:

{paypertranscript-0.2.8 → paypertranscript-0.3.0}/paypertranscript/core/text_inserter.py

@@ -19,6 +19,27 @@ log = get_logger("core.text_inserter")
 pyautogui.FAILSAFE = False
 pyautogui.PAUSE = 0
 
+# Clipboard-Wiederherstellung: Retry-Konfiguration
+_CLIPBOARD_RESTORE_RETRIES = 3
+_CLIPBOARD_RESTORE_DELAY = 0.05  # 50ms zwischen Versuchen
+
+
+def _restore_clipboard(content: str) -> None:
+    """Stellt die Zwischenablage wieder her mit Retry-Logik.
+
+    Andere Apps (Clipboard-Manager, Password-Manager) koennen die
+    Zwischenablage kurzzeitig sperren. Daher mehrere Versuche.
+    """
+    for attempt in range(1, _CLIPBOARD_RESTORE_RETRIES + 1):
+        try:
+            pyperclip.copy(content)
+            return
+        except Exception:
+            if attempt < _CLIPBOARD_RESTORE_RETRIES:
+                time.sleep(_CLIPBOARD_RESTORE_DELAY)
+            else:
+                log.warning("Zwischenablage konnte nicht wiederhergestellt werden (nach %d Versuchen)", _CLIPBOARD_RESTORE_RETRIES)
+
 
 def insert_text(text: str) -> None:
     """Fügt Text an der aktuellen Cursor-Position ein.
@@ -62,10 +83,7 @@ def insert_text(text: str) -> None:
 
     finally:
         # 5. Alte Zwischenablage wiederherstellen
-        try:
-            pyperclip.copy(old_clipboard)
-        except Exception:
-            log.debug("Zwischenablage konnte nicht wiederhergestellt werden")
+        _restore_clipboard(old_clipboard)
 
 
 # Intervall (Sekunden) zwischen Chunk-Pastes bei Streaming-Typing
@@ -125,7 +143,4 @@ def insert_text_streaming(chunks: Iterator[str]) -> None:
                 log.error("Auch Fallback-Paste fehlgeschlagen")
 
     finally:
-        try:
-            pyperclip.copy(old_clipboard)
-        except Exception:
-            log.debug("Zwischenablage konnte nicht wiederhergestellt werden")
+        _restore_clipboard(old_clipboard)

{paypertranscript-0.2.8 → paypertranscript-0.3.0}/paypertranscript/pipeline/transcription.py

@@ -26,9 +26,38 @@ STATUS_STT_DONE = "stt_done"
 STATUS_LLM_START = "llm_start"
 STATUS_DONE = "done"
 STATUS_ERROR = "error"
+STATUS_LLM_FALLBACK = "llm_fallback"
 
 log = get_logger("pipeline.transcription")
 
+# Halluzinationsfilter: Whisper halluziniert bei kurzen Aufnahmen ohne Sprache
+_HALLUCINATION_PATTERNS = [
+    "copyright", "untertitel", "subtitles by",
+    "thanks for watching", "thank you for watching",
+    "sous-titres", "amara.org",
+]
+_HALLUCINATION_MAX_DURATION = 5.0
+
+
+def _is_hallucination(text: str, audio_duration: float) -> bool:
+    """Prueft ob ein STT-Ergebnis eine Whisper-Halluzination ist.
+
+    Bei kurzen Aufnahmen (< 5s) ohne Sprache halluziniert Whisper
+    stereotypische Strings wie "Copyright Australian Broadcasting Corporation".
+
+    Args:
+        text: STT-Ergebnis.
+        audio_duration: Audio-Dauer in Sekunden.
+
+    Returns:
+        True wenn der Text als Halluzination erkannt wurde.
+    """
+    if audio_duration >= _HALLUCINATION_MAX_DURATION:
+        return False
+    text_lower = text.lower()
+    return any(pattern in text_lower for pattern in _HALLUCINATION_PATTERNS)
+
+
 # Maximale Prompt-Laenge fuer Whisper (224 Tokens).
 # Konservative Schaetzung: ~4 Zeichen pro Token fuer gemischten DE/EN Text.
 _MAX_PROMPT_CHARS = 896
@@ -86,6 +115,7 @@ class TranscriptionPipeline:
         self._config = config
         self._session_logger = session_logger
         self.last_transcription: str | None = None
+        self.last_wav_path: Path | None = None
         log.info(
             "TranscriptionPipeline initialisiert (LLM: %s, Tracking: %s)",
             "aktiv" if llm_provider else "deaktiviert",
@@ -165,6 +195,7 @@ class TranscriptionPipeline:
             audio_duration_seconds=audio_duration,
             llm_input_tokens=llm_input_tokens,
             llm_output_tokens=llm_output_tokens,
+            llm_model=self._config.get("api.llm_model", ""),
         )
 
         session_data = {
@@ -218,6 +249,8 @@ class TranscriptionPipeline:
                 except Exception:
                     pass
 
+        self.last_wav_path = wav_path
+
         try:
             # Audio-Dauer: entweder uebergeben oder aus WAV-Datei berechnen
             if audio_duration is None:
@@ -240,7 +273,16 @@ class TranscriptionPipeline:
 
             if not text:
                 log.info("Pipeline: STT lieferte leeren Text - uebersprungen")
-                _notify(STATUS_DONE)
+                _notify(STATUS_ERROR, "Kein Text erkannt")
+                return
+
+            if _is_hallucination(text, audio_duration):
+                log.info(
+                    "Pipeline: Halluzination erkannt (%.1fs, '%s') - uebersprungen",
+                    audio_duration,
+                    text[:80],
+                )
+                _notify(STATUS_ERROR, "Keine Sprache erkannt")
                 return
 
             # LLM-Formatierung (falls Window-Mapping existiert)
@@ -261,7 +303,7 @@ class TranscriptionPipeline:
                 except Exception as e:
                     insert_ok = False
                     log.error("Pipeline: Text-Einfuegung fehlgeschlagen: %s", e)
-                    _notify(STATUS_ERROR, "Text konnte nicht eingefuegt werden")
+                    _notify(STATUS_ERROR, f"Text-Einfuegung fehlgeschlagen: {e}")
 
             def _do_insert_stream(chunks_iter: object) -> None:
                 nonlocal insert_ok
@@ -270,7 +312,7 @@ class TranscriptionPipeline:
                 except Exception as e:
                     insert_ok = False
                     log.error("Pipeline: Streaming-Einfuegung fehlgeschlagen: %s", e)
-                    _notify(STATUS_ERROR, "Text konnte nicht eingefuegt werden")
+                    _notify(STATUS_ERROR, f"Text-Einfuegung fehlgeschlagen: {e}")
 
             if system_prompt and self._llm:
                 _notify(STATUS_LLM_START)
@@ -298,6 +340,7 @@ class TranscriptionPipeline:
 
                 except ProviderError as e:
                     log.warning("Pipeline: LLM-Fehler - Fallback auf Rohtext: %s", e)
+                    _notify(STATUS_LLM_FALLBACK, str(e))
                     _do_insert(text)
             else:
                 # Kein Mapping oder kein LLM-Provider -> Rohtext direkt einfuegen

paypertranscript-0.3.0/paypertranscript/providers/groq_provider.py

@@ -0,0 +1,273 @@
+"""GroqCloud API-Provider für PayPerTranscript.
+
+Implementiert STT (Whisper) und LLM-Formatierung über die GroqCloud API.
+"""
+
+import time
+from collections.abc import Iterator
+from pathlib import Path
+
+import groq
+
+from paypertranscript.core.logging import get_logger
+from paypertranscript.providers.base import AbstractLLMProvider, AbstractSTTProvider, ProviderError
+
+log = get_logger("providers.groq")
+
+# Retry-Konfiguration fuer transiente API-Fehler
+_MAX_RETRIES = 3
+_RETRY_BASE_DELAY = 1.0  # Sekunden (exponential: 1s, 2s, 4s)
+_RETRYABLE_ERRORS = (groq.RateLimitError, groq.APITimeoutError, groq.APIConnectionError)
+
+# Minimale WAV-Dateigroesse (44 Bytes = WAV-Header ohne Audio-Daten)
+_MIN_WAV_SIZE = 44
+
+
+class GroqSTTProvider(AbstractSTTProvider):
+    """GroqCloud Whisper STT-Provider.
+
+    Nutzt whisper-large-v3-turbo für Speech-to-Text.
+    Der Groq-Client wird einmal instanziiert und wiederverwendet
+    (Connection Pooling via httpx).
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        model: str = "whisper-large-v3-turbo",
+    ) -> None:
+        self._model = model
+        try:
+            self._client = groq.Groq(api_key=api_key)
+        except groq.GroqError as e:
+            raise ProviderError(f"Groq-Client konnte nicht erstellt werden: {e}") from e
+        log.info("GroqSTTProvider initialisiert (Modell: %s)", self._model)
+
+    def transcribe(self, audio_path: Path, language: str, prompt: str = "") -> str:
+        """Transkribiert eine WAV-Datei via GroqCloud Whisper API."""
+        if not audio_path.exists():
+            raise ProviderError(f"Audio-Datei nicht gefunden: {audio_path}")
+
+        # V05: Audio-Datei validieren (WAV-Header = 44 Bytes, leere Datei vermeiden)
+        file_size = audio_path.stat().st_size
+        if file_size <= _MIN_WAV_SIZE:
+            raise ProviderError(
+                f"Audio-Datei ist leer oder beschädigt ({file_size} Bytes)"
+            )
+
+        log.info(
+            "STT-Anfrage: %s (Sprache: %s, Modell: %s)",
+            audio_path.name,
+            language,
+            self._model,
+        )
+        if prompt:
+            log.info("STT-Prompt: %s", prompt)
+
+        # V01: Retry-Loop fuer transiente Fehler
+        last_error: Exception | None = None
+        for attempt in range(1, _MAX_RETRIES + 1):
+            try:
+                with open(audio_path, "rb") as audio_file:
+                    transcription = self._client.audio.transcriptions.create(
+                        model=self._model,
+                        file=audio_file,
+                        language=language,
+                        prompt=prompt,
+                        response_format="text",
+                        temperature=0.0,
+                    )
+                break  # Erfolg
+            except groq.AuthenticationError as e:
+                raise ProviderError(f"API-Key ungültig: {e}") from e
+            except _RETRYABLE_ERRORS as e:
+                last_error = e
+                if attempt < _MAX_RETRIES:
+                    delay = _RETRY_BASE_DELAY * (2 ** (attempt - 1))
+                    log.warning(
+                        "STT-Versuch %d/%d fehlgeschlagen: %s - Retry in %.1fs",
+                        attempt, _MAX_RETRIES, e, delay,
+                    )
+                    time.sleep(delay)
+                else:
+                    log.error("STT: Alle %d Versuche fehlgeschlagen", _MAX_RETRIES)
+            except groq.APIError as e:
+                raise ProviderError(f"GroqCloud API-Fehler: {e}") from e
+        else:
+            # Alle Retries erschoepft
+            e = last_error
+            if isinstance(e, groq.RateLimitError):
+                raise ProviderError(f"Rate Limit erreicht: {e}") from e
+            elif isinstance(e, groq.APITimeoutError):
+                raise ProviderError(f"GroqCloud Timeout: {e}") from e
+            else:
+                raise ProviderError(f"Keine Verbindung zu GroqCloud: {e}") from e
+
+        # response_format="text" gibt direkt einen String zurück
+        text = transcription.strip() if isinstance(transcription, str) else transcription.text.strip()
+
+        log.info("STT-Ergebnis: %d Zeichen", len(text))
+        return text
+
+
+class GroqLLMProvider(AbstractLLMProvider):
+    """GroqCloud LLM-Provider für Textformatierung.
+
+    Nutzt openai/gpt-oss-20b für kontextabhängige Formatierung.
+    Der Groq-Client wird einmal instanziiert und wiederverwendet.
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        model: str = "openai/gpt-oss-20b",
+        temperature: float | None = None,
+    ) -> None:
+        self._model = model
+        self._temperature = temperature
+        self._last_usage: dict[str, int] | None = None
+        try:
+            self._client = groq.Groq(api_key=api_key)
+        except groq.GroqError as e:
+            raise ProviderError(f"Groq-Client konnte nicht erstellt werden: {e}") from e
+        log.info("GroqLLMProvider initialisiert (Modell: %s, Temperature: %s)", self._model, self._temperature)
+
+    @property
+    def last_usage(self) -> dict[str, int] | None:
+        """Token-Usage der letzten LLM-Anfrage."""
+        return self._last_usage
+
+    def _build_messages(
+        self, system_prompt: str, text: str
+    ) -> list[dict[str, str]]:
+        return [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": f"<transcript>{text}</transcript>"},
+        ]
+
+    def _completion_kwargs(self) -> dict:
+        """Baut gemeinsame kwargs für chat.completions.create."""
+        kwargs: dict = {}
+        if self._temperature is not None:
+            kwargs["temperature"] = self._temperature
+        return kwargs
+
+    def format_text(self, system_prompt: str, text: str) -> str:
+        log.info("LLM-Anfrage (non-streaming, Modell: %s, Temperature: %s)", self._model, self._temperature)
+        self._last_usage = None
+
+        # V01: Retry-Loop fuer transiente Fehler
+        last_error: Exception | None = None
+        for attempt in range(1, _MAX_RETRIES + 1):
+            try:
+                response = self._client.chat.completions.create(
+                    model=self._model,
+                    messages=self._build_messages(system_prompt, text),
+                    stream=False,
+                    **self._completion_kwargs(),
+                )
+                break  # Erfolg
+            except groq.AuthenticationError as e:
+                raise ProviderError(f"API-Key ungültig: {e}") from e
+            except _RETRYABLE_ERRORS as e:
+                last_error = e
+                if attempt < _MAX_RETRIES:
+                    delay = _RETRY_BASE_DELAY * (2 ** (attempt - 1))
+                    log.warning(
+                        "LLM-Versuch %d/%d fehlgeschlagen: %s - Retry in %.1fs",
+                        attempt, _MAX_RETRIES, e, delay,
+                    )
+                    time.sleep(delay)
+                else:
+                    log.error("LLM: Alle %d Versuche fehlgeschlagen", _MAX_RETRIES)
+            except groq.APIError as e:
+                raise ProviderError(f"GroqCloud API-Fehler: {e}") from e
+        else:
+            e = last_error
+            if isinstance(e, groq.RateLimitError):
+                raise ProviderError(f"Rate Limit erreicht: {e}") from e
+            elif isinstance(e, groq.APITimeoutError):
+                raise ProviderError(f"GroqCloud Timeout: {e}") from e
+            else:
+                raise ProviderError(f"Keine Verbindung zu GroqCloud: {e}") from e
+
+        # Usage-Daten erfassen
+        if hasattr(response, "usage") and response.usage:
+            self._last_usage = {
+                "prompt_tokens": response.usage.prompt_tokens or 0,
+                "completion_tokens": response.usage.completion_tokens or 0,
+            }
+
+        result = response.choices[0].message.content or ""
+        result = result.strip()
+        log.info("LLM-Ergebnis: %d Zeichen", len(result))
+        return result
+
+    def format_text_stream(self, system_prompt: str, text: str) -> Iterator[str]:
+        log.info("LLM-Anfrage (streaming, Modell: %s, Temperature: %s)", self._model, self._temperature)
+        self._last_usage = None
+
+        # V01: Retry-Loop fuer transiente Fehler beim Stream-Aufbau
+        last_error: Exception | None = None
+        for attempt in range(1, _MAX_RETRIES + 1):
+            try:
+                stream = self._client.chat.completions.create(
+                    model=self._model,
+                    messages=self._build_messages(system_prompt, text),
+                    stream=True,
+                    **self._completion_kwargs(),
+                )
+                break  # Erfolg
+            except groq.AuthenticationError as e:
+                raise ProviderError(f"API-Key ungültig: {e}") from e
+            except _RETRYABLE_ERRORS as e:
+                last_error = e
+                if attempt < _MAX_RETRIES:
+                    delay = _RETRY_BASE_DELAY * (2 ** (attempt - 1))
+                    log.warning(
+                        "LLM-Stream-Versuch %d/%d fehlgeschlagen: %s - Retry in %.1fs",
+                        attempt, _MAX_RETRIES, e, delay,
+                    )
+                    time.sleep(delay)
+                else:
+                    log.error("LLM-Stream: Alle %d Versuche fehlgeschlagen", _MAX_RETRIES)
+            except groq.APIError as e:
+                raise ProviderError(f"GroqCloud API-Fehler: {e}") from e
+        else:
+            e = last_error
+            if isinstance(e, groq.RateLimitError):
+                raise ProviderError(f"Rate Limit erreicht: {e}") from e
+            elif isinstance(e, groq.APITimeoutError):
+                raise ProviderError(f"GroqCloud Timeout: {e}") from e
+            else:
+                raise ProviderError(f"Keine Verbindung zu GroqCloud: {e}") from e
+
+        # V02: Stream-Iteration in try/except — Verbindungsabbruch waehrend Streaming erkennen
+        total_chars = 0
+        try:
+            for chunk in stream:
+                delta = chunk.choices[0].delta.content
+                if delta:
+                    total_chars += len(delta)
+                    yield delta
+                # Groq streaming: Usage im letzten Chunk via x_groq
+                if (
+                    hasattr(chunk, "x_groq")
+                    and chunk.x_groq
+                    and hasattr(chunk.x_groq, "usage")
+                    and chunk.x_groq.usage
+                ):
+                    usage = chunk.x_groq.usage
+                    self._last_usage = {
+                        "prompt_tokens": getattr(usage, "prompt_tokens", 0) or 0,
+                        "completion_tokens": getattr(usage, "completion_tokens", 0) or 0,
+                    }
+        except groq.APIError as e:
+            raise ProviderError(
+                f"LLM-Stream abgebrochen nach {total_chars} Zeichen: {e}"
+            ) from e
+        except Exception as e:
+            raise ProviderError(
+                f"LLM-Stream abgebrochen nach {total_chars} Zeichen: {e}"
+            ) from e
+        log.info("LLM-Stream abgeschlossen: %d Zeichen", total_chars)