cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/providers/ollama_adapter.py

@@ -0,0 +1,707 @@
+"""
+Ollama Provider Adapter, Streaming Protocol & Repetition Guard for CAT.
+
+Implements Sections 6-10, 12, 24, 25, 28, 30, 31, and 34 of the
+CAT AI Mode Reliability Contract.
+"""
+
+import json
+import logging
+import re
+import threading
+import time
+import uuid
+from typing import Generator, Dict, Any, Optional, List, Tuple
+
+_LOG = logging.getLogger("cct.ollama_adapter")
+
+
+class RequestState:
+    IDLE = "idle"
+    QUEUED = "queued"
+    STARTING = "starting"
+    STREAMING = "streaming"
+    COMPLETED = "completed"
+    CANCELLED = "cancelled"
+    FAILED = "failed"
+
+
+class GenerationGuard:
+    """Detects abnormal generation loops and repetitions in small/base models.
+    
+    Prevents runaway output such as:
+      - 'hihihihihihihihihi'
+      - 'ahahahaha...'
+      - Repeated identical sentences or phrases.
+    """
+
+    def __init__(self, max_repeated_chars: int = 24, max_sentence_repeats: int = 3):
+        self.max_repeated_chars = max_repeated_chars
+        self.max_sentence_repeats = max_sentence_repeats
+        self.buffer = ""
+        self._recent_sentences: List[str] = []
+        self.repetition_detected = False
+        self.repetition_reason = ""
+
+    def feed(self, chunk: str) -> Tuple[bool, str]:
+        """Feed a streamed text chunk into the guard.
+        
+        Returns:
+            (should_continue, clean_chunk)
+            If repetition is detected, should_continue is False and
+            a stopping notice is returned.
+        """
+        if not chunk or self.repetition_detected:
+            return False, ""
+
+        self.buffer += chunk
+
+        # 1. Check for character-level runaway loops (e.g. 'hihihihihihi' or 'ahahahaha')
+        # Matches any 1-6 char alphanumeric pattern repeated more than 8 times
+        loop_match = re.search(r"(.{1,6}?)\1{8,}", self.buffer[-100:])
+        if loop_match:
+            repeated_sub = loop_match.group(1)
+            # Only trigger on repeating letters or digits (e.g. 'hi', 'ha', 'abc').
+            # Markdown dividers ('---', '==='), code banners ('/* **** */'), and table rules
+            # are legitimate syntax and must NOT be treated as runaway loops.
+            if re.search(r"[a-zA-Z0-9]", repeated_sub) and not repeated_sub.isspace():
+                match_span = loop_match.group(0)
+                if len(match_span) >= self.max_repeated_chars:
+                    self.repetition_detected = True
+                    self.repetition_reason = f"Repeating pattern detected: '{repeated_sub}'"
+                    _LOG.warning("GenerationGuard halted stream: %s", self.repetition_reason)
+                    return False, "\n\n*(Generation stopped: repetitive output pattern detected)*"
+
+        # 2. Check for consecutive sentence-level repetitions (e.g. repeating the same prose sentence 3 times in a row)
+        sentences = [s.strip() for s in re.split(r"[.!?\n]+", self.buffer) if len(s.strip()) > 15]
+        if len(sentences) >= 3:
+            s1, s2, s3 = sentences[-1].lower(), sentences[-2].lower(), sentences[-3].lower()
+            # Ignore markdown list items, code comments, and code keywords which naturally repeat
+            is_code_or_list = any(s1.startswith(p) for p in ("- ", "* ", "#", "//", "/*", "return", "import", "def ", "class ", "print"))
+            if not is_code_or_list and s1 == s2 == s3:
+                self.repetition_detected = True
+                self.repetition_reason = f"Repeating sentence: '{s1[:40]}...'"
+                _LOG.warning("GenerationGuard halted stream: %s", self.repetition_reason)
+                return False, "\n\n*(Generation stopped: sentence repetition loop detected)*"
+
+        return True, chunk
+
+
+class OutputSanitizer:
+    """Sanitizes generated tokens to remove stray protocol leakage without destroying code or markdown."""
+
+    # Leading prefixes accidentally generated by base models
+    _PREFIX_PATTERNS = [
+        re.compile(r"^\s*Assistant\s*:\s*", re.IGNORECASE),
+        re.compile(r"^\s*CAT\s*AI\s*:\s*", re.IGNORECASE),
+        re.compile(r"^\s*Response\s*:\s*", re.IGNORECASE),
+    ]
+
+    @classmethod
+    def sanitize_first_chunk(cls, text: str) -> str:
+        """Remove accidental assistant prefix from the beginning of a generation."""
+        s = text
+        for p in cls._PREFIX_PATTERNS:
+            s = p.sub("", s)
+        return s
+
+    @classmethod
+    def sanitize_final(cls, full_text: str) -> str:
+        """Clean any remaining transport wrappers or trailing raw prompts."""
+        cleaned = full_text
+        for p in cls._PREFIX_PATTERNS:
+            cleaned = p.sub("", cleaned)
+        for stop_p in ("<|imend|>", "<|im_end|>", "<|endoftext|>", "<|eot_id|>", "<|end_of_text|>"):
+            cleaned = cleaned.replace(stop_p, "")
+        # Remove trailing unclosed conversation prompts if model hallucinated another turn
+        cleaned = re.sub(r"\n\s*User:\s*$", "", cleaned, flags=re.IGNORECASE)
+        cleaned = re.sub(r"\n\s*Human:\s*$", "", cleaned, flags=re.IGNORECASE)
+        return cleaned.strip()
+
+
+class ThinkingStreamFilter:
+    """Separates reasoning/thinking tokens (<think>...</think> or message.thinking)
+    from final response text, streaming thoughts to live activities in real time
+    while ensuring only post-thinking answer text reaches the chat response bubble."""
+
+    def __init__(self, on_thinking_chunk, on_thinking_end):
+        self.on_thinking_chunk = on_thinking_chunk
+        self.on_thinking_end = on_thinking_end
+        self.in_thinking = False
+        self.buffer = ""
+
+    def process(self, thinking_part: str, content_part: str) -> str:
+        # If model explicitly provides thinking_part (e.g. Ollama 0.5.8+ with DeepSeek-R1)
+        if thinking_part:
+            if not self.in_thinking:
+                self.in_thinking = True
+            self.on_thinking_chunk(thinking_part)
+            if not content_part:
+                return ""
+
+        # Check if we were in thinking_part and now content arrived without thinking_part
+        if self.in_thinking and not thinking_part and content_part and "<think>" not in content_part and "</think>" not in content_part and not self.buffer:
+            self.in_thinking = False
+            self.on_thinking_end()
+
+        # Process content_part for embedded <think>...</think> tags
+        if not content_part:
+            return ""
+
+        text = self.buffer + content_part
+        self.buffer = ""
+        output_tokens = []
+
+        while text:
+            if not self.in_thinking:
+                idx = text.find("<think>")
+                if idx != -1:
+                    if idx > 0:
+                        output_tokens.append(text[:idx])
+                    self.in_thinking = True
+                    text = text[idx + 7:]
+                else:
+                    partial_match = False
+                    for i in range(1, 7):
+                        if text.endswith("<think>"[:i]):
+                            self.buffer = text[-i:]
+                            output_tokens.append(text[:-i])
+                            partial_match = True
+                            text = ""
+                            break
+                    if not partial_match:
+                        output_tokens.append(text)
+                        text = ""
+            else:
+                idx = text.find("</think>")
+                if idx != -1:
+                    thought = text[:idx]
+                    if thought:
+                        self.on_thinking_chunk(thought)
+                    self.in_thinking = False
+                    self.on_thinking_end()
+                    text = text[idx + 8:]
+                else:
+                    partial_match = False
+                    for i in range(1, 8):
+                        if text.endswith("</think>"[:i]):
+                            self.buffer = text[-i:]
+                            thought = text[:-i]
+                            if thought:
+                                self.on_thinking_chunk(thought)
+                            partial_match = True
+                            text = ""
+                            break
+                    if not partial_match:
+                        self.on_thinking_chunk(text)
+                        text = ""
+
+        return "".join(output_tokens)
+
+    def finalize(self) -> str:
+        res = ""
+        if self.in_thinking:
+            self.in_thinking = False
+            if self.buffer:
+                self.on_thinking_chunk(self.buffer)
+            self.on_thinking_end()
+        elif self.buffer:
+            res = self.buffer
+        self.buffer = ""
+        return res
+
+
+class OllamaProvider:
+    """Dedicated provider adapter for local Ollama instances.
+    
+    Guarantees:
+      - Request isolation via unique request IDs.
+      - Stream reset before each generation.
+      - Safe cancellation without memory leaks or cross-request pollution.
+      - Structured /api/chat invocation with error handling.
+      - Repetition detection via GenerationGuard.
+    """
+
+    def __init__(self, base_url: str = "http://localhost:11434"):
+        self.base_url = base_url.rstrip("/")
+        self._lock = threading.Lock()
+        self._active_request_id: Optional[str] = None
+        self._active_response = None
+        self._state: str = RequestState.IDLE
+        self._active_thinking_act_id: Optional[str] = None
+
+    @property
+    def state(self) -> str:
+        return self._state
+
+    def reset_stream(self, new_request_id: Optional[str] = None) -> str:
+        """Reset output buffer and allocate new request ID."""
+        with self._lock:
+            # Cancel any existing active socket
+            if self._active_response is not None:
+                try:
+                    self._active_response.close()
+                except Exception:
+                    pass
+                self._active_response = None
+
+            self._active_request_id = new_request_id or uuid.uuid4().hex
+            self._state = RequestState.STARTING
+            return self._active_request_id
+
+    def cancel_active(self) -> bool:
+        """Explicitly cancel current in-flight generation."""
+        with self._lock:
+            self._state = RequestState.CANCELLED
+            if getattr(self, "_active_thinking_act_id", None):
+                try:
+                    from .. import activity as act_mod
+                    act_mod.manager.update(self._active_thinking_act_id, status=act_mod.STATUS_CANCELLED, result="Cancelled")
+                except Exception:
+                    pass
+                self._active_thinking_act_id = None
+            if self._active_response is not None:
+                try:
+                    from ..aicore import _unregister_response
+                    _unregister_response(self._active_response)
+                except Exception:
+                    pass
+                try:
+                    self._active_response.close()
+                except Exception:
+                    pass
+                self._active_response = None
+                # Asynchronously ping Ollama to abort slot generation immediately
+                def _abort_slot():
+                    try:
+                        import requests
+                        requests.post(f"{self.base_url}/api/generate", json={"model": "", "keep_alive": 0}, timeout=0.6)
+                    except Exception:
+                        pass
+                threading.Thread(target=_abort_slot, daemon=True).start()
+                return True
+        return False
+
+    def stream_chat(
+        self,
+        model: str,
+        messages: List[Dict[str, str]],
+        options: Optional[Dict[str, Any]] = None,
+        timeout: Tuple[float, float] = (90.0, 180.0),
+        request_id: Optional[str] = None,
+        deadline: Optional[float] = None,
+    ) -> Generator[str, None, None]:
+        """Stream chat tokens from Ollama's /api/chat endpoint."""
+        import requests
+        import os
+
+        req_id = self.reset_stream(request_id)
+        guard = GenerationGuard()
+        sanitizer = OutputSanitizer()
+        is_first_chunk = True
+        in_thinking = False
+
+        # Build payload according to Ollama /api/chat schema
+        eff_options = dict(options or {})
+        # Dynamically scale num_ctx based on input messages:
+        # For standard short/normal queries (<1500 tokens), default to lean 2048 context
+        # to maximize GPU offloading and ensure 4x faster CPU inference.
+        total_chars = sum(len(m.get("content", "")) for m in messages if isinstance(m, dict))
+        est_tokens = int(total_chars / 3.5)
+        if est_tokens >= 1500:
+            recommended_ctx = min(32768, int(est_tokens * 1.25) + 1024)
+            if "num_ctx" not in eff_options or eff_options["num_ctx"] < recommended_ctx:
+                eff_options["num_ctx"] = recommended_ctx
+        else:
+            eff_options.setdefault("num_ctx", 2048)
+
+        # Allocate optimal physical CPU cores for multi-threaded inference without thread thrashing
+        optimal_threads = min(8, max(2, (os.cpu_count() or 4) // 2 if (os.cpu_count() or 4) > 4 else (os.cpu_count() or 4)))
+        eff_options.setdefault("num_thread", optimal_threads)
+        # DeepSeek-R1 / reasoning models: default temperature 0.6 prevents runaway thinking loops
+        if any(r in model.lower() for r in ("r1", "reason", "qwq")):
+            eff_options.setdefault("temperature", 0.6)
+        # Ensure generation stops cleanly without spinning indefinitely
+        eff_options.setdefault("num_predict", 1024)
+        # Ensure stop tokens are passed so models like DeepSeek-R1 / Qwen don't leak EOS tokens
+        default_stops = ["<|imend|>", "<|im_end|>", "<|endoftext|>", "<|eot_id|>", "<|end_of_text|>"]
+        cur_stops = eff_options.get("stop", [])
+        if isinstance(cur_stops, str):
+            cur_stops = [cur_stops]
+        elif not isinstance(cur_stops, list):
+            cur_stops = []
+        for s in default_stops:
+            if s not in cur_stops:
+                cur_stops.append(s)
+        eff_options["stop"] = cur_stops
+
+        payload = {
+            "model": model,
+            "messages": messages,
+            "stream": True,
+            "options": eff_options,
+        }
+
+        url = f"{self.base_url}/api/chat"
+        resp = None
+
+        thinking_act = None
+        thinking_buffer: List[str] = []
+        last_thinking_update = [0.0]
+
+        def _on_think_chunk(txt: str):
+            nonlocal thinking_act
+            if not txt:
+                return
+            thinking_buffer.append(txt)
+            try:
+                from .. import activity as act_mod
+                if thinking_act is None:
+                    current_turn = act_mod.get_current_turn() or request_id or ""
+                    thinking_act = act_mod.manager.create(
+                        type=act_mod.TYPE_STATUS,
+                        action="thinking",
+                        title="Thinking…",
+                        status=act_mod.STATUS_RUNNING,
+                        phase=act_mod.PHASE_ANALYSIS,
+                        category=act_mod.CAT_MODEL,
+                        turn_id=current_turn,
+                        model=model,
+                        provider="ollama",
+                        details=txt,
+                        stdout=txt,
+                    )
+                    self._active_thinking_act_id = getattr(thinking_act, "id", None)
+                    last_thinking_update[0] = time.time()
+                else:
+                    now = time.time()
+                    if now - last_thinking_update[0] >= 0.1 or len(txt) > 25:
+                        last_thinking_update[0] = now
+                        full_thought = "".join(thinking_buffer).strip()
+                        lines = [l.strip() for l in full_thought.splitlines() if l.strip()]
+                        snippet = lines[-1] if lines else ""
+                        if len(snippet) > 60:
+                            snippet = "…" + snippet[-57:]
+                        title = f"Thinking… ({snippet})" if snippet else "Thinking…"
+                        act_mod.manager.update(
+                            thinking_act.id,
+                            title=title,
+                            details=full_thought,
+                            stdout=full_thought,
+                        )
+            except Exception:
+                pass
+
+        def _on_think_end():
+            nonlocal thinking_act
+            if thinking_act is not None:
+                try:
+                    from .. import activity as act_mod
+                    full_thought = "".join(thinking_buffer).strip()
+                    word_count = len(full_thought.split())
+                    act_mod.manager.update(
+                        thinking_act.id,
+                        status=act_mod.STATUS_COMPLETED,
+                        title="Reasoning & Thinking",
+                        result=f"Thought for {word_count} words",
+                        details=full_thought,
+                        stdout=full_thought,
+                    )
+                except Exception:
+                    pass
+                self._active_thinking_act_id = None
+                thinking_act = None
+
+        filter_stream = ThinkingStreamFilter(
+            on_thinking_chunk=_on_think_chunk,
+            on_thinking_end=_on_think_end,
+        )
+
+        try:
+            with self._lock:
+                if self._state == RequestState.CANCELLED:
+                    return
+
+            try:
+                resp = requests.post(
+                    url,
+                    json=payload,
+                    timeout=timeout,
+                    stream=True,
+                )
+            except (requests.exceptions.ConnectionError, requests.exceptions.RequestException) as req_err:
+                # If connection dropped due to GPU crash / llama-server restart, retry once with CPU
+                _LOG.warning("Ollama connection exception (%s); retrying with num_gpu=0 (CPU mode)", req_err)
+                time.sleep(1.0)
+                payload.setdefault("options", {})["num_gpu"] = 0
+                resp = requests.post(
+                    url,
+                    json=payload,
+                    timeout=timeout,
+                    stream=True,
+                )
+
+            with self._lock:
+                if self._state == RequestState.CANCELLED:
+                    if resp is not None:
+                        try:
+                            resp.close()
+                        except Exception:
+                            pass
+                    return
+                self._active_response = resp
+                self._state = RequestState.STREAMING
+                try:
+                    from ..aicore import _register_response
+                    _register_response(resp)
+                except Exception:
+                    pass
+
+            if resp.status_code != 200:
+                err_body = resp.text[:400]
+                # Auto-fallback to CPU (num_gpu: 0) if GPU offloading crashed or had buffer overrun
+                is_gpu_crash = (
+                    resp.status_code == 500
+                    or any(k in err_body.lower() for k in (
+                        "llama-server", "terminated", "0xc0000409", "ggml_assert",
+                        "buffer in this appli", "overrun", "out of memory", "cuda", "split"
+                    ))
+                )
+                if is_gpu_crash and payload.get("options", {}).get("num_gpu") != 0:
+                    _LOG.warning("Ollama GPU crash / 500 on model '%s'; auto-retrying with CPU mode (num_gpu=0)", model)
+                    time.sleep(0.5)
+                    payload.setdefault("options", {})["num_gpu"] = 0
+                    try:
+                        resp = requests.post(url, json=payload, timeout=timeout, stream=True)
+                        if resp.status_code == 200:
+                            with self._lock:
+                                self._active_response = resp
+                                self._state = RequestState.STREAMING
+                                try:
+                                    from ..aicore import _register_response
+                                    _register_response(resp)
+                                except Exception:
+                                    pass
+                    except Exception:
+                        pass
+
+                # Auto-recovery for context overflow (HTTP 400: request exceeds available context size)
+                is_ctx_overflow = (
+                    resp.status_code == 400
+                    and any(k in err_body.lower() for k in (
+                        "exceeds the available context size", "context size",
+                        "exceedcontextsizeerror", "num_ctx", "context window"
+                    ))
+                )
+                if is_ctx_overflow:
+                    m = re.search(r"request\s*\((\d+)\s*tokens\)", err_body, re.IGNORECASE) or re.search(r"(\d+)\s*tokens", err_body, re.IGNORECASE)
+                    if m:
+                        req_tok = int(m.group(1))
+                        new_ctx = max(8192, min(65536, int(req_tok * 1.3) + 2048))
+                    else:
+                        new_ctx = max(16384, eff_options.get("num_ctx", 8192) * 2)
+                    _LOG.warning("Ollama context size exceeded (%s); auto-retrying with num_ctx=%d", err_body, new_ctx)
+                    payload.setdefault("options", {})["num_ctx"] = new_ctx
+                    time.sleep(0.3)
+                    try:
+                        resp = requests.post(url, json=payload, timeout=timeout, stream=True)
+                        if resp.status_code == 200:
+                            with self._lock:
+                                self._active_response = resp
+                                self._state = RequestState.STREAMING
+                                try:
+                                    from ..aicore import _register_response
+                                    _register_response(resp)
+                                except Exception:
+                                    pass
+                    except Exception as retry_err:
+                        _LOG.error("Failed to retry with larger num_ctx: %s", retry_err)
+
+                # Auto-fallback to an installed model if requested model is not found (404)
+                if resp.status_code == 404 and "not found" in err_body.lower():
+                    try:
+                        tag_resp = requests.get(f"{self.base_url}/api/tags", timeout=1.5)
+                        if tag_resp.status_code == 200:
+                            raw_models = [m.get("name") for m in tag_resp.json().get("models", []) if m.get("name")]
+                            # Filter out raw base models so fallback is always an instruct/chat model
+                            models = [m for m in raw_models if not any(b in m.lower() for b in ("-base", "_base", "base-q"))]
+                            if not models:
+                                models = raw_models
+                            if models:
+                                # Find best match: prefix match first (e.g. "deepseek-r1" in "deepseek-r1:latest")
+                                alt_model = None
+                                mod_base = model.split(":")[0].lower()
+                                for m in models:
+                                    if mod_base in m.lower():
+                                        alt_model = m
+                                        break
+                                if not alt_model:
+                                    # Prefer lightweight coding/chat models
+                                    for m in models:
+                                        if any(k in m.lower() for k in ("instruct", "chat", "coder", "qwen", "deepseek", "gemma")):
+                                            alt_model = m
+                                            break
+                                if not alt_model:
+                                    alt_model = models[0]
+                                _LOG.warning("Ollama model '%s' not found; auto-falling back to '%s'", model, alt_model)
+                                payload["model"] = alt_model
+                                resp = requests.post(url, json=payload, timeout=timeout, stream=True)
+                                if resp.status_code == 200:
+                                    with self._lock:
+                                        self._active_response = resp
+                                        self._state = RequestState.STREAMING
+                                        try:
+                                            from ..aicore import _register_response
+                                            _register_response(resp)
+                                        except Exception:
+                                            pass
+                    except Exception:
+                        pass
+
+            if resp.status_code != 200:
+                err_body = resp.text[:300]
+                self._state = RequestState.FAILED
+                yield f"Error: Ollama ({resp.status_code}): {err_body}"
+                return
+
+            for raw_line in resp.iter_lines(decode_unicode=True):
+                # Check deadline if specified
+                if deadline and time.monotonic() > deadline:
+                    yield "\n\n*(Generation timed out)*"
+                    break
+
+                # Check if cancelled mid-stream
+                with self._lock:
+                    if self._state == RequestState.CANCELLED:
+                        yield "\n\n⚠️ **Generation interrupted by user.**"
+                        return
+
+                if not raw_line or not raw_line.strip():
+                    continue
+
+                try:
+                    chunk_obj = json.loads(raw_line)
+                except (ValueError, json.JSONDecodeError):
+                    continue
+
+                # Handle Ollama error in JSON body
+                if "error" in chunk_obj:
+                    self._state = RequestState.FAILED
+                    yield f"Ollama Error: {chunk_obj['error']}"
+                    return
+
+                # Extract token from message.content or message.thinking (for DeepSeek-R1 / Qwen reasoning)
+                msg = chunk_obj.get("message") or {}
+                content_part = msg.get("content", "")
+                thinking_part = msg.get("thinking") or msg.get("reasoning_content") or chunk_obj.get("thinking") or ""
+
+                # Route thinking in real time to Live Activities; token holds only answer text
+                token = filter_stream.process(thinking_part, content_part)
+
+                if token:
+                    # Check for ChatML/EOS tokens
+                    stop_hit = False
+                    for stop_pattern in ("<|imend|>", "<|im_end|>", "<|endoftext|>", "<|eot_id|>", "<|end_of_text|>"):
+                        if stop_pattern in token:
+                            token = token.split(stop_pattern)[0]
+                            stop_hit = True
+                            break
+
+                    if is_first_chunk and token:
+                        token = sanitizer.sanitize_first_chunk(token)
+                        is_first_chunk = False
+
+                    if token:
+                        ok, safe_token = guard.feed(token)
+                        if safe_token:
+                            yield safe_token
+                        if not ok or stop_hit:
+                            break
+                    elif stop_hit:
+                        break
+
+                if chunk_obj.get("done", False):
+                    tail = filter_stream.finalize()
+                    if tail:
+                        ok, safe_token = guard.feed(tail)
+                        if safe_token:
+                            yield safe_token
+                    break
+
+            with self._lock:
+                if self._state != RequestState.CANCELLED:
+                    self._state = RequestState.COMPLETED
+
+        except requests.exceptions.ConnectionError:
+            with self._lock:
+                if self._state == RequestState.CANCELLED:
+                    yield "\n\n⚠️ **Generation interrupted by user.**"
+                    return
+            self._state = RequestState.FAILED
+            yield (
+                f"Could not reach Ollama server at {self.base_url}. "
+                "Ensure Ollama is running (`ollama serve`)."
+            )
+        except requests.exceptions.Timeout:
+            with self._lock:
+                if self._state == RequestState.CANCELLED:
+                    yield "\n\n⚠️ **Generation interrupted by user.**"
+                    return
+            self._state = RequestState.FAILED
+            yield "The Ollama request timed out waiting for generation to start."
+        except Exception as e:
+            with self._lock:
+                if self._state == RequestState.CANCELLED:
+                    yield "\n\n⚠️ **Generation interrupted by user.**"
+                    return
+            self._state = RequestState.FAILED
+            yield f"Ollama streaming failure: {e}"
+        finally:
+            try:
+                filter_stream.finalize()
+            except Exception:
+                pass
+            if thinking_act is not None:
+                try:
+                    from .. import activity as act_mod
+                    st = act_mod.STATUS_CANCELLED if self._state == RequestState.CANCELLED else act_mod.STATUS_COMPLETED
+                    act_mod.manager.update(thinking_act.id, status=st)
+                except Exception:
+                    pass
+                self._active_thinking_act_id = None
+                thinking_act = None
+            with self._lock:
+                if self._active_response is not None:
+                    try:
+                        from ..aicore import _unregister_response
+                        _unregister_response(self._active_response)
+                    except Exception:
+                        pass
+                    try:
+                        self._active_response.close()
+                    except Exception:
+                        pass
+                    self._active_response = None
+
+    def run_hello_test(self, model: str) -> Tuple[bool, str]:
+        """Diagnostic health check (Section 34): tests Ollama generation directly."""
+        import requests
+
+        try:
+            url = f"{self.base_url}/api/chat"
+            payload = {
+                "model": model,
+                "messages": [{"role": "user", "content": "Reply with exactly: HELLO_TEST"}],
+                "stream": False,
+                "options": {"temperature": 0.0},
+            }
+            resp = requests.post(url, json=payload, timeout=10.0)
+            if resp.status_code == 200:
+                data = resp.json()
+                reply = (data.get("message", {}).get("content", "") or "").strip()
+                if "HELLO_TEST" in reply:
+                    return True, reply
+                return False, f"Model responded with unexpected output: {reply}"
+            return False, f"Ollama HTTP {resp.status_code}: {resp.text[:100]}"
+        except Exception as e:
+            return False, f"Connection test failed: {e}"