ErrorAI 1.2.0__tar.gz → 1.5.0__tar.gz

{errorai-1.2.0 → errorai-1.5.0}/ErrorAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ErrorAI
-Version: 1.2.0
+Version: 1.5.0
 Summary: Python-only autonomous runtime that watches/analyzes errors with safe local auto-fix fallbacks.
 Author: Aswanth R
 License: MIT
@@ -13,6 +13,10 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: platformdirs>=3.0
 Requires-Dist: onnxruntime>=1.18.0
+Requires-Dist: optimum[onnxruntime]>=1.20.0
+Requires-Dist: transformers>=4.40.0
+Requires-Dist: huggingface_hub>=0.23.0
+Requires-Dist: tomli>=2.0.1; python_version < "3.11"
 Provides-Extra: watch
 Requires-Dist: watchdog>=4.0.0; extra == "watch"
 

errorai-1.5.0/ErrorAI.egg-info/requires.txt

@@ -0,0 +1,11 @@
+platformdirs>=3.0
+onnxruntime>=1.18.0
+optimum[onnxruntime]>=1.20.0
+transformers>=4.40.0
+huggingface_hub>=0.23.0
+
+[:python_version < "3.11"]
+tomli>=2.0.1
+
+[watch]
+watchdog>=4.0.0

{errorai-1.2.0 → errorai-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ErrorAI
-Version: 1.2.0
+Version: 1.5.0
 Summary: Python-only autonomous runtime that watches/analyzes errors with safe local auto-fix fallbacks.
 Author: Aswanth R
 License: MIT
@@ -13,6 +13,10 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: platformdirs>=3.0
 Requires-Dist: onnxruntime>=1.18.0
+Requires-Dist: optimum[onnxruntime]>=1.20.0
+Requires-Dist: transformers>=4.40.0
+Requires-Dist: huggingface_hub>=0.23.0
+Requires-Dist: tomli>=2.0.1; python_version < "3.11"
 Provides-Extra: watch
 Requires-Dist: watchdog>=4.0.0; extra == "watch"
 

errorai-1.5.0/errorai/bootstrap.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import urllib.request
+
+from .config import ModelConfig
+
+
+@dataclass(frozen=True)
+class BootstrapStatus:
+    ready: bool
+    mode: str
+    detail: str
+    model_path: Path | None = None
+
+
+def model_path(config: ModelConfig) -> Path:
+    base = config.cache_dir / "models"
+    if config.provider == "onnx":
+        # ONNX text generation needs a full model directory (config.json,
+        # tokenizer files, model.onnx, etc.), not a single downloaded file.
+        return base / config.name
+    return base / f"{config.name}.gguf"
+
+
+def _model_ready(path: Path, config: ModelConfig) -> bool:
+    if config.provider == "onnx":
+        return path.exists() and path.is_dir() and any(path.iterdir())
+    return path.exists()
+
+
+def _download_onnx_model(config: ModelConfig, destination: Path) -> None:
+    from huggingface_hub import snapshot_download
+
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    downloaded_dir = Path(
+        snapshot_download(
+            repo_id=config.repo_id,
+            cache_dir=str(config.cache_dir / "hf_cache"),
+        )
+    )
+    if destination.exists() or destination.is_symlink():
+        return
+    try:
+        destination.symlink_to(downloaded_dir, target_is_directory=True)
+    except OSError:
+        # Symlinks can fail on some Windows setups without dev mode/admin
+        # rights; fall back to a plain copy of the downloaded snapshot.
+        import shutil
+
+        shutil.copytree(downloaded_dir, destination)
+
+
+def _download_gguf_model(config: ModelConfig, destination: Path) -> None:
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    with urllib.request.urlopen(config.model_url, timeout=config.download_timeout) as response:
+        with destination.open("wb") as handle:
+            while True:
+                chunk = response.read(1 << 20)
+                if not chunk:
+                    break
+                handle.write(chunk)
+
+
+def ensure_model(config: ModelConfig, explicit: bool = False) -> BootstrapStatus:
+    path = model_path(config)
+    if _model_ready(path, config):
+        return BootstrapStatus(True, "model-ready", "Local model available.", path)
+    if not explicit and not config.auto_bootstrap:
+        return BootstrapStatus(False, "rules-only", "Auto-bootstrap is disabled.", None)
+    try:
+        if config.provider == "onnx":
+            _download_onnx_model(config, path)
+        else:
+            _download_gguf_model(config, path)
+    except Exception as exc:
+        return BootstrapStatus(
+            False,
+            "rules-only",
+            f"Model bootstrap failed ({exc.__class__.__name__}: {exc}); continuing without model.",
+            None,
+        )
+    if not _model_ready(path, config):
+        return BootstrapStatus(
+            False, "rules-only", "Model download finished but expected files are missing.", None
+        )
+    return BootstrapStatus(True, "model-ready", "Model bootstrap completed.", path)
+
+
+def model_status(config: ModelConfig) -> BootstrapStatus:
+    path = model_path(config)
+    if _model_ready(path, config):
+        return BootstrapStatus(True, "model-ready", "Model files exist.", path)
+    return BootstrapStatus(False, "rules-only", "Model is not installed.", None)

{errorai-1.2.0 → errorai-1.5.0}/errorai/config.py

@@ -3,8 +3,27 @@ from __future__ import annotations
 from dataclasses import dataclass, field, replace
 from pathlib import Path
 import os
+import sys
 from typing import Any, Dict
 
+
+def _default_project_root() -> Path:
+    """Prefer the directory of the script actually being run.
+
+    Path.cwd() is wrong in IDLE (and many IDEs): "Run Module" does not chdir
+    into the script's folder, it just sets sys.argv[0] to the script path.
+    Falling back to cwd() there means the running file is almost never
+    considered "inside" project_root, and every fix silently gets blocked by
+    Applier.can_edit().
+    """
+    try:
+        candidate = sys.argv[0]
+        if candidate and Path(candidate).is_file():
+            return Path(candidate).resolve().parent
+    except Exception:
+        pass
+    return Path.cwd()
+
 try:
     import tomllib
 except ModuleNotFoundError:  # pragma: no cover - py<3.11 fallback
@@ -25,7 +44,7 @@ class RuntimeConfig:
     auto_watch: bool = True
     safe_mode: bool = True
     dry_run: bool = True
-    project_root: Path = field(default_factory=lambda: Path.cwd())
+    project_root: Path = field(default_factory=_default_project_root)
     ignore_patterns: tuple[str, ...] = (
         ".git",
         "__pycache__",
@@ -41,14 +60,16 @@ class RuntimeConfig:
 @dataclass(frozen=True)
 class ModelConfig:
     provider: str = "onnx"
-    name: str = "onnx-default-python-expert"
+    name: str = "onnx-qwen2.5-coder-0.5b"
+    repo_id: str = "onnx-community/Qwen2.5-Coder-0.5B-Instruct"
     model_url: str = (
-        "https://huggingface.co/onnx-community/Qwen2.5-Coder-1.5B-Instruct-ONNX/resolve/main/"
-        "model.onnx"
+        "https://huggingface.co/onnx-community/Qwen2.5-Coder-0.5B-Instruct/resolve/main/"
+        "onnx/model.onnx"
     )
     context_window: int = 4096
     temperature: float = 0.1
     auto_bootstrap: bool = True
+    download_timeout: int = 600
     cache_dir: Path = field(default_factory=_default_cache_dir)
 
 
@@ -79,7 +100,7 @@ def _coerce_runtime(base: RuntimeConfig, values: Dict[str, Any]) -> RuntimeConfi
 
 def _coerce_model(base: ModelConfig, values: Dict[str, Any]) -> ModelConfig:
     data = {}
-    for key in ("provider", "name", "model_url"):
+    for key in ("provider", "name", "repo_id", "model_url"):
         if key in values:
             data[key] = str(values[key])
     if "context_window" in values:
@@ -88,6 +109,8 @@ def _coerce_model(base: ModelConfig, values: Dict[str, Any]) -> ModelConfig:
         data["temperature"] = float(values["temperature"])
     if "auto_bootstrap" in values:
         data["auto_bootstrap"] = bool(values["auto_bootstrap"])
+    if "download_timeout" in values:
+        data["download_timeout"] = int(values["download_timeout"])
     if "cache_dir" in values:
         data["cache_dir"] = Path(values["cache_dir"]).expanduser().resolve()
     return replace(base, **data)

{errorai-1.2.0 → errorai-1.5.0}/errorai/pipeline.py

@@ -81,18 +81,15 @@ class Applier:
         path = file_path.resolve()
         if not self.can_edit(path):
             return ApplyResult(False, "Blocked by safe mode restrictions.")
-
         lines = path.read_text(encoding="utf-8").splitlines(keepends=True)
         if lineno < 1 or lineno > len(lines):
             return ApplyResult(False, "Line number out of range.")
-
         old_line = lines[lineno - 1]
         indentation = old_line[: len(old_line) - len(old_line.lstrip())]
         candidate = f"{indentation}{new_line.strip()}\n"
         preview = f"- {old_line.rstrip()}\n+ {candidate.rstrip()}"
         if self.config.dry_run:
             return ApplyResult(False, "Dry-run mode enabled; no write applied.", preview=preview)
-
         lines[lineno - 1] = candidate
         path.write_text("".join(lines), encoding="utf-8")
         return ApplyResult(True, "Edit applied.", preview=preview)

errorai-1.5.0/errorai/providers.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+from .config import ModelConfig
+
+
+class ModelProvider(ABC):
+    @abstractmethod
+    def suggest_patch(self, snippet: str, error_message: str) -> str | None:
+        raise NotImplementedError
+
+
+class RulesOnlyProvider(ModelProvider):
+    def suggest_patch(self, snippet: str, error_message: str) -> str | None:
+        lowered = error_message.lower()
+        if "expected ':'" in lowered and not snippet.rstrip().endswith(":"):
+            return f"{snippet.rstrip()}:"
+        return None
+
+
+@dataclass
+class LlamaCppProvider(ModelProvider):
+    config: ModelConfig
+    model_path: Path
+    _llm: object | None = None
+
+    def _get_llm(self):
+        if self._llm is not None:
+            return self._llm
+        from llama_cpp import Llama  # type: ignore
+
+        self._llm = Llama(
+            model_path=str(self.model_path),
+            n_ctx=self.config.context_window,
+            verbose=False,
+        )
+        return self._llm
+
+    def suggest_patch(self, snippet: str, error_message: str) -> str | None:
+        llm = self._get_llm()
+        prompt = (
+            "You are fixing Python code. Return only the fixed single line.\n"
+            f"Error: {error_message}\n"
+            f"Code: {snippet}\n"
+            "Fix:"
+        )
+        response = llm(
+            prompt=prompt,
+            temperature=self.config.temperature,
+            max_tokens=128,
+            stop=["\n\n"],
+        )
+        text = response["choices"][0]["text"].strip()
+        return text or None
+
+
+@dataclass
+class OnnxProvider(ModelProvider):
+    config: ModelConfig
+    model_path: Path
+    _model: object | None = None
+    _tokenizer: object | None = None
+
+    def _get_model(self):
+        if self._model is not None and self._tokenizer is not None:
+            return self._model, self._tokenizer
+
+        # optimum wraps onnxruntime with a HF-style generate() API, so we
+        # don't have to hand-roll KV-cache decoding against a raw .onnx graph.
+        from optimum.onnxruntime import ORTModelForCausalLM  # type: ignore
+        from transformers import AutoTokenizer  # type: ignore
+
+        model_dir = self.model_path if self.model_path.is_dir() else self.model_path.parent
+
+        self._tokenizer = AutoTokenizer.from_pretrained(model_dir)
+        self._model = ORTModelForCausalLM.from_pretrained(
+            model_dir,
+            use_cache=True,
+        )
+        return self._model, self._tokenizer
+
+    def suggest_patch(self, snippet: str, error_message: str) -> str | None:
+        model, tokenizer = self._get_model()
+
+        prompt = (
+            "You are fixing Python code. Return only the fixed single line.\n"
+            f"Error: {error_message}\n"
+            f"Code: {snippet}\n"
+            "Fix:"
+        )
+        inputs = tokenizer(prompt, return_tensors="pt")
+        max_new_tokens = 64
+        eos_token_id = tokenizer.eos_token_id
+
+        try:
+            output_ids = model.generate(
+                **inputs,
+                max_new_tokens=max_new_tokens,
+                do_sample=self.config.temperature > 0,
+                temperature=max(self.config.temperature, 1e-4),
+                eos_token_id=eos_token_id,
+                pad_token_id=eos_token_id,
+            )
+        except Exception:
+            return None
+
+        generated = output_ids[0][inputs["input_ids"].shape[-1]:]
+        text = tokenizer.decode(generated, skip_special_tokens=True).strip()
+        # Model can wander onto a second line/explanation; keep only the fix.
+        text = text.splitlines()[0].strip() if text else ""
+        return text or None

{errorai-1.2.0 → errorai-1.5.0}/errorai/runtime.py

@@ -13,7 +13,17 @@ from .bootstrap import BootstrapStatus, ensure_model, model_status
 from .config import ErrorAIConfig, autostart_enabled, load_config
 from .environment import Capabilities, detect_capabilities
 from .pipeline import Analyzer, Applier, Planner, Reporter, Watcher
-from .providers import LlamaCppProvider, ModelProvider, RulesOnlyProvider
+from .providers import ModelProvider, RulesOnlyProvider
+
+try:
+    from .providers import LlamaCppProvider
+except ImportError:  # pragma: no cover - optional dependency
+    LlamaCppProvider = None  # type: ignore[assignment,misc]
+
+try:
+    from .providers import OnnxProvider
+except ImportError:  # pragma: no cover - optional dependency
+    OnnxProvider = None  # type: ignore[assignment,misc]
 
 
 class RuntimeManager:
@@ -35,6 +45,8 @@ class RuntimeManager:
         self.mode = "rules-only"
         self._orig_sys_hook = sys.excepthook
         self._orig_thread_hook = getattr(threading, "excepthook", None)
+        self._orig_idle_print_exception = None
+        self._idle_hook_installed = False
 
     @classmethod
     def get_instance(cls) -> "RuntimeManager":
@@ -72,6 +84,7 @@ class RuntimeManager:
                     "environment": self.capabilities.environment,
                     "mode": self.mode,
                     "model_mode": self.bootstrap_status.mode,
+                    "idle_hook_installed": self._idle_hook_installed,
                 },
             )
             self._initialized = True
@@ -80,12 +93,26 @@ class RuntimeManager:
     def _select_provider(self, status: BootstrapStatus) -> ModelProvider:
         if not status.ready or status.model_path is None or self.config is None:
             return RulesOnlyProvider()
-        if self.config.model.provider != "llama_cpp":
-            return RulesOnlyProvider()
-        try:
-            return LlamaCppProvider(self.config.model, status.model_path)
-        except Exception:
-            return RulesOnlyProvider()
+
+        provider_name = self.config.model.provider
+
+        if provider_name == "onnx":
+            if OnnxProvider is None:
+                return RulesOnlyProvider()
+            try:
+                return OnnxProvider(self.config.model, status.model_path)
+            except Exception:
+                return RulesOnlyProvider()
+
+        if provider_name == "llama_cpp":
+            if LlamaCppProvider is None:
+                return RulesOnlyProvider()
+            try:
+                return LlamaCppProvider(self.config.model, status.model_path)
+            except Exception:
+                return RulesOnlyProvider()
+
+        return RulesOnlyProvider()
 
     def _register_hooks(self) -> None:
         self._orig_sys_hook = sys.excepthook
@@ -94,6 +121,50 @@ class RuntimeManager:
             self._orig_thread_hook = threading.excepthook
             threading.excepthook = self._thread_excepthook
 
+        if self.capabilities and self.capabilities.environment == "idle":
+            self._install_idle_hook()
+
+    def _install_idle_hook(self) -> None:
+        """IDLE runs user code inside idlelib.run's own exec/except loop and
+        prints tracebacks itself via idlelib.run.print_exception, so the
+        exception never reaches sys.excepthook. Patch that function directly.
+        """
+        try:
+            import idlelib.run as idle_run
+        except ImportError:  # pragma: no cover - not actually running under IDLE
+            return
+
+        if self._idle_hook_installed:
+            return
+
+        self._orig_idle_print_exception = idle_run.print_exception
+
+        def patched_print_exception() -> None:
+            exc_type, exc_value, exc_tb = sys.exc_info()
+            handled = False
+            if exc_type is not None:
+                handled = self.process_exception(exc_type, exc_value, exc_tb)
+            if handled:
+                print("[errorai] exception intercepted")
+                return
+            if self._orig_idle_print_exception is not None:
+                self._orig_idle_print_exception()
+
+        idle_run.print_exception = patched_print_exception
+        self._idle_hook_installed = True
+
+    def _uninstall_idle_hook(self) -> None:
+        if not self._idle_hook_installed:
+            return
+        try:
+            import idlelib.run as idle_run
+        except ImportError:  # pragma: no cover
+            self._idle_hook_installed = False
+            return
+        if self._orig_idle_print_exception is not None:
+            idle_run.print_exception = self._orig_idle_print_exception
+        self._idle_hook_installed = False
+
     def _sys_excepthook(self, exc_type, exc_value, exc_tb):
         handled = self.process_exception(exc_type, exc_value, exc_tb)
         if handled:
@@ -120,10 +191,38 @@ class RuntimeManager:
         filename = frame.filename
         line = linecache.getline(filename, frame.lineno).strip() if filename else ""
         analysis = self.analyzer.analyze_exception(exc_type, exc_value, exc_tb)
-        plan = self.planner.plan_line_fix(line or frame.line or "", analysis["message"])
+        try:
+            plan = self.planner.plan_line_fix(line or frame.line or "", analysis["message"])
+        except Exception as provider_exc:
+            # Never let a broken/missing model provider raise out of an
+            # exception hook -- that can crash the interpreter (or IDLE's
+            # subprocess) while it's in the middle of handling an exception.
+            self.reporter.log(
+                "provider.error",
+                {"analysis": analysis, "error": f"{type(provider_exc).__name__}: {provider_exc}"},
+            )
+            print(f"[errorai] Model provider failed ({type(provider_exc).__name__}: {provider_exc})")
+            return False
+
         if not plan or not filename or "<" in filename:
             self.reporter.log("exception.analyzed", {"analysis": analysis, "fixed": False})
+            print(f"[errorai] Caught {analysis['type']}: {analysis['message']}")
+            print("[errorai] No automatic fix rule matched this error.")
             return False
+
+        print(f"[errorai] Caught {analysis['type']}: {analysis['message']}")
+        print(f"[errorai] Suggested fix -> {plan}")
+
+        if self.capabilities and self.capabilities.can_prompt_user:
+            try:
+                answer = input("[errorai] Should I fix it [Y/N]: ").strip().lower()
+            except (EOFError, OSError):
+                answer = "n"
+            if answer not in {"y", "yes"}:
+                self.reporter.log("exception.declined", {"analysis": analysis})
+                print("[errorai] Skipped.")
+                return False
+
         result = self.applier.apply_line_change(Path(filename), frame.lineno, plan)
         self.reporter.log(
             "exception.handled",
@@ -134,6 +233,12 @@ class RuntimeManager:
                 "preview": result.preview,
             },
         )
+        if result.preview and not result.changed:
+            print("[errorai] suggested fix (dry-run, not applied):")
+            print(result.preview)
+            print("[errorai] set dry_run = false in .errorai.toml to auto-apply")
+        elif result.changed:
+            print(f"[errorai] Applied fix to {filename}:{frame.lineno}")
         return result.changed
 
     def status_report(self) -> dict[str, Any]:
@@ -150,6 +255,7 @@ class RuntimeManager:
             "model_detail": self.bootstrap_status.detail,
             "dry_run": cfg.runtime.dry_run,
             "project_root": str(cfg.runtime.project_root),
+            "idle_hook_installed": self._idle_hook_installed,
         }
 
     def install_model(self) -> BootstrapStatus:
@@ -172,6 +278,7 @@ class RuntimeManager:
         sys.excepthook = self._orig_sys_hook
         if hasattr(threading, "excepthook") and self._orig_thread_hook is not None:
             threading.excepthook = self._orig_thread_hook
+        self._uninstall_idle_hook()
         self._initialized = False
 
 

{errorai-1.2.0 → errorai-1.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ErrorAI"
-version = "1.2.0"
+version = "1.5.0"
 description = "Python-only autonomous runtime that watches/analyzes errors with safe local auto-fix fallbacks."
 readme = "README.md"
 authors = [
@@ -21,6 +21,10 @@ requires-python = ">=3.9"
 dependencies = [
     "platformdirs>=3.0",
     "onnxruntime>=1.18.0",
+    "optimum[onnxruntime]>=1.20.0",
+    "transformers>=4.40.0",
+    "huggingface_hub>=0.23.0",
+    "tomli>=2.0.1; python_version < '3.11'",
 ]
 
 [project.optional-dependencies]

errorai-1.2.0/ErrorAI.egg-info/requires.txt

@@ -1,5 +0,0 @@
-platformdirs>=3.0
-onnxruntime>=1.18.0
-
-[watch]
-watchdog>=4.0.0

errorai-1.2.0/errorai/bootstrap.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from pathlib import Path
-import urllib.request
-
-from .config import ModelConfig
-
-
-@dataclass(frozen=True)
-class BootstrapStatus:
-    ready: bool
-    mode: str
-    detail: str
-    model_path: Path | None = None
-
-
-def model_path(config: ModelConfig) -> Path:
-    return config.cache_dir / "models" / f"{config.name}.gguf"
-
-
-def _download_model(url: str, destination: Path) -> None:
-    destination.parent.mkdir(parents=True, exist_ok=True)
-    with urllib.request.urlopen(url, timeout=5) as response, destination.open("wb") as handle:
-        handle.write(response.read())
-
-
-def ensure_model(config: ModelConfig, explicit: bool = False) -> BootstrapStatus:
-    path = model_path(config)
-    if path.exists():
-        return BootstrapStatus(True, "model-ready", "Local model available.", path)
-
-    if not explicit and not config.auto_bootstrap:
-        return BootstrapStatus(False, "rules-only", "Auto-bootstrap is disabled.", None)
-
-    try:
-        _download_model(config.model_url, path)
-    except Exception as exc:
-        return BootstrapStatus(
-            False,
-            "rules-only",
-            f"Model bootstrap failed ({exc.__class__.__name__}); continuing without model.",
-            None,
-        )
-    return BootstrapStatus(True, "model-ready", "Model bootstrap completed.", path)
-
-
-def model_status(config: ModelConfig) -> BootstrapStatus:
-    path = model_path(config)
-    if path.exists():
-        return BootstrapStatus(True, "model-ready", "Model file exists.", path)
-    return BootstrapStatus(False, "rules-only", "Model file is not installed.", None)

errorai-1.2.0/errorai/providers.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from pathlib import Path
-
-from .config import ModelConfig
-
-
-class ModelProvider(ABC):
-    @abstractmethod
-    def suggest_patch(self, snippet: str, error_message: str) -> str | None:
-        raise NotImplementedError
-
-
-class RulesOnlyProvider(ModelProvider):
-    def suggest_patch(self, snippet: str, error_message: str) -> str | None:
-        lowered = error_message.lower()
-        if "expected ':'" in lowered and not snippet.rstrip().endswith(":"):
-            return f"{snippet.rstrip()}:"
-        return None
-
-
-@dataclass
-class LlamaCppProvider(ModelProvider):
-    config: ModelConfig
-    model_path: Path
-    _llm: object | None = None
-
-    def _get_llm(self):
-        if self._llm is not None:
-            return self._llm
-        from llama_cpp import Llama  # type: ignore
-
-        self._llm = Llama(
-            model_path=str(self.model_path),
-            n_ctx=self.config.context_window,
-            verbose=False,
-        )
-        return self._llm
-
-    def suggest_patch(self, snippet: str, error_message: str) -> str | None:
-        llm = self._get_llm()
-        prompt = (
-            "You are fixing Python code. Return only the fixed single line.\n"
-            f"Error: {error_message}\n"
-            f"Code: {snippet}\n"
-            "Fix:"
-        )
-        response = llm(
-            prompt=prompt,
-            temperature=self.config.temperature,
-            max_tokens=128,
-            stop=["\n\n"],
-        )
-        text = response["choices"][0]["text"].strip()
-        return text or None