llmcycle 0.1.0__py3-none-any.whl

llmcycle/__init__.py

@@ -0,0 +1,25 @@
+"""
+LLMCycle - Production-Grade Universal LLM Router
+=================================================
+Auto multi-key rotation, intelligent error handling, streaming resilience,
+and support for 50+ providers out-of-the-box.
+"""
+from .client import LLMCycle
+from .schema import CompletionRequest, Message, CompletionResponse, StreamChunk
+from .core.keys import KeyManager, KeyStatus
+from .core.router import ModelRouter, RoutingStrategy
+from .core.errors import (
+    LLMCycleError, RateLimitError, AuthenticationError,
+    ProviderError, AllProvidersFailedError, StreamInterruptedError,
+)
+
+__all__ = [
+    "LLMCycle",
+    "CompletionRequest", "Message", "CompletionResponse", "StreamChunk",
+    "KeyManager", "KeyStatus",
+    "ModelRouter", "RoutingStrategy",
+    "LLMCycleError", "RateLimitError", "AuthenticationError",
+    "ProviderError", "AllProvidersFailedError", "StreamInterruptedError",
+]
+
+__version__ = "0.2.0"

llmcycle/cli.py

@@ -0,0 +1,17 @@
+import argparse
+import uvicorn
+
+def main():
+    parser = argparse.ArgumentParser(description="LLMCycle CLI")
+    parser.add_argument("command", choices=["ui"], help="Command to run")
+    parser.add_argument("--host", default="127.0.0.1", help="Host for the UI")
+    parser.add_argument("--port", type=int, default=8000, help="Port for the UI")
+
+    args = parser.parse_args()
+
+    if args.command == "ui":
+        print(f"Starting LLMCycle Dashboard on http://{args.host}:{args.port}")
+        uvicorn.run("llmcycle.ui.app:app", host=args.host, port=args.port, reload=True)
+
+if __name__ == "__main__":
+    main()

llmcycle/client.py

@@ -0,0 +1,73 @@
+import os
+from dotenv import load_dotenv
+from llmcycle.core.keys import KeyManager
+from llmcycle.core.router import ModelRouter, FallbackRouter
+from llmcycle.core.stream import StreamResilienceManager
+from llmcycle.providers.openai_compatible import OpenAICompatibleProvider
+
+# Massive default registry
+PROVIDER_BASE_URLS = {
+    "OPENAI": "https://api.openai.com/v1",
+    "DEEPSEEK": "https://api.deepseek.com/v1",
+    "ANTHROPIC": "https://api.anthropic.com/v1",
+    "TOGETHER": "https://api.together.xyz/v1",
+    "GROQ": "https://api.groq.com/openai/v1",
+    "MISTRAL": "https://api.mistral.ai/v1",
+    "PERPLEXITY": "https://api.perplexity.ai",
+    "ANYSCALE": "https://api.endpoints.anyscale.com/v1",
+    "FIREWORKS": "https://api.fireworks.ai/inference/v1",
+    "COHERE": "https://api.cohere.com/v1",
+    "DATABRICKS": "https://serving.api.databricks.com/serving-endpoints",
+    "HUGGINGFACE": "https://api-inference.huggingface.co/models",
+}
+
+class LLMCycle:
+    """Main entrypoint for LLMCycle with Universal Provider Support."""
+    
+    def __init__(self, env_path: str = ".env", custom_fallbacks: dict = None):
+        load_dotenv(env_path)
+        
+        self.key_manager = KeyManager()
+        self.providers = {}
+        
+        # Auto-discover
+        self._auto_load_keys()
+        
+        # Setup Routing Strategy
+        fallbacks = custom_fallbacks or {}
+        self.router = ModelRouter(FallbackRouter(fallbacks))
+        self.stream_manager = StreamResilienceManager(self.router, self.key_manager, self.providers)
+
+    def _auto_load_keys(self):
+        """Finds any env var ending with _API_KEYS and universally registers the provider."""
+        for key, val in os.environ.items():
+            if key.endswith("_API_KEYS"):
+                provider_name = key.replace("_API_KEYS", "").upper()
+                keys = [k.strip() for k in val.split(",") if k.strip()]
+                
+                if not keys:
+                    continue
+                    
+                # 1. Check if user explicitly defined a BASE URL for this provider
+                # 2. Check the massive default registry
+                # 3. Fallback: Assume a standard OpenAI compatible format
+                base_url = os.environ.get(f"{provider_name}_BASE_URL")
+                if not base_url:
+                    base_url = PROVIDER_BASE_URLS.get(provider_name, f"https://api.{provider_name.lower()}.com/v1")
+                
+                if base_url:
+                    self.providers[provider_name.lower()] = OpenAICompatibleProvider(base_url)
+                    for k in keys:
+                        self.key_manager.add_key(provider_name.lower(), k)
+
+    def get_available_providers(self) -> list[str]:
+        return list(self.providers.keys())
+
+    async def get_provider_models(self, provider_name: str) -> list[str]:
+        p_name = provider_name.lower()
+        if p_name not in self.providers:
+            return []
+        key = self.key_manager.get_next_key(p_name)
+        if not key:
+            return []
+        return await self.providers[p_name].get_models(key)

llmcycle/core/errors.py

@@ -0,0 +1,71 @@
+"""
+Custom exceptions for LLMCycle.
+All errors map from HTTP status codes so the router knows exactly
+what to do: retry, rotate key, skip provider, or give up.
+"""
+
+class LLMCycleError(Exception):
+    """Base error for all LLMCycle exceptions."""
+    def __init__(self, message: str, provider: str = "", model: str = "", status_code: int = 0):
+        super().__init__(message)
+        self.provider = provider
+        self.model = model
+        self.status_code = status_code
+
+class RateLimitError(LLMCycleError):
+    """429: Rate limit exceeded. Rotate key and retry."""
+    pass
+
+class AuthenticationError(LLMCycleError):
+    """401: Invalid API key. Disable key permanently."""
+    pass
+
+class ProviderError(LLMCycleError):
+    """400/500+: Provider-side error. Try next provider."""
+    pass
+
+class QuotaExceededError(LLMCycleError):
+    """402/429 with quota message: Key quota exhausted. Rotate key."""
+    pass
+
+class ContentPolicyError(LLMCycleError):
+    """400: Content policy violation. Do NOT retry - fail fast."""
+    pass
+
+class StreamInterruptedError(LLMCycleError):
+    """Mid-stream disconnection. Contains partial text generated so far."""
+    def __init__(self, message: str, partial_text: str = "", **kwargs):
+        super().__init__(message, **kwargs)
+        self.partial_text = partial_text
+
+class AllProvidersFailedError(LLMCycleError):
+    """Raised when every provider in the fallback chain fails."""
+    def __init__(self, errors: list):
+        msg = f"All {len(errors)} providers failed. Last error: {errors[-1]}"
+        super().__init__(msg)
+        self.errors = errors
+
+
+# Maps HTTP status codes to exception types
+def classify_http_error(status_code: int, response_text: str, provider: str, model: str) -> LLMCycleError:
+    """Factory: Convert an HTTP error into the correct LLMCycle exception."""
+    text_lower = response_text.lower()
+
+    if status_code == 401:
+        return AuthenticationError(f"[{provider}] Auth failed (401): {response_text}", provider=provider, model=model, status_code=status_code)
+
+    if status_code == 429:
+        if any(w in text_lower for w in ("quota", "limit exceeded", "exhausted", "billing")):
+            return QuotaExceededError(f"[{provider}] Quota exceeded (429): {response_text}", provider=provider, model=model, status_code=status_code)
+        return RateLimitError(f"[{provider}] Rate limited (429): {response_text}", provider=provider, model=model, status_code=status_code)
+
+    if status_code == 402:
+        return QuotaExceededError(f"[{provider}] Payment required (402): {response_text}", provider=provider, model=model, status_code=status_code)
+
+    if status_code == 400:
+        if any(w in text_lower for w in ("content_policy", "safety", "harmful", "violat")):
+            return ContentPolicyError(f"[{provider}] Content policy (400): {response_text}", provider=provider, model=model, status_code=status_code)
+        return ProviderError(f"[{provider}] Bad request (400): {response_text}", provider=provider, model=model, status_code=status_code)
+
+    # All other 4xx/5xx
+    return ProviderError(f"[{provider}] HTTP {status_code}: {response_text[:200]}", provider=provider, model=model, status_code=status_code)

llmcycle/core/keys.py

@@ -0,0 +1,184 @@
+"""
+KeyManager - Production Multi-Key Rotation
+==========================================
+Supports:
+ - Round-robin across multiple keys
+ - Rate-limit cooldown per key (auto re-enable after cooldown)
+ - Permanent disable on auth failure (401)
+ - Per-key error tracking with thresholds
+"""
+from __future__ import annotations
+import time
+import threading
+import hashlib
+import logging
+from enum import Enum
+from dataclasses import dataclass, field
+from typing import Optional, Dict, List
+
+logger = logging.getLogger(__name__)
+
+RATE_LIMIT_COOLDOWN_SECS = 60
+QUOTA_COOLDOWN_SECS = 3600
+
+class KeyStatus(Enum):
+    ACTIVE      = "active"
+    RATE_LIMITED = "rate_limited"   # 429 – temporary, retry after cooldown
+    QUOTA_EXHAUSTED = "quota_exhausted"  # 402/429 quota – long cooldown
+    INVALID     = "invalid"         # 401 – permanent disable
+    DISABLED    = "disabled"        # manual disable
+
+@dataclass
+class KeyRecord:
+    key: str
+    provider: str
+    status: KeyStatus = KeyStatus.ACTIVE
+    total_requests: int = 0
+    total_errors: int = 0
+    consecutive_errors: int = 0
+    rate_limit_until: float = 0.0
+    added_at: float = field(default_factory=time.time)
+    last_used: float = 0.0
+
+    @property
+    def key_hint(self) -> str:
+        """Safe display: show first 6 and last 4 chars."""
+        if len(self.key) <= 10:
+            return "***"
+        return f"{self.key[:6]}...{self.key[-4:]}"
+
+    @property
+    def is_usable(self) -> bool:
+        if self.status == KeyStatus.ACTIVE:
+            return True
+        if self.status in (KeyStatus.RATE_LIMITED, KeyStatus.QUOTA_EXHAUSTED):
+            return time.time() >= self.rate_limit_until
+        return False
+
+
+class KeyManager:
+    """Thread-safe multi-key manager with auto rotation and error classification."""
+
+    def __init__(self):
+        self._lock = threading.Lock()
+        # provider → list of KeyRecord (in insertion order for round-robin)
+        self._keys: Dict[str, List[KeyRecord]] = {}
+        # Round-robin pointer per provider
+        self._indexes: Dict[str, int] = {}
+
+    def add_key(self, provider: str, key: str) -> None:
+        """Register one API key for a provider."""
+        p = provider.lower()
+        with self._lock:
+            if p not in self._keys:
+                self._keys[p] = []
+                self._indexes[p] = 0
+            # Don't add duplicates
+            existing = {r.key for r in self._keys[p]}
+            if key not in existing:
+                self._keys[p].append(KeyRecord(key=key, provider=p))
+                logger.debug(f"[{p}] Registered key {KeyRecord(key=key, provider=p).key_hint}")
+
+    def add_keys(self, provider: str, keys: List[str]) -> None:
+        for k in keys:
+            self.add_key(provider, k)
+
+    def get_next_key(self, provider: str) -> Optional[str]:
+        """Round-robin rotation. Auto-recovers rate-limited keys after cooldown."""
+        p = provider.lower()
+        with self._lock:
+            records = self._keys.get(p, [])
+            if not records:
+                return None
+
+            n = len(records)
+            start = self._indexes[p]
+
+            for i in range(n):
+                idx = (start + i) % n
+                rec = records[idx]
+
+                # Auto-recover temporarily banned keys
+                if rec.status in (KeyStatus.RATE_LIMITED, KeyStatus.QUOTA_EXHAUSTED):
+                    if time.time() >= rec.rate_limit_until:
+                        rec.status = KeyStatus.ACTIVE
+                        rec.consecutive_errors = 0
+                        logger.info(f"[{p}] Key {rec.key_hint} auto-recovered from {rec.status.value}")
+
+                if rec.is_usable:
+                    self._indexes[p] = (idx + 1) % n
+                    rec.last_used = time.time()
+                    rec.total_requests += 1
+                    return rec.key
+
+            logger.warning(f"[{p}] No usable keys available!")
+            return None
+
+    def report_success(self, provider: str, key: str) -> None:
+        rec = self._find(provider, key)
+        if rec:
+            rec.consecutive_errors = 0
+
+    def report_error(self, provider: str, key: str, error_type: str) -> None:
+        """
+        error_type: "rate_limit" | "quota" | "auth" | "server" | "connection"
+        """
+        rec = self._find(provider, key)
+        if not rec:
+            return
+
+        rec.total_errors += 1
+        rec.consecutive_errors += 1
+
+        if error_type == "auth":
+            rec.status = KeyStatus.INVALID
+            logger.warning(f"[{provider}] Key {rec.key_hint} permanently disabled (401 Auth)")
+
+        elif error_type == "quota":
+            rec.status = KeyStatus.QUOTA_EXHAUSTED
+            rec.rate_limit_until = time.time() + QUOTA_COOLDOWN_SECS
+            logger.warning(f"[{provider}] Key {rec.key_hint} quota exhausted. Retry after {QUOTA_COOLDOWN_SECS}s")
+
+        elif error_type == "rate_limit":
+            rec.status = KeyStatus.RATE_LIMITED
+            rec.rate_limit_until = time.time() + RATE_LIMIT_COOLDOWN_SECS
+            logger.warning(f"[{provider}] Key {rec.key_hint} rate limited. Retry after {RATE_LIMIT_COOLDOWN_SECS}s")
+
+        elif error_type in ("server", "connection"):
+            # Don't ban the key, just note the error
+            logger.debug(f"[{provider}] Key {rec.key_hint} got {error_type} error (key kept active)")
+
+    def get_stats(self, provider: str) -> List[dict]:
+        p = provider.lower()
+        with self._lock:
+            return [
+                {
+                    "hint": r.key_hint,
+                    "status": r.status.value,
+                    "total_requests": r.total_requests,
+                    "total_errors": r.total_errors,
+                    "last_used": r.last_used,
+                }
+                for r in self._keys.get(p, [])
+            ]
+
+    def list_providers(self) -> List[str]:
+        return list(self._keys.keys())
+
+    def key_count(self, provider: str) -> dict:
+        p = provider.lower()
+        records = self._keys.get(p, [])
+        return {
+            "total": len(records),
+            "active": sum(1 for r in records if r.is_usable),
+            "invalid": sum(1 for r in records if r.status == KeyStatus.INVALID),
+            "rate_limited": sum(1 for r in records if r.status == KeyStatus.RATE_LIMITED),
+        }
+
+    def _find(self, provider: str, key: str) -> Optional[KeyRecord]:
+        p = provider.lower()
+        with self._lock:
+            for rec in self._keys.get(p, []):
+                if rec.key == key:
+                    return rec
+        return None

llmcycle/core/router.py

@@ -0,0 +1,37 @@
+import logging
+from abc import ABC, abstractmethod
+from typing import List, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+class RouterStrategy(ABC):
+    """Abstract strategy for sorting and selecting models."""
+    
+    @abstractmethod
+    def sort_models(self, requested_model: str) -> List[str]:
+        """Return a sorted list of fallback models."""
+        pass
+
+class FallbackRouter(RouterStrategy):
+    """A simple router that uses a pre-defined fallback list."""
+    
+    def __init__(self, fallbacks: Dict[str, List[str]]):
+        # e.g. {"gpt-4": ["gpt-4-turbo", "gpt-3.5-turbo"]}
+        self.fallbacks = fallbacks
+        
+    def sort_models(self, requested_model: str) -> List[str]:
+        # Always try the requested model first, then the fallbacks
+        models = [requested_model]
+        if requested_model in self.fallbacks:
+            models.extend(self.fallbacks[requested_model])
+        return models
+
+class ModelRouter:
+    """Main router class that manages strategies and routes requests."""
+    
+    def __init__(self, strategy: RouterStrategy):
+        self.strategy = strategy
+        
+    def get_route(self, requested_model: str) -> List[str]:
+        """Get ordered list of models to try."""
+        return self.strategy.sort_models(requested_model)

llmcycle/core/stream.py

@@ -0,0 +1,79 @@
+import logging
+from typing import AsyncGenerator
+from llmcycle.schema import CompletionRequest, Message
+from llmcycle.providers.base import LLMProvider
+from llmcycle.core.router import ModelRouter
+from llmcycle.core.keys import KeyManager
+
+logger = logging.getLogger(__name__)
+
+class StreamResilienceManager:
+    """
+    Handles streaming failover.
+    If a stream disconnects mid-response, this manager will capture
+    the text already generated, switch to a fallback model, append
+    the generated text to the assistant's context, and resume the stream.
+    """
+    
+    def __init__(
+        self, 
+        router: ModelRouter, 
+        key_manager: KeyManager, 
+        providers: dict[str, LLMProvider]
+    ):
+        self.router = router
+        self.key_manager = key_manager
+        self.providers = providers # map of model -> LLMProvider instance (simplified)
+
+    async def safe_stream(self, request: CompletionRequest) -> AsyncGenerator[str, None]:
+        models_to_try = self.router.get_route(request.model)
+        generated_text_so_far = ""
+        
+        for model in models_to_try:
+            if model not in self.providers:
+                logger.warning(f"No provider found for model {model}")
+                continue
+                
+            provider = self.providers[model]
+            api_key = self.key_manager.get_next_key(model) # Assumes provider uses model name for key lookups for simplicity
+            
+            if not api_key:
+                logger.warning(f"No active API keys available for model {model}")
+                continue
+                
+            try:
+                # If we're failing over mid-stream, we must update the prompt
+                # to include the generated_text_so_far
+                current_request = request.model_copy(deep=True)
+                current_request.model = model
+                
+                if generated_text_so_far:
+                    current_request.messages.append(
+                        Message(role="assistant", content=generated_text_so_far)
+                    )
+                    # Ideally, you'd instruct the fallback model to continue from here
+                    current_request.messages.append(
+                        Message(role="user", content="Continue exactly from the last assistant message. Do not repeat anything. Just continue.")
+                    )
+
+                logger.info(f"Attempting stream with model {model}")
+                stream_gen = provider.generate_stream(current_request, api_key)
+                
+                async for chunk in stream_gen:
+                    generated_text_so_far += chunk
+                    yield chunk
+                    
+                # If we finish the stream without exceptions, we are done!
+                return
+                
+            except Exception as e:
+                logger.error(f"Stream interrupted on model {model}: {e}")
+                self.key_manager.report_error(api_key, "connection_error")
+                logger.info("Failing over to next model in sequence...")
+                # The loop will continue and try the next model
+        
+        # If we exit the loop, all models failed
+        if not generated_text_so_far:
+            raise RuntimeError("All models failed and no text was generated.")
+        else:
+            logger.error("All models failed, but some text was generated.")

llmcycle/providers/base.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+from typing import AsyncGenerator
+from llmcycle.schema import CompletionRequest
+
+class LLMProvider(ABC):
+    """Base class for all specific LLM implementations."""
+    
+    @abstractmethod
+    async def generate(self, request: CompletionRequest, api_key: str) -> str:
+        """Generate a complete string response."""
+        pass
+
+    @abstractmethod
+    async def generate_stream(self, request: CompletionRequest, api_key: str) -> AsyncGenerator[str, None]:
+        """Generate a streaming response."""
+        pass
+        
+    @abstractmethod
+    async def get_models(self, api_key: str) -> list[str]:
+        """Return a list of models supported by this provider."""
+        pass

llmcycle/providers/openai_compatible.py

@@ -0,0 +1,56 @@
+import httpx
+from typing import AsyncGenerator
+from llmcycle.schema import CompletionRequest
+from llmcycle.providers.base import LLMProvider
+
+class OpenAICompatibleProvider(LLMProvider):
+    """A generic provider for OpenAI-compatible APIs (OpenAI, DeepSeek, Together, etc)."""
+    
+    def __init__(self, base_url: str):
+        # Ensure base_url ends with /v1 or whatever is passed
+        self.base_url = base_url.rstrip('/')
+        
+    async def get_models(self, api_key: str) -> list[str]:
+        headers = {"Authorization": f"Bearer {api_key}"}
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(f"{self.base_url}/models", headers=headers, timeout=5.0)
+                response.raise_for_status()
+                data = response.json()
+                if "data" in data:
+                    return [model["id"] for model in data["data"]]
+                return []
+            except Exception as e:
+                print(f"Failed to fetch models from {self.base_url}: {e}")
+                return []
+
+    async def generate(self, request: CompletionRequest, api_key: str) -> str:
+        headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+        async with httpx.AsyncClient() as client:
+            payload = request.model_dump(exclude_none=True)
+            payload["stream"] = False
+            response = await client.post(f"{self.base_url}/chat/completions", headers=headers, json=payload, timeout=60.0)
+            response.raise_for_status()
+            return response.json()["choices"][0]["message"]["content"]
+
+    async def generate_stream(self, request: CompletionRequest, api_key: str) -> AsyncGenerator[str, None]:
+        headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+        async with httpx.AsyncClient() as client:
+            payload = request.model_dump(exclude_none=True)
+            payload["stream"] = True
+            
+            async with client.stream("POST", f"{self.base_url}/chat/completions", headers=headers, json=payload) as response:
+                response.raise_for_status()
+                async for chunk in response.aiter_text():
+                    # Simplified parsing of Server-Sent Events (SSE)
+                    if chunk.startswith("data: "):
+                        import json
+                        data_str = chunk[6:].strip()
+                        if data_str == "[DONE]":
+                            break
+                        try:
+                            data = json.loads(data_str)
+                            if data["choices"][0]["delta"].get("content"):
+                                yield data["choices"][0]["delta"]["content"]
+                        except json.JSONDecodeError:
+                            pass

llmcycle/providers/registry.py

@@ -0,0 +1,105 @@
+"""
+Universal Provider Registry
+============================
+50+ providers mapped by their env var prefix → base URL.
+All are OpenAI-compatible REST API endpoints.
+Custom provider: set MYPROVIDER_API_KEYS + MYPROVIDER_BASE_URL.
+"""
+
+PROVIDER_REGISTRY: dict[str, str] = {
+    # ── Frontier / Big Cloud ──────────────────────────────────────────────
+    "OPENAI":           "https://api.openai.com/v1",
+    "AZURE":            "https://{resource}.openai.azure.com/openai",   # needs override
+    "ANTHROPIC":        "https://api.anthropic.com/v1",
+    "GOOGLE":           "https://generativelanguage.googleapis.com/v1beta",
+    "VERTEXAI":         "https://us-central1-aiplatform.googleapis.com/v1",
+    "AWS_BEDROCK":      "https://bedrock-runtime.us-east-1.amazonaws.com",
+
+    # ── Chinese / Asia ────────────────────────────────────────────────────
+    "DEEPSEEK":         "https://api.deepseek.com/v1",
+    "QWEN":             "https://dashscope.aliyuncs.com/compatible-mode/v1",
+    "DASHSCOPE":        "https://dashscope.aliyuncs.com/compatible-mode/v1",
+    "MOONSHOT":         "https://api.moonshot.cn/v1",
+    "MINIMAX":          "https://api.minimax.chat/v1",
+    "ZHIPU":            "https://open.bigmodel.cn/api/paas/v4",
+    "BAIDU":            "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop",
+    "VOLCANO":          "https://ark.cn-beijing.volces.com/api/v3",
+    "XIAOMI":           "https://api.mimo.xiaomi.com/v1",
+    "ZAI":              "https://open.bigmodel.cn/api/paas/v4",
+
+    # ── Fast Inference / Aggregators ─────────────────────────────────────
+    "GROQ":             "https://api.groq.com/openai/v1",
+    "TOGETHER":         "https://api.together.xyz/v1",
+    "FIREWORKS":        "https://api.fireworks.ai/inference/v1",
+    "ANYSCALE":         "https://api.endpoints.anyscale.com/v1",
+    "PERPLEXITY":       "https://api.perplexity.ai",
+    "OPENROUTER":       "https://openrouter.ai/api/v1",
+    "REPLICATE":        "https://api.replicate.com/v1",
+    "DEEPINFRA":        "https://api.deepinfra.com/v1/openai",
+    "FEATHERLESS":      "https://api.featherless.ai/v1",
+    "NOVITA":           "https://api.novita.ai/v3/openai",
+    "CHUTES":           "https://llm.chutes.ai/v1",
+    "NSCALE":           "https://inference.api.nscale.com/v1",
+    "NEBIUS":           "https://api.studio.nebius.ai/v1",
+    "HYPERBOLIC":       "https://api.hyperbolic.xyz/v1",
+    "LAMBDA":           "https://api.lambdalabs.com/v1",
+    "SAMBANOVA":        "https://api.sambanova.ai/v1",
+    "CEREBRAS":         "https://api.cerebras.ai/v1",
+    "FRIENDLIAI":       "https://inference.friendli.ai/v1",
+    "GALADRIEL":        "https://api.galadriel.com/v1",
+    "GMI":              "https://api.gmi.cloud/v1",
+    "PUBLICAI":         "https://api.public.ai/v1",
+    "COMETAPI":         "https://api.comet.ai/v1",
+    "AIML":             "https://api.aimlapi.com/v1",
+
+    # ── Specialized Providers ─────────────────────────────────────────────
+    "MISTRAL":          "https://api.mistral.ai/v1",
+    "CODESTRAL":        "https://codestral.mistral.ai/v1",
+    "COHERE":           "https://api.cohere.com/v1",
+    "AI21":             "https://api.ai21.com/studio/v1",
+    "NLP_CLOUD":        "https://api.nlpcloud.io/v1",
+    "ALEPH_ALPHA":      "https://api.aleph-alpha.com",
+    "PREDIBASE":        "https://serving.app.predibase.com",
+    "CLARIFAI":         "https://api.clarifai.com/v2",
+    "HUGGINGFACE":      "https://api-inference.huggingface.co/models",
+    "BASETEN":          "https://model-{model_id}.api.baseten.co/environments/production/predict",
+    "GRADIENT":         "https://api.gradient.ai/api",
+
+    # ── Local / Self-Hosted ───────────────────────────────────────────────
+    "OLLAMA":           "http://localhost:11434/v1",
+    "LM_STUDIO":        "http://localhost:1234/v1",
+    "VLLM":             "http://localhost:8000/v1",
+    "LLAMAFILE":        "http://localhost:8080/v1",
+    "TRITON":           "http://localhost:8001/v2",
+    "XINFERENCE":       "http://localhost:9997/v1",
+    "DOCKER_MODEL":     "http://localhost:12434/engines/llama.cpp/v1",
+
+    # ── Enterprise / Cloud ────────────────────────────────────────────────
+    "DATABRICKS":       "https://{workspace}.azuredatabricks.net/serving-endpoints",
+    "SAGEMAKER":        "https://runtime.sagemaker.us-east-1.amazonaws.com",
+    "SNOWFLAKE":        "https://{account}.snowflakecomputing.com/api/v2",
+    "WATSONX":          "https://us-south.ml.cloud.ibm.com/ml/v1",
+    "SAP":              "https://api.ai.internalprod.eu-central-1.aws.ml.hana.ondemand.com",
+    "OCI":              "https://inference.generativeai.us-chicago-1.oci.customer-oci.com/20231130",
+    "CLOUDFLARE":       "https://api.cloudflare.com/client/v4/accounts/{account_id}/ai/run",
+    "HEROKU":           "https://llm.api.heroku.com/v1",
+    "OVH":              "https://oai.endpoints.kepler.ai.cloud.ovh.net/api/openai_compat/v1",
+    "SCALEWAY":         "https://api.scaleway.ai/v1",
+    "DATAROBOT":        "https://app.datarobot.com/api/v2",
+
+    # ── Nvidia ────────────────────────────────────────────────────────────
+    "NVIDIA":           "https://integrate.api.nvidia.com/v1",
+    "NVIDIA_NIM":       "https://integrate.api.nvidia.com/v1",
+
+    # ── GitHub / Microsoft ────────────────────────────────────────────────
+    "GITHUB":           "https://models.inference.ai.azure.com",
+    "VERCEL":           "https://ai-gateway.vercel.sh",
+    "XAI":              "https://api.x.ai/v1",
+
+    # ── Image Generation ─────────────────────────────────────────────────
+    "STABILITY":        "https://api.stability.ai/v1",
+    "FAL":              "https://fal.run",
+    "RECRAFT":          "https://external.api.recraft.ai/v1",
+    "RUNWAYML":         "https://api.dev.runwayml.com/v1",
+    "BLACK_FOREST":     "https://api.us1.bfl.ai/v1",
+}

llmcycle/schema.py

@@ -0,0 +1,47 @@
+"""
+Production schema models with Pydantic v2.
+"""
+from __future__ import annotations
+from typing import Optional, List, Dict, Any, Union
+from pydantic import BaseModel, Field
+import time
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+class CompletionRequest(BaseModel):
+    model: str
+    messages: List[Message]
+    stream: bool = False
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    top_p: Optional[float] = None
+    frequency_penalty: Optional[float] = None
+    presence_penalty: Optional[float] = None
+    stop: Optional[Union[str, List[str]]] = None
+    extra: Optional[Dict[str, Any]] = None
+
+    def to_api_dict(self) -> dict:
+        """Serialize for sending to OpenAI-compatible API."""
+        d = self.model_dump(exclude_none=True, exclude={"extra"})
+        d["messages"] = [m.model_dump() for m in self.messages]
+        if self.extra:
+            d.update(self.extra)
+        return d
+
+class CompletionResponse(BaseModel):
+    id: str
+    model: str
+    provider: str
+    content: str
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    latency_ms: float = 0.0
+    created_at: float = Field(default_factory=time.time)
+
+class StreamChunk(BaseModel):
+    content: str
+    model: str
+    provider: str
+    done: bool = False

llmcycle/ui/__init__.py

@@ -0,0 +1 @@
+"""UI Package."""

llmcycle/ui/app.py

@@ -0,0 +1,88 @@
+import os
+import secrets
+from fastapi import FastAPI, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from typing import List, Dict, Any
+from llmcycle import LLMCycle
+from pathlib import Path
+
+app = FastAPI(title="LLMCycle API Dashboard")
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="api/token")
+
+# Static token for simplicity in this MVP. For prod, use JWTs.
+SESSION_TOKEN = secrets.token_urlsafe(32)
+
+# Path to templates/static
+BASE_DIR = Path(__file__).resolve().parent
+templates_dir = BASE_DIR / "templates"
+
+# Global Client Instance
+llm_client = LLMCycle()
+
+# Models
+class ProviderInfo(BaseModel):
+    name: str
+    base_url: str
+    total_keys: int
+    active_keys: int
+
+class DashboardData(BaseModel):
+    providers: List[ProviderInfo]
+    fallbacks: Dict[str, List[str]]
+
+@app.post("/api/token")
+async def login(form_data: OAuth2PasswordRequestForm = Depends()):
+    correct_username = os.environ.get("LLMCYCLE_USER_ADMIN", "admin")
+    correct_password = os.environ.get("LLMCYCLE_USER_ADMIN_PAASWORD", "admin")
+    
+    if not (secrets.compare_digest(form_data.username, correct_username) and 
+            secrets.compare_digest(form_data.password, correct_password)):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    return {"access_token": SESSION_TOKEN, "token_type": "bearer"}
+
+async def verify_token(token: str = Depends(oauth2_scheme)):
+    if not secrets.compare_digest(token, SESSION_TOKEN):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication credentials",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return token
+
+@app.get("/api/dashboard", response_model=DashboardData)
+async def get_dashboard_data(token: str = Depends(verify_token)):
+    """Protected API endpoint returning all dashboard data as JSON."""
+    providers = llm_client.get_available_providers()
+    
+    provider_details = []
+    for p in providers:
+        keys_list = llm_client.key_manager._keys.get(p, [])
+        active_keys = 0
+        for k in keys_list:
+            stats = llm_client.key_manager._stats.get(k)
+            if stats and stats.is_active:
+                active_keys += 1
+                
+        provider_details.append(ProviderInfo(
+            name=p.upper(),
+            base_url=llm_client.providers[p].base_url,
+            total_keys=len(keys_list),
+            active_keys=active_keys
+        ))
+        
+    fallbacks = llm_client.router.strategy.fallbacks if hasattr(llm_client.router.strategy, 'fallbacks') else {}
+    
+    return DashboardData(providers=provider_details, fallbacks=fallbacks)
+
+@app.get("/")
+async def serve_ui():
+    """Serve the static HTML frontend."""
+    return FileResponse(templates_dir / "dashboard.html")

llmcycle/ui/templates/dashboard.html

@@ -0,0 +1,378 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>LLMCycle API Dashboard</title>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;600;800&display=swap" rel="stylesheet">
+    <style>
+        :root {
+            --bg: #0a0a0f;
+            --glass-bg: rgba(255, 255, 255, 0.03);
+            --glass-border: rgba(255, 255, 255, 0.08);
+            --primary: #6366f1;
+            --primary-glow: rgba(99, 102, 241, 0.4);
+            --text-main: #f8fafc;
+            --text-muted: #94a3b8;
+            --success: #10b981;
+            --error: #ef4444;
+        }
+
+        body {
+            margin: 0;
+            padding: 0;
+            background-color: var(--bg);
+            color: var(--text-main);
+            font-family: 'Inter', sans-serif;
+            min-height: 100vh;
+            background-image: 
+                radial-gradient(circle at 15% 50%, rgba(99, 102, 241, 0.15), transparent 25%),
+                radial-gradient(circle at 85% 30%, rgba(168, 85, 247, 0.15), transparent 25%);
+            background-attachment: fixed;
+        }
+
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 40px 20px;
+        }
+
+        header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 50px;
+        }
+
+        h1 {
+            font-weight: 800;
+            font-size: 2.5rem;
+            margin: 0;
+            background: linear-gradient(135deg, #a855f7, #6366f1);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            text-shadow: 0 0 30px var(--primary-glow);
+        }
+
+        .user-badge {
+            background: var(--glass-bg);
+            border: 1px solid var(--glass-border);
+            padding: 8px 16px;
+            border-radius: 20px;
+            backdrop-filter: blur(10px);
+            font-size: 0.9rem;
+            color: var(--text-muted);
+            cursor: pointer;
+        }
+        
+        .user-badge:hover {
+            border-color: rgba(239, 68, 68, 0.5);
+            color: var(--error);
+        }
+
+        .grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+            gap: 24px;
+        }
+
+        .card {
+            background: var(--glass-bg);
+            border: 1px solid var(--glass-border);
+            border-radius: 16px;
+            padding: 24px;
+            backdrop-filter: blur(12px);
+            transition: transform 0.3s ease, box-shadow 0.3s ease;
+            position: relative;
+            overflow: hidden;
+        }
+
+        .card::before {
+            content: "";
+            position: absolute;
+            top: 0; left: 0; right: 0;
+            height: 1px;
+            background: linear-gradient(90deg, transparent, rgba(255,255,255,0.2), transparent);
+        }
+
+        .card:hover {
+            transform: translateY(-5px);
+            box-shadow: 0 10px 30px -10px var(--primary-glow);
+            border-color: rgba(99, 102, 241, 0.3);
+        }
+
+        .card-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 16px;
+        }
+
+        .card-title {
+            font-size: 1.25rem;
+            font-weight: 600;
+            margin: 0;
+        }
+
+        .status-dot {
+            width: 10px;
+            height: 10px;
+            background-color: var(--success);
+            border-radius: 50%;
+            box-shadow: 0 0 10px var(--success);
+            animation: pulse 2s infinite;
+        }
+
+        @keyframes pulse {
+            0% { box-shadow: 0 0 0 0 rgba(16, 185, 129, 0.4); }
+            70% { box-shadow: 0 0 0 10px rgba(16, 185, 129, 0); }
+            100% { box-shadow: 0 0 0 0 rgba(16, 185, 129, 0); }
+        }
+
+        .metric {
+            display: flex;
+            justify-content: space-between;
+            margin-bottom: 8px;
+            color: var(--text-muted);
+            font-size: 0.95rem;
+        }
+
+        .metric span.value {
+            color: var(--text-main);
+            font-weight: 600;
+        }
+
+        .url {
+            font-size: 0.8rem;
+            color: var(--primary);
+            word-break: break-all;
+            background: rgba(99, 102, 241, 0.1);
+            padding: 4px 8px;
+            border-radius: 6px;
+            margin-top: 12px;
+            display: inline-block;
+        }
+
+        .section-title {
+            margin: 40px 0 20px 0;
+            font-size: 1.5rem;
+            font-weight: 600;
+            color: var(--text-main);
+        }
+        
+        /* Login Form Styles */
+        #login-view {
+            max-width: 400px;
+            margin: 100px auto;
+            text-align: center;
+        }
+        
+        input {
+            width: 100%;
+            padding: 12px;
+            margin-bottom: 16px;
+            border-radius: 8px;
+            border: 1px solid var(--glass-border);
+            background: rgba(0,0,0,0.2);
+            color: white;
+            box-sizing: border-box;
+            font-family: 'Inter', sans-serif;
+        }
+        
+        input:focus {
+            outline: none;
+            border-color: var(--primary);
+        }
+        
+        button {
+            width: 100%;
+            padding: 12px;
+            border-radius: 8px;
+            border: none;
+            background: linear-gradient(135deg, #6366f1, #a855f7);
+            color: white;
+            font-weight: 600;
+            cursor: pointer;
+            font-family: 'Inter', sans-serif;
+            transition: opacity 0.2s;
+        }
+        
+        button:hover {
+            opacity: 0.9;
+        }
+        
+        #error-msg {
+            color: var(--error);
+            margin-bottom: 16px;
+            font-size: 0.9rem;
+            display: none;
+        }
+
+    </style>
+</head>
+<body>
+    <div class="container">
+        
+        <!-- LOGIN VIEW -->
+        <div id="login-view">
+            <h1 style="margin-bottom: 30px;">LLMCycle Login</h1>
+            <div id="error-msg">Invalid username or password.</div>
+            <form id="login-form">
+                <input type="text" id="username" placeholder="Username" required>
+                <input type="password" id="password" placeholder="Password" required>
+                <button type="submit">Authenticate</button>
+            </form>
+        </div>
+
+        <!-- DASHBOARD VIEW -->
+        <div id="dashboard-view" style="display: none;">
+            <header>
+                <h1>LLMCycle ♻️</h1>
+                <div class="user-badge" id="logout-btn">Log Out</div>
+            </header>
+
+            <h2 class="section-title">Active Providers</h2>
+            <div class="grid" id="providers-container">
+                <!-- Dynamically populated -->
+            </div>
+
+            <h2 class="section-title">Fallback Routing Logic</h2>
+            <div class="card" style="max-width: 600px;" id="fallbacks-container">
+                <!-- Dynamically populated -->
+            </div>
+        </div>
+
+    </div>
+
+    <script>
+        const loginView = document.getElementById('login-view');
+        const dashboardView = document.getElementById('dashboard-view');
+        const loginForm = document.getElementById('login-form');
+        const errorMsg = document.getElementById('error-msg');
+        const logoutBtn = document.getElementById('logout-btn');
+
+        // Check if token exists
+        let token = localStorage.getItem('llmcycle_token');
+        
+        if (token) {
+            loadDashboard();
+        } else {
+            loginView.style.display = 'block';
+        }
+
+        // Handle Login
+        loginForm.addEventListener('submit', async (e) => {
+            e.preventDefault();
+            const formData = new URLSearchParams();
+            formData.append('username', document.getElementById('username').value);
+            formData.append('password', document.getElementById('password').value);
+
+            try {
+                const response = await fetch('/api/token', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                    body: formData
+                });
+
+                if (response.ok) {
+                    const data = await response.json();
+                    localStorage.setItem('llmcycle_token', data.access_token);
+                    token = data.access_token;
+                    errorMsg.style.display = 'none';
+                    loadDashboard();
+                } else {
+                    errorMsg.style.display = 'block';
+                }
+            } catch (err) {
+                console.error(err);
+                errorMsg.style.display = 'block';
+            }
+        });
+        
+        // Handle Logout
+        logoutBtn.addEventListener('click', () => {
+            localStorage.removeItem('llmcycle_token');
+            token = null;
+            dashboardView.style.display = 'none';
+            loginView.style.display = 'block';
+            document.getElementById('password').value = '';
+        });
+
+        // Fetch API and Build UI
+        async function loadDashboard() {
+            try {
+                const response = await fetch('/api/dashboard', {
+                    headers: { 'Authorization': `Bearer ${token}` }
+                });
+
+                if (response.status === 401) {
+                    // Token invalid
+                    localStorage.removeItem('llmcycle_token');
+                    loginView.style.display = 'block';
+                    dashboardView.style.display = 'none';
+                    return;
+                }
+
+                const data = await response.json();
+                renderDashboard(data);
+                
+                loginView.style.display = 'none';
+                dashboardView.style.display = 'block';
+            } catch (err) {
+                console.error('Failed to load dashboard', err);
+            }
+        }
+
+        function renderDashboard(data) {
+            const pContainer = document.getElementById('providers-container');
+            const fContainer = document.getElementById('fallbacks-container');
+            
+            pContainer.innerHTML = '';
+            fContainer.innerHTML = '';
+
+            // Providers
+            if (data.providers.length === 0) {
+                pContainer.innerHTML = `
+                    <div class="card" style="grid-column: 1 / -1; text-align: center; border-style: dashed;">
+                        <p style="color: var(--text-muted);">No providers detected. Add API keys to your .env file.</p>
+                    </div>`;
+            } else {
+                data.providers.forEach(p => {
+                    pContainer.innerHTML += `
+                        <div class="card">
+                            <div class="card-header">
+                                <h3 class="card-title">${p.name}</h3>
+                                <div class="status-dot"></div>
+                            </div>
+                            <div class="metric">
+                                <span>Total Keys:</span>
+                                <span class="value">${p.total_keys}</span>
+                            </div>
+                            <div class="metric">
+                                <span>Active Keys:</span>
+                                <span class="value">${p.active_keys}</span>
+                            </div>
+                            <div class="url">${p.base_url}</div>
+                        </div>`;
+                });
+            }
+
+            // Fallbacks
+            const fKeys = Object.keys(data.fallbacks);
+            if (fKeys.length === 0) {
+                fContainer.innerHTML = `<p style="color: var(--text-muted); margin: 0;">No custom fallback routes configured.</p>`;
+            } else {
+                fKeys.forEach(primary => {
+                    const secondaries = data.fallbacks[primary].join(', ');
+                    fContainer.innerHTML += `
+                        <div class="metric" style="align-items: center; border-bottom: 1px solid var(--glass-border); padding-bottom: 12px; margin-bottom: 12px;">
+                            <span style="font-weight: 600; color: #a855f7;">${primary}</span>
+                            <span style="color: var(--text-muted); margin: 0 10px;">➜ falls back to ➜</span>
+                            <span style="font-weight: 600;">${secondaries}</span>
+                        </div>`;
+                });
+            }
+        }
+    </script>
+</body>
+</html>

llmcycle-0.1.0.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: llmcycle
+Version: 0.1.0
+Summary: Cycle through multiple LLM providers with smart fallback, load balancing, and unified API
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.136.1
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: python-multipart>=0.0.29
+Requires-Dist: uvicorn>=0.47.0
+Description-Content-Type: text/markdown
+
+# LLMCycle ♻️
+
+An enterprise-grade, highly resilient LLM management and routing framework. Designed to be **better than LiteLLM** with advanced multi-key support, customized routing (sort order), robust mid-stream error failovers, and a premium **Web Dashboard**.
+
+## 🚀 Key Features
+
+*   **🔑 Universal Provider Support**: Supports *any* provider on the market instantly. Just add `<PROVIDER_NAME>_API_KEYS` to your `.env`!
+*   **⚖️ Auto Load-Balancing**: Load multiple API keys for the same provider simply by comma-separating them in your `.env`. LLMCycle automatically round-robins across them and tracks rate limits locally.
+*   **🛣️ Custom Fallback Routing**: Configure custom routing. If a primary provider fails, it automatically falls back to your configured secondary.
+*   **🛡️ Streaming Time Resilience**: If an LLM disconnects *while streaming a response*, LLMCycle captures the generated text, silently switches to your fallback model, and resumes the stream seamlessly. The client never notices!
+*   **🖥️ Premium Web Dashboard**: Manage and view your keys, active providers, and fallback routes through a beautifully designed, secure UI.
+
+## 📦 Installation
+
+```bash
+uv add llmcycle
+uv add python-dotenv httpx fastapi uvicorn jinja2 python-multipart
+```
+
+## ⚙️ Configuration (`.env`)
+
+Drop your keys into a `.env` file. To use multiple keys for load balancing, just separate them with commas!
+
+```env
+DEEPSEEK_API_KEYS=sk-deepseek-1,sk-deepseek-2
+OPENAI_API_KEYS=sk-openai-primary
+TOGETHER_API_KEYS=sk-together-1
+
+# You can even use completely custom providers!
+# LLMCycle will default the base URL to https://api.mycustomai.com/v1
+MYCUSTOMAI_API_KEYS=sk-custom
+# Or explicitly define the base URL for custom providers
+OLLAMA_API_KEYS=local
+OLLAMA_BASE_URL=http://localhost:11434/v1
+
+# UI Dashboard Auth
+LLMCYCLE_USER_ADMIN=admin
+LLMCYCLE_USER_ADMIN_PAASWORD=admin
+```
+
+## 🖥️ Starting the Web Dashboard
+
+We built a gorgeous, premium Glassmorphism dashboard to monitor your providers.
+
+```bash
+# Make sure your PYTHONPATH is set if running from source:
+# Windows: $env:PYTHONPATH="src"
+# Linux/Mac: export PYTHONPATH="src"
+
+uv run llmcycle ui
+```
+*Navigate to `http://127.0.0.1:8000` and login with the credentials defined in your `.env`!*
+
+## 💻 Usage: Everything in One!
+
+```python
+import asyncio
+from llmcycle import LLMCycle
+
+async def main():
+    # 1. Initialization (Auto-loads all providers & keys from .env)
+    client = LLMCycle(
+        env_path=".env",
+        custom_fallbacks={
+            "deepseek": ["openai", "together"] # Sort order / Fallback chain
+        }
+    )
+    
+    # 2. List all dynamically loaded providers
+    providers = client.get_available_providers()
+    print("Loaded Providers:", providers) 
+    
+    # 3. Query models supported by a provider
+    models = await client.get_provider_models("deepseek")
+    print("DeepSeek Models:", models)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## 🔌 Massive Universal Provider Registry
+
+LLMCycle is pre-configured with base URLs for the most popular platforms:
+`OPENAI`, `DEEPSEEK`, `ANTHROPIC`, `TOGETHER`, `GROQ`, `MISTRAL`, `PERPLEXITY`, `ANYSCALE`, `FIREWORKS`, `COHERE`, `DATABRICKS`, `HUGGINGFACE`.
+
+**Wildcard Support:** If you type `RANDOM_API_KEYS`, LLMCycle will automatically assume `https://api.random.com/v1`. If that's wrong, just define `RANDOM_BASE_URL` in your `.env`!

llmcycle-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+llmcycle/__init__.py,sha256=JajfAd6eO65ZR5mcqSFaFH55qrlUtUTB25jIgVaMEXQ,921
+llmcycle/cli.py,sha256=SFD1mMmVNlDPWjseSxpCIM3roVLccVxVRwKX2jZGTzw,613
+llmcycle/client.py,sha256=WZepJ5-pBK26F7u1DPVQ-lcUMwop-dHEEldvnZCXhu4,3100
+llmcycle/schema.py,sha256=en8KR8u4uhgd40OsnJ7gGtdGdbtUaVWGCndlgdQYS-8,1293
+llmcycle/core/errors.py,sha256=yL8HWqKGTl8DIfr1wqOPBxXI4xXbbTz6KCy82QLQI5A,3208
+llmcycle/core/keys.py,sha256=CUUqNXhP2VO7Ov3kIcAesBcMH7zdpmJ6Uh9zbeQ0Ews,6585
+llmcycle/core/router.py,sha256=RNR1CE7lq4k9R_WS1szyf458MNTDh6-9O77pxpEt-DE,1291
+llmcycle/core/stream.py,sha256=Cxr3G7-MEs_LoPgj2snDvairrgml7SOuFytEweEUFqQ,3397
+llmcycle/providers/base.py,sha256=u7pegcCUA4HhLcvMVyW1JKqJvSdM_2OmLHzJ_6YKTHM,722
+llmcycle/providers/openai_compatible.py,sha256=FR5AOAstzE9eDTKo3Gv2fRiyghVP_IxWYRUGlwsK93Y,2829
+llmcycle/providers/registry.py,sha256=v1g0bpBqPI14tdrS0HM_F4B-16d0AfRVvOENiU-aWW4,6747
+llmcycle/ui/__init__.py,sha256=tUoGY9CO2NW1BZ5oOJ1Es1QB_qEMRr2uTGDhreaB2Nw,18
+llmcycle/ui/app.py,sha256=OAZK0Mo8Lj6loayG04G4nxNIXSLQvvBiNuCFxbkmV6Y,3040
+llmcycle/ui/templates/dashboard.html,sha256=vt2E6qgVL7SR1NYIlcoNW45p6WhPUVXVXIrZa-_GFT4,12744
+llmcycle-0.1.0.dist-info/METADATA,sha256=Jd_PQqNiLYZB1sZ9LrDku0M9zF0wIDQPqQsnHM3sihw,3874
+llmcycle-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+llmcycle-0.1.0.dist-info/entry_points.txt,sha256=F8C9GmojlaRYpS_ru_t0MwL7Ju06fZLy1KqJlVaDuck,47
+llmcycle-0.1.0.dist-info/RECORD,,

llmcycle-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

llmcycle-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+llmcycle = llmcycle.cli:main