agent-smart-router 0.1.0__tar.gz

agent_smart_router-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: agent-smart-router
+Version: 0.1.0
+Summary: A lightweight CLI tool for delegating LLM tasks to expert models across multiple providers.
+Author-email: Kerem Barbaros Karnabat <kbarbaros@hotmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: openai>=1.0.0
+Requires-Dist: filelock>=3.12.0
+Requires-Dist: anthropic>=0.30.0
+
+# Smart Router (CLI Delegation Tool)
+
+> A lightweight, fault-tolerant CLI tool for delegating LLM tasks to expert models across multiple providers (Nvidia NIM, Groq, OpenAI, Anthropic Claude, Gemini).
+
+![Python](https://img.shields.io/badge/Python-3.8%2B-blue)
+![License](https://img.shields.io/badge/License-MIT-green)
+![CI](https://github.com/cadakerem/smart-router/actions/workflows/ci.yml/badge.svg)
+
+## ⚡ Features
+
+- **Multi-Provider Support:** seamlessly route requests to `nvidia`, `groq`, `openai`, `anthropic`, or `gemini`.
+- **Automatic Fallbacks:** Provide a comma-separated list of models. If one fails, it instantly falls back to the next.
+- **Circuit Breaker:** Built-in health tracking and cooldowns to prevent spamming dead endpoints.
+- **Reasoning Extraction:** Automatically extracts and formats hidden `<thought>` or `reasoning` blocks (e.g., from Nemotron or DeepSeek).
+- **Streaming Native:** Built on the official OpenAI SDK for fast and reliable streaming chunks.
+
+## 📦 Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/cadakerem/smart-router.git
+cd smart-router
+
+# Install dependencies
+pip install agent-smart-router
+```
+
+### Setup API Keys
+The router checks for a `keys.json` file in the same directory, or falls back to system environment variables.
+
+**Option 1: keys.json**
+Create a `keys.json` file in the root directory:
+```json
+{
+  "NVIDIA_API_KEY": "nvapi-...",
+  "GROQ_API_KEY": "gsk_...",
+  "OPENAI_API_KEY": "sk-...",
+  "ANTHROPIC_API_KEY": "sk-ant-...",
+  "GEMINI_API_KEY": "AIza..."
+}
+```
+
+**Option 2: Environment Variables**
+```bash
+export OPENAI_API_KEY="sk-..."
+export ANTHROPIC_API_KEY="sk-ant-..."
+export GEMINI_API_KEY="AIza..."
+export NVIDIA_API_KEY="nvapi-..."
+export GROQ_API_KEY="gsk_..."
+```
+
+## 💻 Usage
+
+```bash
+python smart_router.py -m "<provider:model1>,<provider:model2>" -p "<your prompt>"
+```
+
+You can also read prompts from a file or via standard input:
+```bash
+python smart_router.py -m "nvidia:nemotron,groq:llama3" -f prompt.txt
+cat logs.txt | python smart_router.py -m "groq:llama3"
+```
+
+### Examples
+
+**Heavy Coding Task (Nvidia Laguna -> Groq Fallback):**
+```bash
+python smart_router.py -m "nvidia:poolside/laguna-xs-2.1,groq:groq/compound" -p "Write a python script to parse logs."
+```
+
+**Custom Cooldown and Project ID:**
+```bash
+python smart_router.py -m "groq:llama3" -p "Hello" --project "agent-core" --max-failures 3 --cooldown 300
+```
+
+## 🏗️ Architecture Overview
+
+The router uses a `FileLock`-backed JSON state (`circuit_breaker.json`) to track failures across concurrent runs. 
+If an endpoint times out or returns a 5xx error more than `MAX_FAILURES` times, the circuit trips and forces the router to skip that endpoint for the next 120 seconds, immediately trying the next fallback model.
+

agent_smart_router-0.1.0/README.md

@@ -0,0 +1,80 @@
+# Smart Router (CLI Delegation Tool)
+
+> A lightweight, fault-tolerant CLI tool for delegating LLM tasks to expert models across multiple providers (Nvidia NIM, Groq, OpenAI, Anthropic Claude, Gemini).
+
+![Python](https://img.shields.io/badge/Python-3.8%2B-blue)
+![License](https://img.shields.io/badge/License-MIT-green)
+![CI](https://github.com/cadakerem/smart-router/actions/workflows/ci.yml/badge.svg)
+
+## ⚡ Features
+
+- **Multi-Provider Support:** seamlessly route requests to `nvidia`, `groq`, `openai`, `anthropic`, or `gemini`.
+- **Automatic Fallbacks:** Provide a comma-separated list of models. If one fails, it instantly falls back to the next.
+- **Circuit Breaker:** Built-in health tracking and cooldowns to prevent spamming dead endpoints.
+- **Reasoning Extraction:** Automatically extracts and formats hidden `<thought>` or `reasoning` blocks (e.g., from Nemotron or DeepSeek).
+- **Streaming Native:** Built on the official OpenAI SDK for fast and reliable streaming chunks.
+
+## 📦 Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/cadakerem/smart-router.git
+cd smart-router
+
+# Install dependencies
+pip install agent-smart-router
+```
+
+### Setup API Keys
+The router checks for a `keys.json` file in the same directory, or falls back to system environment variables.
+
+**Option 1: keys.json**
+Create a `keys.json` file in the root directory:
+```json
+{
+  "NVIDIA_API_KEY": "nvapi-...",
+  "GROQ_API_KEY": "gsk_...",
+  "OPENAI_API_KEY": "sk-...",
+  "ANTHROPIC_API_KEY": "sk-ant-...",
+  "GEMINI_API_KEY": "AIza..."
+}
+```
+
+**Option 2: Environment Variables**
+```bash
+export OPENAI_API_KEY="sk-..."
+export ANTHROPIC_API_KEY="sk-ant-..."
+export GEMINI_API_KEY="AIza..."
+export NVIDIA_API_KEY="nvapi-..."
+export GROQ_API_KEY="gsk_..."
+```
+
+## 💻 Usage
+
+```bash
+python smart_router.py -m "<provider:model1>,<provider:model2>" -p "<your prompt>"
+```
+
+You can also read prompts from a file or via standard input:
+```bash
+python smart_router.py -m "nvidia:nemotron,groq:llama3" -f prompt.txt
+cat logs.txt | python smart_router.py -m "groq:llama3"
+```
+
+### Examples
+
+**Heavy Coding Task (Nvidia Laguna -> Groq Fallback):**
+```bash
+python smart_router.py -m "nvidia:poolside/laguna-xs-2.1,groq:groq/compound" -p "Write a python script to parse logs."
+```
+
+**Custom Cooldown and Project ID:**
+```bash
+python smart_router.py -m "groq:llama3" -p "Hello" --project "agent-core" --max-failures 3 --cooldown 300
+```
+
+## 🏗️ Architecture Overview
+
+The router uses a `FileLock`-backed JSON state (`circuit_breaker.json`) to track failures across concurrent runs. 
+If an endpoint times out or returns a 5xx error more than `MAX_FAILURES` times, the circuit trips and forces the router to skip that endpoint for the next 120 seconds, immediately trying the next fallback model.
+

agent_smart_router-0.1.0/agent_smart_router.egg-info/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: agent-smart-router
+Version: 0.1.0
+Summary: A lightweight CLI tool for delegating LLM tasks to expert models across multiple providers.
+Author-email: Kerem Barbaros Karnabat <kbarbaros@hotmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: openai>=1.0.0
+Requires-Dist: filelock>=3.12.0
+Requires-Dist: anthropic>=0.30.0
+
+# Smart Router (CLI Delegation Tool)
+
+> A lightweight, fault-tolerant CLI tool for delegating LLM tasks to expert models across multiple providers (Nvidia NIM, Groq, OpenAI, Anthropic Claude, Gemini).
+
+![Python](https://img.shields.io/badge/Python-3.8%2B-blue)
+![License](https://img.shields.io/badge/License-MIT-green)
+![CI](https://github.com/cadakerem/smart-router/actions/workflows/ci.yml/badge.svg)
+
+## ⚡ Features
+
+- **Multi-Provider Support:** seamlessly route requests to `nvidia`, `groq`, `openai`, `anthropic`, or `gemini`.
+- **Automatic Fallbacks:** Provide a comma-separated list of models. If one fails, it instantly falls back to the next.
+- **Circuit Breaker:** Built-in health tracking and cooldowns to prevent spamming dead endpoints.
+- **Reasoning Extraction:** Automatically extracts and formats hidden `<thought>` or `reasoning` blocks (e.g., from Nemotron or DeepSeek).
+- **Streaming Native:** Built on the official OpenAI SDK for fast and reliable streaming chunks.
+
+## 📦 Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/cadakerem/smart-router.git
+cd smart-router
+
+# Install dependencies
+pip install agent-smart-router
+```
+
+### Setup API Keys
+The router checks for a `keys.json` file in the same directory, or falls back to system environment variables.
+
+**Option 1: keys.json**
+Create a `keys.json` file in the root directory:
+```json
+{
+  "NVIDIA_API_KEY": "nvapi-...",
+  "GROQ_API_KEY": "gsk_...",
+  "OPENAI_API_KEY": "sk-...",
+  "ANTHROPIC_API_KEY": "sk-ant-...",
+  "GEMINI_API_KEY": "AIza..."
+}
+```
+
+**Option 2: Environment Variables**
+```bash
+export OPENAI_API_KEY="sk-..."
+export ANTHROPIC_API_KEY="sk-ant-..."
+export GEMINI_API_KEY="AIza..."
+export NVIDIA_API_KEY="nvapi-..."
+export GROQ_API_KEY="gsk_..."
+```
+
+## 💻 Usage
+
+```bash
+python smart_router.py -m "<provider:model1>,<provider:model2>" -p "<your prompt>"
+```
+
+You can also read prompts from a file or via standard input:
+```bash
+python smart_router.py -m "nvidia:nemotron,groq:llama3" -f prompt.txt
+cat logs.txt | python smart_router.py -m "groq:llama3"
+```
+
+### Examples
+
+**Heavy Coding Task (Nvidia Laguna -> Groq Fallback):**
+```bash
+python smart_router.py -m "nvidia:poolside/laguna-xs-2.1,groq:groq/compound" -p "Write a python script to parse logs."
+```
+
+**Custom Cooldown and Project ID:**
+```bash
+python smart_router.py -m "groq:llama3" -p "Hello" --project "agent-core" --max-failures 3 --cooldown 300
+```
+
+## 🏗️ Architecture Overview
+
+The router uses a `FileLock`-backed JSON state (`circuit_breaker.json`) to track failures across concurrent runs. 
+If an endpoint times out or returns a 5xx error more than `MAX_FAILURES` times, the circuit trips and forces the router to skip that endpoint for the next 120 seconds, immediately trying the next fallback model.
+

agent_smart_router-0.1.0/agent_smart_router.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+smart_router.py
+agent_smart_router.egg-info/PKG-INFO
+agent_smart_router.egg-info/SOURCES.txt
+agent_smart_router.egg-info/dependency_links.txt
+agent_smart_router.egg-info/entry_points.txt
+agent_smart_router.egg-info/requires.txt
+agent_smart_router.egg-info/top_level.txt
+tests/test_circuit.py

agent_smart_router-0.1.0/agent_smart_router.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agent_smart_router-0.1.0/agent_smart_router.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+smart-router = smart_router:main

agent_smart_router-0.1.0/agent_smart_router.egg-info/requires.txt

@@ -0,0 +1,3 @@
+openai>=1.0.0
+filelock>=3.12.0
+anthropic>=0.30.0

agent_smart_router-0.1.0/agent_smart_router.egg-info/top_level.txt

@@ -0,0 +1 @@
+smart_router

agent_smart_router-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agent-smart-router"
+version = "0.1.0"
+authors = [
+  { name="Kerem Barbaros Karnabat", email="kbarbaros@hotmail.com" }
+]
+description = "A lightweight CLI tool for delegating LLM tasks to expert models across multiple providers."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "openai>=1.0.0",
+    "filelock>=3.12.0",
+    "anthropic>=0.30.0"
+]
+
+[project.scripts]
+smart-router = "smart_router:main"

agent_smart_router-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agent_smart_router-0.1.0/smart_router.py

@@ -0,0 +1,239 @@
+import sys
+import os
+import json
+import time
+import random
+import argparse
+import logging
+from openai import OpenAI
+from filelock import FileLock, Timeout
+
+__version__ = "0.1.0"
+
+# Optional import for anthropic
+try:
+    import anthropic
+    HAS_ANTHROPIC = True
+except ImportError:
+    HAS_ANTHROPIC = False
+
+# Setup Logging
+logger = logging.getLogger("smart_router")
+handler = logging.StreamHandler(sys.stderr)
+formatter = logging.Formatter("[%(levelname)s] %(message)s")
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+logger.setLevel(logging.INFO)
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+
+def get_api_key(provider):
+    keys_file = os.path.join(SCRIPT_DIR, "keys.json")
+    if os.path.exists(keys_file):
+        try:
+            with open(keys_file, 'r', encoding='utf-8') as f:
+                keys = json.load(f)
+                env_name = f"{provider.upper()}_API_KEY"
+                if keys.get(env_name):
+                    return keys[env_name]
+        except Exception:
+            pass
+    return os.environ.get(f"{provider.upper()}_API_KEY")
+
+PROVIDERS = {
+    "nvidia": {"base_url": "https://integrate.api.nvidia.com/v1", "api_key": get_api_key("NVIDIA")},
+    "openai": {"base_url": "https://api.openai.com/v1", "api_key": get_api_key("OPENAI")},
+    "groq": {"base_url": "https://api.groq.com/openai/v1", "api_key": get_api_key("GROQ")},
+    "gemini": {"base_url": "https://generativelanguage.googleapis.com/v1beta/openai/", "api_key": get_api_key("GEMINI")},
+    "anthropic": {"api_key": get_api_key("ANTHROPIC")}
+}
+
+class CircuitBreaker:
+    def __init__(self, project_id, max_failures=2, cooldown_seconds=120):
+        self.max_failures = max_failures
+        self.cooldown_seconds = cooldown_seconds
+        
+        safe_proj = "".join([c if c.isalnum() else "_" for c in project_id])
+        self.circuit_file = os.path.join(SCRIPT_DIR, f"circuit_breaker_{safe_proj}.json")
+        self.lock_file = os.path.join(SCRIPT_DIR, f"circuit_breaker_{safe_proj}.json.lock")
+        
+    def load(self):
+        for _ in range(3):
+            if os.path.exists(self.circuit_file):
+                try:
+                    with open(self.circuit_file, 'r', encoding='utf-8') as f:
+                        return json.load(f)
+                except Exception:
+                    time.sleep(random.uniform(0.01, 0.05))
+        return {}
+        
+    def save(self, data):
+        for _ in range(3):
+            try:
+                current_time = time.time()
+                active_data = {
+                    k: v for k, v in data.items()
+                    if v.get('failures', 0) > 0 or v.get('cooldown_until', 0) > current_time
+                }
+                if not active_data:
+                    if os.path.exists(self.circuit_file):
+                        os.remove(self.circuit_file)
+                    return
+                with open(self.circuit_file, 'w', encoding='utf-8') as f:
+                    json.dump(active_data, f)
+                break
+            except Exception:
+                time.sleep(random.uniform(0.01, 0.05))
+                
+    def check_health(self, model_id):
+        try:
+            with FileLock(self.lock_file, timeout=5):
+                circuit = self.load()
+                if model_id in circuit:
+                    stats = circuit[model_id]
+                    if stats.get('cooldown_until', 0) > time.time():
+                        return False
+                return True
+        except Timeout:
+            logger.debug(f"Timeout acquiring lock for {model_id} health check. Assuming healthy.")
+            return True
+            
+    def record_failure(self, model_id):
+        try:
+            with FileLock(self.lock_file, timeout=5):
+                circuit = self.load()
+                if model_id not in circuit:
+                    circuit[model_id] = {'failures': 0, 'cooldown_until': 0}
+                
+                circuit[model_id]['failures'] += 1
+                
+                if circuit[model_id]['failures'] >= self.max_failures:
+                    circuit[model_id]['cooldown_until'] = time.time() + self.cooldown_seconds
+                    circuit[model_id]['failures'] = 0
+                    logger.warning(f"CIRCUIT BREAKER: {model_id} tripped! Cooldown: {self.cooldown_seconds}s.")
+                self.save(circuit)
+        except Timeout:
+            logger.debug(f"Timeout acquiring lock. Could not record failure for {model_id}.")
+            
+    def record_success(self, model_id):
+        try:
+            with FileLock(self.lock_file, timeout=5):
+                circuit = self.load()
+                if model_id in circuit and circuit[model_id]['failures'] > 0:
+                    circuit[model_id]['failures'] = 0
+                    self.save(circuit)
+        except Timeout:
+            pass
+
+def parse_model(model_string):
+    if ":" in model_string:
+        provider, model = model_string.split(":", 1)
+        return provider.strip().lower(), model.strip()
+    return "nvidia", model_string.strip()
+
+def query_ai(models_list, prompt, cb: CircuitBreaker, max_retries=2, base_timeout=30):
+    if isinstance(models_list, str):
+        models_list = [m.strip() for m in models_list.split(',')]
+        
+    for current_model_str in models_list:
+        provider, current_model = parse_model(current_model_str)
+        
+        if not cb.check_health(current_model_str):
+            logger.info(f"Health Check Failed: {current_model_str} is in cooldown. Skipping...")
+            continue
+            
+        provider_config = PROVIDERS.get(provider)
+        if not provider_config or not provider_config.get("api_key"):
+            logger.error(f"Provider '{provider}' not configured or missing API key. Skipping...")
+            continue
+            
+        is_nemotron = "nemotron" in current_model.lower()
+        model_timeout = 90 if is_nemotron else base_timeout
+            
+        for attempt in range(max_retries):
+            try:
+                full_reasoning = ""
+                full_content = ""
+
+                if provider == "anthropic":
+                    if not HAS_ANTHROPIC:
+                        raise ImportError("Anthropic package is missing. 'pip install anthropic' required.")
+                    client = anthropic.Anthropic(api_key=provider_config["api_key"], timeout=model_timeout)
+                    with client.messages.stream(
+                        model=current_model, max_tokens=4096,
+                        messages=[{"role": "user", "content": prompt}], temperature=0.7
+                    ) as stream:
+                        for text in stream.text_stream:
+                            full_content += text
+                else:
+                    client = OpenAI(
+                        base_url=provider_config["base_url"], api_key=provider_config["api_key"], timeout=model_timeout
+                    )
+                    extra_body = {"chat_template_kwargs": {"enable_thinking": True}} if (provider == "nvidia" and "nemotron" in current_model.lower()) else {}
+                    completion = client.chat.completions.create(
+                        model=current_model, messages=[{"role": "user", "content": prompt}],
+                        temperature=0.7, max_tokens=4096, extra_body=extra_body if extra_body else None, stream=True
+                    )
+                    for chunk in completion:
+                        if not chunk.choices: continue
+                        reasoning = getattr(chunk.choices[0].delta, "reasoning_content", None)
+                        if reasoning: full_reasoning += reasoning
+                        content = chunk.choices[0].delta.content
+                        if content: full_content += content
+                            
+                cb.record_success(current_model_str)
+                output = ""
+                if full_reasoning: output += f"--- REASONING ({current_model_str}) ---\n{full_reasoning}\n--- END REASONING ---\n\n"
+                output += full_content
+                return output
+                
+            except Exception as e:
+                error_msg = str(e).lower()
+                logger.error(f"Attempt {attempt+1} failed for {current_model_str}: {str(e)}")
+                cb.record_failure(current_model_str)
+                if "404" in error_msg or "not found" in error_msg or "auth" in error_msg: break 
+                if attempt == max_retries - 1: break 
+                time.sleep((2 ** attempt) + random.uniform(0.1, 1.5))
+                
+    logger.error("All fallback models failed, timed out, or are in cooldown.")
+    sys.exit(1)
+
+def main():
+    parser = argparse.ArgumentParser(description="Smart Router: A fault-tolerant CLI tool for LLM delegation.")
+    parser.add_argument("-v", "--version", action="version", version=f"Smart Router v{__version__}")
+    parser.add_argument("-m", "--models", required=True, help="Comma-separated list of provider:model fallbacks (e.g. nvidia:nemotron,groq:llama3).")
+    parser.add_argument("-p", "--prompt", help="The prompt text to send to the model.")
+    parser.add_argument("-f", "--file", help="Path to a text file containing the prompt.")
+    parser.add_argument("--project", default="default", help="Project ID for isolating circuit breaker state.")
+    parser.add_argument("--max-failures", type=int, default=2, help="Failures before tripping the circuit breaker.")
+    parser.add_argument("--cooldown", type=int, default=120, help="Cooldown in seconds when circuit is tripped.")
+    
+    args = parser.parse_args()
+    
+    prompt_text = ""
+    if args.prompt:
+        prompt_text = args.prompt
+    elif args.file:
+        try:
+            with open(args.file, "r", encoding="utf-8") as f:
+                prompt_text = f.read()
+        except Exception as e:
+            logger.error(f"Error reading file: {e}")
+            sys.exit(1)
+    elif not sys.stdin.isatty():
+        prompt_text = sys.stdin.read()
+    else:
+        parser.error("You must provide a prompt via -p, -f, or stdin (piped input).")
+        
+    if not prompt_text.strip():
+        logger.error("Prompt cannot be empty.")
+        sys.exit(1)
+        
+    cb = CircuitBreaker(args.project, args.max_failures, args.cooldown)
+    response = query_ai(args.models, prompt_text, cb)
+    
+    # Print the final LLM response to stdout so it can be piped properly
+    print(response)
+
+if __name__ == "__main__":
+    main()

agent_smart_router-0.1.0/tests/test_circuit.py

@@ -0,0 +1,48 @@
+import os
+import time
+import pytest
+from smart_router import CircuitBreaker
+
+def test_circuit_breaker_isolation(tmp_path):
+    # Test that different projects don't share state
+    cb1 = CircuitBreaker("proj1", max_failures=2, cooldown_seconds=10)
+    cb2 = CircuitBreaker("proj2", max_failures=2, cooldown_seconds=10)
+    
+    cb1.circuit_file = str(tmp_path / "cb1.json")
+    cb1.lock_file = str(tmp_path / "cb1.json.lock")
+    cb2.circuit_file = str(tmp_path / "cb2.json")
+    cb2.lock_file = str(tmp_path / "cb2.json.lock")
+    
+    cb1.record_failure("modelA")
+    cb1.record_failure("modelA")
+    
+    # cb1 should be tripped
+    assert cb1.check_health("modelA") == False
+    # cb2 should be unaffected
+    assert cb2.check_health("modelA") == True
+
+def test_circuit_breaker_cooldown(tmp_path):
+    cb = CircuitBreaker("test", max_failures=1, cooldown_seconds=1)
+    cb.circuit_file = str(tmp_path / "cb.json")
+    cb.lock_file = str(tmp_path / "cb.json.lock")
+    
+    assert cb.check_health("modelB") == True
+    cb.record_failure("modelB")
+    
+    assert cb.check_health("modelB") == False
+    time.sleep(1.1)
+    # After cooldown, should be healthy again
+    assert cb.check_health("modelB") == True
+    
+def test_circuit_breaker_success_reset(tmp_path):
+    cb = CircuitBreaker("test2", max_failures=2, cooldown_seconds=10)
+    cb.circuit_file = str(tmp_path / "cb.json")
+    cb.lock_file = str(tmp_path / "cb.json.lock")
+    
+    cb.record_failure("modelC")
+    circuit = cb.load()
+    assert circuit["modelC"]["failures"] == 1
+    
+    cb.record_success("modelC")
+    circuit = cb.load()
+    assert "modelC" not in circuit or circuit["modelC"]["failures"] == 0