diffron 0.1.6__tar.gz → 0.1.8__tar.gz

{diffron-0.1.6 → diffron-0.1.8}/CHANGELOG.md

@@ -9,11 +9,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-### Planned
-- Pre-commit hook for linting suggestions
-- Custom model selection per repository
-- Multi-language commit message support
-- Integration with GitHub CLI for auto PR creation
+### Added
+**Robust Model Reload Fix** — Properly unload and reload Lemonade model using SDK's native methods when unresponsive
+- Fixed `'NoneType' object is not subscriptable` error by using `_LemonadeSDKClient` for server operations
+- Uses `sdk_client.unload_model()` followed by `sdk_client.load_model(model_name=self.model)` for true server restart
+- Added 0.5 second delay between unload and load for clean server state
+- Renamed SDK import to `_LemonadeSDKClient` to avoid naming conflicts with diffron's own `LemonadeClient` class
 
 ---
 

{diffron-0.1.6/diffron.egg-info → diffron-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffron
-Version: 0.1.6
+Version: 0.1.8
 Summary: Git commit message and PR description generator using Lemonade
 Home-page: https://github.com/diffron/diffron
 Author: Diffron Contributors
@@ -454,4 +454,4 @@ pytest tests/
 
 ---
 
-*Version: 0.1.0 | Last updated: 2026-03-28*
+*Version: 0.1.6 | Last updated: 2026-04-25*

{diffron-0.1.6 → diffron-0.1.8}/README.md

@@ -411,4 +411,4 @@ pytest tests/
 
 ---
 
-*Version: 0.1.0 | Last updated: 2026-03-28*
+*Version: 0.1.6 | Last updated: 2026-04-25*

{diffron-0.1.6 → diffron-0.1.8}/diffron/__init__.py

@@ -17,7 +17,7 @@ from .models import (
     get_model_config,
 )
 
-__version__ = "0.1.3"
+__version__ = "0.1.8"
 __author__ = "Diffron Contributors"
 __all__ = [
     "DiffronClient",

diffron-0.1.8/diffron/lemonade.py

@@ -0,0 +1,241 @@
+"""Lemonade integration for Diffron.
+
+Provides automatic port detection and API client for Lemonade LLM server.
+"""
+
+import os
+import typing
+from typing import Optional, List
+from urllib.parse import urlparse
+
+import openai
+from openai import OpenAI
+
+from .utils import is_port_open
+
+# Import lemonade-python-sdk for verification
+try:
+    from lemonade_sdk.port_scanner import verify_lemonade_server
+    from lemonade_sdk.port_scanner import find_available_lemonade_port
+    from lemonade_sdk.client import LemonadeClient as _LemonadeSDKClient
+    HAS_LEMONADE_SDK = True
+except ImportError:
+    HAS_LEMONADE_SDK = False
+
+DEFAULT_HOST = "localhost"
+DEFAULT_PORT = 8020  # Default Lemonade port
+DEFAULT_PORTS = [8020, 8000, 8001, 8080, 8081, 5000, 5001]
+LEMONADE_API_KEY = "lemonade"  # Default API key for Lemonade
+DEFAULT_MODEL = "qwen2.5-it-3b-FLM"  # Default Lemonade model
+
+
+def detect_lemonade_port(
+    host: Optional[str] = None,
+    ports: Optional[List[int]] = None
+) -> Optional[int]:
+    """Detect port for running Lemonade server.
+
+    Uses lemonade-python-sdk's verify_lemonade_server to distinguish
+    Lemonade from other services (e.g., Axo Biomarker on port 8000).
+
+    Args:
+        host: Host to check. Defaults to DIFFRON_LEMONADE_HOST or localhost.
+        ports: List of ports to scan. Defaults to common Lemonade ports.
+
+    Returns:
+        Port number if found, None otherwise.
+    """
+    # Check LEMONADE_SERVER_URL environment variable first (standard Lemonade env)
+    server_url = os.environ.get("LEMONADE_SERVER_URL")
+    if server_url:
+        parsed = urlparse(server_url)
+        port = parsed.port
+        if port and is_port_open(parsed.hostname or "localhost", port):
+            return port
+
+    # Use SDK for verification
+    h = host or os.environ.get("DIFFRON_LEMONADE_HOST") or DEFAULT_HOST
+    p = ports or DEFAULT_PORTS
+    for port in p:
+        if verify_lemonade_server(port, h):
+            return port
+
+
+class LemonadeClient:
+    """Lemonade LLM API client with automatic port detection.
+
+    Wraps the OpenAI-compatible API of the Lemonade server,
+    handling connection setup and model inference.
+    """
+
+    def __init__(
+        self,
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        api_key: str = LEMONADE_API_KEY,
+        model: str = DEFAULT_MODEL,
+    ) -> None:
+        """Initialize Lemonade client.
+
+        Args:
+            host: Host of the Lemonade server. Defaults to env or localhost.
+            port: Port of the Lemonade server. Auto-detects if None.
+            api_key: API key for the server.
+            model: Model name to use for inference.
+        """
+        self.host = host or os.environ.get("DIFFRON_LEMONADE_HOST") or DEFAULT_HOST
+        self.api_key = api_key
+        self.model = model
+
+        # Auto-detect port if not provided
+        if port:
+            self._port = port
+            self.port = port
+        else:
+            detected = detect_lemonade_port(host=self.host)
+            if detected:
+                self._port = detected
+                self.port = detected
+            else:
+                # Fallback to default port
+                self._port = DEFAULT_PORT
+                self.port = DEFAULT_PORT
+
+        self.base_url = f"http://{self.host}:{self._port}"
+        self._init_client()
+
+    def _init_client(self) -> None:
+        """Reinitialize OpenAI client with current configuration."""
+        self.client = OpenAI(
+            base_url=f"{self.base_url}/api/v1",
+            api_key=self.api_key,
+        )
+
+    def chat_completion(
+        self,
+        messages: List[dict],
+        max_tokens: int = 100,
+        temperature: float = 0.2,
+        **kwargs
+    ) -> str:
+        """Generate chat completion.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'.
+            max_tokens: Maximum tokens to generate.
+            temperature: Sampling temperature.
+            **kwargs: Additional arguments to pass to API.
+
+        Returns:
+            Generated response content.
+
+        Raises:
+            RuntimeError: If model fails after retry attempts.
+        """
+        max_retries = 3
+        for attempt in range(1, max_retries + 1):
+            try:
+                response = self.client.chat.completions.create(
+                    model=self.model,
+                    messages=messages,
+                    max_tokens=max_tokens,
+                    temperature=temperature,
+                    **kwargs,
+                )
+
+                # Handle None response (model unresponsive)
+                if response is None or not response.choices:
+                    if attempt < max_retries:
+                        self._reload_model()
+                        continue
+                    raise RuntimeError("Lemonade model returned no response")
+
+                return response.choices[0].message.content
+
+            except Exception as e:
+                if attempt < max_retries:
+                    self._reload_model()
+                    continue
+                raise RuntimeError(
+                    f"Lemonade model failed after {max_retries} attempts: {e}"
+                )
+
+    def _reload_model(self) -> None:
+        """Unload and reload Lemonade model when unresponsive.
+
+        Uses lemonade-python-sdk's unload_model() and load_model() methods
+        to properly force a server-side model restart.
+        """
+        try:
+            # Use SDK's LemonadeClient for server operations
+            sdk_client = _LemonadeSDKClient(
+                base_url=f"http://{self.host}:{self._port}"
+            )
+
+            # Unload current model from server
+            sdk_client.unload_model()
+
+            # Small delay to allow server to complete unload
+            import time
+            time.sleep(0.5)
+
+            # Load the model back on server
+            sdk_client.load_model(model_name=self.model)
+
+            # Reinitialize our client (same port, model should be fresh)
+            self._init_client()
+
+        except Exception:
+            pass  # Continue even if reload fails
+
+    def __repr__(self) -> str:
+        return f"LemonadeClient(base_url={self.base_url}, model={self.model})"
+def is_lemonade_running(
+    host: Optional[str] = None,
+    port: Optional[int] = None,
+) -> bool:
+    """Check if Lemonade server is running.
+
+    Args:
+        host: Host to check. Defaults to DIFFRON_LEMONADE_HOST or localhost.
+        port: Port to check. Defaults to auto-detection.
+
+    Returns:
+        True if Lemonade server is running, False otherwise.
+    """
+    try:
+        detected_port = detect_lemonade_port(host=host)
+        if detected_port is not None:
+            return True
+    except Exception:
+        pass
+
+    # Fallback: check default port
+    try:
+        return is_port_open(DEFAULT_HOST, DEFAULT_PORT)
+    except Exception:
+        return False
+
+
+def get_lemonade_url(
+    host: Optional[str] = None,
+    port: Optional[int] = None,
+) -> str:
+    """Get the Lemonade server URL.
+
+    Auto-detects port if not provided.
+
+    Args:
+        host: Host to use. Defaults to DIFFRON_LEMONADE_HOST or localhost.
+        port: Port to use. Auto-detects if None.
+
+    Returns:
+        The Lemonade server URL (e.g., http://localhost:8020).
+    """
+    h = host or os.environ.get("DIFFRON_LEMONADE_HOST") or DEFAULT_HOST
+
+    if port is None:
+        detected = detect_lemonade_port(host=h)
+        port = detected or DEFAULT_PORT
+
+    return f"http://{h}:{port}"

{diffron-0.1.6 → diffron-0.1.8}/diffron/lemonade.pyi

@@ -64,3 +64,8 @@ class LemonadeClient:
 
     def __repr__(self) -> str:
         ...
+def get_lemonade_url(
+    host: Optional[str] = None,
+    port: Optional[int] = None,
+) -> str:
+    """Get the Lemonade server URL."""

{diffron-0.1.6 → diffron-0.1.8/diffron.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffron
-Version: 0.1.6
+Version: 0.1.8
 Summary: Git commit message and PR description generator using Lemonade
 Home-page: https://github.com/diffron/diffron
 Author: Diffron Contributors
@@ -454,4 +454,4 @@ pytest tests/
 
 ---
 
-*Version: 0.1.0 | Last updated: 2026-03-28*
+*Version: 0.1.6 | Last updated: 2026-04-25*

{diffron-0.1.6 → diffron-0.1.8}/diffron.egg-info/SOURCES.txt

@@ -36,6 +36,9 @@ diffron/hooks/prepare-commit-msg
 diffron/hooks/prepare-commit-msg-global.py
 diffron/hooks/prepare-commit-msg.py
 docs/HOOKS.md
+docs/LEMONADE_PORT_VERIFICATION_FIX.md
+docs/LEMONADE_UNRESPONSIVE_FIX.md
+docs/MODEL_NAME_CASE_FIX.md
 docs/SETUP.md
 docs/USAGE.md
 hooks/aipr.py

{diffron-0.1.6 → diffron-0.1.8}/diffron.egg-info/top_level.txt

@@ -1,4 +1,6 @@
+build
 diffron
 dist
 docs
 hooks
+internal

diffron-0.1.8/docs/LEMONADE_PORT_VERIFICATION_FIX.md

@@ -0,0 +1,105 @@
+# Lemonade Port Verification Fix
+
+## Problem
+
+Diffron incorrectly connected to **port 8000** (running Axo Biomarker Analyzer) instead of **port 8020** (running Lemonade), causing:
+
+```
+Error code: 404 - {'detail': 'Not Found'}
+```
+
+### Root Cause
+
+The `detect_lemonade_port()` function in `diffron/lemonade.py` only checked if a **port was open** (`is_port_open`), not whether it was actually a **Lemonade server**.
+
+When port 8000 responded (Axo Biomarker web app), Diffron mistakenly identified it as Lemonade and sent API requests to the wrong service.
+
+| Port | Service | Response |
+|------|---------|----------|
+| 8000 | Axo Biomarker Analyzer | HTML web page |
+| 8020 | **Lemonade** (correct) | `{"data": [...]}` API |
+
+## Solution
+
+### Use lemonade-python-sdk's `verify_lemonade_server`
+
+The **lemonade-python-sdk** provides `verify_lemonade_server(port, host)` which:
+
+1. Queries the native Lemonade API endpoint `/api/v1/models`
+2. Validates the response format (`{"data": [...]}` or list)
+3. Distinguishes Lemonade from other services (Ollama, web apps, etc.)
+
+### Changes
+
+**1. Added `lemonade-sdk` dependency**
+
+Updated `requirements.txt`:
+```txt
+lemonade-sdk>=0.1.0
+```
+
+**2. Updated `detect_lemonade_port()`**
+
+`diffron/lemonade.py` now:
+
+- Imports `verify_lemonade_server` and `find_available_lemonade_port` from `lemonade_sdk.port_scanner`
+- **Verifies** each open port is actually Lemonade before returning it
+- Falls back to legacy `is_port_open` behavior if SDK is not installed
+
+```python
+# Import from lemonade-python-sdk for proper Lemonade verification
+try:
+    from lemonade_sdk.port_scanner import verify_lemonade_server, find_available_lemonade_port
+    HAS_LEMONADE_SDK = True
+except ImportError:
+    HAS_LEMONADE_SDK = False
+
+def detect_lemonade_port(...) -> Optional[int]:
+    # ... existing env var checks ...
+
+    # Try SDK's find_available_lemonade_port first
+    if HAS_LEMONADE_SDK:
+        found = find_available_lemonade_port(hostname, scan_ports)
+        if found:
+            return found
+
+    # Fallback: manual scan with SDK verification
+    for port in ports_to_scan:
+        if is_port_open(hostname, port):
+            if HAS_LEMONADE_SDK:
+                if verify_lemonade_server(port, hostname):  # ← Key fix!
+                    return port
+            else:
+                return port  # Legacy: no verification
+```
+
+**3. Added graceful fallback**
+
+If `lemonade-sdk` is not installed, Diffron falls back to the original `is_port_open` behavior (first open port wins), maintaining backward compatibility.
+
+## Testing
+
+```bash
+# Before fix: returned 8000 (Axo Biomarker)
+# After fix: returns 8020 (Lemonade)
+python -c "from diffron.lemonade import detect_lemonade_port; print(detect_lemonade_port())"
+# Output: 8020
+```
+
+## Impact
+
+- **Fixes 404 errors** when other services run on ports 8000/8080
+- **No breaking changes** - existing setups continue to work
+- **Better diagnostics** - clear separation between Lemonade and non-Lemonade services
+
+## Files Changed
+
+| File | Change |
+|------|--------|
+| `diffron/lemonade.py` | Use `verify_lemonade_server` for port detection |
+| `requirements.txt` | Add `lemonade-sdk>=0.1.0` dependency |
+
+## Version
+
+- **Fixed in**: 0.1.3
+- **Date**: 2026-04-13

diffron-0.1.8/docs/LEMONADE_UNRESPONSIVE_FIX.md

@@ -0,0 +1,97 @@
+# Lemonade Model Unresponsive Fix
+
+## Problem
+
+Lemonade-Modell wurde manchmal unresponsive, was zu Fehlern in Diffron führte:
+
+```
+Diffron error: 'NoneType' object is not subscriptable
+```
+
+oder
+
+```
+Lemonade model failed after 3 attempts: Lemonade model returned no response
+```
+
+## Lösung
+
+In [`diffron/lemonade.py`](diffron/lemonade.py) wurde die Retry-Logik mit automatischem Entladen und Neuladen des Modells implementiert.
+
+### Änderungen in `LemonadeClient.chat_completion()`
+
+```python
+max_retries = 3
+for attempt in range(1, max_retries + 1):
+    try:
+        response = self.client.chat.completions.create(...)
+        # Handle None response (model unresponsive)
+        if response is None or not response.choices:
+            if attempt < max_retries:
+                self._reload_model()
+                continue
+            raise RuntimeError("Lemonade model returned no response")
+        return response.choices[0].message.content
+    except Exception as e:
+        if attempt < max_retries:
+            self._reload_model()
+            continue
+        raise RuntimeError(
+            f"Lemonade model failed after {max_retries} attempts: {e}"
+        )
+```
+
+### Neue Methode `_reload_model()`
+
+Entlädt und lädt das Lemonade-Modell neu, wenn es unresponsive wird. Verwendet die `unload_model()` und `load_model()` Methoden des lemonade-python-sdk, um einen echten Server-seitigen Neustart zu erzwingen.
+
+```python
+def _reload_model(self) -> None:
+    """Unload and reload Lemonade model when unresponsive.
+    
+    Uses lemonade-python-sdk's unload_model() and load_model() methods
+    to properly force a server-side model restart.
+    """
+    try:
+        # Use SDK's LemonadeClient for server operations
+        sdk_client = _LemonadeSDKClient(
+            base_url=f"http://{self.host}:{self._port}"
+        )
+
+        # Unload current model from server
+        sdk_client.unload_model()
+
+        # Small delay to allow server to complete unload
+        import time
+        time.sleep(0.5)
+
+        # Load the model back on server
+        sdk_client.load_model(model_name=self.model)
+
+        # Reinitialize our client (same port, model should be fresh)
+        self._init_client()
+
+    except Exception:
+        pass  # Continue even if reload fails
+```
+
+### Wichtige Änderungen
+
+1. **Import-Alias**: Der SDK-Import wurde zu `_LemonadeSDKClient` umbenanmt, um Namenskonflikte mit der eigenen `LemonadeClient` Klasse zu vermeiden.
+
+2. **Echter Server-Neustart**: Statt nur den Port zu wechseln (was nicht funktioniert hat), wird jetzt das Modell über die SDK-API entladen und neu geladen:
+   - `sdk_client.unload_model()` - Entlädt das aktuelle Modell vom Server
+   - `time.sleep(0.5)` - Kurze Wartezeit für sauberen unload
+   - `sdk_client.load_model(model_name=self.model)` - Lädt das Modell neu
+
+3. **Retry-Logik**: Bei 3 Versuchen wird jeweils versucht, das Modell neu zu laden, bevor ein Fehler geworfen wird.
+
+## Technische Details
+
+- **Maximale Wiederholungen**: 3
+- **Wartezeit zwischen Reloads**: 0.5 Sekunden
+- **Fehlerbehandlung**: Bei jedem Reload-Versuch werden alle Exceptions abgefangen, damit der Prozess fortgesetzt werden kann
+
+## Version
+
+Diese Änderung wurde in Version 0.1.5 veröffentlicht.

diffron-0.1.8/docs/MODEL_NAME_CASE_FIX.md

@@ -0,0 +1,88 @@
+# Model Name Case Sensitivity Fix
+
+## Problem
+
+Diffron returned a **404 Not Found** error from the Lemonade server when using the `Qwen3.5-0.8B-GGUF` model.
+
+### Root Cause
+
+The Lemonade server is **case-sensitive** when matching model names. Diffron's curated model configuration used the wrong casing:
+
+| Location | Model Name (Before) | Model Name (Expected) |
+|----------|---------------------|------------------------|
+| `diffron/models.py` | `qwen3.5-0.8b-gguf` | `Qwen3.5-0.8B-GGUF` |
+
+This caused the OpenAI SDK to send a request with the wrong model identifier, resulting in:
+
+```
+Error code: 404 - {'detail': 'Not Found'}
+```
+
+## Solution
+
+### 1. Corrected Model Name
+
+Updated the canonical model name in `diffron/models.py`:
+
+```python
+# Before
+ModelConfig(name="qwen3.5-0.8b-gguf", ...)
+
+# After
+ModelConfig(name="Qwen3.5-0.8B-GGUF", ...)
+```
+
+### 2. Case-Insensitive Model Lookup
+
+Enhanced `get_model_config()` to accept case-insensitive input while always returning the **canonical name**:
+
+```python
+def get_model_config(model_name: str) -> Optional[ModelConfig]:
+    # Exact match first
+    for model in AVAILABLE_MODELS:
+        if model.name == model_name:
+            return model
+    # Case-insensitive fallback
+    for model in AVAILABLE_MODEOLS:
+        if model.name.lower() == model_name.lower():
+            return model
+    return None
+```
+
+This allows users to type `qwen3.5-0.8b-gguf`, `QWEN3.5-0.8B-GGUF`, etc., but Diffron always sends the correct name to the server.
+
+### 3. CLI Canonical Name Enforcement
+
+The `setup_model_cli()` now stores the **canonical name** from the config, not the user's raw input:
+
+```python
+# Always uses config.name (canonical) instead of args.model (user input)
+os.environ["DIFFRON_MODEL"] = config.name
+subprocess.run(["setx", "DIFFRON_MODEL", config.name], check=True)
+```
+
+## Testing
+
+```bash
+# All of these now work correctly:
+diffron-setup-model --model Qwen3.5-0.8B-GGUF   # exact
+diffron-setup-model --model qwen3.5-0.8b-gguf   # lowercase (fallback)
+diffron-setup-model --model QWEN3.5-0.8B-GGUF   # uppercase (fallback)
+```
+
+## Impact
+
+- **No breaking changes** - existing `DIFFRON_MODEL` values with wrong casing are now resolved correctly
+- **Improved UX** - users don't need to memorize exact casing
+- **Server compatibility** - correct model name is always sent to Lemonade
+
+## Files Changed
+
+| File | Change |
+|------|--------|
+| `diffron/models.py` | Fixed `Qwen3.5-0.8B-GGUF` name, added case-insensitive lookup |
+
+## Version
+
+- **Fixed in**: 0.1.3
+- **Date**: 2026-04-13

{diffron-0.1.6 → diffron-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "diffron"
-version = "0.1.6"
+version = "0.1.8"
 description = "Git commit message and PR description generator using Lemonade"
 readme = "README.md"
 license = {text = "MIT"}

{diffron-0.1.6 → diffron-0.1.8}/setup.py

@@ -10,7 +10,7 @@ with open("requirements.txt", "r", encoding="utf-8") as fh:
 
 setup(
     name="diffron",
-    version="0.1.4",
+    version="0.1.5",
     author="Diffron Contributors",
     author_email="diffron@example.com",
     description="Git commit message and PR description generator using Lemonade",

diffron-0.1.6/diffron/lemonade.py

@@ -1,249 +0,0 @@
-"""Lemonade integration for Diffron.
-
-Provides automatic port detection and API client for Lemonade LLM server.
-"""
-
-import os
-import typing
-from typing import Optional, List
-from urllib.parse import urlparse
-
-import openai
-from openai import OpenAI
-
-from .utils import is_port_open
-
-# Import lemonade-python-sdk for verification
-try:
-    from lemonade_sdk.port_scanner import verify_lemonade_server
-    from lemonade_sdk.port_scanner import find_available_lemonade_port
-    HAS_LEMONADE_SDK = True
-except ImportError:
-    HAS_LEMONADE_SDK = False
-
-DEFAULT_HOST = "localhost"
-DEFAULT_PORT = 8020  # Default Lemonade port
-DEFAULT_PORTS = [8020, 8000, 8001, 8080, 8081, 5000, 5001]
-LEMONADE_API_KEY = "lemonade"  # Default API key for Lemonade
-DEFAULT_MODEL = "qwen2.5-it-3b-FLM"  # Default Lemonade model
-
-
-def detect_lemonade_port(
-    host: Optional[str] = None,
-    ports: Optional[List[int]] = None
-) -> Optional[int]:
-    """Auto-detect port for running Lemonade server.
-
-    Uses lemonade-python-sdk's verify_lemonade_server to distinguish
-    Lemonade from other services (e.g., Axo Biomarker on port 8000).
-
-    Args:
-        host: Host to check. Defaults to DIFFRON_LEMONADE_HOST or localhost.
-        ports: List of ports to scan. Defaults to common Lemonade ports.
-
-    Returns:
-        Port number if found, None otherwise.
-    """
-    # Check LEMONADE_SERVER_URL environment variable first (standard Lemonade env)
-    server_url = os.environ.get("LEMONADE_SERVER_URL")
-    if server_url:
-        from urllib.parse import urlparse
-        parsed = urlparse(server_url)
-        port = parsed.port
-        hostname = parsed.hostname or DEFAULT_HOST
-        # Verify it's actually Lemonade
-        if HAS_LEMONADE_SDK and verify_lemonade_server(port, hostname):
-            return port
-        elif is_port_open(hostname, port):
-            return port
-
-    # Check DIFFRON_LEMONADE_PORT (Diffron-specific)
-    env_port = os.environ.get("DIFFRON_LEMONADE_PORT")
-    if env_port:
-        try:
-            port = int(env_port)
-            hostname = host or DEFAULT_HOST
-            if HAS_LEMONADE_SDK and verify_lemonade_server(port, hostname):
-                return port
-            elif is_port_open(hostname, port):
-                return port
-        except ValueError:
-            pass
-
-    # Use lemonade-python-sdk's find_available_lemonade_port
-    if HAS_LEMONADE_SDK:
-        hostname = host or os.environ.get("DIFFRON_LEMONADE_HOST", DEFAULT_HOST)
-        scan_ports = ports or DEFAULT_PORTS
-        found = find_available_lemonade_port(hostname, scan_ports)
-        if found:
-            return found
-
-    # Fallback: manual scan verification
-    hostname = host or os.environ.get("DIFFRON_LEMONADE_HOST", DEFAULT_HOST)
-    ports_to_scan = ports or DEFAULT_PORTS
-    for port in ports_to_scan:
-        if is_port_open(hostname, port):
-            if HAS_LEMONADE_SDK and verify_lemonade_server(port, hostname):
-                return port
-    # Without SDK, return first open port (legacy behavior)
-    return None
-
-
-def get_lemonade_url() -> str:
-    """Get Lemonade server URL from environment or default.
-
-    Returns:
-        Lemonade server URL.
-    """
-    # Check LEMONADE_SERVER_URL first (standard)
-    server_url = os.environ.get("LEMONADE_SERVER_URL")
-    if server_url:
-        return server_url.strip().rstrip("/")
-
-    # Build URL from host/port
-    host = os.environ.get("DIFFRON_LEMONADE_HOST", DEFAULT_HOST)
-    port = detect_lemonade_port(host)
-    if port:
-        return f"http://{host}:{port}"
-
-    # Fallback to default
-    return f"http://{DEFAULT_HOST}:{DEFAULT_PORT}"
-
-
-def is_lemonade_running(
-    host: Optional[str] = None,
-    port: Optional[int] = None
-) -> bool:
-    """Check if Lemonade is running.
-
-    Args:
-        host: Host to check. Defaults to DIFFRON_LEMONADE_HOST or localhost.
-        port: Port to check. Auto-detects if not provided.
-
-    Returns:
-        True if Lemonade is running, False otherwise.
-    """
-    if port is None:
-        port = detect_lemonade_port(host)
-    if port is None:
-        return False
-
-    host = host or os.environ.get("DIFFRON_LEMONADE_HOST", DEFAULT_HOST)
-    return is_port_open(host, port)
-
-
-class LemonadeClient:
-    """Client for interacting with Lemonade LLM server.
-
-    Detects running Lemonade instance and provides a convenient
-    interface for chat completions.
-    """
-
-    def __init__(
-        self,
-        base_url: Optional[str] = None,
-        api_key: Optional[str] = None,
-        model: Optional[str] = None
-    ) -> None:
-        """Initialize Lemonade client.
-
-        Args:
-            base_url: Lemonade server URL. Auto-detects from
-                      LEMONADE_SERVER_URL, defaults to http://localhost:8020.
-            api_key: API key. Defaults to "lemonade".
-            model: Model name. Defaults to qwen2.5-it-3b-FLM.
-        """
-        # Get base URL from parameter or environment default
-        self.base_url = (base_url or get_lemonade_url()).rstrip("/")
-        # Parse host and port from base_url
-        parsed = urlparse(self.base_url)
-        self.host = parsed.hostname or DEFAULT_HOST
-        self.port = parsed.port or DEFAULT_PORT
-        self.api_key = api_key or LEMONADE_API_KEY
-        # Model: parameter > environment > default
-        self.model = model or os.environ.get("DIFFRON_MODEL") or DEFAULT_MODEL
-        self._port = self.port  # Track current port for reload
-        self.client = OpenAI(
-            base_url=f"{self.base_url}/api/v1",
-            api_key=self.api_key
-        )
-
-    def chat_completion(
-        self,
-        messages: List[dict],
-        max_tokens: int = 100,
-        temperature: float = 0.2,
-        **kwargs
-    ) -> str:
-        """Generate chat completion.
-
-        Args:
-            messages: List of message dicts with 'role' and 'content'.
-            max_tokens: Maximum tokens to generate.
-            temperature: Sampling temperature.
-            **kwargs: Additional arguments to pass to the API.
-
-        Returns:
-            Generated response content.
-
-        Raises:
-            RuntimeError: If model fails after retry attempts.
-        """
-        max_retries = 3
-        for attempt in range(1, max_retries + 1):
-            try:
-                response = self.client.chat.completions.create(
-                    model=self.model,
-                    messages=messages,
-                    max_tokens=max_tokens,
-                    temperature=temperature,
-                    **kwargs
-                )
-                # Handle None response (model unresponsive)
-                if response is None or not response.choices:
-                    if attempt < max_retries:
-                        self._reload_model()
-                        continue
-                    raise RuntimeError("Lemonade model returned no response")
-                return response.choices[0].message.content
-            except Exception as e:
-                if attempt < max_retries:
-                    self._reload_model()
-                    continue
-                raise RuntimeError(
-                    f"Lemonade model failed after {max_retries} attempts: {e}"
-                )
-
-    def _reload_model(self) -> None:
-        """Unload and reload the Lemonade model when unresponsive.
-
-        Uses lemonade-python-sdk to detect and reconnect to the
-        Lemonade server, which triggers a model reload.
-        """
-        try:
-            if HAS_LEMONADE_SDK:
-                # Find available port (triggers unload/reload via SDK)
-                new_port = find_available_lemonade_port(
-                    hostname=self.host or DEFAULT_HOST,
-                    ports=DEFAULT_PORTS
-                )
-                if new_port and new_port != self._port:
-                    self._port = new_port
-                    self.port = new_port  # Update the port attribute
-                    # Rebuild the base_url with the new port and the same host
-                    self.base_url = f"http://{self.host}:{new_port}"
-                    # Reinitialize client with new base_url
-                    self._init_client()
-        except Exception:
-            # Silently continue on reload failure
-            pass
-
-    def _init_client(self) -> None:
-        """Reinitialize the OpenAI client with current configuration."""
-        self.client = OpenAI(
-            base_url=f"{self.base_url}/api/v1",
-            api_key=self.api_key
-        )
-
-    def __repr__(self) -> str:
-        return f"LemonadeClient(base_url='{self.base_url}', model='{self.model}')"