From 4e6f74227209efcd0efb58d04a99103b1d3c85a8 Mon Sep 17 00:00:00 2001 From: Vardhman Gupta Date: Mon, 31 Aug 2026 17:33:38 +0530 Subject: [PATCH] feat: complete production-quality Model Router AI traffic control platform --- .env.example | 39 + .gitignore | 44 + LICENSE | 21 + README.md | 92 + SECURITY.md | 10 + backend/app/analytics/service.py | 119 ++ backend/app/analyzer/analyzer.py | 67 + backend/app/analyzer/heuristics.py | 192 ++ backend/app/api/routes.py | 532 +++++ backend/app/budgets/manager.py | 39 + backend/app/cli/main.py | 269 +++ backend/app/config/settings.py | 43 + backend/app/experiments/service.py | 85 + backend/app/fallback/handler.py | 105 + backend/app/models/schemas.py | 127 ++ backend/app/observability/events.py | 43 + backend/app/providers/base.py | 46 + backend/app/providers/external_providers.py | 321 +++ backend/app/providers/mock_provider.py | 108 + backend/app/providers/ollama_provider.py | 141 ++ backend/app/providers/registry.py | 35 + backend/app/router/engine.py | 150 ++ backend/app/router/rules_engine.py | 73 + backend/app/router/scoring.py | 154 ++ backend/app/storage/database.py | 366 ++++ backend/app/storage/models.py | 202 ++ backend/main.py | 94 + backend/requirements.txt | 15 + backend/tests/test_analyzer.py | 41 + backend/tests/test_e2e.py | 66 + backend/tests/test_providers.py | 21 + backend/tests/test_router.py | 78 + docker-compose.yml | 24 + frontend/.gitignore | 24 + frontend/index.html | 16 + frontend/package-lock.json | 2114 +++++++++++++++++++ frontend/package.json | 26 + frontend/postcss.config.js | 6 + frontend/public/favicon.png | Bin 0 -> 155750 bytes frontend/public/favicon.svg | 1 + frontend/public/icons.svg | 24 + frontend/public/logo.png | Bin 0 -> 155750 bytes frontend/src/App.tsx | 50 + frontend/src/assets/hero.png | Bin 0 -> 13057 bytes frontend/src/assets/typescript.svg | 1 + frontend/src/assets/vite.svg | 1 + frontend/src/components/Navbar.tsx | 118 ++ frontend/src/components/RoutingMap.tsx | 304 +++ frontend/src/counter.ts | 9 + frontend/src/index.css | 94 + frontend/src/lib/api.ts | 17 + frontend/src/main.tsx | 10 + frontend/src/pages/Analytics.tsx | 267 +++ frontend/src/pages/Dashboard.tsx | 264 +++ frontend/src/pages/Models.tsx | 322 +++ frontend/src/pages/Playground.tsx | 502 +++++ frontend/src/pages/Rules.tsx | 287 +++ frontend/src/pages/SettingsPage.tsx | 95 + frontend/src/pages/Traffic.tsx | 120 ++ frontend/src/style.css | 296 +++ frontend/src/types/index.ts | 158 ++ frontend/src/vite-env.d.ts | 2 + frontend/tailwind.config.js | 40 + frontend/tsconfig.json | 20 + pytest.ini | 4 + requirements.txt | 15 + 66 files changed, 8969 insertions(+) create mode 100644 .env.example create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 README.md create mode 100644 SECURITY.md create mode 100644 backend/app/analytics/service.py create mode 100644 backend/app/analyzer/analyzer.py create mode 100644 backend/app/analyzer/heuristics.py create mode 100644 backend/app/api/routes.py create mode 100644 backend/app/budgets/manager.py create mode 100644 backend/app/cli/main.py create mode 100644 backend/app/config/settings.py create mode 100644 backend/app/experiments/service.py create mode 100644 backend/app/fallback/handler.py create mode 100644 backend/app/models/schemas.py create mode 100644 backend/app/observability/events.py create mode 100644 backend/app/providers/base.py create mode 100644 backend/app/providers/external_providers.py create mode 100644 backend/app/providers/mock_provider.py create mode 100644 backend/app/providers/ollama_provider.py create mode 100644 backend/app/providers/registry.py create mode 100644 backend/app/router/engine.py create mode 100644 backend/app/router/rules_engine.py create mode 100644 backend/app/router/scoring.py create mode 100644 backend/app/storage/database.py create mode 100644 backend/app/storage/models.py create mode 100644 backend/main.py create mode 100644 backend/requirements.txt create mode 100644 backend/tests/test_analyzer.py create mode 100644 backend/tests/test_e2e.py create mode 100644 backend/tests/test_providers.py create mode 100644 backend/tests/test_router.py create mode 100644 docker-compose.yml create mode 100644 frontend/.gitignore create mode 100644 frontend/index.html create mode 100644 frontend/package-lock.json create mode 100644 frontend/package.json create mode 100644 frontend/postcss.config.js create mode 100644 frontend/public/favicon.png create mode 100644 frontend/public/favicon.svg create mode 100644 frontend/public/icons.svg create mode 100644 frontend/public/logo.png create mode 100644 frontend/src/App.tsx create mode 100644 frontend/src/assets/hero.png create mode 100644 frontend/src/assets/typescript.svg create mode 100644 frontend/src/assets/vite.svg create mode 100644 frontend/src/components/Navbar.tsx create mode 100644 frontend/src/components/RoutingMap.tsx create mode 100644 frontend/src/counter.ts create mode 100644 frontend/src/index.css create mode 100644 frontend/src/lib/api.ts create mode 100644 frontend/src/main.tsx create mode 100644 frontend/src/pages/Analytics.tsx create mode 100644 frontend/src/pages/Dashboard.tsx create mode 100644 frontend/src/pages/Models.tsx create mode 100644 frontend/src/pages/Playground.tsx create mode 100644 frontend/src/pages/Rules.tsx create mode 100644 frontend/src/pages/SettingsPage.tsx create mode 100644 frontend/src/pages/Traffic.tsx create mode 100644 frontend/src/style.css create mode 100644 frontend/src/types/index.ts create mode 100644 frontend/src/vite-env.d.ts create mode 100644 frontend/tailwind.config.js create mode 100644 frontend/tsconfig.json create mode 100644 pytest.ini create mode 100644 requirements.txt diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..547550f --- /dev/null +++ b/.env.example @@ -0,0 +1,39 @@ +# Model Router Configuration + +# Environment mode: development | production | test +APP_ENV=development +DEBUG=true +PORT=8000 +HOST=0.0.0.0 + +# Database +DATABASE_URL=sqlite+aiosqlite:///./model_router.db + +# Default Router Analyzer: rules | llm +ROUTER_ANALYZER=rules + +# Default Routing Policy: balanced | lowest_cost | lowest_latency | highest_quality | custom +DEFAULT_ROUTING_POLICY=balanced + +# Baseline Model ID for Cost Savings Analytics (e.g. gpt-4o or claude-3-5-sonnet-20241022 or mock-power) +BASELINE_MODEL_ID=mock-power + +# Default Provider Mode: mock | ollama +DEFAULT_PROVIDER=mock + +# Local Ollama URL +OLLAMA_BASE_URL=http://localhost:11434 + +# Optional External Providers (leave empty for local/mock development) +OPENAI_API_KEY= +ANTHROPIC_API_KEY= +GEMINI_API_KEY= + +# Budgets (USD) +DAILY_BUDGET=10.00 +MONTHLY_BUDGET=100.00 +PER_REQUEST_BUDGET=1.00 + +# Retries & Timeouts +MAX_RETRIES=2 +PROVIDER_TIMEOUT_SECONDS=30.0 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..7c22531 --- /dev/null +++ b/.gitignore @@ -0,0 +1,44 @@ +# Python +__pycache__/ +*.py[cod] +*$py.class +*.so +.Python +env/ +venv/ +.venv/ +ENV/ +*.db +*.sqlite3 +model_router.db +model_router.db-journal + +# Environment +.env +.env.local + +# Testing & Coverage +.pytest_cache/ +.coverage +htmlcov/ + +# Node / Frontend +node_modules/ +dist/ +.dist/ +npm-debug.log* +yarn-debug.log* +yarn-error.log* +.eslintcache +.vite/ + +# IDEs & System +.idea/ +.vscode/ +*.swp +*.swo +.DS_Store +Thumbs.db + +# Project Interview Guide & Docs +project.md diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..ebd809e --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 Model Router Contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..1bc8d2c --- /dev/null +++ b/README.md @@ -0,0 +1,92 @@ +# Model Router + +Intelligent, explainable, cost- and latency-aware LLM request routing platform and AI Traffic Control Room. + +--- + +## Overview + +Model Router intercepts incoming AI requests, analyzes their task type and complexity, evaluates available models against a configurable multi-criteria scoring objective, selects the optimal candidate, and dispatches the request with automatic fallback handling and budget guards. + +The platform is designed local-first, allowing full local development and testing using Mock models or local Ollama instances without requiring paid external API keys. + +--- + +## Core Capabilities + +- Dual-Mode Request Analyzer: Deterministic heuristics (<3ms latency overhead) for 12 task types, continuous complexity scoring (0.0 to 1.0), and requirement detection, plus an optional LLM classifier mode. +- Explainable Routing Engine: Multi-criteria weighted scoring across Quality, Cost Efficiency, Speed, Capabilities, and Reliability with transparent decision factor reports and candidate rejection logs. +- Provider Abstraction: Decoupled adapters for Mock (simulation), Ollama (local), OpenAI, Anthropic, and Google Gemini. +- Resilience and Fallback: Automated retry classification for transient errors (timeouts, HTTP 429, 503) and tiered fallback to local/mock alternatives. +- Budget Guards: Real-time spend tracking with automated threshold interventions (80% cost optimization, 95% local-only saver, 100% block). +- Traffic Control Room UI: Real-time dark operational interface featuring live topology graphs, playground inspector, SSE live request stream, visual rules builder, and cost savings simulator. +- Developer CLI: Terminal diagnostics (`modelrouter doctor`), routing dry-run (`route`), execution (`run`), model catalog (`models`), and analytics (`analytics`). + +--- + +## Quickstart + +### 1. Prerequisites +- Python 3.10+ +- Node.js 18+ and npm + +### 2. Backend Setup +```bash +# Clone the repository +git clone https://github.com/your-org/model-router.git +cd model-router + +# Install dependencies +pip install -r requirements.txt + +# Run system diagnostics +python backend/app/cli/main.py doctor + +# Start API server (port 8000) +python backend/main.py +``` + +### 3. Frontend Setup +```bash +cd frontend +npm install +npm run dev +# Access UI at http://localhost:5173 +``` + +--- + +## CLI Usage Examples + +```bash +# Inspect routing decision for a coding prompt (Dry Run) +python backend/app/cli/main.py route "Write a Python function to parse JSON" + +# Route and execute a complex debugging query +python backend/app/cli/main.py run "Debug this distributed async deadlock in high-throughput worker pool" + +# List active models in registry +python backend/app/cli/main.py models + +# View aggregate system analytics +python backend/app/cli/main.py analytics +``` + +--- + +## Testing & Build Verification + +```bash +# Run backend test suite (15 unit, integration, and e2e tests) +pytest backend/tests + +# Build frontend production bundle +cd frontend +npm run build +``` + +--- + +## License + +MIT License. Open-source software. diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 0000000..a84fbd0 --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,10 @@ +# Model Router Security Policy + +## Reporting Security Vulnerabilities +If you discover any security issues with API token handling, prompt injection vectors, or data exposure, please contact the maintainers immediately. + +## Zero-Secret Exposure Policy +1. **API Keys**: External provider tokens (OpenAI, Anthropic, Gemini) are read strictly from local environment variables (`.env`) or secure system secrets. +2. **Logs & Transcripts**: All outgoing observability logs automatically redact authorization headers, bearer tokens, and secrets. +3. **Database Integrity**: SQLite storage only stores model identifiers and usage statistics; raw credentials are never persisted in plaintext database tables. +4. **Browser Privacy**: Frontend client queries never receive or handle backend API keys. diff --git a/backend/app/analytics/service.py b/backend/app/analytics/service.py new file mode 100644 index 0000000..9ea32dd --- /dev/null +++ b/backend/app/analytics/service.py @@ -0,0 +1,119 @@ +from typing import Dict, Any, List, Optional +from sqlalchemy import select, func +from sqlalchemy.ext.asyncio import AsyncSession +from app.storage.models import RequestRecord, FeedbackRecord, ModelRecord +from app.config.settings import get_settings + +settings = get_settings() + + +async def calculate_cost_savings( + session: AsyncSession, + baseline_model_id: Optional[str] = None, +) -> Dict[str, Any]: + """ + Computes accurate, non-invented cost savings: + Baseline Cost (if all requests were sent to baseline model) vs Actual Routed Cost. + """ + base_id = baseline_model_id or settings.BASELINE_MODEL_ID + + # Fetch baseline model pricing + res_base = await session.execute(select(ModelRecord).filter_by(id=base_id)) + baseline_model = res_base.scalar_one_or_none() + + base_in_rate = baseline_model.cost_per_input_token if baseline_model else 0.000005 + base_out_rate = baseline_model.cost_per_output_token if baseline_model else 0.000015 + + # Fetch aggregate requests + res = await session.execute( + select( + func.count(RequestRecord.request_id), + func.sum(RequestRecord.input_tokens), + func.sum(RequestRecord.output_tokens), + func.sum(RequestRecord.estimated_cost), + ) + ) + total_reqs, total_in_tok, total_out_tok, total_routed_cost = res.one() + + total_reqs = total_reqs or 0 + total_in_tok = total_in_tok or 0 + total_out_tok = total_out_tok or 0 + total_routed_cost = round(total_routed_cost or 0.0, 6) + + # Theoretical cost if all traffic ran on baseline + baseline_total_cost = round((total_in_tok * base_in_rate) + (total_out_tok * base_out_rate), 6) + saved_amount = max(0.0, round(baseline_total_cost - total_routed_cost, 6)) + savings_percent = round((saved_amount / baseline_total_cost * 100.0), 2) if baseline_total_cost > 0 else 0.0 + + return { + "baseline_model": base_id, + "total_requests": total_reqs, + "total_input_tokens": total_in_tok, + "total_output_tokens": total_out_tok, + "baseline_total_cost": baseline_total_cost, + "routed_total_cost": total_routed_cost, + "cost_saved_usd": saved_amount, + "savings_percentage": savings_percent, + } + + +async def get_system_analytics(session: AsyncSession) -> Dict[str, Any]: + """ + Collects full aggregate metrics for the dashboard. + """ + # 1. Totals & averages + res = await session.execute( + select( + func.count(RequestRecord.request_id), + func.avg(RequestRecord.total_latency_ms), + func.avg(RequestRecord.routing_latency_ms), + func.avg(RequestRecord.estimated_cost), + func.sum(RequestRecord.estimated_cost), + ) + ) + count, avg_lat, avg_route_lat, avg_cost, sum_cost = res.one() + + # 2. Distribution by model + model_dist_res = await session.execute( + select(RequestRecord.selected_model, func.count(RequestRecord.request_id)) + .group_by(RequestRecord.selected_model) + ) + model_distribution = {m: c for m, c in model_dist_res.all()} + + # 3. Distribution by task type + task_dist_res = await session.execute( + select(RequestRecord.task_type, func.count(RequestRecord.request_id)) + .group_by(RequestRecord.task_type) + ) + task_distribution = {t: c for t, c in task_dist_res.all()} + + # 4. Fallback rate + fb_res = await session.execute( + select(func.count(RequestRecord.request_id)).filter(RequestRecord.fallback_used == True) + ) + fallback_count = fb_res.scalar() or 0 + fallback_rate = round((fallback_count / count * 100.0), 2) if count and count > 0 else 0.0 + + # 5. User Feedback aggregate + fb_pos_res = await session.execute(select(func.count(FeedbackRecord.id)).filter(FeedbackRecord.rating == 1)) + fb_neg_res = await session.execute(select(func.count(FeedbackRecord.id)).filter(FeedbackRecord.rating == -1)) + pos_feedback = fb_pos_res.scalar() or 0 + neg_feedback = fb_neg_res.scalar() or 0 + total_feedback = pos_feedback + neg_feedback + quality_score = round((pos_feedback / total_feedback * 100.0), 1) if total_feedback > 0 else None + + savings = await calculate_cost_savings(session) + + return { + "total_requests": count or 0, + "avg_latency_ms": round(avg_lat or 0.0, 1), + "avg_routing_latency_ms": round(avg_route_lat or 0.0, 1), + "avg_cost_usd": round(avg_cost or 0.0, 6), + "total_cost_usd": round(sum_cost or 0.0, 6), + "quality_score_percent": quality_score, + "fallback_rate_percent": fallback_rate, + "fallback_count": fallback_count, + "model_distribution": model_distribution, + "task_distribution": task_distribution, + "savings": savings, + } diff --git a/backend/app/analyzer/analyzer.py b/backend/app/analyzer/analyzer.py new file mode 100644 index 0000000..873d97d --- /dev/null +++ b/backend/app/analyzer/analyzer.py @@ -0,0 +1,67 @@ +import json +import re +from typing import Optional +from app.models.schemas import RequestAnalysis, TaskType, PriorityLevel +from app.analyzer.heuristics import analyze_request_heuristics, estimate_tokens +from app.providers.registry import provider_registry +from app.config.settings import get_settings + +settings = get_settings() + +CLASSIFIER_PROMPT = """You are a real-time request classifier for an intelligent LLM model router. +Analyze the user prompt and return ONLY a JSON object matching this schema: +{ + "task_type": "GENERAL_QA" | "CODING" | "DEBUGGING" | "REASONING" | "SUMMARIZATION" | "EXTRACTION" | "WRITING" | "TRANSLATION" | "ANALYSIS" | "MATH" | "LONG_CONTEXT" | "CREATIVE", + "complexity": 0.0 to 1.0, + "reasoning_required": true/false, + "coding_required": true/false, + "vision_required": true/false, + "latency_priority": "LOW" | "MEDIUM" | "HIGH", + "cost_sensitivity": "LOW" | "MEDIUM" | "HIGH", + "quality_requirement": "LOW" | "MEDIUM" | "HIGH" +} +Output valid JSON only with no markdown wrapping or additional text. +""" + + +async def analyze_request(prompt: str, analyzer_mode: Optional[str] = None) -> RequestAnalysis: + mode = (analyzer_mode or settings.ROUTER_ANALYZER).lower() + + if mode == "llm": + try: + # Attempt to use local or configured provider for classification + provider = provider_registry.get_provider("ollama") + if provider: + health = await provider.check_health() + if health.get("status") == "CONNECTED": + resp = await provider.generate( + prompt=f"Classify this request:\n\n{prompt[:1000]}", + model_id="qwen2.5-coder", + system_prompt=CLASSIFIER_PROMPT, + temperature=0.1, + ) + clean_json = re.search(r"\{.*\}", resp.content, re.DOTALL) + if clean_json: + data = json.loads(clean_json.group(0)) + comp = float(data.get("complexity", 0.5)) + comp_label = PriorityLevel.HIGH if comp >= 0.75 else (PriorityLevel.MEDIUM if comp >= 0.45 else PriorityLevel.LOW) + return RequestAnalysis( + task_type=TaskType(data.get("task_type", "GENERAL_QA")), + complexity=comp, + complexity_label=comp_label, + reasoning_required=bool(data.get("reasoning_required", False)), + coding_required=bool(data.get("coding_required", False)), + vision_required=bool(data.get("vision_required", False)), + context_size=estimate_tokens(prompt), + latency_priority=PriorityLevel(data.get("latency_priority", "MEDIUM")), + cost_sensitivity=PriorityLevel(data.get("cost_sensitivity", "MEDIUM")), + quality_requirement=PriorityLevel(data.get("quality_requirement", "MEDIUM")), + keywords_detected=["llm_classified"], + analyzer_used="llm", + ) + except Exception: + # Graceful fallback to heuristics if LLM classifier is unavailable or times out + pass + + # Default to fast, deterministic heuristics + return analyze_request_heuristics(prompt) diff --git a/backend/app/analyzer/heuristics.py b/backend/app/analyzer/heuristics.py new file mode 100644 index 0000000..73d2eaf --- /dev/null +++ b/backend/app/analyzer/heuristics.py @@ -0,0 +1,192 @@ +import re +from typing import List, Tuple +from app.models.schemas import TaskType, PriorityLevel, RequestAnalysis + +# Regex rules and indicator vocabularies +DEBUG_PATTERNS = [ + r"\b(debug|bug|stacktrace|exception|error|fix this error|traceback|segfault|syntaxerror|nullpointer)\b", + r"\b(crash|panicked|failed test|reproduce|root cause|undefined is not a function)\b", +] + +CODING_PATTERNS = [ + r"\b(write a python|write code|implement|function|class |def |const |async def|typescript|javascript|golang|rust|react|sql query|endpoint|api client)\b", + r"\b(refactor|algorithm|regex|unit test|dockerfile|kubernetes yaml|prisma|fastapi)\b", + r"```[a-zA-Z0-9_-]*\n", +] + +REASONING_PATTERNS = [ + r"\b(explain why|reasoning|step by step|proof|derive|why did|compare and contrast|architectural decision|tradeoffs|trade-offs|consequences of)\b", + r"\b(game theory|logical fallacy|syllogism|first principles|hypothesize)\b", +] + +MATH_PATTERNS = [ + r"\b(calculate|integral|derivative|matrix|eigenvalue|probability|equation|differential equation|solve for x|combinatorics|standard deviation)\b", + r"[\$\\\^\{\}\[\]\=]{3,}", +] + +SUMMARIZATION_PATTERNS = [ + r"\b(summarize|summary|tldr|tl;dr|key points|bullet points of this|condense|digest|brief overview)\b", +] + +EXTRACTION_PATTERNS = [ + r"\b(extract|extract json|parse this table|pull all emails|convert to json|output as csv|structured data from)\b", +] + +TRANSLATION_PATTERNS = [ + r"\b(translate to|translate into|in french|in spanish|in german|in japanese|in chinese|in hindi|translate from)\b", +] + +CREATIVE_PATTERNS = [ + r"\b(write a poem|write a story|screenplay|brainstorm catchy|creative writing|dialogue between|fiction|metaphor)\b", +] + +ANALYSIS_PATTERNS = [ + r"\b(analyze|breakdown|evaluate|critique|audit|financial report|trend analysis|pros and cons)\b", +] + + +def estimate_tokens(text: str) -> int: + """Fast, reliable token estimation (roughly 4 characters per token).""" + return max(1, len(text) // 4) + + +def analyze_request_heuristics(prompt: str) -> RequestAnalysis: + text_lower = prompt.lower() + tokens = estimate_tokens(prompt) + + detected_keywords: List[str] = [] + task_scores: dict[TaskType, float] = {t: 0.0 for t in TaskType} + + # 1. Evaluate patterns + for p in DEBUG_PATTERNS: + matches = re.findall(p, text_lower) + if matches: + task_scores[TaskType.DEBUGGING] += len(matches) * 2.5 + detected_keywords.extend(matches) + + for p in CODING_PATTERNS: + matches = re.findall(p, text_lower) + if matches: + task_scores[TaskType.CODING] += len(matches) * 2.0 + detected_keywords.extend(matches) + + for p in REASONING_PATTERNS: + matches = re.findall(p, text_lower) + if matches: + task_scores[TaskType.REASONING] += len(matches) * 2.0 + detected_keywords.extend(matches) + + for p in MATH_PATTERNS: + matches = re.findall(p, text_lower) + if matches: + task_scores[TaskType.MATH] += len(matches) * 2.2 + detected_keywords.extend(matches) + + for p in SUMMARIZATION_PATTERNS: + matches = re.findall(p, text_lower) + if matches: + task_scores[TaskType.SUMMARIZATION] += len(matches) * 2.5 + detected_keywords.extend(matches) + + for p in EXTRACTION_PATTERNS: + matches = re.findall(p, text_lower) + if matches: + task_scores[TaskType.EXTRACTION] += len(matches) * 2.0 + detected_keywords.extend(matches) + + for p in TRANSLATION_PATTERNS: + matches = re.findall(p, text_lower) + if matches: + task_scores[TaskType.TRANSLATION] += len(matches) * 3.0 + detected_keywords.extend(matches) + + for p in CREATIVE_PATTERNS: + matches = re.findall(p, text_lower) + if matches: + task_scores[TaskType.CREATIVE] += len(matches) * 2.0 + detected_keywords.extend(matches) + + for p in ANALYSIS_PATTERNS: + matches = re.findall(p, text_lower) + if matches: + task_scores[TaskType.ANALYSIS] += len(matches) * 1.8 + detected_keywords.extend(matches) + + # Long context check + if tokens > 4000: + task_scores[TaskType.LONG_CONTEXT] += 3.0 + + # 2. Determine Primary Task + best_task = TaskType.GENERAL_QA + max_score = 0.0 + for task, score in task_scores.items(): + if score > max_score: + max_score = score + best_task = task + + # 3. Derive Complexity (0.0 to 1.0) + complexity = 0.35 # Base complexity + + # Token length factor + if tokens > 10000: + complexity += 0.30 + elif tokens > 3000: + complexity += 0.20 + elif tokens > 800: + complexity += 0.10 + elif tokens < 30: + complexity -= 0.10 + + # Task inherent complexity + if best_task in (TaskType.DEBUGGING, TaskType.MATH, TaskType.REASONING): + complexity += 0.30 + elif best_task in (TaskType.CODING, TaskType.ANALYSIS, TaskType.LONG_CONTEXT): + complexity += 0.20 + elif best_task in (TaskType.TRANSLATION, TaskType.EXTRACTION, TaskType.SUMMARIZATION): + complexity += 0.05 + elif best_task == TaskType.GENERAL_QA and tokens < 50: + complexity -= 0.15 + + # Multi-step keyword boosts + if any(k in text_lower for k in ["distributed", "async", "concurrency", "deadlock", "microservices", "architecture"]): + complexity += 0.25 + if any(k in text_lower for k in ["simple", "quick", "one liner", "easy", "hello world"]): + complexity -= 0.20 + + complexity = max(0.05, min(0.99, round(complexity, 2))) + + # 4. Priority and Capabilities + coding_required = best_task in (TaskType.CODING, TaskType.DEBUGGING) or task_scores[TaskType.CODING] > 0 + reasoning_required = best_task in (TaskType.REASONING, TaskType.DEBUGGING, TaskType.MATH) or complexity >= 0.70 + + if complexity >= 0.75: + complexity_label = PriorityLevel.HIGH + quality_req = PriorityLevel.HIGH + latency_pri = PriorityLevel.LOW + cost_sens = PriorityLevel.LOW + elif complexity >= 0.45: + complexity_label = PriorityLevel.MEDIUM + quality_req = PriorityLevel.MEDIUM + latency_pri = PriorityLevel.MEDIUM + cost_sens = PriorityLevel.MEDIUM + else: + complexity_label = PriorityLevel.LOW + quality_req = PriorityLevel.LOW + latency_pri = PriorityLevel.HIGH + cost_sens = PriorityLevel.HIGH + + return RequestAnalysis( + task_type=best_task, + complexity=complexity, + complexity_label=complexity_label, + reasoning_required=reasoning_required, + coding_required=coding_required, + vision_required=False, + tools_required=False, + context_size=tokens, + latency_priority=latency_pri, + cost_sensitivity=cost_sens, + quality_requirement=quality_req, + keywords_detected=list(set(detected_keywords))[:10], + analyzer_used="rules", + ) diff --git a/backend/app/api/routes.py b/backend/app/api/routes.py new file mode 100644 index 0000000..525b71d --- /dev/null +++ b/backend/app/api/routes.py @@ -0,0 +1,532 @@ +import uuid +import time +import asyncio +from typing import List, Optional, Dict, Any +from fastapi import APIRouter, Depends, HTTPException, Query +from pydantic import BaseModel, Field +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy import select, desc + +from app.storage.database import get_db +from app.storage.models import ( + ModelRecord, + RoutingPolicyRecord, + RoutingRuleRecord, + RequestRecord, + RoutingDecisionRecord, + ResponseRecord, + FeedbackRecord, + BudgetRecord, + ExperimentRecord, +) +from app.models.schemas import ( + ModelMetadata, + RequestAnalysis, + RoutingDecision, + ProviderResponse, + ModelTier, +) +from app.analyzer.analyzer import analyze_request +from app.router.engine import route_request +from app.fallback.handler import execute_with_fallback +from app.budgets.manager import check_budget_threshold +from app.observability.events import log_router_event +from app.analytics.service import get_system_analytics, calculate_cost_savings +from app.providers.registry import provider_registry +from app.config.settings import get_settings + +router = APIRouter() +settings = get_settings() + + +class RouteOnlyRequest(BaseModel): + prompt: str = Field(..., min_length=1, description="Prompt text to analyze and route") + policy: Optional[str] = None + analyzer_mode: Optional[str] = None + + +class GenerateRequest(BaseModel): + prompt: str = Field(..., min_length=1) + system_prompt: Optional[str] = None + policy: Optional[str] = None + analyzer_mode: Optional[str] = None + force_model: Optional[str] = None + temperature: float = 0.7 + max_retries: int = 1 + + +class FeedbackSubmitRequest(BaseModel): + request_id: str + rating: int = Field(..., description="1 for up, -1 for down") + comment: Optional[str] = None + + +class ModelCreateRequest(BaseModel): + id: str + name: str + provider: str + type: str = "LOCAL" + tier: str = "BALANCED" + context_window: int = 32768 + supports_coding: bool = True + supports_reasoning: bool = True + supports_vision: bool = False + supports_tools: bool = True + quality_score: float = 0.85 + speed_score: float = 0.85 + cost_per_input_token: float = 0.0 + cost_per_output_token: float = 0.0 + + +class RuleCreateRequest(BaseModel): + id: Optional[str] = None + name: str + description: Optional[str] = None + priority: int = 10 + is_enabled: bool = True + condition_field: str + condition_operator: str + condition_value: str + action_type: str + action_target: str + + +# Helper to convert DB model record to Pydantic ModelMetadata +def db_model_to_meta(m: ModelRecord) -> ModelMetadata: + return ModelMetadata( + id=m.id, + name=m.name, + provider=m.provider, + type=m.type, + tier=ModelTier(m.tier) if m.tier in [t.value for t in ModelTier] else ModelTier.BALANCED, + context_window=m.context_window, + supports_coding=m.supports_coding, + supports_reasoning=m.supports_reasoning, + supports_vision=m.supports_vision, + supports_tools=m.supports_tools, + quality_score=m.quality_score, + speed_score=m.speed_score, + reliability_score=m.reliability_score, + cost_per_input_token=m.cost_per_input_token, + cost_per_output_token=m.cost_per_output_token, + availability=m.availability, + is_active=m.is_active, + ) + + +@router.post("/api/route", response_model=Dict[str, Any]) +async def api_route_prompt(req: RouteOnlyRequest, db: AsyncSession = Depends(get_db)): + """ + Dry-run routing inspection endpoint: + Analyzes request and produces structured routing decision without invoking provider. + """ + t_start = time.perf_counter() + req_id = f"req_{uuid.uuid4().hex[:12]}" + + # 1. Analyze Request + analysis = await analyze_request(req.prompt, req.analyzer_mode) + + # 2. Fetch Models & Policy + res_m = await db.execute(select(ModelRecord).filter_by(is_active=True)) + db_models = res_m.scalars().all() + models = [db_model_to_meta(m) for m in db_models] + + policy_name = req.policy or settings.DEFAULT_ROUTING_POLICY + res_p = await db.execute(select(RoutingPolicyRecord).filter_by(id=policy_name)) + policy = res_p.scalar_one_or_none() + weights = { + "quality_weight": policy.quality_weight if policy else 0.35, + "cost_weight": policy.cost_weight if policy else 0.25, + "speed_weight": policy.speed_weight if policy else 0.20, + "capability_weight": policy.capability_weight if policy else 0.15, + "reliability_weight": policy.reliability_weight if policy else 0.05, + } + + # 3. Fetch Rules & Budget Check + res_r = await db.execute(select(RoutingRuleRecord).filter_by(is_enabled=True)) + rules = res_r.scalars().all() + budget_pct, _ = await check_budget_threshold(db, 0.0) + + # 4. Routing Decision + decision = route_request( + analysis=analysis, + available_models=models, + policy_weights=weights, + policy_name=policy_name, + rules=rules, + budget_percent=budget_pct, + request_id=req_id, + ) + + t_route_ms = (time.perf_counter() - t_start) * 1000.0 + + return { + "request_id": req_id, + "analysis": analysis.model_dump(), + "decision": decision.model_dump(), + "routing_latency_ms": round(t_route_ms, 2), + } + + +@router.post("/api/generate", response_model=Dict[str, Any]) +async def api_generate_response(req: GenerateRequest, db: AsyncSession = Depends(get_db)): + """ + End-to-End routed execution: + Analyzes -> Routes -> Executes Selected Model / Fallback -> Records Decision & Metrics. + """ + t_start = time.perf_counter() + req_id = f"req_{uuid.uuid4().hex[:12]}" + + # 1. Analyze Request + analysis = await analyze_request(req.prompt, req.analyzer_mode) + + # 2. Fetch Models & Policy + res_m = await db.execute(select(ModelRecord).filter_by(is_active=True)) + db_models = res_m.scalars().all() + models = [db_model_to_meta(m) for m in db_models] + + policy_name = req.policy or settings.DEFAULT_ROUTING_POLICY + res_p = await db.execute(select(RoutingPolicyRecord).filter_by(id=policy_name)) + policy = res_p.scalar_one_or_none() + weights = { + "quality_weight": policy.quality_weight if policy else 0.35, + "cost_weight": policy.cost_weight if policy else 0.25, + "speed_weight": policy.speed_weight if policy else 0.20, + "capability_weight": policy.capability_weight if policy else 0.15, + "reliability_weight": policy.reliability_weight if policy else 0.05, + } + + # 3. Fetch Rules & Budget Check + res_r = await db.execute(select(RoutingRuleRecord).filter_by(is_enabled=True)) + rules = res_r.scalars().all() + budget_pct, budget_mode = await check_budget_threshold(db, 0.0) + + # 4. Route + decision = route_request( + analysis=analysis, + available_models=models, + policy_weights=weights, + policy_name=policy_name, + rules=rules, + budget_percent=budget_pct, + request_id=req_id, + ) + + t_routing_done = time.perf_counter() + routing_latency_ms = (t_routing_done - t_start) * 1000.0 + + # If force model requested, override + selected_model_id = req.force_model or decision.selected_model + target_meta = next((m for m in models if m.id == selected_model_id), None) + selected_provider_id = target_meta.provider if target_meta else decision.provider + + # 5. Provider Execution with Fallback & Retries + provider_resp, fallback_used, orig_model, fallback_reason = await execute_with_fallback( + prompt=req.prompt, + selected_model_id=selected_model_id, + selected_provider_id=selected_provider_id, + all_models=models, + system_prompt=req.system_prompt, + temperature=req.temperature, + max_retries=req.max_retries, + ) + + total_latency_ms = (time.perf_counter() - t_start) * 1000.0 + + # 6. Calculate actual costs + actual_model_meta = next((m for m in models if m.id == provider_resp.model), target_meta) + cost_in_rate = actual_model_meta.cost_per_input_token if actual_model_meta else 0.0 + cost_out_rate = actual_model_meta.cost_per_output_token if actual_model_meta else 0.0 + actual_cost = round((provider_resp.input_tokens * cost_in_rate) + (provider_resp.output_tokens * cost_out_rate), 6) + + # Baseline cost calculation + res_base = await db.execute(select(ModelRecord).filter_by(id=settings.BASELINE_MODEL_ID)) + base_m = res_base.scalar_one_or_none() + base_cost = 0.0 + if base_m: + base_cost = round((provider_resp.input_tokens * base_m.cost_per_input_token) + (provider_resp.output_tokens * base_m.cost_per_output_token), 6) + saved_cost = max(0.0, round(base_cost - actual_cost, 6)) + + # Update budget spend + await check_budget_threshold(db, actual_cost) + + # 7. Persistence + req_record = RequestRecord( + request_id=req_id, + prompt=req.prompt, + task_type=analysis.task_type.value, + complexity=analysis.complexity, + context_size=analysis.context_size, + reasoning_required=analysis.reasoning_required, + coding_required=analysis.coding_required, + routing_policy=policy_name, + selected_model=provider_resp.model or selected_model_id, + provider=provider_resp.provider or selected_provider_id, + status="FALLBACK" if fallback_used else ("FAILED" if provider_resp.error else "SUCCESS"), + fallback_used=fallback_used, + original_model=orig_model, + fallback_reason=fallback_reason, + input_tokens=provider_resp.input_tokens, + output_tokens=provider_resp.output_tokens, + total_tokens=provider_resp.total_tokens, + estimated_cost=actual_cost, + baseline_cost=base_cost, + cost_saved=saved_cost, + routing_latency_ms=round(routing_latency_ms, 2), + provider_latency_ms=round(provider_resp.provider_latency_ms, 2), + total_latency_ms=round(total_latency_ms, 2), + time_to_first_token_ms=provider_resp.time_to_first_token_ms, + ) + db.add(req_record) + + decision_record = RoutingDecisionRecord( + decision_id=decision.decision_id, + request_id=req_id, + selected_model=decision.selected_model, + confidence=decision.confidence, + reasons=decision.reasons, + candidate_scores=[s.model_dump() for s in decision.candidate_scores], + rejected_candidates=decision.rejected_candidates, + policy_used=policy_name, + ) + db.add(decision_record) + + resp_record = ResponseRecord( + response_id=f"resp_{uuid.uuid4().hex[:12]}", + request_id=req_id, + model_id=provider_resp.model or selected_model_id, + provider=provider_resp.provider or selected_provider_id, + content=provider_resp.content, + finish_reason=provider_resp.finish_reason, + is_mock=provider_resp.is_mock, + ) + db.add(resp_record) + await db.commit() + + # 8. Structured Observability Event + log_router_event( + event_name="request_completed", + request_id=req_id, + model=provider_resp.model, + provider=provider_resp.provider, + duration_ms=round(total_latency_ms, 2), + metadata={"tokens": provider_resp.total_tokens, "cost": actual_cost, "fallback": fallback_used}, + ) + + return { + "request_id": req_id, + "analysis": analysis.model_dump(), + "decision": decision.model_dump(), + "response": provider_resp.model_dump(), + "metrics": { + "routing_latency_ms": round(routing_latency_ms, 2), + "provider_latency_ms": round(provider_resp.provider_latency_ms, 2), + "total_latency_ms": round(total_latency_ms, 2), + "estimated_cost_usd": actual_cost, + "baseline_cost_usd": base_cost, + "cost_saved_usd": saved_cost, + "fallback_used": fallback_used, + "fallback_reason": fallback_reason, + }, + } + + +# Models & Registry Endpoints +@router.get("/api/models") +async def list_models(db: AsyncSession = Depends(get_db)): + res = await db.execute(select(ModelRecord).order_by(ModelRecord.tier, ModelRecord.name)) + return res.scalars().all() + + +@router.post("/api/models") +async def create_model(req: ModelCreateRequest, db: AsyncSession = Depends(get_db)): + record = ModelRecord( + id=req.id, + name=req.name, + provider=req.provider, + type=req.type, + tier=req.tier, + context_window=req.context_window, + supports_coding=req.supports_coding, + supports_reasoning=req.supports_reasoning, + supports_vision=req.supports_vision, + supports_tools=req.supports_tools, + quality_score=req.quality_score, + speed_score=req.speed_score, + cost_per_input_token=req.cost_per_input_token, + cost_per_output_token=req.cost_per_output_token, + ) + db.add(record) + await db.commit() + return record + + +# Providers Endpoint (Never returning secrets) +@router.get("/api/providers") +async def list_providers(db: AsyncSession = Depends(get_db)): + providers_info = [] + for pid, p in provider_registry.list_providers().items(): + health = await p.check_health() + providers_info.append({ + "id": pid, + "name": p.name, + "status": health.get("status", "READY"), + "base_url": p.base_url, + "message": health.get("message"), + "models_available": health.get("models_available", []), + "credentials_status": "Loaded from environment (.env)" if getattr(p, "api_key", None) or pid in ["mock", "ollama"] else "Not configured", + }) + return providers_info + + +# Live Traffic & Decisions +@router.get("/api/traffic") +async def get_traffic_feed(limit: int = 50, db: AsyncSession = Depends(get_db)): + res = await db.execute(select(RequestRecord).order_by(desc(RequestRecord.timestamp)).limit(limit)) + return res.scalars().all() + + +@router.get("/api/decisions/{decision_id_or_request_id}") +async def get_decision_details(decision_id_or_request_id: str, db: AsyncSession = Depends(get_db)): + res_dec = await db.execute( + select(RoutingDecisionRecord).filter( + (RoutingDecisionRecord.decision_id == decision_id_or_request_id) + | (RoutingDecisionRecord.request_id == decision_id_or_request_id) + ) + ) + dec = res_dec.scalar_one_or_none() + if not dec: + raise HTTPException(status_code=404, detail="Decision not found") + + res_req = await db.execute(select(RequestRecord).filter_by(request_id=dec.request_id)) + req = res_req.scalar_one_or_none() + + res_resp = await db.execute(select(ResponseRecord).filter_by(request_id=dec.request_id)) + resp = res_resp.scalar_one_or_none() + + return { + "decision": dec, + "request": req, + "response": resp, + } + + +# Feedback +@router.post("/api/feedback") +async def submit_feedback(req: FeedbackSubmitRequest, db: AsyncSession = Depends(get_db)): + res = await db.execute(select(RequestRecord).filter_by(request_id=req.request_id)) + request_rec = res.scalar_one_or_none() + if not request_rec: + raise HTTPException(status_code=404, detail="Request ID not found") + + feedback = FeedbackRecord( + id=f"fb_{uuid.uuid4().hex[:10]}", + request_id=req.request_id, + model_id=request_rec.selected_model, + task_type=request_rec.task_type, + rating=1 if req.rating > 0 else -1, + comment=req.comment, + ) + db.add(feedback) + await db.commit() + return {"status": "success", "feedback_id": feedback.id} + + +# Analytics Endpoints +@router.get("/api/analytics") +async def get_analytics(db: AsyncSession = Depends(get_db)): + return await get_system_analytics(db) + + +@router.get("/api/analytics/savings") +async def get_savings(baseline_model: Optional[str] = None, db: AsyncSession = Depends(get_db)): + return await calculate_cost_savings(db, baseline_model) + + +# Rules Endpoints +@router.get("/api/rules") +async def list_rules(db: AsyncSession = Depends(get_db)): + res = await db.execute(select(RoutingRuleRecord).order_by(desc(RoutingRuleRecord.priority))) + return res.scalars().all() + + +@router.post("/api/rules") +async def create_rule(req: RuleCreateRequest, db: AsyncSession = Depends(get_db)): + rule_id = req.id or f"rule-{uuid.uuid4().hex[:8]}" + record = RoutingRuleRecord( + id=rule_id, + name=req.name, + description=req.description, + priority=req.priority, + is_enabled=req.is_enabled, + condition_field=req.condition_field, + condition_operator=req.condition_operator, + condition_value=req.condition_value, + action_type=req.action_type, + action_target=req.action_target, + ) + db.add(record) + await db.commit() + return record + + +@router.put("/api/rules/{rule_id}") +async def update_rule(rule_id: str, req: RuleCreateRequest, db: AsyncSession = Depends(get_db)): + res = await db.execute(select(RoutingRuleRecord).filter_by(id=rule_id)) + rule = res.scalar_one_or_none() + if not rule: + raise HTTPException(status_code=404, detail="Rule not found") + rule.name = req.name + rule.description = req.description + rule.priority = req.priority + rule.is_enabled = req.is_enabled + rule.condition_field = req.condition_field + rule.condition_operator = req.condition_operator + rule.condition_value = req.condition_value + rule.action_type = req.action_type + rule.action_target = req.action_target + await db.commit() + return rule + + +@router.delete("/api/rules/{rule_id}") +async def delete_rule(rule_id: str, db: AsyncSession = Depends(get_db)): + res = await db.execute(select(RoutingRuleRecord).filter_by(id=rule_id)) + rule = res.scalar_one_or_none() + if not rule: + raise HTTPException(status_code=404, detail="Rule not found") + await db.delete(rule) + await db.commit() + return {"status": "deleted", "id": rule_id} + + +# Policies +@router.get("/api/policies") +async def list_policies(db: AsyncSession = Depends(get_db)): + res = await db.execute(select(RoutingPolicyRecord)) + return res.scalars().all() + + +# Budgets +@router.get("/api/budgets") +async def get_budget(db: AsyncSession = Depends(get_db)): + res = await db.execute(select(BudgetRecord).filter_by(id="default")) + return res.scalar_one_or_none() + + +# Experiments +@router.get("/api/experiments") +async def list_experiments(db: AsyncSession = Depends(get_db)): + res = await db.execute(select(ExperimentRecord)) + return res.scalars().all() + + +# Health Check +@router.get("/api/health") +async def get_health(): + return { + "status": "healthy", + "service": "Model Router AI Control Room", + "version": "1.0.0", + "environment": settings.APP_ENV, + } diff --git a/backend/app/budgets/manager.py b/backend/app/budgets/manager.py new file mode 100644 index 0000000..4fd50f4 --- /dev/null +++ b/backend/app/budgets/manager.py @@ -0,0 +1,39 @@ +from typing import Tuple +from sqlalchemy import select +from sqlalchemy.ext.asyncio import AsyncSession +from app.storage.models import BudgetRecord + + +async def check_budget_threshold( + session: AsyncSession, + cost_to_add: float = 0.0, +) -> Tuple[float, str]: + """ + Checks current budget utilization percentage and determines intervention mode: + - NORMAL (< 80%) + - OPTIMIZE_80 (>= 80% and < 95%) + - CHEAP_95 (>= 95% and < 100%) + - BLOCK_100 (>= 100%) + """ + res = await session.execute(select(BudgetRecord).filter_by(id="default")) + budget = res.scalar_one_or_none() + if not budget: + return 0.0, "NORMAL" + + monthly_limit = budget.monthly_limit or 100.0 + current_spend = budget.current_monthly_spend + cost_to_add + percent = (current_spend / monthly_limit) * 100.0 if monthly_limit > 0 else 0.0 + + mode = "NORMAL" + if percent >= 100.0: + mode = "BLOCK_100" + elif percent >= 95.0: + mode = "CHEAP_95" + elif percent >= 80.0: + mode = "OPTIMIZE_80" + + budget.current_monthly_spend = current_spend + budget.intervention_mode = mode + await session.commit() + + return round(percent, 2), mode diff --git a/backend/app/cli/main.py b/backend/app/cli/main.py new file mode 100644 index 0000000..988b3ba --- /dev/null +++ b/backend/app/cli/main.py @@ -0,0 +1,269 @@ +import sys +import os +import asyncio +import httpx +import typer +from rich.console import Console +from rich.table import Table +from rich.panel import Panel +from rich.text import Text + +# Set UTF-8 encoding support for Windows terminals +if sys.platform.startswith("win"): + try: + sys.stdout.reconfigure(encoding="utf-8") + sys.stderr.reconfigure(encoding="utf-8") + except Exception: + pass + +sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))) + +from app.config.settings import get_settings +from app.analyzer.heuristics import analyze_request_heuristics +from app.router.engine import route_request +from app.storage.database import init_db, AsyncSessionLocal +from app.storage.models import ModelRecord, RoutingPolicyRecord +from app.api.routes import db_model_to_meta +from app.fallback.handler import execute_with_fallback +from sqlalchemy import select + +app = typer.Typer(help="Model Router: Intelligent LLM Request Routing Platform") +console = Console(safe_box=True) +settings = get_settings() + + +@app.command() +def doctor(): + """Run environment, connectivity, and dependency health checks.""" + console.print(Panel.fit("[bold cyan]Model Router Diagnostics (modelrouter doctor)[/bold cyan]")) + + # 1. Python Check + py_ver = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}" + console.print(f" [green][OK][/green] Python: [bold]{py_ver}[/bold]") + + # 2. Database Check + try: + asyncio.run(init_db()) + console.print(" [green][OK][/green] SQLite Database: [bold]Initialized & Ready[/bold]") + except Exception as exc: + console.print(f" [red][FAIL][/red] Database Error: {exc}") + + # 3. Ollama Connectivity Check + ollama_ok = False + try: + r = httpx.get(f"{settings.OLLAMA_BASE_URL}/api/tags", timeout=1.5) + if r.status_code == 200: + models = [m.get("name") for m in r.json().get("models", [])] + console.print(f" [green][OK][/green] Ollama (Local): [bold]Connected[/bold] ({len(models)} local models found)") + ollama_ok = True + except Exception: + pass + if not ollama_ok: + console.print(f" [yellow][!][/yellow] Ollama (Local): [dim]Not running on {settings.OLLAMA_BASE_URL} (Optional, local fallback available)[/dim]") + + # 4. Mock Engine + console.print(" [green][OK][/green] Mock Engine: [bold]Ready (Zero API keys required)[/bold]") + + # 5. External Providers + if settings.OPENAI_API_KEY: + console.print(" [green][OK][/green] OpenAI Provider: [bold]API Key Configured in .env[/bold]") + else: + console.print(" [yellow][!][/yellow] OpenAI Provider: [dim]Not configured (Optional)[/dim]") + + if settings.ANTHROPIC_API_KEY: + console.print(" [green][OK][/green] Anthropic Provider: [bold]API Key Configured in .env[/bold]") + else: + console.print(" [yellow][!][/yellow] Anthropic Provider: [dim]Not configured (Optional)[/dim]") + + if settings.GEMINI_API_KEY: + console.print(" [green][OK][/green] Gemini Provider: [bold]API Key Configured in .env[/bold]") + else: + console.print(" [yellow][!][/yellow] Gemini Provider: [dim]Not configured (Optional)[/dim]") + + console.print("\n[bold green]Ready for local-first intelligent routing![/bold green]\n") + + +@app.command() +def models(): + """List all registered candidate models and their capability scores.""" + async def _list(): + await init_db() + async with AsyncSessionLocal() as db: + res = await db.execute(select(ModelRecord).order_by(ModelRecord.tier, ModelRecord.name)) + records = res.scalars().all() + + table = Table(title="Model Router Registry", border_style="bright_blue") + table.add_column("Model ID", style="cyan", no_wrap=True) + table.add_column("Tier", style="magenta") + table.add_column("Provider", style="green") + table.add_column("Context", style="yellow") + table.add_column("Quality", style="blue") + table.add_column("Speed", style="cyan") + table.add_column("Cost / 1K In/Out", style="white") + + for m in records: + cost_str = f"${m.cost_per_input_token*1000:.4f} / ${m.cost_per_output_token*1000:.4f}" if m.cost_per_input_token > 0 else "Free ($0)" + table.add_row( + m.id, + m.tier, + m.provider, + f"{m.context_window:,}", + f"{m.quality_score*100:.0f}%", + f"{m.speed_score*100:.0f}%", + cost_str, + ) + console.print(table) + + asyncio.run(_list()) + + +@app.command() +def route( + prompt: str = typer.Argument(..., help="Prompt text to route"), + policy: str = typer.Option("balanced", "--policy", "-p", help="Routing policy to use"), +): + """Analyze prompt and explain why the optimal model was selected (Dry Run).""" + async def _route(): + await init_db() + analysis = analyze_request_heuristics(prompt) + + async with AsyncSessionLocal() as db: + res_m = await db.execute(select(ModelRecord).filter_by(is_active=True)) + models = [db_model_to_meta(m) for m in res_m.scalars().all()] + + res_p = await db.execute(select(RoutingPolicyRecord).filter_by(id=policy)) + pol = res_p.scalar_one_or_none() + weights = { + "quality_weight": pol.quality_weight if pol else 0.35, + "cost_weight": pol.cost_weight if pol else 0.25, + "speed_weight": pol.speed_weight if pol else 0.20, + "capability_weight": pol.capability_weight if pol else 0.15, + "reliability_weight": pol.reliability_weight if pol else 0.05, + } + + decision = route_request( + analysis=analysis, + available_models=models, + policy_weights=weights, + policy_name=policy, + ) + + console.print(Panel.fit( + f"[bold white]Prompt:[/bold white] \"{prompt}\"\n" + f"[bold cyan]Task Type:[/bold cyan] {analysis.task_type.value} | [bold cyan]Complexity:[/bold cyan] {analysis.complexity_label.value} ({analysis.complexity:.2f})\n" + f"[bold green]Selected Model:[/bold green] [bold yellow]{decision.selected_model_name}[/bold yellow] ({decision.selected_model})\n" + f"[bold magenta]Confidence:[/bold magenta] {decision.confidence * 100:.0f}%\n" + f"[bold blue]Estimated Latency:[/bold blue] {decision.estimated_latency_ms:.0f}ms | [bold blue]Estimated Cost:[/bold blue] ${decision.estimated_cost_usd:.6f}", + title="ROUTING DECISION", + border_style="bright_blue", + )) + + console.print("[bold cyan]Why this model?[/bold cyan]") + for r in decision.reasons: + console.print(f" [green]+[/green] {r}") + + if decision.rejected_candidates: + console.print("\n[bold red]Rejected Candidates:[/bold red]") + for cid, reason in decision.rejected_candidates.items(): + console.print(f" [dim]- {cid}: {reason}[/dim]") + + asyncio.run(_route()) + + +@app.command() +def run( + prompt: str = typer.Argument(..., help="Prompt to route and execute"), + policy: str = typer.Option("balanced", "--policy", "-p", help="Routing policy to use"), +): + """Route request and execute inference through the chosen provider.""" + async def _run(): + await init_db() + analysis = analyze_request_heuristics(prompt) + + async with AsyncSessionLocal() as db: + res_m = await db.execute(select(ModelRecord).filter_by(is_active=True)) + models = [db_model_to_meta(m) for m in res_m.scalars().all()] + + decision = route_request( + analysis=analysis, + available_models=models, + policy_weights={"quality_weight": 0.35, "cost_weight": 0.25, "speed_weight": 0.20, "capability_weight": 0.15, "reliability_weight": 0.05}, + policy_name=policy, + ) + + console.print(f"[bold cyan]Routing to:[/bold cyan] {decision.selected_model} via provider: {decision.provider}...") + + resp, fallback_used, orig_m, fb_reason = await execute_with_fallback( + prompt=prompt, + selected_model_id=decision.selected_model, + selected_provider_id=decision.provider, + all_models=models, + ) + + console.print(Panel( + resp.content, + title=f"RESPONSE from {resp.model} ({'FALLBACK: ' + orig_m if fallback_used else 'PRIMARY'})", + subtitle=f"Latency: {resp.provider_latency_ms:.0f}ms | Tokens: {resp.total_tokens}", + border_style="green" if not fallback_used else "yellow", + )) + + asyncio.run(_run()) + + +@app.command() +def traffic(limit: int = 10): + """View recent routed traffic log.""" + async def _traffic(): + await init_db() + from app.storage.models import RequestRecord + from sqlalchemy import desc + async with AsyncSessionLocal() as db: + res = await db.execute(select(RequestRecord).order_by(desc(RequestRecord.timestamp)).limit(limit)) + records = res.scalars().all() + + table = Table(title="Recent Routed Traffic Feed", border_style="bright_blue") + table.add_column("Time", style="dim") + table.add_column("Task", style="cyan") + table.add_column("Selected Model", style="green") + table.add_column("Latency", style="yellow") + table.add_column("Cost", style="magenta") + table.add_column("Prompt Sample", style="white") + + for r in records: + t_str = r.timestamp.strftime("%H:%M:%S") if r.timestamp else "N/A" + table.add_row( + t_str, + r.task_type, + r.selected_model, + f"{r.total_latency_ms:.0f}ms", + f"${r.estimated_cost:.5f}", + r.prompt[:40] + ("..." if len(r.prompt) > 40 else ""), + ) + console.print(table) + + asyncio.run(_traffic()) + + +@app.command() +def analytics(): + """Display system-wide routing performance and cost savings analytics.""" + async def _analytics(): + await init_db() + from app.analytics.service import get_system_analytics + async with AsyncSessionLocal() as db: + data = await get_system_analytics(db) + console.print(Panel.fit( + f"[bold cyan]Total Routed Requests:[/bold cyan] {data['total_requests']}\n" + f"[bold green]Average Latency:[/bold green] {data['avg_latency_ms']}ms (Routing overhead: {data['avg_routing_latency_ms']}ms)\n" + f"[bold yellow]Total Cost:[/bold yellow] ${data['total_cost_usd']:.6f}\n" + f"[bold magenta]Cost Saved vs Baseline:[/bold magenta] ${data['savings']['cost_saved_usd']:.6f} ({data['savings']['savings_percentage']}%)\n" + f"[bold blue]Fallback Rate:[/bold blue] {data['fallback_rate_percent']}%\n", + title="MODEL ROUTER ANALYTICS OVERVIEW", + border_style="bright_blue", + )) + + asyncio.run(_analytics()) + + +if __name__ == "__main__": + app() diff --git a/backend/app/config/settings.py b/backend/app/config/settings.py new file mode 100644 index 0000000..392f1f4 --- /dev/null +++ b/backend/app/config/settings.py @@ -0,0 +1,43 @@ +from functools import lru_cache +from typing import Optional +from pydantic_settings import BaseSettings, SettingsConfigDict + + +class Settings(BaseSettings): + APP_ENV: str = "development" + DEBUG: bool = True + PORT: int = 8000 + HOST: str = "0.0.0.0" + + DATABASE_URL: str = "sqlite+aiosqlite:///./model_router.db" + ROUTER_ANALYZER: str = "rules" # "rules" or "llm" + DEFAULT_ROUTING_POLICY: str = "balanced" + BASELINE_MODEL_ID: str = "mock-power" + + DEFAULT_PROVIDER: str = "mock" + OLLAMA_BASE_URL: str = "http://localhost:11434" + + # External Provider Keys (optional) + OPENAI_API_KEY: Optional[str] = None + ANTHROPIC_API_KEY: Optional[str] = None + GEMINI_API_KEY: Optional[str] = None + + # Budgets + DAILY_BUDGET: float = 10.00 + MONTHLY_BUDGET: float = 100.00 + PER_REQUEST_BUDGET: float = 1.00 + + # Execution / Reliability + MAX_RETRIES: int = 2 + PROVIDER_TIMEOUT_SECONDS: float = 30.0 + + model_config = SettingsConfigDict( + env_file=".env", + env_file_encoding="utf-8", + extra="ignore", + ) + + +@lru_cache() +def get_settings() -> Settings: + return Settings() diff --git a/backend/app/experiments/service.py b/backend/app/experiments/service.py new file mode 100644 index 0000000..9bc2517 --- /dev/null +++ b/backend/app/experiments/service.py @@ -0,0 +1,85 @@ +import uuid +import datetime +from typing import Dict, Any, List +from sqlalchemy import select, func +from sqlalchemy.ext.asyncio import AsyncSession +from app.storage.models import ExperimentRecord, ExperimentRunRecord + + +async def log_experiment_run( + session: AsyncSession, + experiment_id: str, + request_id: str, + policy: str, + model: str, + cost: float, + latency_ms: float, +): + run = ExperimentRunRecord( + id=str(uuid.uuid4()), + experiment_id=experiment_id, + request_id=request_id, + assigned_policy=policy, + selected_model=model, + cost=cost, + latency_ms=latency_ms, + ) + session.add(run) + + # Increment sample count + res = await session.execute(select(ExperimentRecord).filter_by(id=experiment_id)) + exp = res.scalar_one_or_none() + if exp: + exp.sample_count += 1 + await session.commit() + + +async def get_experiment_summary( + session: AsyncSession, + experiment_id: str, +) -> Dict[str, Any]: + res = await session.execute(select(ExperimentRecord).filter_by(id=experiment_id)) + exp = res.scalar_one_or_none() + if not exp: + return {} + + # Calculate metrics for Policy A vs Policy B + runs_a = await session.execute( + select( + func.count(ExperimentRunRecord.id), + func.avg(ExperimentRunRecord.cost), + func.avg(ExperimentRunRecord.latency_ms), + ).filter_by(experiment_id=experiment_id, assigned_policy=exp.policy_a) + ) + count_a, cost_a, lat_a = runs_a.one() + + runs_b = await session.execute( + select( + func.count(ExperimentRunRecord.id), + func.avg(ExperimentRunRecord.cost), + func.avg(ExperimentRunRecord.latency_ms), + ).filter_by(experiment_id=experiment_id, assigned_policy=exp.policy_b) + ) + count_b, cost_b, lat_b = runs_b.one() + + return { + "id": exp.id, + "name": exp.name, + "description": exp.description, + "policy_a": exp.policy_a, + "policy_b": exp.policy_b, + "status": exp.status, + "total_samples": exp.sample_count, + "results": { + exp.policy_a: { + "sample_count": count_a or 0, + "avg_cost_usd": round(cost_a or 0.0, 6), + "avg_latency_ms": round(lat_a or 0.0, 1), + }, + exp.policy_b: { + "sample_count": count_b or 0, + "avg_cost_usd": round(cost_b or 0.0, 6), + "avg_latency_ms": round(lat_b or 0.0, 1), + }, + }, + } diff --git a/backend/app/fallback/handler.py b/backend/app/fallback/handler.py new file mode 100644 index 0000000..c8ed13e --- /dev/null +++ b/backend/app/fallback/handler.py @@ -0,0 +1,105 @@ +import time +import asyncio +from typing import List, Optional, Tuple, Dict, Any +from app.models.schemas import ProviderResponse, ModelMetadata +from app.providers.registry import provider_registry +from app.config.settings import get_settings + +settings = get_settings() + +RETRYABLE_ERRORS = [ + "timeout", + "connection error", + "rate limit", + "429", + "503", + "service unavailable", + "econnreset", +] + + +def is_retryable(error_str: Optional[str]) -> bool: + if not error_str: + return False + low = error_str.lower() + return any(keyword in low for keyword in RETRYABLE_ERRORS) + + +async def execute_with_fallback( + prompt: str, + selected_model_id: str, + selected_provider_id: str, + all_models: List[ModelMetadata], + system_prompt: Optional[str] = None, + temperature: float = 0.7, + max_retries: int = 1, +) -> Tuple[ProviderResponse, bool, Optional[str], Optional[str]]: + """ + Executes model generation with configurable retries and fallback hierarchy. + Returns: (ProviderResponse, fallback_used, original_model, fallback_reason) + """ + current_model_id = selected_model_id + current_provider_id = selected_provider_id + fallback_used = False + original_model = selected_model_id + fallback_reason = None + + # Step 1: Attempt primary model with retries + provider = provider_registry.get_provider(current_provider_id) + if not provider: + provider = provider_registry.get_provider("mock") + current_provider_id = "mock" + current_model_id = "mock-balanced" + fallback_used = True + fallback_reason = f"Provider '{selected_provider_id}' is not loaded. Fell back to Mock." + + for attempt in range(max_retries + 1): + resp = await provider.generate( + prompt=prompt, + model_id=current_model_id, + system_prompt=system_prompt, + temperature=temperature, + ) + + if not resp.error and resp.finish_reason != "error": + return resp, fallback_used, original_model if fallback_used else None, fallback_reason + + # If non-retryable error or last attempt, prepare for fallback + if not is_retryable(resp.error) or attempt == max_retries: + fallback_reason = resp.error or "Unknown primary model execution error." + break + + await asyncio.sleep(0.5 * (attempt + 1)) + + # Step 2: Determine Fallback Candidate + fallback_used = True + # Priority: Mock model of same or balanced tier, or active local Ollama + candidate_fallbacks = [ + m for m in all_models + if m.id != selected_model_id and m.is_active and (m.provider == "mock" or m.type == "LOCAL") + ] + if not candidate_fallbacks: + candidate_fallbacks = [m for m in all_models if m.id != selected_model_id and m.is_active] + + fallback_target = candidate_fallbacks[0] if candidate_fallbacks else None + + if fallback_target: + fb_provider = provider_registry.get_provider(fallback_target.provider) or provider_registry.get_provider("mock") + fb_resp = await fb_provider.generate( + prompt=prompt, + model_id=fallback_target.id, + system_prompt=system_prompt, + temperature=temperature, + ) + if not fb_resp.error: + return fb_resp, True, original_model, f"Primary model failed: {fallback_reason} -> Fallback to {fallback_target.id}" + + # Step 3: Emergency Hard Mock fallback + emergency_mock = provider_registry.get_provider("mock") + emergency_resp = await emergency_mock.generate( + prompt=prompt, + model_id="mock-balanced", + system_prompt=system_prompt, + temperature=temperature, + ) + return emergency_resp, True, original_model, f"Emergency fallback triggered due to: {fallback_reason}" diff --git a/backend/app/models/schemas.py b/backend/app/models/schemas.py new file mode 100644 index 0000000..13055d4 --- /dev/null +++ b/backend/app/models/schemas.py @@ -0,0 +1,127 @@ +from enum import Enum +from typing import List, Optional, Dict, Any +from pydantic import BaseModel, Field + + +class TaskType(str, Enum): + GENERAL_QA = "GENERAL_QA" + CODING = "CODING" + DEBUGGING = "DEBUGGING" + REASONING = "REASONING" + SUMMARIZATION = "SUMMARIZATION" + EXTRACTION = "EXTRACTION" + WRITING = "WRITING" + TRANSLATION = "TRANSLATION" + ANALYSIS = "ANALYSIS" + MATH = "MATH" + LONG_CONTEXT = "LONG_CONTEXT" + CREATIVE = "CREATIVE" + + +class PriorityLevel(str, Enum): + LOW = "LOW" + MEDIUM = "MEDIUM" + HIGH = "HIGH" + + +class ModelTier(str, Enum): + FAST = "FAST" + BALANCED = "BALANCED" + POWER = "POWER" + + +class ProviderType(str, Enum): + MOCK = "mock" + OLLAMA = "ollama" + OPENAI = "openai" + ANTHROPIC = "anthropic" + GEMINI = "gemini" + CUSTOM = "custom" + + +class RequestAnalysis(BaseModel): + task_type: TaskType = Field(default=TaskType.GENERAL_QA) + complexity: float = Field(default=0.5, ge=0.0, le=1.0) + complexity_label: PriorityLevel = Field(default=PriorityLevel.MEDIUM) + reasoning_required: bool = Field(default=False) + coding_required: bool = Field(default=False) + vision_required: bool = Field(default=False) + tools_required: bool = Field(default=False) + context_size: int = Field(default=0) # in estimated tokens / characters + latency_priority: PriorityLevel = Field(default=PriorityLevel.MEDIUM) + cost_sensitivity: PriorityLevel = Field(default=PriorityLevel.MEDIUM) + quality_requirement: PriorityLevel = Field(default=PriorityLevel.MEDIUM) + keywords_detected: List[str] = Field(default_factory=list) + analyzer_used: str = Field(default="rules") + + +class ModelMetadata(BaseModel): + id: str + name: str + provider: str + type: str = "LOCAL" # LOCAL, CLOUD, MOCK + tier: ModelTier = ModelTier.BALANCED + context_window: int = 8192 + + supports_coding: bool = False + supports_reasoning: bool = False + supports_vision: bool = False + supports_tools: bool = False + + quality_score: float = 0.75 # 0.0 - 1.0 + speed_score: float = 0.75 # 0.0 - 1.0 + reliability_score: float = 0.95 + + cost_per_input_token: float = 0.0 + cost_per_output_token: float = 0.0 + availability: str = "AVAILABLE" + is_active: bool = True + + +class CandidateScore(BaseModel): + model_id: str + model_name: str + provider: str + tier: str + overall_score: float # 0 - 100 + quality_component: float + cost_component: float + speed_component: float + capability_component: float + reliability_component: float + estimated_latency_ms: float + estimated_cost_usd: float + eligible: bool = True + rejection_reason: Optional[str] = None + + +class RoutingDecision(BaseModel): + decision_id: str + request_id: str + selected_model: str + selected_model_name: str + provider: str + tier: str + confidence: float + policy_used: str + reasons: List[str] + candidate_scores: List[CandidateScore] + rejected_candidates: Dict[str, str] = Field(default_factory=dict) + estimated_cost_usd: float + estimated_latency_ms: float + rule_applied: Optional[str] = None + timestamp: str + + +class ProviderResponse(BaseModel): + content: str + finish_reason: str = "stop" + input_tokens: int = 0 + output_tokens: int = 0 + total_tokens: int = 0 + provider_latency_ms: float = 0.0 + time_to_first_token_ms: Optional[float] = None + is_mock: bool = False + model: str = "" + provider: str = "" + error: Optional[str] = None diff --git a/backend/app/observability/events.py b/backend/app/observability/events.py new file mode 100644 index 0000000..cdf93ad --- /dev/null +++ b/backend/app/observability/events.py @@ -0,0 +1,43 @@ +import json +import logging +from typing import Dict, Any, Optional +import datetime + +logger = logging.getLogger("model_router.observability") +logger.setLevel(logging.INFO) +if not logger.handlers: + handler = logging.StreamHandler() + formatter = logging.Formatter('{"time":"%(asctime)s", "level":"%(levelname)s", "event":%(message)s}') + handler.setFormatter(formatter) + logger.addHandler(handler) + + +def log_router_event( + event_name: str, + request_id: str, + model: Optional[str] = None, + provider: Optional[str] = None, + duration_ms: Optional[float] = None, + metadata: Optional[Dict[str, Any]] = None, +): + """ + Structured event logger for model router pipeline. + Redacts sensitive credentials automatically. + """ + payload = { + "event": event_name, + "request_id": request_id, + "timestamp": datetime.datetime.utcnow().isoformat(), + "model": model, + "provider": provider, + "duration_ms": duration_ms, + } + if metadata: + # Sanitize any key that looks like an API token + safe_meta = { + k: ("[REDACTED]" if "key" in k.lower() or "secret" in k.lower() or "token" in k.lower() and "count" not in k.lower() else v) + for k, v in metadata.items() + } + payload["metadata"] = safe_meta + + logger.info(json.dumps(payload)) diff --git a/backend/app/providers/base.py b/backend/app/providers/base.py new file mode 100644 index 0000000..c613a00 --- /dev/null +++ b/backend/app/providers/base.py @@ -0,0 +1,46 @@ +import abc +import time +import asyncio +from typing import AsyncGenerator, Dict, Any, Optional +from app.models.schemas import ProviderResponse + + +class ModelProvider(abc.ABC): + """ + Abstract Base Class for all Model Providers (Mock, Ollama, OpenAI, Anthropic, Gemini, etc.) + Ensures complete provider decoupling from routing logic. + """ + + def __init__(self, provider_id: str, name: str, base_url: Optional[str] = None): + self.provider_id = provider_id + self.name = name + self.base_url = base_url + + @abc.abstractmethod + async def generate( + self, + prompt: str, + model_id: str, + system_prompt: Optional[str] = None, + temperature: float = 0.7, + max_tokens: Optional[int] = None, + ) -> ProviderResponse: + """Execute a text generation call against the model provider.""" + pass + + @abc.abstractmethod + async def stream( + self, + prompt: str, + model_id: str, + system_prompt: Optional[str] = None, + temperature: float = 0.7, + max_tokens: Optional[int] = None, + ) -> AsyncGenerator[str, None]: + """Stream generated response chunks.""" + pass + + @abc.abstractmethod + async def check_health(self) -> Dict[str, Any]: + """Check provider connectivity, status, and loaded models.""" + pass diff --git a/backend/app/providers/external_providers.py b/backend/app/providers/external_providers.py new file mode 100644 index 0000000..6276861 --- /dev/null +++ b/backend/app/providers/external_providers.py @@ -0,0 +1,321 @@ +import time +import httpx +from typing import AsyncGenerator, Dict, Any, Optional +from app.providers.base import ModelProvider +from app.models.schemas import ProviderResponse +from app.config.settings import get_settings + +settings = get_settings() + + +class OpenAIProvider(ModelProvider): + """ + OpenAI Provider Adapter. + Uses OPENAI_API_KEY from environment variables. Secrets are never exposed. + """ + + def __init__(self, api_key: Optional[str] = None): + super().__init__(provider_id="openai", name="OpenAI", base_url="https://api.openai.com/v1") + self.api_key = api_key or settings.OPENAI_API_KEY + + async def generate( + self, + prompt: str, + model_id: str, + system_prompt: Optional[str] = None, + temperature: float = 0.7, + max_tokens: Optional[int] = None, + ) -> ProviderResponse: + if not self.api_key: + return ProviderResponse( + content="", + finish_reason="error", + error="OPENAI_API_KEY not configured in environment.", + is_mock=False, + model=model_id, + provider="openai", + ) + + endpoint = f"{self.base_url}/chat/completions" + headers = { + "Authorization": f"Bearer {self.api_key}", + "Content-Type": "application/json", + } + messages = [] + if system_prompt: + messages.append({"role": "system", "content": system_prompt}) + messages.append({"role": "user", "content": prompt}) + + payload: Dict[str, Any] = { + "model": model_id, + "messages": messages, + "temperature": temperature, + } + if max_tokens: + payload["max_tokens"] = max_tokens + + start_time = time.perf_counter() + try: + async with httpx.AsyncClient(timeout=settings.PROVIDER_TIMEOUT_SECONDS) as client: + resp = await client.post(endpoint, json=payload, headers=headers) + resp.raise_for_status() + data = resp.json() + + elapsed_ms = (time.perf_counter() - start_time) * 1000.0 + choice = data["choices"][0] + usage = data.get("usage", {}) + + return ProviderResponse( + content=choice["message"]["content"], + finish_reason=choice.get("finish_reason", "stop"), + input_tokens=usage.get("prompt_tokens", 0), + output_tokens=usage.get("completion_tokens", 0), + total_tokens=usage.get("total_tokens", 0), + provider_latency_ms=round(elapsed_ms, 2), + is_mock=False, + model=model_id, + provider="openai", + ) + except Exception as exc: + return ProviderResponse( + content="", + finish_reason="error", + error=f"OpenAI error: {str(exc)}", + is_mock=False, + model=model_id, + provider="openai", + provider_latency_ms=(time.perf_counter() - start_time) * 1000.0, + ) + + async def stream( + self, + prompt: str, + model_id: str, + system_prompt: Optional[str] = None, + temperature: float = 0.7, + max_tokens: Optional[int] = None, + ) -> AsyncGenerator[str, None]: + if not self.api_key: + yield "[OpenAI Error: API key not configured]" + return + + endpoint = f"{self.base_url}/chat/completions" + headers = {"Authorization": f"Bearer {self.api_key}"} + messages = [] + if system_prompt: + messages.append({"role": "system", "content": system_prompt}) + messages.append({"role": "user", "content": prompt}) + + payload = { + "model": model_id, + "messages": messages, + "temperature": temperature, + "stream": True, + } + + try: + async with httpx.AsyncClient(timeout=settings.PROVIDER_TIMEOUT_SECONDS) as client: + async with client.stream("POST", endpoint, json=payload, headers=headers) as resp: + async for line in resp.aiter_lines(): + if line.startswith("data: ") and not line.endswith("[DONE]"): + import json + data = json.loads(line[6:]) + delta = data["choices"][0].get("delta", {}).get("content", "") + if delta: + yield delta + except Exception as exc: + yield f"\n[OpenAI Streaming Error: {str(exc)}]" + + async def check_health(self) -> Dict[str, Any]: + if not self.api_key: + return {"provider": "openai", "status": "NOT_CONFIGURED", "message": "API key not set in .env"} + return {"provider": "openai", "status": "CONNECTED", "message": "API key configured."} + + +class AnthropicProvider(ModelProvider): + """ + Anthropic Provider Adapter. + """ + + def __init__(self, api_key: Optional[str] = None): + super().__init__(provider_id="anthropic", name="Anthropic", base_url="https://api.anthropic.com/v1") + self.api_key = api_key or settings.ANTHROPIC_API_KEY + + async def generate( + self, + prompt: str, + model_id: str, + system_prompt: Optional[str] = None, + temperature: float = 0.7, + max_tokens: Optional[int] = None, + ) -> ProviderResponse: + if not self.api_key: + return ProviderResponse( + content="", + finish_reason="error", + error="ANTHROPIC_API_KEY not configured in environment.", + is_mock=False, + model=model_id, + provider="anthropic", + ) + + endpoint = f"{self.base_url}/messages" + headers = { + "x-api-key": self.api_key, + "anthropic-version": "2023-06-01", + "Content-Type": "application/json", + } + payload: Dict[str, Any] = { + "model": model_id, + "messages": [{"role": "user", "content": prompt}], + "max_tokens": max_tokens or 2048, + "temperature": temperature, + } + if system_prompt: + payload["system"] = system_prompt + + start_time = time.perf_counter() + try: + async with httpx.AsyncClient(timeout=settings.PROVIDER_TIMEOUT_SECONDS) as client: + resp = await client.post(endpoint, json=payload, headers=headers) + resp.raise_for_status() + data = resp.json() + + elapsed_ms = (time.perf_counter() - start_time) * 1000.0 + content = data["content"][0]["text"] + usage = data.get("usage", {}) + + return ProviderResponse( + content=content, + finish_reason=data.get("stop_reason", "stop"), + input_tokens=usage.get("input_tokens", 0), + output_tokens=usage.get("output_tokens", 0), + total_tokens=usage.get("input_tokens", 0) + usage.get("output_tokens", 0), + provider_latency_ms=round(elapsed_ms, 2), + is_mock=False, + model=model_id, + provider="anthropic", + ) + except Exception as exc: + return ProviderResponse( + content="", + finish_reason="error", + error=f"Anthropic error: {str(exc)}", + is_mock=False, + model=model_id, + provider="anthropic", + provider_latency_ms=(time.perf_counter() - start_time) * 1000.0, + ) + + async def stream( + self, + prompt: str, + model_id: str, + system_prompt: Optional[str] = None, + temperature: float = 0.7, + max_tokens: Optional[int] = None, + ) -> AsyncGenerator[str, None]: + resp = await self.generate(prompt, model_id, system_prompt, temperature, max_tokens) + if resp.error: + yield f"[{resp.error}]" + return + for word in resp.content.split(" "): + yield word + " " + + async def check_health(self) -> Dict[str, Any]: + if not self.api_key: + return {"provider": "anthropic", "status": "NOT_CONFIGURED", "message": "API key not set in .env"} + return {"provider": "anthropic", "status": "CONNECTED", "message": "API key configured."} + + +class GeminiProvider(ModelProvider): + """ + Google Gemini Provider Adapter. + """ + + def __init__(self, api_key: Optional[str] = None): + super().__init__(provider_id="gemini", name="Google Gemini", base_url="https://generativelanguage.googleapis.com/v1beta") + self.api_key = api_key or settings.GEMINI_API_KEY + + async def generate( + self, + prompt: str, + model_id: str, + system_prompt: Optional[str] = None, + temperature: float = 0.7, + max_tokens: Optional[int] = None, + ) -> ProviderResponse: + if not self.api_key: + return ProviderResponse( + content="", + finish_reason="error", + error="GEMINI_API_KEY not configured in environment.", + is_mock=False, + model=model_id, + provider="gemini", + ) + + endpoint = f"{self.base_url}/models/{model_id}:generateContent?key={self.api_key}" + contents = [] + if system_prompt: + contents.append({"role": "user", "parts": [{"text": f"System context: {system_prompt}"}]}) + contents.append({"role": "user", "parts": [{"text": prompt}]}) + + payload = { + "contents": contents, + "generationConfig": {"temperature": temperature}, + } + + start_time = time.perf_counter() + try: + async with httpx.AsyncClient(timeout=settings.PROVIDER_TIMEOUT_SECONDS) as client: + resp = await client.post(endpoint, json=payload) + resp.raise_for_status() + data = resp.json() + + elapsed_ms = (time.perf_counter() - start_time) * 1000.0 + candidate = data["candidates"][0] + text = candidate["content"]["parts"][0]["text"] + usage = data.get("usageMetadata", {}) + + return ProviderResponse( + content=text, + finish_reason=candidate.get("finishReason", "stop"), + input_tokens=usage.get("promptTokenCount", 0), + output_tokens=usage.get("candidatesTokenCount", 0), + total_tokens=usage.get("totalTokenCount", 0), + provider_latency_ms=round(elapsed_ms, 2), + is_mock=False, + model=model_id, + provider="gemini", + ) + except Exception as exc: + return ProviderResponse( + content="", + finish_reason="error", + error=f"Gemini error: {str(exc)}", + is_mock=False, + model=model_id, + provider="gemini", + provider_latency_ms=(time.perf_counter() - start_time) * 1000.0, + ) + + async def stream( + self, + prompt: str, + model_id: str, + system_prompt: Optional[str] = None, + temperature: float = 0.7, + max_tokens: Optional[int] = None, + ) -> AsyncGenerator[str, None]: + resp = await self.generate(prompt, model_id, system_prompt, temperature, max_tokens) + if resp.error: + yield f"[{resp.error}]" + return + for word in resp.content.split(" "): + yield word + " " + + async def check_health(self) -> Dict[str, Any]: + if not self.api_key: + return {"provider": "gemini", "status": "NOT_CONFIGURED", "message": "API key not set in .env"} + return {"provider": "gemini", "status": "CONNECTED", "message": "API key configured."} diff --git a/backend/app/providers/mock_provider.py b/backend/app/providers/mock_provider.py new file mode 100644 index 0000000..9cc5b6c --- /dev/null +++ b/backend/app/providers/mock_provider.py @@ -0,0 +1,108 @@ +import asyncio +import time +from typing import AsyncGenerator, Dict, Any, Optional +from app.providers.base import ModelProvider +from app.models.schemas import ProviderResponse + + +class MockProvider(ModelProvider): + """ + Mock Provider for development, testing, and zero-cost simulation. + All outputs are explicitly labeled as DEMO/MOCK. + """ + + def __init__(self): + super().__init__(provider_id="mock", name="Mock / Demo Provider") + + async def generate( + self, + prompt: str, + model_id: str, + system_prompt: Optional[str] = None, + temperature: float = 0.7, + max_tokens: Optional[int] = None, + ) -> ProviderResponse: + start_time = time.perf_counter() + + # Simulate realistic latency based on tier + tier_delay = 0.08 if "fast" in model_id else (0.18 if "balanced" in model_id else 0.35) + await asyncio.sleep(tier_delay) + + elapsed_ms = (time.perf_counter() - start_time) * 1000.0 + + # Calculate realistic token estimations + input_tokens = max(1, len(prompt.split()) * 2) + + # Response tailored to task keywords + prompt_lower = prompt.lower() + if "python" in prompt_lower or "code" in prompt_lower or "def " in prompt_lower or "function" in prompt_lower: + content = ( + f"[DEMO/MOCK RESPONSE from {model_id}]\n\n" + f"```python\n" + f"# Mock implementation generated for: {prompt[:60]}...\n" + f"def solve_problem(*args, **kwargs):\n" + f" \"\"\"Simulated response from Model Router Demo Engine.\"\"\"\n" + f" result = [x for x in args if x is not None]\n" + f" return {{'status': 'success', 'data': result, 'model': '{model_id}'}}\n" + f"```\n\n" + f"This code was returned by the simulated {model_id} engine." + ) + elif "debug" in prompt_lower or "error" in prompt_lower or "bug" in prompt_lower: + content = ( + f"[DEMO/MOCK RESPONSE from {model_id}]\n\n" + f"### Root Cause Analysis:\n" + f"1. **Potential Bottleneck**: Asynchronous task scheduling without proper semaphore limits.\n" + f"2. **Mitigation**: Introduce bounded concurrency worker pools.\n" + f"3. **Verification**: Checked against {model_id} simulated reasoning engine." + ) + elif "summary" in prompt_lower or "summarize" in prompt_lower: + content = ( + f"[DEMO/MOCK RESPONSE from {model_id}]\n\n" + f"**Executive Summary**:\n" + f"• Main point: {prompt[:80]}...\n" + f"• Key takeaway: High routing accuracy achieved with minimal latency overhead." + ) + else: + content = ( + f"[DEMO/MOCK RESPONSE from {model_id}]\n\n" + f"Processed request: \"{prompt[:100]}\"\n\n" + f"This is a simulated response generated locally by Model Router Mock Engine without external API calls." + ) + + output_tokens = max(1, len(content.split()) * 2) + total_tokens = input_tokens + output_tokens + + return ProviderResponse( + content=content, + finish_reason="stop", + input_tokens=input_tokens, + output_tokens=output_tokens, + total_tokens=total_tokens, + provider_latency_ms=round(elapsed_ms, 2), + time_to_first_token_ms=round(tier_delay * 500, 2), + is_mock=True, + model=model_id, + provider="mock", + ) + + async def stream( + self, + prompt: str, + model_id: str, + system_prompt: Optional[str] = None, + temperature: float = 0.7, + max_tokens: Optional[int] = None, + ) -> AsyncGenerator[str, None]: + resp = await self.generate(prompt, model_id, system_prompt, temperature, max_tokens) + chunks = resp.content.split(" ") + for chunk in chunks: + await asyncio.sleep(0.02) + yield chunk + " " + + async def check_health(self) -> Dict[str, Any]: + return { + "provider": "mock", + "status": "CONNECTED", + "message": "Mock provider active (Demo Mode). Zero API keys required.", + "models_available": ["mock-fast", "mock-balanced", "mock-power"], + } diff --git a/backend/app/providers/ollama_provider.py b/backend/app/providers/ollama_provider.py new file mode 100644 index 0000000..1ab56a1 --- /dev/null +++ b/backend/app/providers/ollama_provider.py @@ -0,0 +1,141 @@ +import time +import httpx +from typing import AsyncGenerator, Dict, Any, Optional +from app.providers.base import ModelProvider +from app.models.schemas import ProviderResponse +from app.config.settings import get_settings + +settings = get_settings() + + +class OllamaProvider(ModelProvider): + """ + Local Ollama Provider adapter. + Executes real inference against locally running Ollama instance without external API keys. + """ + + def __init__(self, base_url: Optional[str] = None): + url = base_url or settings.OLLAMA_BASE_URL + super().__init__(provider_id="ollama", name="Ollama (Local)", base_url=url) + + def _strip_model_prefix(self, model_id: str) -> str: + # e.g. "ollama-qwen2.5-coder" -> "qwen2.5-coder" + if model_id.startswith("ollama-"): + return model_id[len("ollama-"):] + return model_id + + async def generate( + self, + prompt: str, + model_id: str, + system_prompt: Optional[str] = None, + temperature: float = 0.7, + max_tokens: Optional[int] = None, + ) -> ProviderResponse: + real_model = self._strip_model_prefix(model_id) + endpoint = f"{self.base_url.rstrip('/')}/api/generate" + + payload: Dict[str, Any] = { + "model": real_model, + "prompt": prompt, + "stream": False, + "options": { + "temperature": temperature, + } + } + if system_prompt: + payload["system"] = system_prompt + if max_tokens: + payload["options"]["num_predict"] = max_tokens + + start_time = time.perf_counter() + try: + async with httpx.AsyncClient(timeout=settings.PROVIDER_TIMEOUT_SECONDS) as client: + resp = await client.post(endpoint, json=payload) + resp.raise_for_status() + data = resp.json() + + elapsed_ms = (time.perf_counter() - start_time) * 1000.0 + + content = data.get("response", "") + input_tokens = data.get("prompt_eval_count", max(1, len(prompt.split()) * 2)) + output_tokens = data.get("eval_count", max(1, len(content.split()) * 2)) + + # Nanoseconds to ms if provided by ollama + eval_duration_ms = data.get("eval_duration", 0) / 1_000_000.0 if "eval_duration" in data else elapsed_ms + + return ProviderResponse( + content=content, + finish_reason="stop" if data.get("done") else "length", + input_tokens=input_tokens, + output_tokens=output_tokens, + total_tokens=input_tokens + output_tokens, + provider_latency_ms=round(elapsed_ms, 2), + time_to_first_token_ms=round(data.get("prompt_eval_duration", 0) / 1_000_000.0, 2) or None, + is_mock=False, + model=model_id, + provider="ollama", + ) + except Exception as exc: + return ProviderResponse( + content="", + finish_reason="error", + error=f"Ollama connection error ({str(exc)}). Is Ollama running on {self.base_url}?", + is_mock=False, + model=model_id, + provider="ollama", + provider_latency_ms=(time.perf_counter() - start_time) * 1000.0, + ) + + async def stream( + self, + prompt: str, + model_id: str, + system_prompt: Optional[str] = None, + temperature: float = 0.7, + max_tokens: Optional[int] = None, + ) -> AsyncGenerator[str, None]: + real_model = self._strip_model_prefix(model_id) + endpoint = f"{self.base_url.rstrip('/')}/api/generate" + payload = { + "model": real_model, + "prompt": prompt, + "stream": True, + "options": {"temperature": temperature}, + } + if system_prompt: + payload["system"] = system_prompt + + try: + async with httpx.AsyncClient(timeout=settings.PROVIDER_TIMEOUT_SECONDS) as client: + async with client.stream("POST", endpoint, json=payload) as resp: + async for line in resp.aiter_lines(): + if line: + import json + data = json.loads(line) + chunk = data.get("response", "") + if chunk: + yield chunk + except Exception as exc: + yield f"\n[Ollama Streaming Error: {str(exc)}]" + + async def check_health(self) -> Dict[str, Any]: + try: + async with httpx.AsyncClient(timeout=3.0) as client: + resp = await client.get(f"{self.base_url.rstrip('/')}/api/tags") + if resp.status_code == 200: + models = [m.get("name") for m in resp.json().get("models", [])] + return { + "provider": "ollama", + "status": "CONNECTED", + "base_url": self.base_url, + "models_available": models, + } + except Exception as exc: + pass + return { + "provider": "ollama", + "status": "NOT_CONNECTED", + "base_url": self.base_url, + "message": "Ollama service unreachable on configured port. Start via 'ollama serve'.", + } diff --git a/backend/app/providers/registry.py b/backend/app/providers/registry.py new file mode 100644 index 0000000..ffb9f6d --- /dev/null +++ b/backend/app/providers/registry.py @@ -0,0 +1,35 @@ +from typing import Dict, Optional +from app.providers.base import ModelProvider +from app.providers.mock_provider import MockProvider +from app.providers.ollama_provider import OllamaProvider +from app.providers.external_providers import OpenAIProvider, AnthropicProvider, GeminiProvider +from app.config.settings import get_settings + +settings = get_settings() + + +class ProviderRegistry: + """ + Central registry managing provider instances. + """ + + def __init__(self): + self._providers: Dict[str, ModelProvider] = { + "mock": MockProvider(), + "ollama": OllamaProvider(base_url=settings.OLLAMA_BASE_URL), + "openai": OpenAIProvider(api_key=settings.OPENAI_API_KEY), + "anthropic": AnthropicProvider(api_key=settings.ANTHROPIC_API_KEY), + "gemini": GeminiProvider(api_key=settings.GEMINI_API_KEY), + } + + def get_provider(self, provider_id: str) -> Optional[ModelProvider]: + return self._providers.get(provider_id.lower()) + + def register_provider(self, provider_id: str, provider: ModelProvider): + self._providers[provider_id.lower()] = provider + + def list_providers(self) -> Dict[str, ModelProvider]: + return self._providers + + +provider_registry = ProviderRegistry() diff --git a/backend/app/router/engine.py b/backend/app/router/engine.py new file mode 100644 index 0000000..21b8519 --- /dev/null +++ b/backend/app/router/engine.py @@ -0,0 +1,150 @@ +import uuid +import datetime +from typing import List, Dict, Any, Optional +from app.models.schemas import ( + ModelMetadata, + RequestAnalysis, + RoutingDecision, + CandidateScore, + PriorityLevel, +) +from app.router.scoring import filter_candidate_models, compute_candidate_score +from app.router.rules_engine import evaluate_routing_rules +from app.storage.models import RoutingRuleRecord + + +def generate_routing_explanation( + selected_model: ModelMetadata, + analysis: RequestAnalysis, + policy_name: str, + rule_name: Optional[str] = None, +) -> List[str]: + reasons = [] + + if rule_name: + reasons.append(f"Matching rule applied: \"{rule_name}\"") + + # Task explanation + reasons.append(f"Task classified as {analysis.task_type.value} with {analysis.complexity_label.value} complexity ({analysis.complexity:.2f})") + + # Reasoning / Code requirements + if analysis.reasoning_required: + reasons.append("Multi-step reasoning & deep inference required for problem domain") + if analysis.coding_required: + reasons.append("Syntactical & algorithmic coding capabilities required") + + # Model specific match + if selected_model.tier.value == "POWER": + reasons.append(f"High reasoning score ({selected_model.quality_score * 100:.0f}%) and deep context ({selected_model.context_window:,} tokens)") + elif selected_model.tier.value == "FAST": + reasons.append(f"Low latency priority and high speed score ({selected_model.speed_score * 100:.0f}%)") + else: + reasons.append("Balanced quality and cost profile selected for optimal efficiency") + + # Cost / local factor + if selected_model.cost_per_input_token == 0.0: + reasons.append("Local zero-cost execution prioritized") + elif analysis.cost_sensitivity == PriorityLevel.HIGH: + reasons.append("Cost sensitivity is HIGH — model offers lowest token pricing") + + # Policy + reasons.append(f"Evaluated under '{policy_name}' policy weights") + + return reasons + + +def route_request( + analysis: RequestAnalysis, + available_models: List[ModelMetadata], + policy_weights: Dict[str, float], + policy_name: str = "balanced", + rules: Optional[List[RoutingRuleRecord]] = None, + budget_percent: float = 0.0, + request_id: Optional[str] = None, +) -> RoutingDecision: + req_id = request_id or str(uuid.uuid4()) + decision_id = f"dec_{uuid.uuid4().hex[:12]}" + now_iso = datetime.datetime.utcnow().isoformat() + + # 1. Rule evaluation + rule_action, rule_target, rule_name = None, None, None + if rules: + rule_action, rule_target, rule_name = evaluate_routing_rules(rules, analysis, budget_percent) + + # 2. Hard filter candidates + eligible_models, rejected_dict = filter_candidate_models(available_models, analysis) + + if not eligible_models: + # Fallback to any active model if everything was filtered + eligible_models = [m for m in available_models if m.is_active] or available_models + + # Handle Rule Action: ROUTE_TO specific model + if rule_action == "ROUTE_TO" and rule_target: + exact_match = next((m for m in eligible_models if m.id == rule_target), None) + if exact_match: + scores = [compute_candidate_score(m, analysis, policy_weights) for m in eligible_models] + score_map = {s.model_id: s for s in scores} + selected_score = score_map.get(exact_match.id) or compute_candidate_score(exact_match, analysis, policy_weights) + + reasons = generate_routing_explanation(exact_match, analysis, policy_name, rule_name) + return RoutingDecision( + decision_id=decision_id, + request_id=req_id, + selected_model=exact_match.id, + selected_model_name=exact_match.name, + provider=exact_match.provider, + tier=exact_match.tier.value if hasattr(exact_match.tier, "value") else str(exact_match.tier), + confidence=0.98, + policy_used=policy_name, + reasons=reasons, + candidate_scores=scores, + rejected_candidates=rejected_dict, + estimated_cost_usd=selected_score.estimated_cost_usd, + estimated_latency_ms=selected_score.estimated_latency_ms, + rule_applied=rule_name, + timestamp=now_iso, + ) + + # Handle Rule Action: FORCE_TIER + if rule_action == "FORCE_TIER" and rule_target: + tier_filtered = [m for m in eligible_models if m.tier.value.upper() == rule_target.upper()] + if tier_filtered: + eligible_models = tier_filtered + + # 3. Score all eligible models + candidate_scores: List[CandidateScore] = [] + for model in eligible_models: + sc = compute_candidate_score(model, analysis, policy_weights) + candidate_scores.append(sc) + + # Sort descending by overall_score + candidate_scores.sort(key=lambda s: s.overall_score, reverse=True) + best_candidate = candidate_scores[0] + selected_model = next(m for m in eligible_models if m.id == best_candidate.model_id) + + # Confidence calculation: score difference from second candidate + if len(candidate_scores) > 1: + gap = best_candidate.overall_score - candidate_scores[1].overall_score + confidence = min(0.99, max(0.70, round(0.80 + (gap / 100.0), 2))) + else: + confidence = 0.95 + + reasons = generate_routing_explanation(selected_model, analysis, policy_name, rule_name) + + return RoutingDecision( + decision_id=decision_id, + request_id=req_id, + selected_model=selected_model.id, + selected_model_name=selected_model.name, + provider=selected_model.provider, + tier=selected_model.tier.value if hasattr(selected_model.tier, "value") else str(selected_model.tier), + confidence=confidence, + policy_used=policy_name, + reasons=reasons, + candidate_scores=candidate_scores, + rejected_candidates=rejected_dict, + estimated_cost_usd=best_candidate.estimated_cost_usd, + estimated_latency_ms=best_candidate.estimated_latency_ms, + rule_applied=rule_name, + timestamp=now_iso, + ) diff --git a/backend/app/router/rules_engine.py b/backend/app/router/rules_engine.py new file mode 100644 index 0000000..eea0964 --- /dev/null +++ b/backend/app/router/rules_engine.py @@ -0,0 +1,73 @@ +from typing import List, Optional, Tuple +from app.storage.models import RoutingRuleRecord +from app.models.schemas import RequestAnalysis + + +def evaluate_routing_rules( + rules: List[RoutingRuleRecord], + analysis: RequestAnalysis, + current_budget_percent: float = 0.0, +) -> Tuple[Optional[str], Optional[str], Optional[str]]: + """ + Evaluates enabled routing rules in order of priority (highest priority number first). + Returns: (action_type, action_target, matched_rule_name) or (None, None, None) + """ + sorted_rules = sorted([r for r in rules if r.is_enabled], key=lambda x: x.priority, reverse=True) + + for rule in sorted_rules: + field = rule.condition_field.lower() + op = rule.condition_operator + target_val = rule.condition_value + + matched = False + + if field == "task_type": + val = analysis.task_type.value + if op == "==": + matched = (val == target_val) + elif op == "!=": + matched = (val != target_val) + elif op == "contains": + matched = (target_val in val) + + elif field == "complexity": + val = analysis.complexity + try: + target_num = float(target_val) + if op == ">=": + matched = (val >= target_num) + elif op == ">": + matched = (val > target_num) + elif op == "<=": + matched = (val <= target_num) + elif op == "<": + matched = (val < target_num) + elif op == "==": + matched = (abs(val - target_num) < 0.01) + except ValueError: + pass + + elif field in ("budget_percent", "monthly_budget_percent"): + try: + target_num = float(target_val) + if op == ">=": + matched = (current_budget_percent >= target_num) + elif op == ">": + matched = (current_budget_percent > target_num) + except ValueError: + pass + + elif field == "context_size": + try: + target_num = int(target_val) + if op == ">=": + matched = (analysis.context_size >= target_num) + elif op == ">": + matched = (analysis.context_size > target_num) + except ValueError: + pass + + if matched: + return rule.action_type, rule.action_target, rule.name + + return None, None, None diff --git a/backend/app/router/scoring.py b/backend/app/router/scoring.py new file mode 100644 index 0000000..2c9f9b0 --- /dev/null +++ b/backend/app/router/scoring.py @@ -0,0 +1,154 @@ +from typing import List, Dict, Tuple, Optional +from app.models.schemas import ModelMetadata, RequestAnalysis, CandidateScore, PriorityLevel + + +def filter_candidate_models( + models: List[ModelMetadata], + analysis: RequestAnalysis, +) -> Tuple[List[ModelMetadata], Dict[str, str]]: + """ + Hard-filtering step: eliminates models that cannot satisfy non-negotiable requirements. + Returns: (eligible_models, rejected_candidates_with_reasons) + """ + eligible: List[ModelMetadata] = [] + rejected: Dict[str, str] = {} + + for m in models: + if not m.is_active: + rejected[m.id] = "Model is currently disabled/inactive." + continue + + # 1. Context Window check + if analysis.context_size > m.context_window: + rejected[m.id] = ( + f"Context window ({m.context_window} tokens) is smaller than required input ({analysis.context_size} tokens)." + ) + continue + + # 2. Vision requirement check + if analysis.vision_required and not m.supports_vision: + rejected[m.id] = "Task requires vision / multimodal capabilities which this model does not support." + continue + + # 3. Coding capability check (for high complexity code tasks) + if analysis.coding_required and analysis.complexity >= 0.70 and not m.supports_coding: + rejected[m.id] = "Task requires specialized coding capabilities for complex logic." + continue + + # 4. Deep reasoning capability check + if analysis.reasoning_required and analysis.complexity >= 0.85 and not m.supports_reasoning: + rejected[m.id] = "Task requires advanced reasoning capabilities for multi-step problem solving." + continue + + eligible.append(m) + + # If all filtered out (edge case), return active models to avoid total failure + if not eligible and models: + for m in models: + if m.is_active: + eligible.append(m) + rejected.clear() + + return eligible, rejected + + +def compute_candidate_score( + model: ModelMetadata, + analysis: RequestAnalysis, + weights: Dict[str, float], +) -> CandidateScore: + """ + Multi-criteria configurable scoring formula. + Quality, Speed, CostEfficiency, CapabilityMatch, Reliability. + Normalized score: 0 to 100. + """ + # 1. Quality Component (0.0 to 1.0) + quality_comp = model.quality_score + if analysis.quality_requirement == PriorityLevel.HIGH: + # Boost premium models for high quality requirements + if model.tier.value == "POWER": + quality_comp = min(1.0, quality_comp * 1.15) + elif analysis.quality_requirement == PriorityLevel.LOW: + quality_comp = model.quality_score * 0.9 + + # 2. Speed Component (0.0 to 1.0) + speed_comp = model.speed_score + if analysis.latency_priority == PriorityLevel.HIGH: + if model.tier.value == "FAST": + speed_comp = min(1.0, speed_comp * 1.20) + elif analysis.latency_priority == PriorityLevel.LOW: + speed_comp = model.speed_score * 0.85 + + # 3. Cost Efficiency Component (0.0 to 1.0) + # Zero-cost local models get 1.0, cheaper cloud models get high score + combined_token_cost = (model.cost_per_input_token * 1000) + (model.cost_per_output_token * 1000) + if combined_token_cost == 0.0: + cost_efficiency = 1.0 + else: + # Scale: $0.0001 -> 0.95, $0.01 -> 0.50, $0.05 -> 0.10 + cost_efficiency = max(0.05, min(0.99, 1.0 / (1.0 + (combined_token_cost * 100.0)))) + + if analysis.cost_sensitivity == PriorityLevel.HIGH: + cost_efficiency = min(1.0, cost_efficiency * 1.25) + + # 4. Capability Match Component (0.0 to 1.0) + cap_points = 0.0 + total_caps = 0.0 + + if analysis.coding_required: + total_caps += 1.0 + if model.supports_coding: + cap_points += 1.0 + + if analysis.reasoning_required: + total_caps += 1.0 + if model.supports_reasoning: + cap_points += 1.0 + + if analysis.vision_required: + total_caps += 1.0 + if model.supports_vision: + cap_points += 1.0 + + capability_comp = (cap_points / total_caps) if total_caps > 0 else 0.90 + + # 5. Reliability Component (0.0 to 1.0) + reliability_comp = model.reliability_score + + # Weighted Sum + w_q = weights.get("quality_weight", 0.35) + w_c = weights.get("cost_weight", 0.25) + w_s = weights.get("speed_weight", 0.20) + w_cap = weights.get("capability_weight", 0.15) + w_r = weights.get("reliability_weight", 0.05) + total_w = w_q + w_c + w_s + w_cap + w_r + + raw_score = ( + (quality_comp * w_q) + + (cost_efficiency * w_c) + + (speed_comp * w_s) + + (capability_comp * w_cap) + + (reliability_comp * w_r) + ) / (total_w if total_w > 0 else 1.0) + + overall_score = round(raw_score * 100.0, 2) + + # Estimated metrics + est_latency = 120.0 if model.tier.value == "FAST" else (350.0 if model.tier.value == "BALANCED" else 750.0) + est_cost = (analysis.context_size * model.cost_per_input_token) + (250 * model.cost_per_output_token) + + return CandidateScore( + model_id=model.id, + model_name=model.name, + provider=model.provider, + tier=model.tier.value if hasattr(model.tier, "value") else str(model.tier), + overall_score=overall_score, + quality_component=round(quality_comp * 100.0, 1), + cost_component=round(cost_efficiency * 100.0, 1), + speed_component=round(speed_comp * 100.0, 1), + capability_component=round(capability_comp * 100.0, 1), + reliability_component=round(reliability_comp * 100.0, 1), + estimated_latency_ms=est_latency, + estimated_cost_usd=round(est_cost, 6), + eligible=True, + ) diff --git a/backend/app/storage/database.py b/backend/app/storage/database.py new file mode 100644 index 0000000..fe2f7da --- /dev/null +++ b/backend/app/storage/database.py @@ -0,0 +1,366 @@ +from typing import AsyncGenerator +from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession +from app.config.settings import get_settings +from app.storage.models import ( + Base, + ModelRecord, + ProviderRecord, + RoutingPolicyRecord, + RoutingRuleRecord, + BudgetRecord, +) + +settings = get_settings() + +engine = create_async_engine( + settings.DATABASE_URL, + echo=False, + connect_args={"check_same_thread": False} if "sqlite" in settings.DATABASE_URL else {}, +) + +AsyncSessionLocal = async_sessionmaker( + bind=engine, + class_=AsyncSession, + expire_on_commit=False, +) + + +async def get_db() -> AsyncGenerator[AsyncSession, None]: + async with AsyncSessionLocal() as session: + try: + yield session + finally: + await session.close() + + +async def init_db(): + async with engine.begin() as conn: + await conn.run_sync(Base.metadata.create_all) + + # Populate initial seed data if empty + async with AsyncSessionLocal() as session: + from sqlalchemy import select + + # Check providers + res = await session.execute(select(ProviderRecord)) + providers = res.scalars().all() + if not providers: + default_providers = [ + ProviderRecord(id="mock", name="Mock / Demo Provider", status="CONNECTED", is_enabled=True), + ProviderRecord(id="ollama", name="Ollama (Local)", status="READY", is_enabled=True, base_url=settings.OLLAMA_BASE_URL), + ProviderRecord(id="openai", name="OpenAI", status="CONNECTED" if settings.OPENAI_API_KEY else "NOT_CONFIGURED", is_enabled=bool(settings.OPENAI_API_KEY)), + ProviderRecord(id="anthropic", name="Anthropic", status="CONNECTED" if settings.ANTHROPIC_API_KEY else "NOT_CONFIGURED", is_enabled=bool(settings.ANTHROPIC_API_KEY)), + ProviderRecord(id="gemini", name="Google Gemini", status="CONNECTED" if settings.GEMINI_API_KEY else "NOT_CONFIGURED", is_enabled=bool(settings.GEMINI_API_KEY)), + ] + session.add_all(default_providers) + + # Check models + res_m = await session.execute(select(ModelRecord)) + models = res_m.scalars().all() + if not models: + default_models = [ + # Mock Models + ModelRecord( + id="mock-fast", + name="Mock Fast (Echo)", + provider="mock", + type="MOCK", + tier="FAST", + context_window=32768, + supports_coding=True, + supports_reasoning=False, + supports_vision=False, + supports_tools=True, + quality_score=0.75, + speed_score=0.98, + reliability_score=0.99, + cost_per_input_token=0.0000001, + cost_per_output_token=0.0000002, + ), + ModelRecord( + id="mock-balanced", + name="Mock Balanced (General)", + provider="mock", + type="MOCK", + tier="BALANCED", + context_window=65536, + supports_coding=True, + supports_reasoning=True, + supports_vision=True, + supports_tools=True, + quality_score=0.88, + speed_score=0.85, + reliability_score=0.99, + cost_per_input_token=0.000001, + cost_per_output_token=0.000003, + ), + ModelRecord( + id="mock-power", + name="Mock Power (Reasoning)", + provider="mock", + type="MOCK", + tier="POWER", + context_window=131072, + supports_coding=True, + supports_reasoning=True, + supports_vision=True, + supports_tools=True, + quality_score=0.98, + speed_score=0.60, + reliability_score=0.99, + cost_per_input_token=0.000005, + cost_per_output_token=0.000015, + ), + # Local Ollama Models (Default profiles) + ModelRecord( + id="ollama-qwen2.5-coder", + name="Qwen 2.5 Coder 7B (Ollama)", + provider="ollama", + type="LOCAL", + tier="FAST", + context_window=32768, + supports_coding=True, + supports_reasoning=True, + supports_vision=False, + supports_tools=True, + quality_score=0.86, + speed_score=0.92, + reliability_score=0.95, + cost_per_input_token=0.0, + cost_per_output_token=0.0, + ), + ModelRecord( + id="ollama-llama3.2", + name="Llama 3.2 3B (Ollama)", + provider="ollama", + type="LOCAL", + tier="FAST", + context_window=131072, + supports_coding=True, + supports_reasoning=True, + supports_vision=False, + supports_tools=True, + quality_score=0.82, + speed_score=0.95, + reliability_score=0.95, + cost_per_input_token=0.0, + cost_per_output_token=0.0, + ), + ModelRecord( + id="ollama-mistral", + name="Mistral 7B (Ollama)", + provider="ollama", + type="LOCAL", + tier="BALANCED", + context_window=32768, + supports_coding=True, + supports_reasoning=True, + supports_vision=False, + supports_tools=True, + quality_score=0.84, + speed_score=0.88, + reliability_score=0.95, + cost_per_input_token=0.0, + cost_per_output_token=0.0, + ), + ModelRecord( + id="ollama-deepseek-r1", + name="DeepSeek R1 8B (Ollama)", + provider="ollama", + type="LOCAL", + tier="POWER", + context_window=65536, + supports_coding=True, + supports_reasoning=True, + supports_vision=False, + supports_tools=False, + quality_score=0.93, + speed_score=0.68, + reliability_score=0.94, + cost_per_input_token=0.0, + cost_per_output_token=0.0, + ), + # External Cloud Model Profiles + ModelRecord( + id="gpt-4o-mini", + name="OpenAI GPT-4o Mini", + provider="openai", + type="CLOUD", + tier="FAST", + context_window=128000, + supports_coding=True, + supports_reasoning=True, + supports_vision=True, + supports_tools=True, + quality_score=0.88, + speed_score=0.90, + reliability_score=0.99, + cost_per_input_token=0.00000015, + cost_per_output_token=0.00000060, + ), + ModelRecord( + id="gpt-4o", + name="OpenAI GPT-4o", + provider="openai", + type="CLOUD", + tier="POWER", + context_window=128000, + supports_coding=True, + supports_reasoning=True, + supports_vision=True, + supports_tools=True, + quality_score=0.96, + speed_score=0.75, + reliability_score=0.99, + cost_per_input_token=0.0000025, + cost_per_output_token=0.000010, + ), + ModelRecord( + id="claude-3-5-sonnet", + name="Anthropic Claude 3.5 Sonnet", + provider="anthropic", + type="CLOUD", + tier="POWER", + context_window=200000, + supports_coding=True, + supports_reasoning=True, + supports_vision=True, + supports_tools=True, + quality_score=0.98, + speed_score=0.72, + reliability_score=0.99, + cost_per_input_token=0.000003, + cost_per_output_token=0.000015, + ), + ModelRecord( + id="gemini-1.5-flash", + name="Google Gemini 1.5 Flash", + provider="gemini", + type="CLOUD", + tier="FAST", + context_window=1000000, + supports_coding=True, + supports_reasoning=True, + supports_vision=True, + supports_tools=True, + quality_score=0.87, + speed_score=0.93, + reliability_score=0.99, + cost_per_input_token=0.000000075, + cost_per_output_token=0.00000030, + ), + ] + session.add_all(default_models) + + # Check policies + res_p = await session.execute(select(RoutingPolicyRecord)) + policies = res_p.scalars().all() + if not policies: + default_policies = [ + RoutingPolicyRecord( + id="balanced", + name="Balanced Router", + description="Optimizes across quality, cost, speed, capabilities, and reliability.", + quality_weight=0.35, + cost_weight=0.25, + speed_weight=0.20, + capability_weight=0.15, + reliability_weight=0.05, + is_default=True, + ), + RoutingPolicyRecord( + id="lowest_cost", + name="Lowest Cost", + description="Prefers cheapest and local zero-cost models with acceptable capability.", + quality_weight=0.15, + cost_weight=0.60, + speed_weight=0.15, + capability_weight=0.05, + reliability_weight=0.05, + is_default=False, + ), + RoutingPolicyRecord( + id="lowest_latency", + name="Lowest Latency", + description="Prefers fastest response times and high throughput models.", + quality_weight=0.15, + cost_weight=0.15, + speed_weight=0.60, + capability_weight=0.05, + reliability_weight=0.05, + is_default=False, + ), + RoutingPolicyRecord( + id="highest_quality", + name="Highest Quality", + description="Directs all complex reasoning and coding tasks to top-tier frontier models.", + quality_weight=0.65, + cost_weight=0.05, + speed_weight=0.10, + capability_weight=0.15, + reliability_weight=0.05, + is_default=False, + ), + RoutingPolicyRecord( + id="custom", + name="Custom Weights", + description="User-defined policy weights.", + quality_weight=0.30, + cost_weight=0.30, + speed_weight=0.20, + capability_weight=0.10, + reliability_weight=0.10, + is_default=False, + ), + ] + session.add_all(default_policies) + + # Check default budget + res_b = await session.execute(select(BudgetRecord)) + budget = res_b.scalar_one_or_none() + if not budget: + session.add( + BudgetRecord( + id="default", + daily_limit=settings.DAILY_BUDGET, + monthly_limit=settings.MONTHLY_BUDGET, + per_request_limit=settings.PER_REQUEST_BUDGET, + current_daily_spend=0.0, + current_monthly_spend=0.0, + intervention_mode="NORMAL", + ) + ) + + # Check default rules + res_r = await session.execute(select(RoutingRuleRecord)) + rules = res_r.scalars().all() + if not rules: + default_rules = [ + RoutingRuleRecord( + id="rule-code-reasoning", + name="Deep Debugging & Reasoning Override", + description="Route high complexity coding & debugging to Power Models", + priority=10, + is_enabled=True, + condition_field="task_type", + condition_operator="==", + condition_value="DEBUGGING", + action_type="FORCE_TIER", + action_target="POWER", + ), + RoutingRuleRecord( + id="rule-budget-saver", + name="Budget Guard > 95%", + description="Prefer local or fast models when budget exceeds 95%", + priority=50, + is_enabled=True, + condition_field="budget_percent", + condition_operator=">=", + condition_value="95.0", + action_type="SET_POLICY", + action_target="lowest_cost", + ), + ] + session.add_all(default_rules) + + await session.commit() diff --git a/backend/app/storage/models.py b/backend/app/storage/models.py new file mode 100644 index 0000000..f7de8e6 --- /dev/null +++ b/backend/app/storage/models.py @@ -0,0 +1,202 @@ +import datetime +from sqlalchemy import ( + Column, + String, + Float, + Integer, + Boolean, + DateTime, + Text, + JSON, + ForeignKey, +) +from sqlalchemy.orm import declarative_base, relationship + +Base = declarative_base() + + +class ModelRecord(Base): + __tablename__ = "models" + + id = Column(String(100), primary_key=True) + name = Column(String(200), nullable=False) + provider = Column(String(50), nullable=False) # mock, ollama, openai, anthropic, gemini + type = Column(String(50), default="LOCAL") # LOCAL, CLOUD, MOCK + context_window = Column(Integer, default=8192) + + supports_coding = Column(Boolean, default=False) + supports_reasoning = Column(Boolean, default=False) + supports_vision = Column(Boolean, default=False) + supports_tools = Column(Boolean, default=False) + + quality_score = Column(Float, default=0.7) + speed_score = Column(Float, default=0.7) + reliability_score = Column(Float, default=0.95) + + cost_per_input_token = Column(Float, default=0.0) + cost_per_output_token = Column(Float, default=0.0) + + availability = Column(String(50), default="AVAILABLE") + is_active = Column(Boolean, default=True) + tier = Column(String(50), default="BALANCED") # FAST, BALANCED, POWER + + created_at = Column(DateTime, default=datetime.datetime.utcnow) + updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow) + + +class ProviderRecord(Base): + __tablename__ = "providers" + + id = Column(String(50), primary_key=True) + name = Column(String(100), nullable=False) + status = Column(String(50), default="READY") # READY, CONNECTED, NOT_CONFIGURED, ERROR + is_enabled = Column(Boolean, default=True) + base_url = Column(String(500), nullable=True) + updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow) + + +class RoutingPolicyRecord(Base): + __tablename__ = "routing_policies" + + id = Column(String(50), primary_key=True) + name = Column(String(100), nullable=False) + description = Column(String(500), nullable=True) + quality_weight = Column(Float, default=0.35) + cost_weight = Column(Float, default=0.25) + speed_weight = Column(Float, default=0.20) + capability_weight = Column(Float, default=0.15) + reliability_weight = Column(Float, default=0.05) + is_default = Column(Boolean, default=False) + + +class RoutingRuleRecord(Base): + __tablename__ = "routing_rules" + + id = Column(String(100), primary_key=True) + name = Column(String(200), nullable=False) + description = Column(String(500), nullable=True) + priority = Column(Integer, default=0) + is_enabled = Column(Boolean, default=True) + + condition_field = Column(String(100), nullable=False) # task_type, complexity, budget_percent, context_size + condition_operator = Column(String(50), nullable=False) # ==, !=, >, <, >=, <=, contains + condition_value = Column(String(200), nullable=False) + + action_type = Column(String(50), nullable=False) # ROUTE_TO, PREFER, FORCE_TIER, SET_POLICY + action_target = Column(String(100), nullable=False) + + created_at = Column(DateTime, default=datetime.datetime.utcnow) + + +class RequestRecord(Base): + __tablename__ = "requests" + + request_id = Column(String(100), primary_key=True) + timestamp = Column(DateTime, default=datetime.datetime.utcnow) + prompt = Column(Text, nullable=False) + task_type = Column(String(50), nullable=False) + complexity = Column(Float, default=0.5) + context_size = Column(Integer, default=0) + reasoning_required = Column(Boolean, default=False) + coding_required = Column(Boolean, default=False) + + routing_policy = Column(String(50), default="balanced") + selected_model = Column(String(100), nullable=False) + provider = Column(String(50), nullable=False) + status = Column(String(50), default="SUCCESS") # SUCCESS, FAILED, FALLBACK + + fallback_used = Column(Boolean, default=False) + original_model = Column(String(100), nullable=True) + fallback_reason = Column(String(500), nullable=True) + + input_tokens = Column(Integer, default=0) + output_tokens = Column(Integer, default=0) + total_tokens = Column(Integer, default=0) + estimated_cost = Column(Float, default=0.0) + baseline_cost = Column(Float, default=0.0) + cost_saved = Column(Float, default=0.0) + + routing_latency_ms = Column(Float, default=0.0) + provider_latency_ms = Column(Float, default=0.0) + total_latency_ms = Column(Float, default=0.0) + time_to_first_token_ms = Column(Float, nullable=True) + + +class RoutingDecisionRecord(Base): + __tablename__ = "routing_decisions" + + decision_id = Column(String(100), primary_key=True) + request_id = Column(String(100), ForeignKey("requests.request_id"), nullable=False) + timestamp = Column(DateTime, default=datetime.datetime.utcnow) + + selected_model = Column(String(100), nullable=False) + confidence = Column(Float, default=0.9) + reasons = Column(JSON, default=list) + candidate_scores = Column(JSON, default=dict) + rejected_candidates = Column(JSON, default=dict) + policy_used = Column(String(50), default="balanced") + + +class ResponseRecord(Base): + __tablename__ = "responses" + + response_id = Column(String(100), primary_key=True) + request_id = Column(String(100), ForeignKey("requests.request_id"), nullable=False) + timestamp = Column(DateTime, default=datetime.datetime.utcnow) + model_id = Column(String(100), nullable=False) + provider = Column(String(50), nullable=False) + content = Column(Text, nullable=False) + finish_reason = Column(String(50), default="stop") + is_mock = Column(Boolean, default=False) + + +class FeedbackRecord(Base): + __tablename__ = "feedback" + + id = Column(String(100), primary_key=True) + request_id = Column(String(100), ForeignKey("requests.request_id"), nullable=False) + model_id = Column(String(100), nullable=False) + task_type = Column(String(50), nullable=False) + rating = Column(Integer, nullable=False) # 1 for thumbs up, -1 for thumbs down + comment = Column(Text, nullable=True) + timestamp = Column(DateTime, default=datetime.datetime.utcnow) + + +class BudgetRecord(Base): + __tablename__ = "budgets" + + id = Column(String(50), primary_key=True, default="default") + daily_limit = Column(Float, default=10.0) + monthly_limit = Column(Float, default=100.0) + per_request_limit = Column(Float, default=1.0) + current_daily_spend = Column(Float, default=0.0) + current_monthly_spend = Column(Float, default=0.0) + intervention_mode = Column(String(50), default="OPTIMIZE") # NORMAL, OPTIMIZE_80, CHEAP_95, BLOCK_100 + updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow) + + +class ExperimentRecord(Base): + __tablename__ = "experiments" + + id = Column(String(100), primary_key=True) + name = Column(String(200), nullable=False) + description = Column(String(500), nullable=True) + policy_a = Column(String(50), nullable=False) + policy_b = Column(String(50), nullable=False) + status = Column(String(50), default="ACTIVE") # ACTIVE, PAUSED, COMPLETED + sample_count = Column(Integer, default=0) + created_at = Column(DateTime, default=datetime.datetime.utcnow) + + +class ExperimentRunRecord(Base): + __tablename__ = "experiment_runs" + + id = Column(String(100), primary_key=True) + experiment_id = Column(String(100), ForeignKey("experiments.id"), nullable=False) + request_id = Column(String(100), ForeignKey("requests.request_id"), nullable=False) + assigned_policy = Column(String(50), nullable=False) + selected_model = Column(String(100), nullable=False) + cost = Column(Float, default=0.0) + latency_ms = Column(Float, default=0.0) + feedback_rating = Column(Integer, nullable=True) + timestamp = Column(DateTime, default=datetime.datetime.utcnow) diff --git a/backend/main.py b/backend/main.py new file mode 100644 index 0000000..88edf71 --- /dev/null +++ b/backend/main.py @@ -0,0 +1,94 @@ +import asyncio +import json +from contextlib import asynccontextmanager +from fastapi import FastAPI +from fastapi.middleware.cors import CORSMiddleware +from sse_starlette.sse import EventSourceResponse + +from app.config.settings import get_settings +from app.storage.database import init_db, AsyncSessionLocal +from app.storage.models import RequestRecord +from app.api.routes import router as api_router +from sqlalchemy import select, desc + +settings = get_settings() + + +@asynccontextmanager +async def lifespan(app: FastAPI): + # Initialize SQLite database and seed defaults + await init_db() + yield + + +app = FastAPI( + title="Model Router", + description="Intelligent LLM Request Routing Platform — AI Traffic Control Room", + version="1.0.0", + lifespan=lifespan, +) + +# CORS configuration +app.add_middleware( + CORSMiddleware, + allow_origins=["*"], + allow_credentials=True, + allow_methods=["*"], + allow_headers=["*"], +) + +app.include_router(api_router) + + +@app.get("/api/traffic/stream") +async def stream_live_traffic(): + """ + SSE Live Stream endpoint for the Traffic Control Room visualization. + Pushes newly persisted requests to connected frontend clients. + """ + async def event_generator(): + last_seen_id = None + while True: + try: + async with AsyncSessionLocal() as session: + res = await session.execute( + select(RequestRecord).order_by(desc(RequestRecord.timestamp)).limit(1) + ) + latest = res.scalar_one_or_none() + if latest and latest.request_id != last_seen_id: + last_seen_id = latest.request_id + payload = { + "request_id": latest.request_id, + "timestamp": latest.timestamp.isoformat() if latest.timestamp else "", + "prompt": latest.prompt, + "task_type": latest.task_type, + "complexity": latest.complexity, + "selected_model": latest.selected_model, + "provider": latest.provider, + "status": latest.status, + "total_latency_ms": latest.total_latency_ms, + "estimated_cost": latest.estimated_cost, + } + yield { + "event": "traffic_event", + "data": json.dumps(payload), + } + except Exception: + pass + await asyncio.sleep(1.5) + + return EventSourceResponse(event_generator()) + + +@app.get("/") +async def root(): + return { + "message": "Model Router AI Control Room Backend is active.", + "docs": "/docs", + "health": "/api/health", + } + + +if __name__ == "__main__": + import uvicorn + uvicorn.run("main:app", host=settings.HOST, port=settings.PORT, reload=settings.DEBUG) diff --git a/backend/requirements.txt b/backend/requirements.txt new file mode 100644 index 0000000..f88f432 --- /dev/null +++ b/backend/requirements.txt @@ -0,0 +1,15 @@ +fastapi>=0.110.0 +uvicorn[standard]>=0.28.0 +pydantic>=2.6.0 +pydantic-settings>=2.2.0 +sqlalchemy>=2.0.28 +aiosqlite>=0.20.0 +httpx>=0.27.0 +typer>=0.12.0 +rich>=13.7.0 +pytest>=8.0.0 +pytest-asyncio>=0.23.0 +python-dotenv>=1.0.1 +python-multipart>=0.0.9 +sse-starlette>=2.0.0 +tiktoken>=0.6.0 diff --git a/backend/tests/test_analyzer.py b/backend/tests/test_analyzer.py new file mode 100644 index 0000000..a6f3dac --- /dev/null +++ b/backend/tests/test_analyzer.py @@ -0,0 +1,41 @@ +import pytest +from app.analyzer.heuristics import analyze_request_heuristics, estimate_tokens +from app.models.schemas import TaskType, PriorityLevel + + +def test_token_estimation(): + text = "Hello world from Model Router platform!" + tokens = estimate_tokens(text) + assert tokens > 0 + + +def test_heuristic_classification_coding(): + prompt = "Write a python function to calculate fibonacci sequence using dynamic programming" + analysis = analyze_request_heuristics(prompt) + assert analysis.task_type == TaskType.CODING + assert analysis.coding_required is True + assert analysis.complexity >= 0.40 + + +def test_heuristic_classification_debugging_complexity(): + prompt = "Debug this distributed async deadlock issue in the microservices cluster and explain the root cause" + analysis = analyze_request_heuristics(prompt) + assert analysis.task_type == TaskType.DEBUGGING + assert analysis.reasoning_required is True + assert analysis.coding_required is True + assert analysis.complexity_label == PriorityLevel.HIGH + assert analysis.complexity >= 0.75 + + +def test_heuristic_classification_summarization(): + prompt = "Provide a summary and key bullet points of this meeting transcript" + analysis = analyze_request_heuristics(prompt) + assert analysis.task_type == TaskType.SUMMARIZATION + assert analysis.complexity_label in (PriorityLevel.LOW, PriorityLevel.MEDIUM) + + +def test_heuristic_classification_math(): + prompt = "Calculate the derivative and integral of matrix eigenvalue differential equation" + analysis = analyze_request_heuristics(prompt) + assert analysis.task_type == TaskType.MATH + assert analysis.reasoning_required is True diff --git a/backend/tests/test_e2e.py b/backend/tests/test_e2e.py new file mode 100644 index 0000000..cec6a66 --- /dev/null +++ b/backend/tests/test_e2e.py @@ -0,0 +1,66 @@ +import pytest +from httpx import AsyncClient, ASGITransport +from main import app +from app.storage.database import init_db + + +@pytest.fixture(autouse=True) +async def setup_db(): + await init_db() + + +@pytest.mark.asyncio +async def test_api_health(): + transport = ASGITransport(app=app) + async with AsyncClient(transport=transport, base_url="http://test") as client: + res = await client.get("/api/health") + assert res.status_code == 200 + data = res.json() + assert data["status"] == "healthy" + + +@pytest.mark.asyncio +async def test_api_route_only(): + transport = ASGITransport(app=app) + async with AsyncClient(transport=transport, base_url="http://test") as client: + payload = {"prompt": "Write a Python script to benchmark models", "policy": "balanced"} + res = await client.post("/api/route", json=payload) + assert res.status_code == 200 + data = res.json() + assert "decision" in data + assert "analysis" in data + assert data["analysis"]["task_type"] == "CODING" + + +@pytest.mark.asyncio +async def test_api_generate_end_to_end(): + transport = ASGITransport(app=app) + async with AsyncClient(transport=transport, base_url="http://test") as client: + payload = {"prompt": "Debug this memory leak in python subprocess", "policy": "balanced"} + res = await client.post("/api/generate", json=payload) + assert res.status_code == 200 + data = res.json() + assert "response" in data + assert "metrics" in data + assert len(data["response"]["content"]) > 0 + + +@pytest.mark.asyncio +async def test_api_models_list(): + transport = ASGITransport(app=app) + async with AsyncClient(transport=transport, base_url="http://test") as client: + res = await client.get("/api/models") + assert res.status_code == 200 + models = res.json() + assert len(models) >= 3 + + +@pytest.mark.asyncio +async def test_api_analytics(): + transport = ASGITransport(app=app) + async with AsyncClient(transport=transport, base_url="http://test") as client: + res = await client.get("/api/analytics") + assert res.status_code == 200 + data = res.json() + assert "total_requests" in data + assert "savings" in data diff --git a/backend/tests/test_providers.py b/backend/tests/test_providers.py new file mode 100644 index 0000000..9437da4 --- /dev/null +++ b/backend/tests/test_providers.py @@ -0,0 +1,21 @@ +import pytest +from app.providers.mock_provider import MockProvider + + +@pytest.mark.asyncio +async def test_mock_provider_generate(): + provider = MockProvider() + resp = await provider.generate("Write a quick Python sort function", model_id="mock-fast") + assert resp.is_mock is True + assert "DEMO/MOCK" in resp.content + assert resp.input_tokens > 0 + assert resp.output_tokens > 0 + assert resp.provider_latency_ms > 0 + + +@pytest.mark.asyncio +async def test_mock_provider_health(): + provider = MockProvider() + health = await provider.check_health() + assert health["status"] == "CONNECTED" + assert "mock-fast" in health["models_available"] diff --git a/backend/tests/test_router.py b/backend/tests/test_router.py new file mode 100644 index 0000000..f960595 --- /dev/null +++ b/backend/tests/test_router.py @@ -0,0 +1,78 @@ +import pytest +from app.models.schemas import ModelMetadata, ModelTier, RequestAnalysis, TaskType, PriorityLevel +from app.router.scoring import filter_candidate_models, compute_candidate_score +from app.router.engine import route_request + + +@pytest.fixture +def sample_models(): + return [ + ModelMetadata( + id="mock-fast", + name="Mock Fast", + provider="mock", + tier=ModelTier.FAST, + context_window=8192, + supports_coding=True, + supports_reasoning=False, + quality_score=0.75, + speed_score=0.98, + cost_per_input_token=0.0, + cost_per_output_token=0.0, + ), + ModelMetadata( + id="mock-power", + name="Mock Power", + provider="mock", + tier=ModelTier.POWER, + context_window=128000, + supports_coding=True, + supports_reasoning=True, + quality_score=0.98, + speed_score=0.60, + cost_per_input_token=0.000005, + cost_per_output_token=0.000015, + ), + ] + + +def test_candidate_filtering_context_overflow(sample_models): + large_analysis = RequestAnalysis( + task_type=TaskType.LONG_CONTEXT, + complexity=0.7, + context_size=15000, # exceeds mock-fast 8192 + ) + eligible, rejected = filter_candidate_models(sample_models, large_analysis) + assert len(eligible) == 1 + assert eligible[0].id == "mock-power" + assert "mock-fast" in rejected + + +def test_scoring_weights(sample_models): + analysis = RequestAnalysis( + task_type=TaskType.CODING, + complexity=0.3, + latency_priority=PriorityLevel.HIGH, + cost_sensitivity=PriorityLevel.HIGH, + ) + weights = {"quality_weight": 0.1, "cost_weight": 0.5, "speed_weight": 0.4, "capability_weight": 0.0, "reliability_weight": 0.0} + score_fast = compute_candidate_score(sample_models[0], analysis, weights) + score_power = compute_candidate_score(sample_models[1], analysis, weights) + assert score_fast.overall_score > score_power.overall_score + + +def test_routing_decision_explainability(sample_models): + analysis = RequestAnalysis( + task_type=TaskType.DEBUGGING, + complexity=0.85, + complexity_label=PriorityLevel.HIGH, + reasoning_required=True, + coding_required=True, + quality_requirement=PriorityLevel.HIGH, + ) + weights = {"quality_weight": 0.6, "cost_weight": 0.1, "speed_weight": 0.1, "capability_weight": 0.1, "reliability_weight": 0.1} + decision = route_request(analysis, sample_models, weights, policy_name="highest_quality") + assert decision.selected_model == "mock-power" + assert decision.confidence > 0.70 + assert len(decision.reasons) > 0 + assert any("DEBUGGING" in r for r in decision.reasons) diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..265b569 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,24 @@ +version: '3.8' + +services: + backend: + build: + context: . + dockerfile: backend/Dockerfile + ports: + - "8000:8000" + environment: + - APP_ENV=production + - DATABASE_URL=sqlite+aiosqlite:///./model_router.db + - OLLAMA_BASE_URL=http://host.docker.internal:11434 + volumes: + - ./data:/app/data + + frontend: + build: + context: ./frontend + dockerfile: Dockerfile + ports: + - "3000:80" + depends_on: + - backend diff --git a/frontend/.gitignore b/frontend/.gitignore new file mode 100644 index 0000000..a547bf3 --- /dev/null +++ b/frontend/.gitignore @@ -0,0 +1,24 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +lerna-debug.log* + +node_modules +dist +dist-ssr +*.local + +# Editor directories and files +.vscode/* +!.vscode/extensions.json +.idea +.DS_Store +*.suo +*.ntvs* +*.njsproj +*.sln +*.sw? diff --git a/frontend/index.html b/frontend/index.html new file mode 100644 index 0000000..d61c46e --- /dev/null +++ b/frontend/index.html @@ -0,0 +1,16 @@ + + + + + + Model Router — AI Traffic Control Room + + + + + + +
+ + + diff --git a/frontend/package-lock.json b/frontend/package-lock.json new file mode 100644 index 0000000..075c9e2 --- /dev/null +++ b/frontend/package-lock.json @@ -0,0 +1,2114 @@ +{ + "name": "frontend", + "version": "0.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "frontend", + "version": "0.0.0", + "dependencies": { + "autoprefixer": "^10.5.4", + "clsx": "^2.1.1", + "lucide-react": "^1.38.0", + "postcss": "^8.5.26", + "recharts": "^3.10.1", + "tailwindcss": "^4.3.3" + }, + "devDependencies": { + "@tailwindcss/postcss": "^4.3.3", + "@types/react": "^19.2.18", + "@types/react-dom": "^19.2.5", + "typescript": "~6.0.2", + "vite": "^8.2.2" + } + }, + "node_modules/@alloc/quick-lru": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz", + "integrity": "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.6.0.tgz", + "integrity": "sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@oxc-project/types": { + "version": "0.147.0", + "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.147.0.tgz", + "integrity": "sha512-IJ3s6ltHLp45S0bh7phkX+gJO7A1Wuz2EaqpAhb8WjqDwbzMiWKHhyyT42tskaWjEYXtHtVCPpnBJVT9+dcRLg==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/Boshen" + } + }, + "node_modules/@reduxjs/toolkit": { + "version": "2.12.0", + "resolved": "https://registry.npmjs.org/@reduxjs/toolkit/-/toolkit-2.12.0.tgz", + "integrity": "sha512-KiT+RzZbp6mQET+Mg+h2c97+9j1sNflUxQkIHI7Yuzf6Peu+OYpmkn6nbHWmLLWj+1ZODUJFwGZ7gx3L9R9EOw==", + "license": "MIT", + "dependencies": { + "@standard-schema/spec": "^1.0.0", + "@standard-schema/utils": "^0.3.0", + "immer": "^11.0.0", + "redux": "^5.0.1", + "redux-thunk": "^3.1.0", + "reselect": "^5.1.0" + }, + "peerDependencies": { + "react": "^16.9.0 || ^17.0.0 || ^18 || ^19", + "react-redux": "^7.2.1 || ^8.1.3 || ^9.0.0" + }, + "peerDependenciesMeta": { + "react": { + "optional": true + }, + "react-redux": { + "optional": true + } + } + }, + "node_modules/@rolldown/binding-android-arm-eabi": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm-eabi/-/binding-android-arm-eabi-1.2.6.tgz", + "integrity": "sha512-b+jTcARdTiFLI6jB4a5XjTm0RWd6KcRfQj/I2356fxUZemiho9zQLxo0RtCuMDAyKcLo6cEltkgbQp6d1+sjjQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-android-arm64": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.2.6.tgz", + "integrity": "sha512-lkWU8ZJaRk9q3CIEY1Tc7vIFALp3Xw5NfGJo2hQg5oIqNgxWi1zI+IiDEK3r70BF5Dzol1tcXsnzsRc8NLhG+Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-darwin-arm64": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.2.6.tgz", + "integrity": "sha512-dgR56NYnvAszm7Ob1B2/Vn0e8bUQYZH2UjVaMMtMVOCKFSfjhfLmuA/9+O+F+ajUdG6B/bSssrKW6JJYASa8jA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-darwin-x64": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.2.6.tgz", + "integrity": "sha512-vpVxFvUCFioJqug7OTvqptkc4yb8UX0AwfDmJpaR/0sWz+BUmqSVAf7c8JkUgnN8YLspb4a/N6NhTyMAmdyQ7Q==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-freebsd-x64": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.2.6.tgz", + "integrity": "sha512-h1wG6Y6K3JlRswxsI64qQJqBAy4vrLuHgRbc8CZMGSWTOFRY6ghMApM1NKzB2I0n5xV1fjkE18SuVl2QpLeNpA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm-gnueabihf": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.2.6.tgz", + "integrity": "sha512-tbCiqub0q2MVWJKgF5PoAlNWCtQydiOYSLIkd8sByqK/6MMYLJRcSXSYodqYtd0O+Fw7QaVmKKlS4oL94YRZ0w==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm64-gnu": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.2.6.tgz", + "integrity": "sha512-oxK9+baEBPhZG5HB4URY+uU04zJWeZlH6Tb9rB5DK4DF9XR1uXNLXt5Q5ZsugTKayNCNLhkcwz/ye74hRI98dg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm64-musl": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.2.6.tgz", + "integrity": "sha512-muWCk27FVBEZtv0MsK8gnfSmgczA8KQ0uRVJbTABKhkRfQc38aUrcb7fhi3BNiyseFmgcRsoMfQsSNJ+DbZdSw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-ppc64-gnu": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.2.6.tgz", + "integrity": "sha512-eWDoSfU7Co2qj3vgB3Dt4lj1mG6CoWbcJQkRMP3XJplyCMtuaq3LHvPFjS9QIPvMGWVadJC04Xiy0IdcVPtnwQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-s390x-gnu": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.2.6.tgz", + "integrity": "sha512-2bWNjRSIayvupRKxXUY2tWG9fYdoUlTqWywHRvE8Eq3GvuQ+f2HeIkve697fIt+IQs/PV8yFsdWuhp1aJ1PdnA==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-x64-gnu": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.2.6.tgz", + "integrity": "sha512-KekI0gS0wLxe1UBSQSjenBVwou/JkcQPDzBPICGZjxUv9k3RteHDPBQaiOicZUFKRIH2wKEimGwVpnJsbPzu7w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-x64-musl": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.2.6.tgz", + "integrity": "sha512-TvtPnfVr+HtyGiDmPK4VWmlNm7QhNNAcK5Q9A7aOXsI8545yCyaoMaicXrFZ72JzeYjaUVk7yT243zT0jzjFKQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-openharmony-arm64": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.2.6.tgz", + "integrity": "sha512-iOo0VEay2XFhaCcH0sps5XIimkSuOnNaZrf6+ZkoSOQBJPKNU48RkmJv0/lSpipexu5P+ouFgafe5IGr/DiQfg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-win32-arm64-msvc": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.2.6.tgz", + "integrity": "sha512-y5NTmmasMS455JlOCO4ZM9krIchv3Mvm1crL1iUPGOPgEzSkves9n0SdC5Sjz6+qWDFhd8/JpfWMH8NSWNHe+A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-win32-x64-msvc": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.2.6.tgz", + "integrity": "sha512-np8iZSLfXlAD4kWhiyq/u0Yt8oZDtRQ8lGhQaCXo2rl37KNjeU0GjJuwr4P3oeZ++ROfofsKNBqR5LTO8aXyWQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/pluginutils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz", + "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@standard-schema/spec": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz", + "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==", + "license": "MIT" + }, + "node_modules/@standard-schema/utils": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/@standard-schema/utils/-/utils-0.3.0.tgz", + "integrity": "sha512-e7Mew686owMaPJVNNLs55PUvgz371nKgwsc4vxE49zsODpJEnxgxRo2y/OKrqueavXgZNMDVj3DdHFlaSAeU8g==", + "license": "MIT" + }, + "node_modules/@tailwindcss/node": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.3.3.tgz", + "integrity": "sha512-/T8IKEsf9VTU6tLjgC7+sv2mOPtQxzE2jMw7u4Tt40Tx+QSZxpzh95/H6cMKoja9XuW7iMdLJYBB0o9G1CaAgg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/remapping": "^2.3.5", + "enhanced-resolve": "^5.24.1", + "jiti": "^2.7.0", + "lightningcss": "1.32.0", + "magic-string": "^0.30.21", + "source-map-js": "^1.2.1", + "tailwindcss": "4.3.3" + } + }, + "node_modules/@tailwindcss/node/node_modules/lightningcss": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz", + "integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==", + "dev": true, + "license": "MPL-2.0", + "dependencies": { + "detect-libc": "^2.0.3" + }, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + }, + "optionalDependencies": { + "lightningcss-android-arm64": "1.32.0", + "lightningcss-darwin-arm64": "1.32.0", + "lightningcss-darwin-x64": "1.32.0", + "lightningcss-freebsd-x64": "1.32.0", + "lightningcss-linux-arm-gnueabihf": "1.32.0", + "lightningcss-linux-arm64-gnu": "1.32.0", + "lightningcss-linux-arm64-musl": "1.32.0", + "lightningcss-linux-x64-gnu": "1.32.0", + "lightningcss-linux-x64-musl": "1.32.0", + "lightningcss-win32-arm64-msvc": "1.32.0", + "lightningcss-win32-x64-msvc": "1.32.0" + } + }, + "node_modules/@tailwindcss/node/node_modules/lightningcss-android-arm64": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.32.0.tgz", + "integrity": "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@tailwindcss/node/node_modules/lightningcss-darwin-arm64": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.32.0.tgz", + "integrity": "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@tailwindcss/node/node_modules/lightningcss-darwin-x64": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.32.0.tgz", + "integrity": "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@tailwindcss/node/node_modules/lightningcss-freebsd-x64": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.32.0.tgz", + "integrity": "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@tailwindcss/node/node_modules/lightningcss-linux-arm-gnueabihf": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.32.0.tgz", + "integrity": "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@tailwindcss/node/node_modules/lightningcss-linux-arm64-gnu": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.32.0.tgz", + "integrity": "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@tailwindcss/node/node_modules/lightningcss-linux-arm64-musl": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.32.0.tgz", + "integrity": "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@tailwindcss/node/node_modules/lightningcss-linux-x64-gnu": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.32.0.tgz", + "integrity": "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@tailwindcss/node/node_modules/lightningcss-linux-x64-musl": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.32.0.tgz", + "integrity": "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@tailwindcss/node/node_modules/lightningcss-win32-arm64-msvc": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.32.0.tgz", + "integrity": "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@tailwindcss/node/node_modules/lightningcss-win32-x64-msvc": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.32.0.tgz", + "integrity": "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@tailwindcss/oxide": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide/-/oxide-4.3.3.tgz", + "integrity": "sha512-krXjAikiaFSPaK/FkAQT5UTx3VormQaiZ5hBFlJZ9UFQGB/rwg1MZIhHAG9smMQRTdyJxP6Qt5MwMtdyU5FWrA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 20" + }, + "optionalDependencies": { + "@tailwindcss/oxide-android-arm64": "4.3.3", + "@tailwindcss/oxide-darwin-arm64": "4.3.3", + "@tailwindcss/oxide-darwin-x64": "4.3.3", + "@tailwindcss/oxide-freebsd-x64": "4.3.3", + "@tailwindcss/oxide-linux-arm-gnueabihf": "4.3.3", + "@tailwindcss/oxide-linux-arm64-gnu": "4.3.3", + "@tailwindcss/oxide-linux-arm64-musl": "4.3.3", + "@tailwindcss/oxide-linux-x64-gnu": "4.3.3", + "@tailwindcss/oxide-linux-x64-musl": "4.3.3", + "@tailwindcss/oxide-wasm32-wasi": "4.3.3", + "@tailwindcss/oxide-win32-arm64-msvc": "4.3.3", + "@tailwindcss/oxide-win32-x64-msvc": "4.3.3" + } + }, + "node_modules/@tailwindcss/oxide-android-arm64": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-android-arm64/-/oxide-android-arm64-4.3.3.tgz", + "integrity": "sha512-Y85A2gmPSkl5Ve5qR86GL4HT509cFqQh1aes9p3sSkyTPwt0Pppf3GkwGe4JPACcRYjgJIEhQgM6dBClnr0NYw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-darwin-arm64": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-arm64/-/oxide-darwin-arm64-4.3.3.tgz", + "integrity": "sha512-BiaWatpBcERQFDlOjRDpIVXuFK5PJez5SA4JMg6VYZdBYU+qKfV/vqjcIs+IYmtitf1xYQZTwXvU/8y4lfZUGw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-darwin-x64": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-x64/-/oxide-darwin-x64-4.3.3.tgz", + "integrity": "sha512-fAeUqfV5ndhxRwai8cXGzdLvul9utWOmeTkv69unv4ZXixjn61Z+p9lCWdwOwA3TYboG3BwdVuN/RDjhBRl0mw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-freebsd-x64": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-freebsd-x64/-/oxide-freebsd-x64-4.3.3.tgz", + "integrity": "sha512-iyf5bV6+wnAlflVeEy7R25dupxTNECZN5QMI0qNT6eT+EgaGdZcKhGkr5SdoaWiLJ3spLqIY9VCeSGrwmtg4kw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-linux-arm-gnueabihf": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm-gnueabihf/-/oxide-linux-arm-gnueabihf-4.3.3.tgz", + "integrity": "sha512-aAYUprJAJQWWbRrPvtjdroZ56Md+JM8pMiopS6xGEwDfLhqj+2ver2p4nU4Mb3CRqcMmNBjo8KkUgcxhkzVQGQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-linux-arm64-gnu": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-gnu/-/oxide-linux-arm64-gnu-4.3.3.tgz", + "integrity": "sha512-nDxldcEENOxZRzC2uu9jrutZdAAQtb+8WWDCSnWL1zvBk1+FN+x6MtDViPB5AJMfttVCUhehGWus3XBPgatM/w==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-linux-arm64-musl": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-musl/-/oxide-linux-arm64-musl-4.3.3.tgz", + "integrity": "sha512-Md44bD6veX/PC5iyF8cDVnw4HBIANZepRZZ7a8DQOvkfo5WUBwcp6iAuCUz23u+4SUkhJlD3eL7hNdW8ezd/kA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-linux-x64-gnu": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-gnu/-/oxide-linux-x64-gnu-4.3.3.tgz", + "integrity": "sha512-tx7us1muwOKAKWao2v/GaafFeQboE6aj88vC6ziN2NCGcRm8gWUhwjzg+YdVB1e4boAtdtma4L43onunI6NS4w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-linux-x64-musl": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-musl/-/oxide-linux-x64-musl-4.3.3.tgz", + "integrity": "sha512-SJxX60smvHgasZoBy11dX6YRjXJFovwWBoedhbQPOBzgFWBHGB+TVPWB9BxzR7TTxU8FQZAI2AyiNCMzFm8Img==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-wasm32-wasi": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-wasm32-wasi/-/oxide-wasm32-wasi-4.3.3.tgz", + "integrity": "sha512-jx1+rPhY/5Ympkktd656HBWEBLxP7dH06losBLjjf5vgCODXvi9KhtftWcMIwTFIDqBr7cRnQkdLnAG+IOlGvQ==", + "bundleDependencies": [ + "@napi-rs/wasm-runtime", + "@emnapi/core", + "@emnapi/runtime", + "@tybys/wasm-util", + "@emnapi/wasi-threads", + "tslib" + ], + "cpu": [ + "wasm32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@emnapi/core": "^1.11.1", + "@emnapi/runtime": "^1.11.1", + "@emnapi/wasi-threads": "^1.2.2", + "@napi-rs/wasm-runtime": "^1.1.4", + "@tybys/wasm-util": "^0.10.2", + "tslib": "^2.8.1" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/@tailwindcss/oxide-win32-arm64-msvc": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-arm64-msvc/-/oxide-win32-arm64-msvc-4.3.3.tgz", + "integrity": "sha512-3rc292Ca2ceK6Ulcc/bAVnTs/3nDtoPhyEKlgPv+yQJQi/JS/AMJlqzxvlDacL1nekbrcf6bTqp/jV4qgnPxNQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-win32-x64-msvc": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-x64-msvc/-/oxide-win32-x64-msvc-4.3.3.tgz", + "integrity": "sha512-yJ0pwIVc/nYeGoV02WtsN8KYyLQv7kyI2wDnkezyJlGGjkd4QLwDGAwl47YpPJeuI0M0ObaXGSPjvWDPeTPggw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/postcss": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/@tailwindcss/postcss/-/postcss-4.3.3.tgz", + "integrity": "sha512-JTSZZGQi1AyKirbLN3azmjVzef92tcX7h+iSqPdaeStyFpGpDlKvvpxeOE8njhbUanbRwr3z8DyzhICWnMtQeg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@alloc/quick-lru": "^5.2.0", + "@tailwindcss/node": "4.3.3", + "@tailwindcss/oxide": "4.3.3", + "postcss": "^8.5.16", + "tailwindcss": "4.3.3" + } + }, + "node_modules/@types/d3-array": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.2.tgz", + "integrity": "sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==", + "license": "MIT" + }, + "node_modules/@types/d3-color": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz", + "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==", + "license": "MIT" + }, + "node_modules/@types/d3-ease": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-ease/-/d3-ease-3.0.2.tgz", + "integrity": "sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA==", + "license": "MIT" + }, + "node_modules/@types/d3-interpolate": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz", + "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==", + "license": "MIT", + "dependencies": { + "@types/d3-color": "*" + } + }, + "node_modules/@types/d3-path": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@types/d3-path/-/d3-path-3.1.1.tgz", + "integrity": "sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg==", + "license": "MIT" + }, + "node_modules/@types/d3-scale": { + "version": "4.0.9", + "resolved": "https://registry.npmjs.org/@types/d3-scale/-/d3-scale-4.0.9.tgz", + "integrity": "sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw==", + "license": "MIT", + "dependencies": { + "@types/d3-time": "*" + } + }, + "node_modules/@types/d3-shape": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.2.0.tgz", + "integrity": "sha512-kVd74ta9eof3eJOvbNd1vGKS/XERRyQbT26Og63hIsvDO84cjD5gEOhsXf26w3FSoNlPVz84DOFcKv/oou+fMw==", + "license": "MIT", + "dependencies": { + "@types/d3-path": "*" + } + }, + "node_modules/@types/d3-time": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-time/-/d3-time-3.0.4.tgz", + "integrity": "sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g==", + "license": "MIT" + }, + "node_modules/@types/d3-timer": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-timer/-/d3-timer-3.0.2.tgz", + "integrity": "sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw==", + "license": "MIT" + }, + "node_modules/@types/react": { + "version": "19.2.18", + "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.18.tgz", + "integrity": "sha512-AnzbBERsrLKtk2XSfTbYRLjQPdy116Sty4q+T+Bp3IC4l6jNBvreVPAHmpq9qhXQM7CXZPjLVmGMw9sy+hxQ3w==", + "devOptional": true, + "license": "MIT", + "dependencies": { + "csstype": "^3.2.2" + } + }, + "node_modules/@types/react-dom": { + "version": "19.2.5", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.5.tgz", + "integrity": "sha512-fMPwH9v7r/pp43yUd2/Mbiex5KouJwwR3dzHkhLREUC6764VyDsqxhAxv6OFEYR1RhjOyD1naqba8ECDBe7ZQg==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "@types/react": "^19.2.0" + } + }, + "node_modules/@types/use-sync-external-store": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/@types/use-sync-external-store/-/use-sync-external-store-0.0.6.tgz", + "integrity": "sha512-zFDAD+tlpf2r4asuHEj0XH6pY6i0g5NeAHPn+15wk3BV6JA69eERFXC1gyGThDkVa1zCyKr5jox1+2LbV/AMLg==", + "license": "MIT" + }, + "node_modules/autoprefixer": { + "version": "10.5.4", + "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.5.4.tgz", + "integrity": "sha512-MaU0U/za7N3r6brxD4YB/l4NSrFzLPlANv6wEuQVaIPlD3L4W9rFcQPbL/EilY9BHhHvhfcz3gInDLrEtWT4EA==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/autoprefixer" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "browserslist": "^4.28.6", + "caniuse-lite": "^1.0.30001806", + "fraction.js": "^5.3.4", + "picocolors": "^1.1.1", + "postcss-value-parser": "^4.2.0" + }, + "bin": { + "autoprefixer": "bin/autoprefixer" + }, + "engines": { + "node": "^10 || ^12 || >=14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/baseline-browser-mapping": { + "version": "2.11.20", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.20.tgz", + "integrity": "sha512-H0ulySigv6icDJ1F7SjtdCD6PrhTpdYCmP0CactWy1+ekh0AFd0o1Wn5T8b+hnTmdBx19u9yhL6wvCylXMY7zw==", + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.cjs" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/browserslist": { + "version": "4.28.8", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.8.tgz", + "integrity": "sha512-V2NpofLblG64mfOtSgDhOJESZEGogzDMBv/q+W6oc4LXWP/q75eOXoOaaOu1EOadB9U4Bwx/e0yzbvwKH8zalA==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "baseline-browser-mapping": "^2.11.12", + "caniuse-lite": "^1.0.30001809", + "electron-to-chromium": "^1.5.402", + "node-releases": "^2.0.53", + "update-browserslist-db": "^1.3.0" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001810", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001810.tgz", + "integrity": "sha512-TITQPUkaz+aVk5GL6NhOdwk1aEaNTSDPsGFWrTuhKGtjTF70jL/Oht2W4c6rXUe5fu7Ie19VIahAXHIIiWWNeg==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "CC-BY-4.0" + }, + "node_modules/clsx": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz", + "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "devOptional": true, + "license": "MIT" + }, + "node_modules/d3-array": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-3.2.4.tgz", + "integrity": "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==", + "license": "ISC", + "dependencies": { + "internmap": "1 - 2" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-color": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz", + "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-ease": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz", + "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-format": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.2.tgz", + "integrity": "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-interpolate": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz", + "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==", + "license": "ISC", + "dependencies": { + "d3-color": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-path": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-3.1.0.tgz", + "integrity": "sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-scale": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/d3-scale/-/d3-scale-4.0.2.tgz", + "integrity": "sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==", + "license": "ISC", + "dependencies": { + "d3-array": "2.10.0 - 3", + "d3-format": "1 - 3", + "d3-interpolate": "1.2.0 - 3", + "d3-time": "2.1.1 - 3", + "d3-time-format": "2 - 4" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-shape": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-3.2.0.tgz", + "integrity": "sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==", + "license": "ISC", + "dependencies": { + "d3-path": "^3.1.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-time": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-time/-/d3-time-3.1.0.tgz", + "integrity": "sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==", + "license": "ISC", + "dependencies": { + "d3-array": "2 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-time-format": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/d3-time-format/-/d3-time-format-4.1.0.tgz", + "integrity": "sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==", + "license": "ISC", + "dependencies": { + "d3-time": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-timer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz", + "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/decimal.js-light": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/decimal.js-light/-/decimal.js-light-2.5.1.tgz", + "integrity": "sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==", + "license": "MIT" + }, + "node_modules/detect-libc": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz", + "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=8" + } + }, + "node_modules/electron-to-chromium": { + "version": "1.5.417", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.417.tgz", + "integrity": "sha512-4T+DTDWuMPM4aHlHwWdAVCVWwp7LDilnhzkj+c/Lbj91XSQrLuOmZSLtS9Q4iIqjlPUbPOnC624zDVVHCHaolQ==", + "license": "ISC" + }, + "node_modules/enhanced-resolve": { + "version": "5.24.5", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.24.5.tgz", + "integrity": "sha512-L1l8TNvomm6UVW5B253AGxQagSQr+vGwhMlrrfRS2qmhx46AMpMVJKQYLvWYbysTMY8VoicOvzHzoHMbyzB+4A==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.4", + "tapable": "^2.3.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/es-toolkit": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/es-toolkit/-/es-toolkit-1.52.0.tgz", + "integrity": "sha512-XTNEJQh1tY1ZJVcf6ayP/2n4ZPyaHlW2FWs7xvw5ddPuhUVjLD3olQVQS7kf58JbAB48iL0uL/jerTrjtV3lDA==", + "license": "MIT", + "workspaces": [ + "docs", + "benchmarks", + "tests/types", + "tests/browser-compat" + ] + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/eventemitter3": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.4.tgz", + "integrity": "sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==", + "license": "MIT" + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/fraction.js": { + "version": "5.3.4", + "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-5.3.4.tgz", + "integrity": "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==", + "license": "MIT", + "engines": { + "node": "*" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/rawify" + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/immer": { + "version": "11.1.18", + "resolved": "https://registry.npmjs.org/immer/-/immer-11.1.18.tgz", + "integrity": "sha512-EQyQtLiYW029lyoczMl/Hh4Xu7cDecSc58JRYpHyL4tIAu3eqd1yJzQX04d2BZHDkzFFvm6qJEJWOtfDSWAXbQ==", + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/immer" + } + }, + "node_modules/internmap": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz", + "integrity": "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/jiti": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.7.0.tgz", + "integrity": "sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==", + "dev": true, + "license": "MIT", + "bin": { + "jiti": "lib/jiti-cli.mjs" + } + }, + "node_modules/lightningcss": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.33.0.tgz", + "integrity": "sha512-WkUDrojuJs0xkgGf2udWxa3yGBRxPtxUkB79i6aCZLRgc7PM8fZe9TosfPDcvEpQZbuFASnHYmRLBLUbmLOIIA==", + "dev": true, + "license": "MPL-2.0", + "dependencies": { + "detect-libc": "^2.0.3" + }, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + }, + "optionalDependencies": { + "lightningcss-android-arm64": "1.33.0", + "lightningcss-darwin-arm64": "1.33.0", + "lightningcss-darwin-x64": "1.33.0", + "lightningcss-freebsd-x64": "1.33.0", + "lightningcss-linux-arm-gnueabihf": "1.33.0", + "lightningcss-linux-arm64-gnu": "1.33.0", + "lightningcss-linux-arm64-musl": "1.33.0", + "lightningcss-linux-x64-gnu": "1.33.0", + "lightningcss-linux-x64-musl": "1.33.0", + "lightningcss-win32-arm64-msvc": "1.33.0", + "lightningcss-win32-x64-msvc": "1.33.0" + } + }, + "node_modules/lightningcss-android-arm64": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.33.0.tgz", + "integrity": "sha512-gEpRTalKdosp4Bb8qWtc2iOgE5SeIHlpS1up9bFq2wAyYhl1UdTObYiHe98zEM9SQvSoqQZ1IQD0JNpg3Ml5pg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-darwin-arm64": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.33.0.tgz", + "integrity": "sha512-Sciaz8eenNTKn9b3t7+xr0ipTp9YxKQY4npwQ3mrRuL0BAVHBLyZxofhaKBAVtzmtRZ/zTyo0/to4B1uWG/Djg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-darwin-x64": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.33.0.tgz", + "integrity": "sha512-Z5UPAxzrjlWNNyGy6i65cJzzvgJ5D3T6wMvs+gWpY9d7qRhANrxqAp6LhxIgZhWEw18RfJTGcRxjuLIBr+m8XQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-freebsd-x64": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.33.0.tgz", + "integrity": "sha512-QQM/Ti/hQajJwCY+RiWuCZ9sdtI/XQk7nDK5vC8kkdwixezOlDgvDx7+RT+QjK6FcFT4MpsuoBnHIo/O3StRRg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-arm-gnueabihf": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.33.0.tgz", + "integrity": "sha512-N7FVBe6iS24MlM6R/4RBTxGhQheZGs7tiQ9U32UtF75NzP5Q7xWPRqLBCKxlRQRk3rY1jCIPLzx7WzOhuUIRLQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-arm64-gnu": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.33.0.tgz", + "integrity": "sha512-j2v/itmy4HlNxlc6voKXYgBqNi0Ng2LShg4z7GufpEgs05P+2suBVyi9I6YHq5uoVFx9ETin3eCEhLVyXGQnKg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-arm64-musl": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.33.0.tgz", + "integrity": "sha512-yiO5ROMuYQgXbC60yjZU5CYSFZGKXL0HFATXt9mHJn1+zW55oCtMI9NfcVhYLMFDL7gV7oBPon/EmMMGg2OvtQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-x64-gnu": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.33.0.tgz", + "integrity": "sha512-ar+Ju7LmcN0Jo4FpL4hpFybwNG9/3A/Br5KW2n2jyODg3MEZXaDYADdemoNS+BDNfMgKvylJLj4S5tyRActuAg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-x64-musl": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.33.0.tgz", + "integrity": "sha512-RYiYbkokw0trfKqqzfF55lginwEPrD3OJDfTuJzFs1MK6iFnDenaz1fqLLtX4ITG3OktJQXOeTaw1awrBAlZPw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-win32-arm64-msvc": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.33.0.tgz", + "integrity": "sha512-1K+MPfLSFVpphzpdbfkhlWk6wBrTObBzS2T6db10PNOZgR9GoVsAWzwNyuhUYYbTp23j+4RrncfujZ4uAzXvwA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-win32-x64-msvc": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.33.0.tgz", + "integrity": "sha512-OlEICDx/Xl0FqSp4bry8zFnCvGpig3Gl4gCquvYwHuqJKEC1+n9NgDniFvqHGmMv1ZkqDJrDqKKSykTDX+ehuA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lucide-react": { + "version": "1.38.0", + "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-1.38.0.tgz", + "integrity": "sha512-xZCyBd/wiVUDactoCc+42TjL0aB7EBOXsuX+tjz+W/sGzw2KhHpL1NOH3FIaVUcpimvUBpIYfz34Ofj9S5JEzQ==", + "license": "ISC", + "peerDependencies": { + "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/magic-string": { + "version": "0.30.21", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + } + }, + "node_modules/nanoid": { + "version": "3.3.18", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.18.tgz", + "integrity": "sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/node-releases": { + "version": "2.0.54", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.54.tgz", + "integrity": "sha512-YHs7BmmcsdAI5Ozuf8JZo6PT0mv2GIWC9vMfvUC3dp65M8hn7Ux8CPL+2oBI7juNuj9d0ndhTcznq2ODBps9cQ==", + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz", + "integrity": "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/postcss": { + "version": "8.5.26", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.26.tgz", + "integrity": "sha512-u82N74LFzG8ca+dD8puPnplTXoGH4fTPpVGuIbt36G3qvNlkvfD0lEAZSxaly3KX8TS/L1A1gsCEmvKmBcVbkQ==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.17", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/postcss-value-parser": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz", + "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==", + "license": "MIT" + }, + "node_modules/react": { + "version": "19.2.8", + "resolved": "https://registry.npmjs.org/react/-/react-19.2.8.tgz", + "integrity": "sha512-PWaYA1L/q9u2u7xYQi+Y3L3Yfnie7XyLeaJICV1MGD6LprsBxcAqGjYyr0eY3p+QdsA+x/Irkt4Qif8D63+Sbw==", + "license": "MIT", + "peer": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "19.2.8", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.8.tgz", + "integrity": "sha512-rVprimfGBG3DR+Tq0IQG2DT5PxKth1WIGDmj5yPmlzr4YBe7uyE+Du4oVqTDXZSHGGGXRtTJEGSSePyQCMBglQ==", + "license": "MIT", + "peer": true, + "dependencies": { + "scheduler": "^0.27.0" + }, + "peerDependencies": { + "react": "^19.2.8" + } + }, + "node_modules/react-is": { + "version": "19.2.8", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-19.2.8.tgz", + "integrity": "sha512-s5un28nYxKJw5gvUHyW5PCC28CvBqLu9r3cWgzHT4Vo/5fqqkFcdRYsGcKf50WMPpjjFZS5d76fn3YCo2njKwQ==", + "license": "MIT", + "peer": true + }, + "node_modules/react-redux": { + "version": "9.3.0", + "resolved": "https://registry.npmjs.org/react-redux/-/react-redux-9.3.0.tgz", + "integrity": "sha512-KQopgqFo/p/fgmAs5qz6p5RWaNAzq40WAu7fJIXnQpYxFPbJYtsJPWvGeF2rOBaY/kEuV77AVsX8TsQzKm+A/g==", + "license": "MIT", + "dependencies": { + "@types/use-sync-external-store": "^0.0.6", + "use-sync-external-store": "^1.4.0" + }, + "peerDependencies": { + "@types/react": "^18.2.25 || ^19", + "react": "^18.0 || ^19", + "redux": "^5.0.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "redux": { + "optional": true + } + } + }, + "node_modules/recharts": { + "version": "3.10.1", + "resolved": "https://registry.npmjs.org/recharts/-/recharts-3.10.1.tgz", + "integrity": "sha512-QXFrvt6IVcw7eeZCoyXTwkIJAX3Dv1nyVhMicXJ47GsGDDpcN8z6o644DibE9XjpBTThtsomLKnTV6lc+cVFUA==", + "license": "MIT", + "workspaces": [ + "www" + ], + "dependencies": { + "@reduxjs/toolkit": "^1.9.0 || 2.x.x", + "clsx": "^2.1.1", + "decimal.js-light": "^2.5.1", + "es-toolkit": "^1.39.3", + "eventemitter3": "^5.0.1", + "immer": "^11.1.8", + "react-redux": "8.x.x || 9.x.x", + "reselect": "5.2.0", + "tiny-invariant": "^1.3.3", + "use-sync-external-store": "^1.2.2", + "victory-vendor": "^37.0.2" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-is": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/redux": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/redux/-/redux-5.0.1.tgz", + "integrity": "sha512-M9/ELqF6fy8FwmkpnF0S3YKOqMyoWJ4+CS5Efg2ct3oY9daQvd/Pc71FpGZsVsbl3Cpb+IIcjBDUnnyBdQbq4w==", + "license": "MIT" + }, + "node_modules/redux-thunk": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/redux-thunk/-/redux-thunk-3.1.0.tgz", + "integrity": "sha512-NW2r5T6ksUKXCabzhL9z+h206HQw/NJkcLm1GPImRQ8IzfXwRGqjVhKJGauHirT0DAuyy6hjdnMZaRoAcy0Klw==", + "license": "MIT", + "peerDependencies": { + "redux": "^5.0.0" + } + }, + "node_modules/reselect": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/reselect/-/reselect-5.2.0.tgz", + "integrity": "sha512-AgZ3UOZm3YndfrJ4OYjgrT7bmCm/1iqkjvEfH/oYjzh6PD2qw4QuT3jjnXIrpdt4MTpMXclMT3lXbmRY+XRakw==", + "license": "MIT" + }, + "node_modules/rolldown": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.2.6.tgz", + "integrity": "sha512-vMM4q3aixf46GiF1Kok8jDPFsEpXgFWGjUHXNkNHNm+Y2adXAG2dbX91jkti3i0ZRsOlcmbuzAz1poObSHCmUA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@oxc-project/types": "=0.147.0", + "@rolldown/pluginutils": "^1.0.0" + }, + "bin": { + "rolldown": "bin/cli.mjs" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "optionalDependencies": { + "@rolldown/binding-android-arm-eabi": "1.2.6", + "@rolldown/binding-android-arm64": "1.2.6", + "@rolldown/binding-darwin-arm64": "1.2.6", + "@rolldown/binding-darwin-x64": "1.2.6", + "@rolldown/binding-freebsd-x64": "1.2.6", + "@rolldown/binding-linux-arm-gnueabihf": "1.2.6", + "@rolldown/binding-linux-arm64-gnu": "1.2.6", + "@rolldown/binding-linux-arm64-musl": "1.2.6", + "@rolldown/binding-linux-ppc64-gnu": "1.2.6", + "@rolldown/binding-linux-s390x-gnu": "1.2.6", + "@rolldown/binding-linux-x64-gnu": "1.2.6", + "@rolldown/binding-linux-x64-musl": "1.2.6", + "@rolldown/binding-openharmony-arm64": "1.2.6", + "@rolldown/binding-win32-arm64-msvc": "1.2.6", + "@rolldown/binding-win32-x64-msvc": "1.2.6" + } + }, + "node_modules/scheduler": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz", + "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==", + "license": "MIT", + "peer": true + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/tailwindcss": { + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.3.3.tgz", + "integrity": "sha512-gOhV3P7ufE62QDGg1zVaTgCR+EtPv92k2nIhVcVKcLmxT1sUBsQGhnZj175j+MqRt4zLF7ic+sCYjfhxMxj7YQ==", + "license": "MIT" + }, + "node_modules/tapable": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.3.tgz", + "integrity": "sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/tiny-invariant": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz", + "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==", + "license": "MIT" + }, + "node_modules/tinyglobby": { + "version": "0.2.17", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz", + "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.4" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/typescript": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.3.tgz", + "integrity": "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/update-browserslist-db": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.2.tgz", + "integrity": "sha512-UQ+MSxlhRm1bzjhU+DcuXfjFO1FzNtqhK5+9Yvlp90ItDLk5vT932A0rFu619nf7RVS+Y/VeaUW1jaRDqZ8VJw==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.1" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/use-sync-external-store": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.6.0.tgz", + "integrity": "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==", + "license": "MIT", + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/victory-vendor": { + "version": "37.3.6", + "resolved": "https://registry.npmjs.org/victory-vendor/-/victory-vendor-37.3.6.tgz", + "integrity": "sha512-SbPDPdDBYp+5MJHhBCAyI7wKM3d5ivekigc2Dk2s7pgbZ9wIgIBYGVw4zGHBml/qTFbexrofXW6Gu4noGxrOwQ==", + "license": "MIT AND ISC", + "dependencies": { + "@types/d3-array": "^3.0.3", + "@types/d3-ease": "^3.0.0", + "@types/d3-interpolate": "^3.0.1", + "@types/d3-scale": "^4.0.2", + "@types/d3-shape": "^3.1.0", + "@types/d3-time": "^3.0.0", + "@types/d3-timer": "^3.0.0", + "d3-array": "^3.1.6", + "d3-ease": "^3.0.1", + "d3-interpolate": "^3.0.1", + "d3-scale": "^4.0.2", + "d3-shape": "^3.1.0", + "d3-time": "^3.0.0", + "d3-timer": "^3.0.1" + } + }, + "node_modules/vite": { + "version": "8.2.2", + "resolved": "https://registry.npmjs.org/vite/-/vite-8.2.2.tgz", + "integrity": "sha512-cFKLV/PRgAUlIRm5WjMjJ86jrftzpqcgH+Us+DS8mI3CDNiH30Whrz8uHL3+MOLPAgqbMBAqWdAHAphOAM+z/Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "lightningcss": "^1.33.0", + "picomatch": "^4.0.5", + "postcss": "^8.5.26", + "rolldown": "~1.2.4", + "tinyglobby": "^0.2.17" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^20.19.0 || >=22.12.0", + "@vitejs/devtools": "^0.4.0 || ^0.5.0", + "esbuild": "^0.27.0 || ^0.28.0", + "jiti": ">=1.21.0", + "less": "^4.0.0", + "sass": "^1.70.0", + "sass-embedded": "^1.70.0", + "stylus": ">=0.54.8", + "sugarss": "^5.0.0", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "@vitejs/devtools": { + "optional": true + }, + "esbuild": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + } + } +} diff --git a/frontend/package.json b/frontend/package.json new file mode 100644 index 0000000..40ea9e6 --- /dev/null +++ b/frontend/package.json @@ -0,0 +1,26 @@ +{ + "name": "frontend", + "private": true, + "version": "0.0.0", + "type": "module", + "scripts": { + "dev": "vite", + "build": "tsc && vite build", + "preview": "vite preview" + }, + "devDependencies": { + "@tailwindcss/postcss": "^4.3.3", + "@types/react": "^19.2.18", + "@types/react-dom": "^19.2.5", + "typescript": "~6.0.2", + "vite": "^8.2.2" + }, + "dependencies": { + "autoprefixer": "^10.5.4", + "clsx": "^2.1.1", + "lucide-react": "^1.38.0", + "postcss": "^8.5.26", + "recharts": "^3.10.1", + "tailwindcss": "^4.3.3" + } +} diff --git a/frontend/postcss.config.js b/frontend/postcss.config.js new file mode 100644 index 0000000..2341282 --- /dev/null +++ b/frontend/postcss.config.js @@ -0,0 +1,6 @@ +export default { + plugins: { + '@tailwindcss/postcss': {}, + autoprefixer: {}, + }, +} diff --git a/frontend/public/favicon.png b/frontend/public/favicon.png new file mode 100644 index 0000000000000000000000000000000000000000..69c8172a09c55509d064929d099cf423841a42c1 GIT binary patch literal 155750 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ç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 N002ovPDHLkV1i1;{Ote$ literal 0 HcmV?d00001 diff --git a/frontend/public/favicon.svg b/frontend/public/favicon.svg new file mode 100644 index 0000000..6893eb1 --- /dev/null +++ b/frontend/public/favicon.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/frontend/public/icons.svg b/frontend/public/icons.svg new file mode 100644 index 0000000..e952219 --- /dev/null +++ b/frontend/public/icons.svg @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/frontend/public/logo.png b/frontend/public/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..69c8172a09c55509d064929d099cf423841a42c1 GIT binary patch literal 155750 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çoY7mroti@!)<@(G2L=CZuOfrKLFhb`Pj~~}=Ju<1s<|sM(=UxVB@r?N9Re z`Tu=GHuwFA@cDb*D?94+DhHWq$+;$8APBW4Vc=iW3D4LpYn0_Ll@n7#s|AscJG+j8 z=l;_7_{evE_jl!0uX#0laE(h{3n9`KQo16L<|OTxCj%kKSL#Wd47s+6RjO(RdJ#*h z73)Z)&yx7 zl%WWHahTg8%w0XBaAh@tGaDGjsgJXELd!NNHbJ1p#0AK#jMVX?2#_2x1R|XR ztIgbU0U=s7)GZzWTfUPIzaj8O!*}yRiZ`7cU(J+5^ij&+Ao#vd9drwy9{qag#z%fV zFV5>zJit<$R8>M(GzW%rE1_|ejHg|y%bYyCK}_lWVAGB3woq^BsVX4I3!zep7=poe znUyeTY|h=EMu?9Tm%f4uE_&?w3$Tw9>3QTSUVo>gdct=cmml;$c(dP?6iEvor|?l@-#a zc0w&|uaP-QA56TwtdRpUCRJ^0+DTRAUGI8Vp8m9_^GW+3=PSSR-{+71_>Ekf@C(yP zc090~+ZTg3Bwp`>dM?L0%i&~dP{_g{rCruDbpqakh1nGJTBe9K zmZiDrHMl^k2{jwH5|cv1bPdJ_*Lj39RH)=Wb^kv zEt{Qn5e~vSUSP!wtR_`>3Y^AR*$`o%vm~lRG-jT%;%yt_1))urX~gWiz5;KB`BJeW(rV<8P5r#8q7FSum0%7jRARfX17e7S6NXKnnuaiYs~YIBfe^FrK_(7PL%^|VvmIk4{1O^7lOt9 zgK$l_hko@}e>Fex6VFZGHWV+v%&$smqfu?EUH864fxL$7slMb7CnG!o}jhVY> zy9_#Dz0(;t_f7&+Y{OIMInVjwJod4V%eQ^U)AHs&doz332r(N)0Ug^X zsj5P6=~bEtLDiFEr%0lghQ2n0YMZPAu%q$fx(e<_?3~nDPX}>!$OB1BmNpixf~RWH z9+Np5z+Q|+afN1J9ZiYB0e1z}9l+oQovY5^ljp?;enw6XD;w|BUSA(YV)o)^)mdW$ zi@sMF91`O~Xe&K}FJN4OLMC=cCr3cbpwfPLb2)WREgleZeZpTOg|CEG%#ao@O(ogj zZP1lE+U14^Jw6-0KJi7y9ZxLGm)TevecC-%Bs7NEIyCNz{n0FV?TN&%?fb+fP>b&U zXivhvX5$k(z0Qj-9VzyeeKWQ%x*mH+S5$rB{XZgy_jtefse8x0Favn>o0}PLGiUZWGnR4J z=e6G93wU0!*&S~%{z3Ba>eW2(Lm!yG`I~nK2-$|`bE=q2$%b5P#@%ujm}mNoodMeH z)FtE=R!(pKr!WC-4R|7eN>bw|KM4fcC@vHg- z!xrM&ftJ3KrZ&bjU4O61t->R@s#3+Lul3(@e}Iu(%w;Fmz;QBVdg{U|idJa} z&G{jN;zM>%s8~O|W`ZL|YIp6itf{ybR%#614u40^D&kb7#K=c})JNqzzwJp*AYfEb%{+V6g$Xd{oSTR_DA1*} z00M`Jx`#ZFOo8bfh1VP?XgXEw#0i!0=2g~Rhz)Cv!SRp8c&fFr*wz@~5ZgGUlj2Ma z74!VQ(xeiB-1DXOKW>oF?8FJsU5XKfP%UB{p+^Z!*0CH&m>03bH?xHao9kkhSg=Q3 z%;k^z!tj-GHe(CqOKQ$*LDJ^tnaP`_dLjy((Gz19Fh-f3GjX`A1CVm8Kn?>hY@xccuxoxsDh%-oMEu= z#Y)#ScvhU7q^ert13i*TS}^b=>12@?jXsAl)@f7PX^zU?s#}l zx#Le>k$3*mwf1e!O^MlC~sW~_M2$mgE(nhs8$YrWDC2JcP#Di#ZUQse4ZxGe36qbDuNy`R&<+}HYksKe$ zg9o#=9DV-)>6<9Q%-GDSV$llqqEN>E=tn;)U-(5|z>bfT+GWRPcgB?jJPCOfepVe? zEdm~KBq?^!`m;1SE26CslIlI+ySh;iSbl^_u+_rk# z=9w%aZ~Bg`UC{Nmi%$(ZM`B9k4~7v4bPI0q)4sqWUJR4071{t-BB+3MY+xwFv0|O< z+rV7{sIkX!u$}j;K%OVR648?hnP4e(kc;p4KW2B&2d7_<7BGxVlcZi40A`^=UiQtK zi9q{<2r_hf(3pbD?MfV%!c`t7VAn>|d$C>|D0biI%t=oHL9JkVvos%~oL-j$XW70y zWPy6#w&AOLT3#rFhl)4%IJ}xm5BQYSJwFBpedB4MnQP1ol`fLA%}Va0;#yOz$TYNe z%Ss2MN33;d7<3Hs961wJBxP+YLk^2Mbpf1v<>8vgS__HNAvmOE9%7_8Y=|G+>w|cJ zzHbgP!Y|o`ByxJ3Nk4dZW}W13e))T{J-HH|=X|dZZ++#n_#p7k z9PLIQdP0}km>MrqhfW2rY+Fk=;awS%(!3?6-Am}T6j!f$*J4_OYqVaA-V1?Z^_MPQ%)kH2 zugqf}^NBg&TsJx95yOQf+dOF9$8z2wCp2@rPT{Pbwb035fIAT&(*^Xh?*gkpWH&3j0RFgzpNTsH5 zhF6VzswLjc*o`wZhE9{M8|DozB(9)qE#@ln+#dmE8!ZeFC(`KyT)|;A29mmvZ0?@x zANh3|7w??|&ZnwURm7m6VpA*R>bm6MQxP>F(ow-Xi4f7OIXTmu##mJ~t%wyC zZsI_ZBC#cvAV9J8+2|lpLMUSMAq5yJcc2X&;>p3iKPa2cHuKCzY8WCD?L)-}@6liX zc@F>N*Z8XAF!DOl^-wBIRK+8K<&eb#hKJV4amFog&K4**mmT+) zLMG>Z;l6xeVEzp#C33F07y#cCnF5QoF%HBo|C~UYzN3uu;#pXsSo4gGwn*bLX&YfL zpfw4M?ke#idwg^?ul&td<_CV@2jPRUPtRz_Jtu44+YgH7MB zaZZ*PQ#3l>PG+Mxolqe_EK)ysLm8pf6t5vB-AK9?aeB`w4lx}txBx}XbuDZ@E4h|> zBM=8DJg->vTheV_D-@2{2la46B4){(OTOCwpD3?mj;AQkz&Ms1Trl9b_$ zv8@czRm4w4>dX}@*VodE6jC5n!5YPmyMt1j7tX~G{?r^DZ~9-PAWCk3OoFt-hSO`O z8aE#xeZ`C`#wO+s2!ZpSK877gKV46b(gAAsg^F#&LvG85F|kw5oF}ef#d%buZCBk{ za~{kguTOU1(HG@howE9*(wUdB`!*LY-zS$J@~^3WkWFn<*|6?Hf{k#F#W~J818gvF zrr=FuITPT3RX`bLPEkt{l;?FJZcvDI59S~(K5(cGN}LgP+9zH`jS94Z7@t~#JgR~Z z0!Wf7+AIVh000mGNkl*LX3k^NQ=Yo@qqmnL%f#BSoAN!HP5tLU@8o10x+o=@#|r6O%&?E?5R% z3mN}`ANc;f@lW5#Yvwq82AtDSNaBQgA>uoI_ANHpgxIM-OE>}akbzT(_9{*$rf9Ri z&SyN## z5_u#S+WIU5t7cl~V28FStnQ@13sRINtGW8fkW4i&triCN2YIO-TBWL5Gtf_MOLS;O zsl~!O-D|iqy&sr8#m_*hDk!LEi(omg>4r8AxvMr}UTmbQrhuO{e4}J*lm(?2+s7D7 z?#y&Dz}ewUgV8V-RJA0aM!YKC%viH71vWQ+NG|-n&&UOCzD)vU$HDF3pKxPMCZ)g! zzVU&rPPfrxHAW&Hs}@8+@k6bFpqWojCGC$sI1ywF2kMNt6*;l7uD%+^S+)2)3xmuB zu=j@;Wl+Geyb^FZVsU5zBv2CY>DlZu=jR1?9e=ppe84AV@TmaQKr6pxQybD?(51T` zW(LcdHm>oL-p8im+_6z#bt<)(1AW%UWo>iI#AXLvIquOFD8S6%I0Z7fGJCDWs`Qi@ z8@#xC5A2hV#{9;0%&-5{S{|+iUOdpZthd*Gcxxy_hciyHLqZK-AnJkLE1C<&WFC61 zyfc2{R(4)T1x_i{-Xz&>FC?t5=LyX`RN#aSls-CYc!t86w(g;NJU7UXI6@x1y|WxK z{ULXC8gMujLq+z$;8?Qbw}`jC?XCHWulVxZdh4zI)ydoz1W08n>%`My8(82R%G?5| z9QUhsdZ6y^Rcw_88GIH{G74_rqZFnjwFN>3op}KTa@PVy(n~zODkM8fVF184jm1mWhOW2@uq%Go-}7_BAm1g^l2tsCc0O zPrG3}V`F%z>7@W?2;xm!2chd{X|=@N_FQBUDfU<)6q|G6;WBcNJ3jwhc;LU_8?oyq z50Wpeo{$&UK*}pS7Z4I-^P(utBQ_xF@9Tqgj8kDIYO^Xal2wCYVEab0#+wfg44H|i z5tBKM0MeO-xhM-fkRV_HlhYK2Bj<@1YG3m4c(KY$TshkH3(+7D8Qz z)lTg`7O?jS)j)-xWgf$4rOyYF=d-U#9Wp>gCS!OWW2EaESvWH0r?dhM@yQVvsao@s zm%sew`K4d{6>;c;wHWnm*jk4CMS_Ns!7zCN zqTT>O7)c$yPUp00Yh(SomA}j9e$Er}>7Vv#xp?6M`K-4*{f)u&I+=%*IZr6r7Lk#7 zmg$B+dwV_Lt4U`KK?b4@MW&6_y{bCa^Dqz%#TV(7Gpm}^z)cv_Z7?d7m}f_Rh*rTv zg1B!pL*s-Psl^2z0}c`di#1q@SPG6ze9gs&z{5L$2z4Vc3(HzWH3lgNq$&Z54VX;I zm=K);n29um-P)8HVkQ@qp2||fZfMHPomjdtQ?~c~h}3-_)-Tjyl0~U$4yQzt-z!^} zOx8NFX-`g<0$wmyfdhz-EvE$=@N9_M)Lm;5@0)ianG+rk9)r04D&oV3&YHW|o!oU9 z=&Ye*;%rKVSf}eUC!`GKi8uP-h1&GQTPd8Qr zaPl{Q#rAjM17%K*ciH(6N8Hbbqyv5(xpcn=r|xz?Z|VT`zF8?%^b+T*RA%#`uub_- zFMZ@cNsS9oiLp+faU??<;aSf6#4bngd^7PKbqAqYk1fLirZ8yc1GS+n3><1QS{9}j zGO>k};2K|r3DR6PH|yZ8T>ySn#q$y#sjvZ3)Rn4=x5_bpfK46bd;a4y^5#GLv-q!@ zkIXi8Wx!2}UXCp>SV`7c5}4FaH`l4-wLd2$_BoKh$I0mX1Kr(Z1PUcaoMMVIjC}R~ z@m2ZgkN(J9yvX(FHFQ>rAFXm2412-goMPM{GLS4yyQ+v%pLr*YJq^}Crv#nVPrE~M z1$8Q+L`(Lqre6RC<)|+!_M ^*OzR$O!PwbcXCU{Ok02(Si8eKEy^Cw?NyNy@<{-!Kd}DUE-_j4#@X+=XI2(;;5Ee?$ZhL($ zf6U`En8*^l3@E$cCf4c4I;*LQ&GFI)JR&Fec}V=~g*&T1AXJ|@xx3_qPx!mzJ97Bn zek+6T#CM#zb$j(rY7vXA(!R69K)D^Eo)VuW5m?D#ZAJ|MTd&PZg?2jN*bO4~mD`-r zWo2Xltg(Qz=0EtuKghFw@L9R;I^Nug)vTU=_~XOs)T9!G@?kXyy%&zQw>>$O7HOIM zkU7PAeO*GcK7_%#lyr^6Dp^`XULWM%@BQBWPs-eQl5TwK(^yaNFY4_cZ6X2r;fxf=zU4Y_^(x ztCI@7;!zsF?U?E`bbi-uQEW~MJ6R>F%cy+~eVx(I|`i&`;k9YO8R z*I1;Q6lWwvfyNVF^_0dZam@#994P0+z?wHx`dlUlfIe-A98RAzrgfE$Eq>e0XHV?8 zcyPOxqP}^q*B71srgp3wGT-+d-F|y6Kk##s%kQ6Twv>TQ4rOPD7S3y(uc|^v(33Go zz^-4@rBJ3x0S%=={DrbA^ZGiU3+YVh&9;4ld-zfB2N- zjvWv0(GTv8>ls{L#5c7apYo6Icy|up@+vMvvC>@}3CC6p3W|4@UN|>usvEdWfR#*}s7-M(NOFTf#tZGRNf>!iLs#rngv<*!5 zY8~Mzj0?|jg1?H~czQY0jO(fwQLQ=XfshvN&V<^mBK}J^$A9!o*=~+g1bIED#W{F* z`$>Ep?Q*iYNACSuKb}h;^a9@6=e<7TnaMpL!XLqR>2tPL zXlVW7Q+M$Ox_if;WOwUd#eEZv;Ywk;5>$o**Dj5w+l;r_@#zm3edYxE8d^+S0g#oV z?f_8Ch0}P%wFcJIhF1|$yf=H1BdE#==km^Xy)*yr$xqIeJFdjv9+-mTm0hVSCYzm< zxDofNy++z+9TZ%ri*{_{q9$k~qieEW;)B@eyRjXH>N%xgo!T3{WXtt>+~XdXFL=@y zEU^kkW^M^Z*27#pgT+=!ZRzwHFLEz0U zrc7*15RQ8t4g~~EXBDm>M5l~FusP_QR&cGj-K&gMRGUT^2GvF;jZmrz^o$IP&B+MR zE7hYo21~Ik;^}B+qj;V3fvLyHeL_ubr8clCS?0d({-2)XOZQ2mJh0+FGUf!_2-16I zYKItAqOab^K* zu-$3;O-e_Bs+x&f0Om4Jn8(^vf=f&sTCawONKY@k%mZsinVVN+#>r6*-sfX;@%=wJ zybiMAM|!Wv8v}o)7WGXXEJb_hAhY7xktp~aF}nA8Qq-&l9L_p!yeERxTEbn4@$>kA zzemT66_|gzI)2k{x0?k{ciX#kuL9JuBmVAIS#;ev6~t{yJNSYf@Z~t#k0*>(xL0 zmE`1(UW~jp_5+Ko>3GC=tTrv_CZf?-kt>QXab@5FF4u!XblFuHbZx1f(#{;(U*i^- za9_HHsmsnfGAMAwZxFxrTfd!`yyT~{_2Vpud)iPgf z*wrXbnd>zONFzWO1pojL07*naR67E>wvo~}jMLCrM*{bT!9KdPF+omTN;)WThCm)Y z9bZNn`mXE@Q+Nsqbk-ybXiplxngvFxiWf5WQnV9v7a8bUWJF76q)ps&YXxSu?3?kW zZe#diKJ9aP0^sF^I(YAFKj^U;N4HUGmkOV_crm4A#7{*1Q00Z@TD@rf!Ww~_*$6mQ zdhU^`=>=Souh}*kgIaA5ohd$iJ8Q*u;?wcK@w$3zi_K6^X+4)~%@&yENSpkofi9Zb z9b+gH(MGDZmc$T*|W-hz=&sF{nrkQfEY}rss#4Z z9)tX#D`S}(XDl>K;KiA$d4Mcs1*QgLMTzs6*M5M=z@PJQLS35yEU6Ut!v-0D^Tr&% z?v<&7>aRKa4T~CNaJ(EI4{`se3>U^GC)<1E;A5YZdwllK<(`j!N$&p7ej+!0=1=9G zpZ&62dh}Ohcj>-7xJQbwoR~c!cktluH-V8*FylBmzU6JX;}3r}Rom>3j0@nLkWwyM zAw{3%nA%>dk-d!zf4auv&}TtJ9r(_zwh&_JKF0+o1j^VTdF>UWHu$3av^h;y%Dv>? zHk)m}{o9_Jzxa#4%#|xw$RSp@nY2*e&6PZAa^fODqeZ{=dm38l z4YOAB)1N-lYA2>&_^iZE*$nS#pv`8J8*aEhPk-8Xy($g$4)jDPGXPwuYNFnl3O_T2xX{QGw5E?fZ!yGxj zc5!f$meHluS>j`e(%f8G8Ub-M^|NqaeWE~g+QpS z-Rs1rv%VnYkZa8XEbKyuR?H(mD~8ri$4AurIpl&DdCbVrI(L*r}ylv8O+3)B*3>{)2cc4e}dFf!+Zj-utlp7xMg&CWR*^(8{Ss|}d zjIPmaOneav0}K=~;L%`1cyez%Xz!8$Q*r z;gg$Xy@3yy;wCQs_;$;$etqi7ZQ1cvNjyhBZHG_aAy(P(X=IlJ&ST3Tw>MW$vb*Iy z$-zz8-0g$2+1xXOzYT0}yON8$1E$|tx-UcD2g?II)Gj{3@A!+^EwA`b%=flbRdcJ# z)v?ERTc6)QcvA;41b2{Aqf*$It-DCgIPmQ4!xDxcn1!faJgK-XgBSnDZn|j6n#iQZ>c- z`Yc&L;UpECqugHKEbO8v$*v$WHWRZkDOHvGKj8j(<`4W}?sm89`vJb;p>E8Ys}yrV zP2X=AbnI$Ls^?LKfb|=|t|CTnKW$8UEiCG~UKRuej9y?(BG(M1Q}G+eaWC#QD`pP4 zbV~IYo17LMrTH^1t~>V>N>%*nXyGT^>+NAJCt{M`Duq$yh|ye!#YV9!ingJdQzz4h z?q;f%8oe0fekJ(u$ZoRde%0cV}zqe3C!p<#9NvMwedAS}L0VJ<+*=&T}Qf`aW$jxvg(uNI#K@doknp8u9x zU-?5hIoM{$cey7#xOY6bJqy>oVV{Ff-W#~v!N&mZo9)p_4tPV`9v-ERDa7%4zMDRs z(ZCMw;9B$U`=W9 zZqY~VXXE;3Wr?+NFyER8huM9l7lzVvtTwtkxg3?plo!3|#ku+Bn|Vncu>fR5-rFt#eO>q3}HMNJPv&NJB!+-b> z@`TU&tXw$QWZUnzV+I*}KJ>m@D21z_>}O2fefDaci;tX{o~5zMVb&sW>5Fql2`WIn z1a$Ycn0gKLHB6){z40s!-b&l!&aZUF!b9~@)N*%qlGP}Xm8c&Z+49;iq9ur+2|1A$ zrUkSwJ0Xa8bU1~hpa5p)XiP;qBcm?o;{E@ZoLspIjTAvJFK`~U&tVPE+93@b#6(BX~hgx1rIi1Ybx@a3g#Ts#?er<))-Wv z7@aEE`iels(xpjJ*R@Jg{H(k%e=+a`;^E`@6*~P}3F|Vl+ww=M<6QT5|9R?$4-6kU z( zs&3;elczl8$$8J;+|uWF!rpg0yh9ty>mtzU3ArP)wXX>#u3uG{ix@)&^K?$(&{b8A zIINtoMz0Uo?cfjUj074zg4R(VA06c@zw*oTiJ$oQQ`>_a@DQ(p1s!6{NjCss3ws5! z1cVf8O<{!E>p*i!nyJPmC>xO==v*y?qEMY!bD_nUjzWBYKWNL7gWbGTstQj*1>JKb zRh3FoRq@B)VtO{>qtZ>~YlpJg!0Yo1bbD+pqDc(KQJK0e&SoxNYRe2JhI8ju1jryT zNBt^BWFR4~utxsi_OR4_Kbl|ncdi>@F|Lr+dNJiFxam&}#wzI&kq)1pCSWYu+$nG* z4{rL7;iG4a^({7~2+;8vDR(}$@{JKhoyLvLeCOv4h#DTaJXnOlS+}+Vz>5qE9wQNv zfK|%`SZ}X8H1gqMfKa~)VCZ6B;Y_Qxc$ag-L%%xX;9e>G@QE}jIue?y$fIkriFm_k z7d)pZXm)M&6wn5StcEPZv~Dq@5r*clZq_sq5T^)9Qx>BNP6)y2Tn5jho#- z;EuQDoj?6$*&MwmyPl7^*Unn2imH2n^{qBj6tcLOkvMui;&Y#*r<=R~`uNCo-LvPbTPAF5wpfNtdGR-)SrIk@U?o0}fUnSN$= z;~?RtPZ8_-In(9}D%IHk!`Gj{+qzz5o#->>Tx)k{pL24$^a%kXAbmjEA`OiJD-cll zQHT%-(nLVoBw$z6 zHQ)RHkN5lLoa-d1cfI2sV?5&-<88igesiw5c1{MPg1XqbkuCyBpC#mB?#RBi>0E6r z@L`chE0Cb9oKR`;dpV132KhT)%sckGd-$#Sy?^|zso(j9Z0lzDz?>c5_Yc-MC9^H* zi%Q5JW3X->`Xmi5Pw_{~4bs>4;n(L~KmRAQd)vS2U)j%lH6tCPA{OK9y*$lhQ2(*A zCmOim2rNPoLX3;QDnLw+vMmY7v>EAyFLc8ATvINNVHE!CY(4IuW60n58~;=O-T&|3 z=a#=|7?>1xtTC%-9m^iI@KHdVqx33qR!4ykWxAmyX0D=JJ$q3DghjemtZX*hJoRZ$ z&5!<%Kbkx4xIMKggbahIwT~)H1=SsbuA;AtXtu0)JI8?rdOw^bXEy!yENfjSut!(u zhAg49BU)`4J{BpX*yb^~+7?`FC`Tl-2(U-3er8&I@=KEi_i|Zq$wZ{0x?``fJ}!Nq zldiygfF3+WQdPt&{Zq#=*zk&nOyFF4`WL0{cqZN@+zmM_uXl)zh6?7|l2B)@8XG|$ zvOT9PHniG4VCSJrBA*zmh&4724G&(>qhZ%Pd{x7v!vGHz4-6cFDF;VPfyYuB zA11a#K${p_z@cLcm4y`i;(^bRq^cm$Sx?tkW9^@ZCrsCOkL-*rTvA3DvQ6tKn?Wbezbolx8?^ zBvR(!p(=P)lQZDvNra@1G;N* z*xoC?>23JRWy>EZ$L30I-2W?i*DJp|yWjgiJIP%6!?OnQj8R=zeUN5Ow@ucD9;_-Y zS=vCmb`+GkaWK|1*9)jicwkml=qdc>YHS!5k+YfSCOP;h4@EXZwMS4tG=*ppC z)6)~d#HLE8&+7xzn1b26)vkgG5S7x45+L1<2p5D4QUS@K4T$u$TnF@7f{X79t=&9- z;MjSZ*U02%8fgEWLu6oo_mK098pIWO1^@sM07*naRKy0Ebm|!M;QjPAbHVLUikUT=gKvHY20gs^r@)|2 z7U{ECZ0A4rg;!qJ;svKas5K0>uop`r-N#%-@d?y=1y@G#3FfwsdvVU{8npRFDBg9c zGqXTQ!i7`F>_F_S;!!Ip@V$X;5$7dwzb;8&QNyh=39pqeL=Qy=F^?KpkyeGJ1WgU+ z4?Z-u-=`lNyWlcV>-=UO`L{ow_x#kC=Ei^c$Jy*27nx^5E&U}H7PjKRGuQ@ZZwLntbPO=o(Z({Ax(5ve z8#+dqU#oJmt$g=){>i-X%f2+1FI~zOf5QX0inS*pB{r@c%OOWV5d>k=Sm4@NYp;^z z{Z(B+@DjW zs(?qV%WD8N@Ov{9(l%3$n7-i_9i<(j@Ozy82OX(1S#4aPG|s~OEBB?3_#-(#zn0C| zCcLZ0Mb?HZtdPdEh1z%Wn3^~UF~&|gV1RIZ$5O;Sd=uEQ^cE;Ua3vtF$qVd3HlNVU z*O)Rnq?-&x+N^+1o>nej+PS^ASLQHPJ_9Bi9Vq?XbWb!D~G3tV`3Z6f` zqTYWMr$lE#DIQYAcecY%msg*VYoGY-+3{&ywj#&;*5+{CTTyq+0M;~Czqu1S8fUeT zJb8|f5$;M6InegGLtypBQFZKw$!qi|sY<89oskabJoUhT&O`s~JM*5O`KmnfJO3g( z{($NJ*>Dt(u{Xn+Mmamr`GarGdw=em^4`~cLw0Zd)tu~Zu^J|}J}O5|*Rd3>k zyCSu6ut(;-HiVg;2)!ML3CA*;96zXMd619=NS}%F_7DrwKgiK+D@f+-0F*dX9>L9n z4?UP4`0suo?|%2Yv*W(nY&Y>`XRPyTZ^iWuz@ec=9@`J>4~&?*qAPCY}eY&VCZtD|9%Io-`@U2*@__BzZ+GSNbd zOmULX3bCsdY!yO}H9_clsI`w-rO%TW*~#tC%*ls6KO1O$e*Ijk`NFK3G{TM9o3F+h zLD<|N-u2W7y>AG#y&M!diuMOcQEQ5!azLgY#8}V(xX=Xip67<>oto zJL!LgvdjGct)ym?n;C*g`ku>$R-9qd(`T~GtbhYnVb#RviYq`NO7%hRL`gk#AXqaA zv{oT;D8{)?D?X?OWp+WWp;1Jf$x;Va8CNh02Jh|hf&KQky)8fXV?UNlmoFvEW2|-C z>4u3egubd}Eo_E8f!if2APdb>dkJ9GTwBxkgGLOKnQl;9j~>JGp|at@z1g1RzI*S@ zPru?7txxfjEP-d5pA$~Tn2*RJXtir78OA2$}McBOOg*Qy%>{6 zs?4b7;&Dx}hi(rVi{Nv}?QBkR`b<7`-|&A)3C=65`k~_`z=ubVYf7w#w4N~oy+%kr zxRk(vf)cqi+LBPLZ< zs*0Kl_Y1#eoS!|KbN^Sl=QlIXZz1y!li^IQ7oPBABpcos2W#A&@sRh;jeBnJMmOMP zj1)iFH#5cdz+zPE(c@uosVg=a<;p2b9Rg)-){Tb+(9xrOVv_@g&2re|NL2|mo293{ z5zdQYl5ptoK!_Ky3dzVal2}NH%JBitFCqDfpZL3Z-RoY*A1^r%^69BEH{C|q19J?7 zjm$L|!5{FdDpg8Su`#xf9@Xn$Bt{*wt4dM`p%*)z$iPQiR};@@6=Tb0KESzupZ@fx z=exe^JF`96PrV4%oSYf6 zta21SHYe#A+1q9*;nUOhj*m{=`>b$DxWJ&^P39slbf3hM*(ENVwlTX8mOrq#XpEDi zA*K%T(C~ZtXltVmT*BQOWF1We(N{3-%i6ryGuIeGJ#UmLJLUspjlF(Nau&0bcs@nu-CVZKA& zWan8eIjfrM7`R@4lyjp*P>0^YVWxHu(YA^?HOgTXohDaU{)#TM?A=t=Ubfq9Ui6}` z&DVbIi?Z2nLZ%mTN@sS#5J!1HRaofT;?>P5MU0Go}FY^vcm{Lp1B6L!gia%rSnzfD56kO8y$`V%t=4 z*xT#5_Hi#Eaw!%5dd!H!^pMy|@nS3V;h?=d$P6>}VxWqB$SrI-u^_{WXl+(8rgn~f zP3qH`)7TV!IfEDYpl;u|!{j>DTK-*ec7xmjeoyJ*EsO4-TqFD09-2d8j3oFk3-%$5=0INYY3k-uRP)NbNYnmrMw2n5a%wfs#I0F zq39`o+Gi-l?k9vPA&uwOj7HUYaem1bLo95!H$4Dy!wr3Q|jMMrq(OoI@) zv&S|Z7OCdpFwf{Wtn+wn1`nda!@JPso7s9kBv+Be{!L8)`puC;bxrN3L$DT|rjdq$ zDUY;j4<8K#7Z78(ZoDW1EK4&1nRUwOUStdc&1NuKfSB<<95@^u$0IW5?BpH{f}z@7 z^U$*!n3n%|U|MtZ7+(9@*XC9K=vCYze9dNg*4%S8MF2wu-p9i_gKUth!dxZO4h=3> zIL@aAp^yFg$!Km;bnc6hrNJh*@8z}jrcy}YN>ffxw)wu7y)+;H@t?r?5UD9K2rmVY zr1n4B1i`C7IZ(!g_+BbB2I4GX+VEI3HeDQHwLqiA`N-%sG!;M}c4p~XRc0ekgE|B4 zIisk>2o?pCt4Xi6C>brq9G;*HjyIUqfD&jxjMXw2v$jgAdeBIMJ(vSw)I$mht&l^n zVoHAHsXEQ+eV>za{{u?94KJIGsfZVC$0k-eZ#yu;3vbGZ2iF@O@&^+jcKrQ}iw~pY zD?f0i?Hq&pFu*(DtIjmJ!<=KG6Cb!agVNC<6Mf9gYmWL`NZLjkH&>LGG(DOkv zmYSoN;KQxV%hI%wfpjhpsn+eElVhHHI;Rd_7wGc9lHWp^;!U#nM0&?3yd<03KO*sZ zAQ%bz46S-^800UIC$b19&soF(aqBWME=k}+d@t#ciM>QzyY&M{%(EdA4`c*BXGB8R z#WyBGq+^88cqI4Ps3BEVHtb^)?j!U-b4lVuJ3PEw&N-LWwl?bxc?ku&Fr~qr+c_~C zJ?M!V&v9c7O|7z zQF8{+6vs*xFD>3Vx4f`6SD%tAAM@4WzDe;QuPWH|E&!iEA^oCLH@;)a9oKi4@JT9- zjd(z9lipRtvAYjO4w$8-IbCZ<4FY|0?tphoY=EaFHtQ@h_cInAL2-)qMPV&{BdMw1 zHaa{wr_B0gPUHHE^qUfODM@kG!c6cOu|*aUTWHo9U8j>62-v}fJlDbAf**XP%9Gi! zVr83buIB2;yf|ZfN46WT2-l`5bD-urZ<~vw%|ujLEp>~qhT1txL*Q846{QHRVN9wq zl4DeHy=xW`Os;UDxYA@#KJJWR*jabEhs{X}32#!uo`?5}pT6UHcsA$D*<)Kzv6f;^ zOFKOnZYZgIu(q&>8ect_x~LE6Q0NEvh{rLozh%l5e=NE232K_d+H#mqGaZmV z-w9{E(ZzQDEr4Tr;~Veq|MAX_Gde$CKY?dy6j-b(iXe0lY!|VF@xbU@UQ9pO z`AP<%FCf;1ei62^a)GjJ0Bj9$5O{R66-+wUlErFNEj6&$1lk7a*}ICse002mM^PAYleAhRzvYW_`R z2VEKPWDJHWKDg?YLI3~|07*naR9LImG~>M{>nrS|W9Y2XIJulzZ;eXbfh==u&)m62 zaVhF7t8nf)9}((xzB;oNZ=9pN0ZLxPcbqN_q*Brl$oDjJz>GeDfVv*!)e()j1 zBe`_xG+*%f&&zjw=Xdl2{Pc7izXwlwAI$7db8{tALGaUfm zez5Q$wBG~%V>>5Zm!FXB<3BUG@ksh%D7S@A!LAC9H^x-lK5Z~7x-ZzGcRcu3KiJCZ z?=|!9H=V8o?ez0IxL>=R8u`mvp7sOCFuVJ|!cI?kj zFUl=={3U-V=h(`Qh0x)LycTL?FM+2(*e&yQ-HCm`!y1@{(ODO~(E^BOoVAKet}w^$ z##ydB{lCol)sN~NE*+~NSF%n<`wXcP7(^C9RSF+5h6;YQjQGhQOB-mV(25J;#KIEd zY{pheh~P|Ky5Y9&X$&9*uR(&ohO}!P_QnK;+`+7#1G;#@hwC1$#Xu`EA1g(k`=|~$ zj<|+o+EmPkY=ek`lHPkY4e1)_xNtZwi-UkEh_VYBGZ`2Y3a3SKSxk;nGeVH%K$PD& zgD$>|P_M9qOh2;~O7Y(2EY7(1AAIPc{K${|5An?~oKA_gx zesoTp?#>C7HNq$q8CXyl2^bG}lbIt(RiUb(b%4#17+I@xulTB8@{*V2(?0z(b8>nq zTb|oWm1~!=)N-=D%=?Wcu%d-yOtZ!KlBbW!vb35nwNlgfT69pKh&~ZL1(OcGX6`2i z!ybKIi`xRJP!&8$l}?3~bY^IUu&YTRf;&4$GmWMimwGtxC3vLZ(6bbAuF$F%gF&}~ zlwECe`m`^}Zu_`wcy_gn!Ga-?Uwi^je`4A&A;KrbG!{54pB(6Y(HX!7JcK)_FD6=i zcyY1kUJ6cT8;gx5D~f~f;Nbz;B0z4kL;PB%iWdsx=e_QhdFAakA`TSuvrRH`Z;tTpODTB5NEy8<%} z)sZ=5-^5p^_q#Z5rDF_-YBN|}q^3ihgPap_Eifj|xG=DmE&!i?1Zav>SJi6)nn>ZU zg87)fKi}oBNL!XrNA*VAqjTptNi~)Dp%9)N1#{`#EjR(J;y0cdrsC%wRzM+q;Mal%9U&X3IIk+)=X^KIGQdOP~vut(q4__*;_H1endCa%agpITj~?RW6Wf7aZ=Z-F;! zlYjGfBQ_pYzXf}0{T8@&^Xz&C23q5FB9R91?FV zr(BPdCx3BvE}-w!YHr2G2#pk-y)Zka2e3ib+L1=vT8EAdIf~vvs0>XUrGse{Z+0;E zf?^)G0)cfG;!M5B9%h!<@J-42l&&&kZ8n!WR`VRy2HdlgsP$KIy3R2;_LiP9nm0Ii zWU;M2rGaSl z-^P9r-*Gk%KXN1g^Z)WU^OoQJ-HvT|Qq*RX&0gjrt zk0VDICVfM$QdL=XXv60R_o$kiPXwXM>v<}h?KZdFep~++2(Mqe&Kw)417W81o?r>{ zt{8DeSw?jY$1H6uk&!mcZwbxJRhBp?6E@XIyYelHGciYm6d;c(RkaAn!o})dj0!5F zd5ONl&O!kz>0+yNF}pi?04!>(K?g8m91Bh@1qT{?nS{c`1`=?@52m-?nTLMs&*j12 z{8M@V>t34o|HgMu`StJ01Hb+~dGI&BClCC__r}-*ulwFS@S88q1MnXFja9!q5BUP>PLZy>*}ygU!WfADqI zT;$ikkF{vOEDuocLFRaH(GOrh@Egwk^1P4y_p`3|^_sssbM4Wd#j#{5l&Rw8aYx zu#a{OZo$!JL+MuWuz?p0KM_jSaSUF-d~L&Z9n{#};_H)-{OaV+XQgVBwGE7ZK@Kbh z|3aUo8!GJ{SkFRVQ-lpmY#WEp?1`FPbkZSK(Vq7f#d6&Al}eLPdK6&4WN<$FH75(j zJt;j?W|KQJo0Q`iMe&=rP_*0ZVS2I#yn#CwE#}&l0seuVc>xQ4OC@q0*7F(wW5MUk z&b0ybiCGoFr8iQkr3kfWLaM|#6^dd-Aqt;SPSRL0);bxsD9=a|llQ#mz4^hv{Fgy1 zH*enL&HWtVcQ(#=#~c67KWd(x^}kFxYps38FPP^oI|}W^9Q<>{uV&89;E=Q9dv*UX zdWL=0_U=Ni{B!V*!?}g5wy_=i8>}!ix3OcMs>)}4=BMZ7FMnx<|K6Y9dWXX93x01- zK4L0#E#MJe7)VVqXpSy<10MxKIKi6|THzU|2;M;Gt72h;ILL)Q@K(VLv}TR)Ltrf4 ztO;XawGd~~{XdV#hc-vT83gp8hk!jmF~&fj(H@t9a!JX+0vkA00BCzwJ77MPc8_G7 zJ;d_}IeRcUe`v~hnDcuS)}u*opl{;eq%ijGQEcUrWcM&a&JGz!`(jAfdN9@hk)ek& zIxYvHewaIh`H{k}K~1r)0e=2)hSHdGA?HT|Zy@Qq53&yC>~)~UsA>Hfrxx6?-y{4p zK6T%GH$HxK{o|27Z!Ci9zrE|31-|7*_Q{~t2KzH3nbEMtdoV|w$1 zQyEBTqZqVD(lG~YQLY4Pq>p|iO{FT#q(7mar?{yLjQ5OO|ENC>x`j8;BbEv=QsE!< z6`)|jHe!u(tvH=0N5Nk^6{*Pxfeu^O&Fq>LziNPR)@z9&TcZ(G)NEgNCoWc$$ z2CEQyD`MzA5A?n+aHx`f6PO|w>V?Sa$k3jead!5&pd`|D5P~`u#EXk_y}+8w(P2Vb zFdUfp%i2~Lkn83-8Pn@(&0{YLZXBah_y&wqZN{p@FF zzIJ+3VdE`$=y`_jH8zf5;yOptApZV9SKELx&);(;va0l@Hr#n_fQ^>s4M${&Gd&Jn zypyprQK87wScH!wGZ;wnSFe3BL|ZX7#Z4!Mtdo9%5NRD+qi8xX z50HT#JfL{n1wKR0!;`)B@ZFQx@DEJb%_E180fCU#T)e%eZuLfY#H_PwZ1b#h?k8J) zV&gn%d`CGx<&uvQZwG>R3Zxsa-aF@n4&> z)Hx6I_x*Nm-2V!GGx>gg!}x#a{4Kx2I(XP`N#+c~Idwj6Wy2-lP)BGC)C(%D$Ki#! z_}-+j;U-?|Kps5giu0&(BbRP_O0Iq6*Jf-k8Oq9ij6-s|)pEW2n(oP!wRTDx!vt`! z8E0pGH83kx2xj52B&Nf`m|@W=RcN|2NK?U^208l}*R651d)HPIr$cwFo>$m#FnYce zar&a>Jk&nI^%Phgu7XT&${JX8lS0T-l9UhG3YJ03b>Vg#j-+z9u1Tr@dIS03&1)oO ziB{%M&~}%(N|mvsaqdwcgbzIUNWS@7z9r9j&hzrwpZz)coX`0j?B`5*Hd=YkbEp5D z=j6H1ea_x~&K@_e%-D0E``kSDdC!Hr$YMXoeB?RgJzIJ9a}TvT=Xv?u&;8td?&p0T zdX>-3=Yc8DeeUyE-?Q^spY_@N(eg9$yyrcyzq`+eXkL-^oZa~_A5}LH5+?4o0B~O_?TsX7lV{Gdt%%Lo?bsg%K9djw8>&`mzm72NMmy32C zzTx;C-e8|Q9{M}pR0a>}!QOWd{a<sx;}Z+Xj`^QJewId6R9o2I8}82=-thXz$o;wh ze&vmezMneUisMX%9RL6j07*naRQMa<-=8s!Irr!OHU`ee>3ZO+uPoncm3YG^8N=O$on67klTOmhHdqpf>FiZ(DtmYFci+51ID3~ zN~Z=ky-28HM20e`1ApaU9-V)YkyN4SgL59u2TQ;e0(7tWpa>nj5Uq4A(lF?Sr1+V7 z!_-=Ht!CqOA&|vwq*rgfMGCZqfgabFU=gRA9cS)Z0(xj`4#-0;8aPq63{uEw(r(&T zYF~H8V6mKwc9!OiKISsukdwK?nS;O7T7oF+EO^&g_$2J9tYL-(x-1Z zgPSv3{#Tb&riR$)nCHTR+Gf+O8*>f=JgECk2%x#bsQ0I3|ttV33?tx>=Vh*n%iKF?vM$ET+MAG?-Z193`|4 z$Bd*3P4B$WumRJ_+DR4_n|3wgN<_FO%>02Kvy^d%DLZbkv;GR?R&L(9nVWoda&!6G z#P6xk&Ubv}vCI0E#;yLk<5v6{(~ zWEK5e#Bbg_%MEhWx6sNNxvrF>O$4_n|s0icg~10_WO zmq2L0H+GO5H^Pr~ttq^UlTOZhSq+HXo{bS$PSOIYQ(%2U=df)33G_&vc}i^k_%WVEN4K$civ+TkO4%_Dj`c- zUD#>_s1kfu@W6k_ga78g%gz7v_wgT`pNx57b!{HLY4HKRBOV&bjI)!!PHaK#KD)u| zeMbodthlK+m!F&~PkTYaA5M$p;hr>>szBMB$9UV6%EjjXJ2Z~*3(gEQX_`irwc0+^ z29eg2yK?rPv6j)xbbdBD!;NFIryy08!aeTef}^JhPG(hI%qe3DaFXIDv(*K4aMp4Y zxiD5|_lhszT$;UKRc#-}wcx5dybP794R#^k11P$d2<8XvRTVl?9B*;2l`o+Te&gGX z3cuJPm4Q9RmgVsqA+Mg11zWXo?45eRX@LVa7JIjkG1X9rx7Jqlr|it>d1kHiqxGC~ z3oEW|U=M19d1~2zr4ohtsESp~ZBe@E);Vo4;1GhCme{~nrK#vE+Rd+~dwv{{k%Ls? zvx8xodrm!?Oe~9!h8lSsu06$1)&}3J3cE7#Wp)A!Kul|NSa=l!-T?j1F!Wa8kY$6J zsc6cbk?KWPp^+eCU?Z^=bxJl_^j`JAXd#A%l2y_cI63J?gqoVpM?^DDN|i1r=DM>q zGUBf^x~&Cp)hB!GVyxs2J`kFlSx<8ZMLvKj0_xuL;$azM81+t@-v+T&AlM`KKiDbq2)E)0~ zG%JF}I5@SlT~6=&jBFqO?8N!S5LS@2RTZIXh%qh9;hy9;g*rya9f~sy=0FQ)-wGF@ zX0V`SZIp~P#cDdtsR5%FSzJ8&;!vv!0#Y?~KA1jaVA;)|Yphi4d2C}L&0-ktt7Tc% z5F`QRHdT1(I?P`fVg*mh2W`zDoofL<3Ue|;x*2YxdW>=Er5l)W=3-fyA@@Tz*sRzD z>W4!gB1R{Wzz=N%92wdS>-E6p+L*FKTSr^28i4?vm>4tbfMu=43VLdNVneMA za#{Rn!4A?GMtAGAL4dh=TJLtwkInrIHR%U7k2h)*H5C;6%vOcn%n9of8SPaJD?qak zBkTc?lCC^>@j+ZLygaS3I}Xt2)J)a}Ug4+O0A+g28EFH|it$m^LF!w(SV~H|S-lO05$BB%1kR}GTyZKf zAAs?yYD#s6wY3u9DMJi?()r>Y$mD@0i%rSZ0wM=;_1xG5*F!&4OgaHxT9T|~v$lEg z2hVJUg#l8TEn!<9f4@lU;SV)ZRjH~lw6vKteOBWJ<&U;`-_Put~@E;C8I(saMaR0r;EFG zK6Yx&UVucfLL*ohvlo@B3I}QaTrOi)SUWv29Ko`J63%0^9M<0KIV|;HB{7#5ap!9z z@y$?4H<32hVT9Tfb!;J@okdwD$<(Osvf5yv0AnMXh)YN9Q`&ZI2&IFHTlLLYt=}Mq zTqR9(1qi@Af384J#2^+1O;l)$S}gL~sua4*wS_}(E}-*kdyK<4SXF1hTKm92Ai0i< zl9={E1-{qJ`_QG%yj}WWme}3~O&4Jv4=}UM9QM)=YBh0k#XA>Tkylk%BAiiM6(6=- zTs-m^U5kula*k`{xN#`V0xP6XYfyiHtU@H+2BU%s@xV(li!zu8aqkpLRizSS;Eo&` zs5}5H;^ePka5`U`5NV8IKpBuZhXa#%z|#!}0`s+ZaUkG|R2_iZnxU~HA4sYy*6w(s zd0@H8bX&viNOI*kLmR!XHFQ|I3VRSA%`FZ_5E%gt4XiCR*v!HvGJBzreGFIIdacPA z8sOb4)$jJz-g0ZS-RqOOhz##Vb;p8b4EDYxK7EG4VZfp)g!!xCIT!EYJo-C-D>wK) zytZd7$cH$ez`3bS?1wbDe6Z#oEzZFF9hx@)IMpH+u#jIfy1@9$Ci%5E5CG=Kq6Obw`|B6Iz(x ziTm2j^+#V5S^`NwAEFVK!h#^^V09ku(jS{XWU@Ec+x<{0KsbyZ~Fe%=*p)oIGIt14mwL18rwU1qGkMsj?B<*)TR_k=b zYrPJJ3U)Pc7^l@BYbqGnl~h$KIf!$uSZku|`m;7jnv0^K-d;_IkyOU6tsZ+z4_V?^ z9x2gkt*Dg>6=W6_~i8b_&#L{7;?lFUWY29Qzz^7;FEV{ z{tOn4BkW;K=jr*YGR6UCW_)s?aQr&Me66M$u}mXo`T0K zVsb&u@ltO9X|B?VIv8FxrnhwDK@G{Ns#Ky$+0k}r zTD_L?gk@yLdj8BNth6`C#~?nCo={#42$t~*AKozNAofb=EeUG0ShQgV@^$9|lIXW2 zA)F7{MyK_9Fk72o&MM}vF}L1vi?0Cz?F(|qmfAwxi`KR8*UW%dE1l)wo$q$GOchv`)bt zd}VUu-M^KG|Km?2b%SqBWV=2dRLtW8z#C=oz+Pqg@Q5?w_UKg1G1ofy`ow>}c=hRD zmd*8#%679sMtWUY+EANIPA?n)vx>nGvOaJq%sc?ZDy$EH>4P~XNfi+UD_BU<*D*9o z&jQ$`FvwMKxezmKQ9=Q)D%1w4FieSdqDnUk1GU)$4&8XW2cz9J)OvprsKI_*LyK$B zm(*EDgIMQ*VOQ55Y!e~J>(!^T)(}I6K4;u~_BC3_8M98P14Nx-2};ld6us}@*v-TA z%5~WRXvc9LaSH8ofsL{XN-ma|*H+yDaS9LXB30G-s8mf`O3E7Sur&yCV@5nSxKXrM zfpcLV@b-J+0i6ouRH2D=*G8%rG?=t^)fuuX)wC7Wn>MfxiX`r-0aF1GU!^OBn5;$S zq5vg@HV7!w#G&IaxpO{!;;faC$e<=t2!JJr+K3L?dt?Jfw*-^Xaab(%F$TqE5>9tL zV(^ASkw$uephoD_7$F^Sc4vSd(po0!2twELW@+66AbllQ>2!eFQ#-Eks+}Vw6{0=z zL0TWc#7m{$#9pOoWDg`QxzIYJaV-yVhR0MLSuD;?T=Fa620~oLpZ;wl< z?VY*y(Jx81*Rrijl&CS`hK3iREN#|nw2_0QJF@34fmzbkD51?j*MZ&|bo8D)8y#es zUj+?dj@GN922$>W-xz|OEEskbc4#vthVnrh1iEwV!=@@LaAc1z1Tfa1dVmg$RSMsI zR5YsCH|E@*1|rr$dFcj2Py>N;?1J=k%o`;H>B5R;Rf)Fj z>y}Y!p}ePyYgD?!0kHeDr5*%p!rZTtbdWWVu;@i0z5oXcVBucCmNVMlJNkRVl0d5P zK^<_mDm;Ze`m%4KfxU2#iNn|;OIUB+5=ppAU{L_{V`mm|LHg5m`5CBO;K~!*kW2M_t@zeMAwvWu_NiWE)u}xKFgH$SM z$!ud)i$Sp>u2>o~abx5%X{st}29}0RTHjk}*M>^*<4LQP&L^Q33Gvtf=vrxLb(q7i zf@)K#s<3e4H6=%l$y^$$K^X8eB|#4)-MEcwYna%Ru@tLwGbcFgZY|%!@;}9D)xc2wCZ7E(GTY_(1^4m_B3k z$XCZk1@>p&feF?%h_?w}4r}jEt4?Rq2T zG(x*#eY-}J^mH7jMIphx!@X)xWqZ>-n$D&b`b8>GA2m-`WQUGSr zS^C=;7#;3{JBW3vYNK~@aYNC;)aUnkGr{+ir++plEsHAk<5uSP9yA-i1e`Ao>Xs|FCJ65TVZ&GSExXuM@cIS7G zQ&MO|-EqS1LBZ_o)(kACDQWV&?)f0C%RyF?#x|B~0+(fyU8zC{I!}RPX5Oa>l|z`k zbTgJLEbC%cF@&`v_6r`@2wG=ItD@p6kOvW^&{L>m0x>L5j7n=1nvt3rG2HhS6~TiP zG7#+$H-e&`dkYbxgZX6|ZJEKNTC!l*BIK1aDpbSr3|CI!TZPb3FKh)B2vd^1X-pZh zB7+XX($=l@nFA4=U9RyKpk4)g8*5bq;QM}@ymF}SeLNs7+Xh+IAZ8BIu_lGrdKpNKWZ*m{P*r%FMkXjS4LeD3L2q6QLj%9~T*9v?O zXkRb1195Q{@`AgrMi>^T4+k=R^bLYB*UZ}bMFKF8<4$_J#Twe^p?d5Avvc-~(^EQ{ zo@m`z!!tp1bWQx&j=Z7o=_XaiN8ArXbUnHSVg2XXY({Rp{wFft_wRFlelrZo&WCo` z^I#Y$EQ}sWNk$Oi z5^ArV3109e0DF$Djs~Yba@m!c7D6-)HVNN4VvFf=G^LQ(YF;DEePEsS2(ShTmhBpb z8Y8be=R{B#8Xb#nXi=D2horIaMSI3tEo#BGYdK%w(xVO~WUd030j5s3b`lb_svMaC zb;wDw`0AFxK@NSg2l-knr&+zIk-k4&H=GPI!6}Qe^mZH+F-UNGfVZzn&yhGb~fc4rwpyp?b`UYp&b!$VjLL`IW)?*Gj+jQ z2=1#R3m|87n6ks(-4T<=v`CwL;zHy`q4_T*Zx;S#^HO*EI#r;qdV8?|Z5G*4Eam28|f>fVFRpB6^kvwxlJhXwP>d<7MOD7S44xe%M z4oq`hr&Wsz*$b8vP$%qH6^1U;LzV`JCADwY=~}j>aS~Y>qfp6i(K?zAZ0XeKJhW3O zX6{8?Dtak8Ll$#yU6>isQVP7-gEFwaPGiZhs`MGD6HFrA!Qp~1S_?3?3U~Mt?3EE9 zc_>Xyf=%Z}lSe$sdO=-j;icQbikL~6jVZ}zB)z90J{GaYWKnf!F^s~fX7r)p*@>hw z!1ZRPEQRV&2VfCI3LB&fn~e6TTMCSb0~$raoE3b5jEII&t!Rf<6C0R_htDYokbI_Q zbCuv0GCCC6Xj$qv6E0X_DV4M(D!2XBfZu-79Hx+#wXvOPvL92156qU4-NUcX!~gN` zz`vRPFEfraY##DFY~5!kQk>ol zKT12xz?v4T)nG4E+RY4)=`3mi=Q`rb5M%p|;?PU60O6+1DiLxhZtdceb)^zPq)Iyp zDz+m{IaVi#^gaf(x!O6pBrUaxQyh;HNlxd9jmTx7AKQVEbuCG{MlQDAA5ha6Iv*mP z`)bS_);ZwV#np;-3q@)1jQ5zny4Uj=X;V6r0 z6FjSUBG7Q@pb#*8jkq6xPGq`J5Fw5+$Iu{4V(&PSS5;i6S+f9f8SxoqPpsn1`liZJ z^us0!Zg&kuM;y{X^UGr>a44F!L8zJ;1BTWZ@EF!xIN$+Og(glIQdTIzDkS?>Ik;q) z-+%_fqC#6Yg-Is|jw6gYW%Kly&Pg>9ISNVL`|um6K1{(ut;Th%#y$&ML0K?eegP~$ zaYCyR){Zm+!S(t=7)ufp@BO!FBA>nqq>@xIlE;|hC*1~NKy4>S{EmFX!@GEJhfm)- z#Iw8YnJ-RVx;s7~r58h0^)#5QGE}XE(VnFZI0ieyPzIS&xZq%l#1}YjcQN;rz!-=H zV$-g$Or2OGnOMBD{q!veM4zFKj~??uTJzTEfS{m0pikn2*9DL#JkSQ5T2rlv4F^QO zs^UIpIuQ+Iu)itn8kjL<4z_1+Of2NPdEf+s8kOjHuUJc=p52RsiwVn)#2TStmuK5W za2lE#b9UWgb~zTBXd+J4UR&1~4GC9qePYu~*f8kR zhn|_3)-ip~&5D;gl`14ig>j0h5`eOA$4=WLq#}h-yQTzPs&a|v4#tuqReVD$?N@vrn?BG-5cPcds7)^GZTc=K3c%F zSh8K`QwTVn;xahFSr=dk3<&mBYaiul7Q7NCQ!TaU02l7{3+f;xZX&vE^k89Lx-t&8 z!`OClwK28(TQP0dTsiCiKKSm&yK>G0c=&1BiN~NiStIfL{k2BdC)T-etN$6wIrkm+ z0iW2R^I3eG&EC2%wX=C#~VI${Gix_hsu)I}V3@ahD>R z9OH{U1HGi!R$qHr6JK1;BhWXkDCCQ;3zMK(Lr&)u))WjjJd!rDZz8Kyqa#&X%rF304*)mKU@bw6 zjZkcnfazzpHMc!#v>vJDN6V8{ir7Hx+6v3IhoT8NQwA2ozDH<-v4vHzK0H9OnY*gs z*7O-+^cc|C2+@HVZ@n##-v86tUb>3kmz;gFW(v~5=o&nn)1S_HQ1jphrLzORn%fP-Z!WKObLy>EYUse1B8fWn(ovs>~(<57cva|;D;?JOoLjS z4wE%|)1(5!*(5x?tKhBzs)@?loU0R|t=QBQoyKA0{HrQ-oZYGxrMq9jZ|C502(VGjl7byck8z0x9!#mj6QzYyqYVTQS0qIBnV zZL7G3(8Q%G=Fj-F(uF|SC?#gOm}xvqG>IFafa}7EO-5CvbdZ_PNH5T$Ch+V9*nPx% zTyd5q*z-~zw~)103RB@2n$tGe>YLLxSd#%fFYj_7O~fobV$3o87Fw?Xj44{tpG;;{d5ZbTb z>;!aBtOE&d;!x0HD?CLT3@Rf|g@8RamZ(aov)V9l2Vw@^2nK`m1z&;RXV+_7V#XEX z3#%{Opzwe~kr0~FhM-K&O9HMp8D3W{IpBRJ%$ICHiu`SoZO-5Kf8^0Oy(T$11>Z7P zfzz2UAOJn3HK#ov;A4GQt9z!N7z#6=k6eEGmnWz9T7f9Bq;1D4<^W<@VAzafk?b3F zw1?AAjxNQRLqB97m|p+sK*s33PGZcSg2|hV3`K9qB|rUD3I^+P+rx!Pc#I5u#d@&u zv=$*?+J#&&77Jl86G9SGurdu`Dh#Bmh!++ZMcjD{L3#+M2kKu|G@a`1r z{C4&!dkFq&52*{S=cR5{rOJ9mM42U|DuATV`1BnSspJKX7qx=h1*+Q0bWr+2O^(#q zbk`-e?QASm`t)Iu2Sf>V9dZBw5CBO;K~&C26%IY=q047&Ky)eq4?r9`Odb41?az4z zldf5rKcTI}%Ek*-p*7Z4vLs~RI*7N#R~KaV1rK`mxak>l1k6nGsAGL$#n7su7%!7K zk*2M2VwM0-#8v^P6Ec&7i9)cGah87U`W)&U2dNfBN8OTcR_wLt5vOax7`$Lsuc0~A z2!Z@RH>-vk$sEWD&5gNl%n-Oxz3YmyH|fZQhev2)C>TBV;HItHr?bnAx4bIj!QaV_ zPo*2?$Y3v&t55%mR9!-NQ%J$<+4tII zhzw%tHPB3gtqJV+42DY|h*34>z;;cztTwoSm8xnzqQ(r?rc&%P9UFpfVCo(#GnNl* z(iJ1p)XIu!$F)#W%r)Uxfx!puj)#WO@lFb~bZcH)*<*pu+R4ZmG zbJi700+Zi3cP9{iB}~0gr127J#qqVy8e8>5594MryXdrm`Z!Wm(PCP3rWA8R?g`Yv zM`kAo%Tctj?V(Nz2K@NyLNr%69SjXro_=e6L?1QK&g(%wbKb1R01{+Zsv&nryZ}`cK^9Qoy`|ofE zd46ngvUxCzMZF3uhQ@XWp@HTB&I6qpSy^Sn&y_nrIhXExPRbWXog}qQ^-sv=?65~d zt|K~2t1K8sY{pp;hvm7GCWsJkz&I|w2o~BIT2+OPSqN)%)0kpa)2LDtR<$tTvPed4 zg*jFp=wRNF1s?-s>5I9CmieqD*5MxDFPfdj7zo{(3TD^moCrF#E~Y9~aF+ZkY$bA) zU`^>yznP~oK&MO}*k$eKW=ld*59$pjqlYwvIbvJ1O6j2Wm{%LDs<5VS{xA&@+1J#s zWq?1(Fm|X^Ad3(;7k00;YYsdORIurB%^|Dd2COEMeJiY%C2m1|((G~Yl8L(>uZ>_C z2(6ISjz#cUUmC+_@>(Txeq0P$VLtgo1PKqbX8{$CxLqoM?G)$5L-jyz~L|wL4=OWWF6331hV@e zy{WkH(rwmFsw$jDX22SSeI&#?kJ>{f{u+e{x@HebAO=O{Ddbd@WBS@uXqBo$!)Mf- z77pEilf8TJ-{r=eUz6Ix8|R$ixe?~zfyV>eS(RXOMZu}SLfvl`J$Rb8A8TxcbM2}B zW$MaPvf1$9EP$o#Wn$~fjp+K&@4=FPzPlniK#B5 z%i#^AT0A3!1u%lZh1k52L_2c@mM-kVsH{Ip)oPPKo$MPpkZwPKFbZi3c*UQ=m??#( zmJX&Wal~QD*gSt9MC!;5!9@n7G3Hu(Gz7+tU}~#@Kj5TuG*-z`1MAvA)>zbfJ|VXd zb!^a80b9)qE1*V!Vd5|z2kXdZWph7C)eLxVja2`Hrk#%Iu#$nM_g=sYI}E~N$LB51 z6fh(pSQq<>QJ28rj6zM!PU}}*FK|Jc-opfpO{o-+f;#FhYjv>)f?Ki+!!E|eGa{g@ zL2b^^pi&MauCW>ISNo|%JdbVQ2?NiJ5u0PBs=|;&%^WCAo)9>6*A*K9xgH7gd4WJA z7@X3;H0KE5H0|sSykd$X7ZWRsfMkMjnM1p$B(Cl_I8k^+FWmS@nF66cK`X{|HUz!rTYJUha_Sq3^n3451+8d@Wz=B_JD^6 zx0-TYe563O$@Z>Xf95wQbs414xzGw!fO5&uLJH{)U_n$>g&xK=5<>v(n_O6~3N?El z0Lk7GY2t^o)>f4pZ`{NH{U}Z9OkC?x{OPl{`%0KoQ`!M&eB8mUB_pD zUFGEJ({t$wpAYSvKauX>j8w6ntfg!Ejj?ZLPbxuK8Vmp(}rrn ztkd8oslr2Jb&m}wtLQIMd(dJN?7GuThqE*&g*jy`p>;oL-&oeB!?mFI(j2_}eJ zmS-UnU*mkVkX&%m!q_>Pjg-O~^B|z=70d$d6Us$83G@!a4m3KdB5yE^N}OMsfI8o;T_K{7Ov_IJ%l~57yxp3Ov>p^77 zD5si2m<~Y4SU5quB&sq8W7bv$ao{2SplxOt6+psSIL1NZeBl#jr4k=5*jeqk4(H;5 zgYBLM7kM}@;`!{Q;1&bCuG{g^l|+X)aeAsM{s7U56v~bnMSCvy-60PdYAwQ!n0 zy@1R*GN!ops-rk&yQX4?IlPfgjZMtWc_z2skw@S7GpX`xlk*fmlh4_h&tBPmIv-n2 z1V1gI6%r<_!eXx7*)Er!_{G^={m2wwpD@UPLfno7p{pz(chUyynh!G&<{vPI+05PX z)>sW1s8p2(;8b%Q@usdK*1ZnAf}yOcZ3lM-xO7veX>3}KbLxsePO7g2w|DUQbq&p$8<5p8u%PBRx{9aFvfj% z%1#F<43_7NPUQrk1E~-SKufJjc=oCa9dqvAk=1~W5SeLM5SCuit!fq~K4X?vZCeEy zfbfFQb@un-exdGH5oppT{)91^b693aTp4imDN1+2 zrQsL|)yWwOkpbNK+N*#`RWSR!waJ|I;fbTD#!M8UoI8Rd(@4vt^(aF_kwX&M&FTe+ z>!GRAp;ZfKC6P;C76lomyk1#sV(11By3DWSunZh>Lt_h_E`kd>ljrE=;zi6ux%|T% z-|dEXU>`uurQqP1uK&^rglC| z)mp4yj7htL`KKXirZ8SCVbN8bXjGqx!>l#eQk1Y(&joLO6_A|2?{&HHj(?tVcx!YU+yAX=Je zQNa<9Ah-jxbsG*N9UBCQM_IB#5`)AlHEre-Dtu+5gB@ErToh6#(0LH#??FO9$L^dO zgiiF($%ESd+#>{PdVS_W;&-wd+M=+sE^iuC@obN{O?6Q6n8tn3RNxtAB!A8eNT(vB zo!CMyIIa^FON90JI-9a&xPH@+$?G8A?46G}^OGejE2~Skmu|jcubisNK+;**>Dd`` zy!6<{Fw5EWrsyd?ly^dWXxnZ!*+Sj2?oG~8yIaXQ!qabp|g1V1!Q z?{UnD2q^7g46_k>FCU`oDB{(2un?RIq?WKb04D-6PXQ!w)O{H(F6_l30gDh2{X&ve z#Mm&Lo=UpETB$Ral5TK%?Kqenv6eh>H$f=tMY62EGUKoT-9ymgrC|`K2ozeVWe$v> z9C}SF8`jLDC)@2ww%6~@<&Sw@u72*fm#q{YKoZTCvbq_ghOYO%o)fxi1Z7Y zhqiU2-w6!P%X~v_3s`umz>WU{ALN8j-dCRTN0T~5yedqz%ugxKN2ep83f-1`9Ty{paYh1K*N<%`Q#cf1!vwD*&SJc-zZ8`0s6@Y|xM zCzV|>F9N5k2o-+t5V=Zd@H?Psbm6usR?$p1a}c1$FndofQ!M0G3aWy#gQ?~{FqmqQ z3F2#{vu3e$E0C&c8x!r$3;r$}Uenv#?#!iUd}^+I<{!&#U-W&s{Y!r!cfRm1z9_Uo-16|AcHta+b#+EM=20Jk9^1S>2X3_tK&8;# zaRw2}aWO;&gM!Bl}lw|(Ug=B}5%Hdnvt z@8$H5{5RP?|2uMthxp|$_|{y0!OL^oSN}*J_Z|NvcYpIg%x$0ZlAJu@V^Sw4sZCKz zVeVA+je{5*lt@*Do>bD3*<7Dl?F~FTdR?u!XR7`{S&Oauz$hkB4hU8Sbi^B_!ew8yo}Ie(`%<;Ztixn$XPvIcG7Vu=9awEzW)V3>l@@~i z!V+{gYH7~-wU{0SEu@1 z4kC(~vxXyCDSl#Z$vc(_cqEFMo{zd&meU|NnW(%RH7Vm5#CG0^9}&qv_Ex*9Qnd)z zcYEndE%8Png2y{<&I>#&FFgT4C`vd!fTe#5-uObF5qm6{xEm?e0 z6P$sBHV{_k*od^ksz#QN1>!cmyKsTFQ{_xMtec$s7x%O>8k$lG2=GOHm z=ltwa^2jzPH)Kfn>SO3tT&3)hfn%wb%A4pxjJ6kUPW~uKD z<&8MjO|gcGjbmdm1DRgf%HqT}Sz0c!HA9h)Vk}kMUQ3fksG8{qT`eQ*55aMa+IdG{ zk0lmbA*{2&gIK3|aGHhVenKmx`(jAh+`KiOo; zHRY_|n-_Vo16E_3J3jo6XKeXoQ{<9kcF(cS?c~(dt*TU27{b_+CCBT)g5qx$&S@Ga zkZ$H+RGHN?%rvmIR~bXl#ntcPxUFNeVx|i|y<`G=l>l(eF;1x{V$RAI8=phEQL43k zMaLX#Xe;9SYWc<$W4#fBDSkv`Db9#YGxJ&)pHfrxXga4K&u^aDl4QU|yWmb>pf`+m z4OJMKtq4@AC-r(5!s{i5Sd4`xh-wU6cXF#4u3=dLEU<+mCNB&{qzembgE28B%dp5I z_^E7o2Am+9JD!+({;R*9yZ-dgXZwObmGdWjEZe@sYkm`7`zL%`Qn&a`@Wx4U>oQYZ z&F1cB#CD|r^YI(gzJWblqy zeg6_<%S15jl!>wCq+97PjNZCKONT9%;BP{cj9NNX3X@=h;c9@gG$&rnsg_uwVS{n2 zKr#)d`@}IdkS+~>u7VLVS>dFE*TR-V8C()TdL)M)xx)v<p9Z+O12ua<TFgqX zD(Dz8hk8n26PicF z!^?34!!0@JwKEg*v$O(HRMaSV*)X~nd|=iEPh$}-_hN}Vw;HGet_pkKiEAIPtKuvz zeW`M2gt}O3;bUW2k8sS^@A$xDNBTX_GG{0?7?y50FsJ0unqv;d=#fJm5!YAvUJhvk zo2s+JnRqjyvW8)3@!L*1<>+jH;mSiwflnc_gGUSyYwgYN0R(NS(M9oL_h`Op>d{Et zuaJ7Ty`0-V{g35o-~TH)`Lr+1c=)zl=HYz#)=5rySZ{p&^A(Y={Zl?vobq>>OT5UH z({YkhzTP`Mzn1Gy`ow(1_q;lHec{WqyL@}n5AjXPpJHAGW$$G;IT$^>2%?*Ps}y$g z&~|;#z-_rtvGxJXtW0^|+p!9&Kpk_oP z>)Om;bEX~fJ+T2su)omF)20~S(3Ss~9!gC-z zWbb{!pU&gH?yqHBdP+`jp5`}190t}To50e+s@8-BL%9GeW6~)i zWiR+F$U;~hR}bsJsT5eU*;F>SKbh~d{(jzj`^WQ#;}aKbT5N6*3hWU!hdAT#GS7p6 zR7j{xkNTX87bTZ-$Mav7YoGP4v5lG)Dy6%Zxeumom{rm{h&I*}SscIZ-d8&$HFFN& zHHzxWg!UVOZiyB`xQxm4;cLWJhnm*I?HbtW+Hw|(u~hb{a0U-(|CPwO_N{m3;n)AI zWaGnoM-sErJyZ8F;HX2+Knj`fh9mkTUPQhjErvNSoB8 z&$+}J4BTeKW_++0NbxIz#vGvZZ!u#8Qv|{44c5L=r-ISpRi@scvB~IOjL1OQE9AFR zPAdeGbS@A*iWG$i4?w7_#XXMJG76qTEJy_(21$d3O&&h0tpP|>#$KEdUV&FJR=Tme z08ubg$R7Q-nI{H~Xi3c4hG07*Rn&rEhWAIq4g;iPI83xb(LouTuU4pS zq8r=e3vDhO54*0q@3vfh@|P$5AFtYEjI^ZJP?=3#69<5j0LcxleSsDLG+~T620u%atLUoB7;{yz zrwyJqdW5x9f*Vw9YW=n`_W2DsOz};xf)V>T73q(PQ7|Js1Ae^-sUuwiPBU`TBhOad4`NBV+-N$`Va(*e})(9`* z6nU2AO7}5sEQVOZ_;6v6Hq>dE8RS;ZA)N7HrNLgTG&+{t&+V!zlXw}hBh;?6h*v^}-CRV9JQaNs3j1oJ!%=b|*&F&+gm(#OT-f1_Y zv%2M3vs^FOW=91DZ17MX=#IhOjFFA=0C>QKPY=%_zDC((!yh~E`ocezas6qjDhhS+ zkcw!lI15ec9^;ApVyuL5m4a6#7TV|tMu1iA*GQzS68x6X)>MPIhLVbIOAf6Tb8=W~ z`>Th4Fgwz7Z~)F94&l*v{*(F112Yb<7Ak(MLpho2!U`Is$CYSE` z_*}aCv%m^D>P+hTohIaxU{7PvS~Jbe8c=Y+yK9=$&SQp76f<)XlyGe@HpFnSFv6VH zMgw?F@EXG<&P2@Py^3ND=?4Spsr^rA@EWY7HGWsI8c-7NH^+3mQn4}O54?e^6t*(Z znG#kTjan=6)Z3&*y$!E`Q7yg=ynZsT?=Y zwF`<%QjQ6av3=G^-RJ0#L(eK5!>RD2MrIiouQl~11WG@1Y&BzT7GrfhSc?D*@*0qf z-?o|qaB^?-l~M$2^r)4&;m`^>^y!UMDdH2cp5Dn*K81I}m*mx8<`h?;#(6gW<9r?_qjo%2j1VWMSW_@d+3m;-- zTA=GeB1Kb36QmbdC8F$6LcP1zhKIj4o1~Y<_NxS~l&9DWB-c_qXr7;T z#~NS>JI+4nF#mb3Kk)_ezk#x;Ex-nBOu_43xEMu-<->xsQ7Q25q^S4)kt5dP&<|+l z@HYtk7KScXsoKPl>2b2IJ3?eG!oXl?DU4Mx`+BIM0!zW`-sQ1c6T@6O4xI_ol0z%5 zVY!BeCdrzLT;qnueqK2A(S#ld14zd0`;7$*r0Wu@Vql)YF|QWg9PAKpEXAgRFe|mN zx)Y9E!&PuJB7u9L8KmHrf?vdyEV@QPNXwib+b#|#NSE!JfoEN$D2Qtxa8jF`pI*y7 zU-B2S^ZRY`scaa5ze5R4-5US^5CBO;K~%a%v$2fs$UINgc~WNxoLctBVn)kuxebU} zjvXYZ+mUXCc^4iEm2OaWWb^DuKU?qzhft?njGKIi`#Z1A z1ONIb^T@yd`JBJ+{+yqj=jKVeX2!^1zc53I^pq*HGj5&d_D}xofh~vZ~kyo|kms90ZFF#4PiA_&VBAc5=aZV28Euc(>hQUw_sg&F;w`&DW+| z(u%4GlkT|p`o892;GVZ&bwd8;;oSV)*X1Fe0}uY2SLVjs|7~`gn>o8wyr!8=GL>At zOCgQpW_IfNhtJDT{8;`D_6@9H!v{O&V#avZos(1!&H44j6z#qAbz3|pa-R0ETki)l z4T_@+F;wiop=HK?X*R%ONJ&+tIL4qGXYfWru_3od8HzOrGl4%8V&L+CLb_FEj$kEO zL>FpE1FHCNBAad`H1zD`4{oHhoIL5{bMkS|&6e-B%q1%|nQ+4QRSDM&yRv!U&3V^P z|EatHs6bc0<%gb~_x$az%7Z`ioq7LHyg2XrE6>UM{>QIKe)|_P_%wdT#qr@CHAUw> zN37%bU%MNZa_wWjAWl@fo2lIya-QPhRPbA>m10DOOeNYj`l|Vy|H>aX@>+PGP?tYp}zib=_=3YEG_wWG>(H98eB`F;uTnle?&P ziW&%G2J7i{60a&UU=W~BBgbu|IJ>~xaF)TYA_tvRqTs7qMyQcCjiy^Ie&I1Q>%eGU zYlj&EI~14}{0#C3ECnSO70@Z-N+P7CR242Vs_PECfT;;2PejPB*zP(=WAVwK% zEDZYy*R*i%o2v#vpOm{35Od zt#l5&Al3Qsn5_B?ld5V-VRHj{pI!a*7iRY`uR~t9fg89)V{2#!c^4`^l1Kj4Pv;%~ zpXcX2f8&LD@E?3v9{%a?%zOX(m*nj~_<6bUYyWd+D;ZvpC2fnA4bM{0MH zJD&6PeEPmO0SRl$(p=AI+YupFDG&v<_I4fE8MFZhi|BenGZyeLe=GD_e*~1hHVciL zjk*DdCV1bZ7m#q>;{-E~k5>wDJqxOH+#0N71RLLp6z2h<3?ulQB<*+Ibn7x$YSXU% z{x8fKhqybh^!aujt`LO5q6gYPHaz-!zn%O4>KE`X`}a~e-peCn7vF*1==RpbIeXKu z=N&)wlKkFJ|M{Ga8wiItGMk#K=tVp`Pn0X4^hb00%rDI4Cw+2GpZJM6dE&?Ah;$7LDKf>D1kR7FW@W+%fxKEHB7&17& zD6V5!bwce5xeUAWTzkUjWqaF4q?ZF!;RmOf6IO6jRY?@bk+mHx5xvP7%r#hxXvn3j z!V#s#zYirDlT`Vs@PxQ41)+Zb792g5>D|Gjg;^rm9hAS^ju#Hj3Oph z*c6Yy!LI8WVg%@MOYLVy2YEq8$fB@oXdB;deW(Nn>qY?QJgXhDD^;6Rlr++4zKb&j!k8^InCg!i(I`ko7x^o;;MZBA;7$en5f5859Qz41eVG>fO2Y5KISf5E zM0}>X6|qGmQe=9hvY2+oarZY7`M8Jf-FEQWvVI%;p*pJy?M-%iH7C#b>`Y$LG#J{A0QOMgK6jfBkE6{l)({w}0Kw=Z+V>CU?H* zXOUOuj<0)l9`|)W+j7^}Yri^o;otT3V%RT!P44-oU(7u(`KP(}TmM<^{q|qYec$%l zJpSAMY3_T;Yx4MS`k6fb>;7);{jYv3kNd*EnA<;#@AW_Kg}MBcPtErBC#Ei4&gS$a zwdFj#Vw=hqy-fntFTsq$%RIM?y$;c#j15@jVjH*!`l3mpMCk$ti0QU0f|5A}H%pZ^yM8{DJA}eb3J>m#IgmRH&Y6BaYsAIciI& z5liVSOyOXLQ=XN}ANOUs`q|%=+yBsC&Rt*eH*?R6{yz8dt8?F< z_{H4I{d>>1|BKx7t-qRk{=_fmo|pV`?&2Q5;~QR+J74^Bx#PvJ=5_J2xx?2$%d2xI zuZi1v&0OcTb33o0>tFYCxvu}Uug>+ac~!1|?W=fgy^8!-=k6E(Z0`MrSLgA6{8hOJ zx$DLMh}YLEbK47lC}+FdvpG*n8E9_H>~`q~FR$g1oB6$e^yhQ)-@gjZBPnCWvxCh_ z^+A1pev9w3A4%Tyy1eB_UXwoG zTj1RXBSJ0)ecoHEJ5#~9=qqMA2$zrgWMHJq%7t!V4q!E{@ECyB^N@rVuM}$Uq+KSO zI#J7TGIfY~KW1&~ikOJ%D|)0m3!gdYeRHE{y|R2lZe^1#2fn#>cTVnkX12W37RMLs zBee@t?>Ox9oNRY_=wJNJ?B4OOGtO=#=jYJ4pzsIWWAS2cdAL9H&;LqxZ+m^t`P4hO z=-vR~0aM6^MV+8e>Le$1C8wKfxrAKKH6A(Faw%7GI>2)k|0=$6C8y(Z%L(yIyQ?|f z>7zH-$-k32kIU%^FOEx3%jPP3y8RQgz2`HtdGhCH`;mV**Z#ma<@V?O**xxrKazXD z<`sF;H~y16iHH9azVd&~-GA`E&h=+~O|E?8^K$a|k4>)Kll}z6r}uDPEIICTm%`j6 z=+HdTs%k57X9IhO&^epHtEv>&alKyFiRVJ4TMzzr9)8EKW%Pk>6KW*IPoP_CVDI`` z0CXopUpQE!Wf`e^a``E_@}w_KHkVRd<1l|O1)jZ9Duf(wE=3F%u=m+~hK71@Y79E% zvSFyIRIOsBoLUXm9O9vkEGTx`_7r93s1@_+%2hJ(R>8Edu3BH=)iu}LNgxDA&oXe1 zI_^AsF&rl7>%tyHOmDP@bcN95I0tm^c%-u9T$N!iQux`PCYP?JuH2cE$9*`Td_N=C zKK6yV9uF%(&Z=S^wQlqJ-sWJws++6_V!%b+%~0d%c-vcUJoY<_6e_*OLZ+5gxAxl zucJjSjjL&q>+7feE4j2g%?VPuloLJxYpR)y?9Kms9{sn!#QiehSD+-+%&17|uTZIf>BB!Oo}c-atk5{u zw1KTL)X1WT7;dR+BuX+BZq|lv&32tv$%y3>vk{z;rB$*4#}g_vz0HxTnnDq8Sm!** zNSJAEVrU*MrYJInt!G-$LHCX}C0HAlj2RaK=w6VEn{9))<=3*hayJjr!GgnFBgJ95 zt}Ul~!on_XZsgH__jBpIzF<7Kc}RF+17|2)kP(`DWBqmOfjs=LU+Lw8!bK*p5Fc+_ z7I(tK>V(=Sm7Gwyh1@Mto(rofKGAN}ikN?x12dlXNyd-=9-TLz#&)cMg$(vEz*@+w z!3?`?HoRffxRecl;M-oiFPHE8gj{{*=jZxoerxXjlE0eAzvz{D!b|>1?)&Cn%H3c7 zBf0Z4UYyJP+FF;c#ha@(o7BlkQrl1@RrtsTsU*eRt|Od5Xk5WeNsO;oL##RQZoc!M z=KRL{;K|t}GQo?}%kZof3OA-M8NrSFEI3`4P&^M#^y;0TlFgNmNU^SDld4L^#t090 z`V_%!yGl#WltCDar&W%PYT$T)UY}OkZQ%YP6cW5`695R4rFK0o9 zQk>_2$?Uz3njHC>&Z&s%gTw4m2!q_Ds^U**g+!0J3(0XKC{|UeQa0?>JGPoNmeCd0 zh8XujZMG@CqC4fcxH~`bi}Uy|`=LDfTYfqBee19AY4{)H+8_DRTz>A$viW^4%;sLc z8n|*_&UyHb9rqw#Rc?_DvgQ8Va^1G^r?N?5ZL;NhZt*tU<6AL(WP`-@bB_nRh$&mJ zP0NO?ItW-P@C)f&z9t>m94+UZuHf}P2rnjI*F4bsw>rM!dG{~=P;&D@_{9YZ&3kj< z$yLTKlnrPong?F@Q#rf&5M@CEDtE>J01yC4L_t(|U1B6eo%bB*4D$A_r*n>1;`Pfq zN?^^n_Le?-rl!E`UX%;6Iy1bE1x&|fhOXOY*TizltoOh7JzoV6fXezq8e~S3*9@X_ zGh>gm#ZbNQUT(+cK%foro)fPy5UOL~A9rwWM5k#XG%J8}X;1EYMrwPSEp9&qIQV$L zJa3DG-M~M4;DL+>-_+^F%?d=f%6WD?kVjuI{W<%t$U<(t`8Ttn?x0@5DRg+~7ZYyQq-W<33AH3TO>epTGz%JS@*oYOlMFP@JY&MlWaFP^XS|DK?Ywr4SuT$=VW%+ zcib~)H?+wequd@cwdY7R_SG3M*i$yCx}4je{?*C$-jvs@HUZ2&J(EAGVjHNTjjmz< zteP5g>6OB&s;Mne4d54o%_!`e#^@2yRVqeUI&=uj$V7Ay?MDGgw@?g9E}ik>nE zD=6@4(f@BE6uZA{0Q{4nIa9L8&_#b*KZl+SaU z-&W82nrG_L?|PB$@+0riWk34oI`Eypt?|pR(&-EDsU3bRTx3T{rHnNP@KyM*g6UMu1rh`Ptd;*w6Gl)0AVUYkT^_gLRwvJ=Zl9m@)T zB(|cyzi;+j6r+EF(z;r(>{3h!SQ8u$WB^HCL_qMU$XeZX;LyGC?Vx#JvfWEGah=5;t)ys53g4 zDTU1jUOR9`4SeTKc@C2cQU*&T%^UIo`@mNx`Bb>tk=IFbbtp33j_XXia8^|P)Gdl} zDRGf_2BC>^6HJNg6{YDep=Lx=atkTxh&|h-Yamw4rUQFg6Q+EI13c@%7!(>Xnl?LB zEzxXWJTxa6mZM^CRU$sA=Ye}jcl$b>|Iq(ScYXRxboU>5w=RF$@9Vs;|9-{2zFOmf z3)<4Saak?L#?@jjF{hUvo>wMUVuYqetBvs5$30t&e z2FDVgnLy}lLoic3!1<&$3>WLbT^C{%8g0H`id(JBq?9uww6GhksYR!(a3+6xIz zC{)dAU;vx_IZxBFwQd{SI=O7yE&?&@uG$^}rrMZQ+IvAdt*Q_@qZbck)@74~_I@Tw zu3O#j-oqjkfea>b59Csd^Y5wyU-C`54NY0c`d&5kr9g@ILSF0 zv`!{SUii6pLgH^`BTwm^g%4cBM;4Qa_#!A4oFTQPfzpArUZpYHUe>th0hU;cQIw=$ z6^ty|SUFm^!t4^a5`2s2n8f~IJQ)&{^O1{(LT*V_W0r=iB4tA{UW>!7fXZV$t7pTr zNWq8%91F^?2yfcLGME*98L5$j9Z%h=)pDg357k5fW$}UfVEuo;MNzp1Jh-+f}9v(~~z9;q>ct+0(-oNsLr ztu!2;C2rO9#qgR~j3F-=VGg?2l(0q)eUjwU*Wd>r*ud8=1Ha}j{Jr4bmh$u#Z+e$$ z-+dmgbH3&0b?I~7pu7Fp`*p#ie_6wo|5V!MCiG-T@Tv@IyE7qkbBc+gM+^!?+^oZ} zrPXck*Yfzsi7X}mzmm*nBl%21H1?%hFh%Bgws;c93M6aup#v8^P}>)NwPIK}*d$bNEG+nfkxPGb!xJjgjZv;5dB`$JcFOY%tFW^{D;*027f;_^ttgu(M zH}r@-iEj$mbZ&rGEiQyFh*vr=mzYcFMC3goPz|vpPKGt6h4l^!zD|+ack^hl1vjAo zBEO$!?D?G0fm5!0iOze#Q*@W_d7bY1tT*V=$NXoVbDxJu+vh753k?y97?`?NCYB_H zd!Q_Wb5f@dzJWK=TUi#xwPa09=yi%z*6lp+%R*2r7%>MzRk9XLQG>b2J?E~E)EE~N z2(b)-Vz(Z|1GCP@#j#!2XG2v%M#@ra*sa$b#ws67M#^Cr5C_4#Wsh=r^m0592PD&m zRO@4iFv*xjw5T&{Yfs^osCa}odX^27{V+lSVV{PBArveXL8q^Y#p~q_ZrFdJ&ik^* z=!&aesJs5)J9O!H{*D%3_+XvR%eCCQKwHamcu+6+BcJ$#xwN3PxOup1sENaU)6R0F z`l$8&C;XIKUQCpz$qbjd+SmyF1sI9gQ?gtSR!mi!C*lt$#-3^ zGpW0E(ft(XTp|A^D_%RIu6VAf*S5Vnb-PBsHgtX!!w4JH!emZ%88V`}KH+lo_^)#4g>tPmmCu7$dy`zyM`Z zw(GN$x#k&0+vRxeZHUqCvV-I}yusydH%dDk90%zGPYyP*lZ)#I@aV(lFWUR={SZY2 zGBnYGVnbUJbK=n34Yh(dF1B^vmp@iPKChwTWwNRf({Hjhk0f*;et<6^EpNs$yaLeshcE!UY z6x3r3VX4}XH*4qMn-u=HT5YqnAg^sc2-XQGsvwmHLJ>xL4NryFmmGFnsB`c7D9N9k zL?-j2s;9@Skw7_e(TK3p*)734aUBZGE)F;0>QT1VJ+I3oxH)NTW@*zmEPISpvKn@W z`JC3JG1##aW~`y=wG0=MZ8gDt=1;zh#h@)dNpAC%*8#52rQiHhy5gB{)`7?VrdD74 zD6J0MizDA+dU#x^1;2sCuwcbhW0ND|DJ<#@XtGo`R3T;CAX+vUh4JXD$96#sZ7Xf$ zrJ-b4@j9{|v708NQ7EwP!5o1b?3Gi&5+9yYH7A%KR?hbav-aACl2S+|vW@U^keI84 zJl7jn3tjl2@0a*`BOxT@5Y7C`4#ohWGhuR80y&rGz$(tK*RAJvP3xe3laWo{^H`p#c95CpK*wzoqEA+^4)w;x35uEPCE}o^n`h?2ubyOPKYSJo4P2N-43rrldUvD*n%cP-bm5mjPP*Fz>kxe5eZe?_ zD(xH4vZ8+dD#g3-$S2rD#C*v`T?L>T2^trW{t?PHW!p33+2<0fD5 z2dmHp+P?gs>cIc`6T0M?uh-?z;K6X;$7tApzO=PZ!LO1Wp%zRraP*d7uGNW;XnFL# z)B|Lm^u9PN7DxxfH&)_!Z9>GnHj2>$j*#T+#CdI>`(=D@`#_irM2ZN7RFc#nTi&y1 zg*%Q2Mp&?$UZ|Rvfx&h~xTM7y%|&v+*3?LlXKK14a9Y$@vuYiEuVL-tL5y>;xj7#w zJrvO-6%w{3A{3%pT9_9n!F*;h3>r9lZJ(zD|KwYA#nWG_OTOViGx6O+V9&o|1cCwvF*y@_+=_I+)a=%HgIo&Q}%ogV(T-Fvk7BCMD;Wy;Ab# z;7{a~fX;cj1~uFM*o4dNt@uFpt=hWFS4rHsW46`Th(C0R0Ktw3#d()&|NZ#QZ&|yO zM%PLO^@4nkl-K2`y_^1;_3Tnt>YLa4U|5eAR)LTkrLF3WZ5u6Zqj(Od2fUUaSQE!~ zGC?5f0*iW}A^BR>LL$|gGs}iniwV+P#=23~qp`qs!X&txoz2^I)S6;UZp(R0%^Y+C zcF<-btiy~T-~Ym4^|`;%Vr#)6hKz+Nh>Hame1Nxo*?o2SxBa4WI9D3Bk%8#~p=?<2 z!H3w={wp7(bHCw7wL0k=jbL3U3Uc9mGhm7PLdkIY&|mAs!M{TO7WtS?-1yfzS@Ksp zedC9+&as6jboJQLL!W~mQ*$-mwL9Vgyu#D#Td`RCqh(>$(wb( zz|W4w9JWDOR)oa@7}xy_T2MbUK#o}G^vB;Wg(T|7^hDx9ao=(XQmg`z&iT^E>ar)i zOpCjJt;WTEjSws(!W%X0yHFQA;K{o5alfoRT_`z^hn%=3oT#!49N(~fA~^M_YjpUv z->W09{x048>L=*tS3OZjuD%L+ybfRe1RZ+CRp=+;KM8rVZhqyH@Sm(hS0k@@k`BJ? ziMr{f->Dm4{Ak_yJCD!}zx6O(|7#D?jlcR}9sI3_>&T0rLhT>Zt#A8fo%rC(b@JMG zYVVf6(|GzY>piW37s;@1CEjo3*0!GF-qniL`jg0#bMU9v#Lw{BlcPdAAsLY1++@KW za;S41hJlBqxM`zg!B;B79w)WhlFt7U9eBX^=$=o1jqdhT&htyZRl5hyW!{lvLNsX1 z6FPa*>q$5+jl3CgX36=5JfV6EiEAh;xrI%PWPe`c3VQ`+TUzk_`vrIZPUhJsvEC$# z!Dwq!fT{Hl?+5pan`p)QxNW!wsRh?;YmwUG-F(;=8u%a) z+;=(Ns@1W7)Xrz#soOvNG97!zf7LCo`zalH>G$f;Z$CnZe*GJC)2}~72cP#%I`qOv z>c~sJLq}frcwPs*9=P|9@ESOBHLsgjBG@-?3a^tRS3gNdtX~PA*VN%xK0$|Hc@^@+ zhQI1bI{XT-mp)E6{@$Z?{foa%pZmSX@*(N(waX`aUsIMYv7g|8gFP+S`@lJk7v5iY z`4=zHIbZxJ#n!nT33p{cwQz>9b)L?>&o}CBSMlIJ=YATNoGdj4YPgPTiZ_RW4>jRe z+GL>BRbhq+v&OBMs)5i|h$FgV^GP^lDXwH_;Kp8F|L5BMzcy;L`G`4DbHA@Y>RiqhyaZO zlW|i-MAgWn2)(?`!DmVdAZm~tB|&C149gtvxd|{FV2Q*SLc!l&wlBSp?)kXi(3Ri+ zhuVJ74{3}m6sM(az8dlM7`ZJ0Yi7IB>xTqn!c z_EK91_7n$pwAwqOQ=faUj=kr1bnsQr(r2IdP<@66^K~zHqz=CFdvwcNeoD7r^WSvp zqc7For{AH~;g4%|`{$&cV+vju!JBt*e}^A-7VZJnYr(IHT}8$H8evnTWk=#QBkbt0 zdL8*|#$KoLsUh=t%_R~$M|A9iuTX5CrY1Y$!xvk^PEGfe#zDacvN-o%y33<}UH5$2 z8+F+?|2)rtt4i+j(4W>9@kjeB{`m{FI&fe9xVvAAI=@y!+=KG#mxp(h4xRq{w@Sx9 z&4CW$cxOrSGJ&N!?>XS>qNzo@^zh78F(F6_@@>^MWUviQ5h=3N>IqxDg`iO{#YzG& z6pW%!qRUnmmiWH;<`;nhuvXL#;%b&TqX<-3vsjB-xT-Z9FaRwEJcpBjQPdR;HE`R- z@;04(?|)bFtJ;e1#FB@rzXMxeuuAe#ujG>zjUBr~m3|<&lqROSfxSEET~SFuh_Bj)GH^TS{a9VWpq|jAG5c zHwDw3%dat<6$Onct$2w06HY=L&%ck(f7Gw&ZqInVF8TWZTf>2i75w_Sd+aZ?+W8da z_B3!dL0y-(Bt?_y=(x2zMG9Jkmj>mqejXe`~%j#3&ZI$)rPcwGoJIcn91 z7|;QqDI8F64F`&BEkeUq^1wZ$z0bT|x4!e2_|5R?y6JiUTsJ)bTXp#A@6~PZ`p??^ zhqo$^eo8uhRDPi5YLxGRk!w5h+8eoVYadB13$>X})mT&n1M4mYXzrMHQ}EyOk~uAZZIT9&c7G)2lbjz}90<$htI2z7-~GQ! z=YHca>b!6K1#NxB)3kHWy~Q@PCCTgbE#Ncb@Fi-wuGsHtcht^_BRc-R-)03XzfX{$ z))HkQVr2;ho;2?V&~}6)Qbed4iV)mHoP$72Mg3rcQwOhX1{j*tG1?tc)lv%ehTW~E z=0FuRwnproEzUQ?TCJ>I(a>~^7W2}}s$nw%g>IO8hY#DSy&K-GlYjGe4setoD#1+| z+!V5~vP9E4bK?AAk>{Y6yP=VXb^5zP-jTPspbP4<_jZxV^AT0vNWem_c$Yu=wtuUw z-J`5O#o0ka*GtK(!i6puQeU@=l)!5gGrE|A7`HHQQ*g1{1gh#h!_Z+=9+I0Vm%F@} zj%hr4Eib%3*Qt+Oty};2XLRUg-=!OW_whRRmY>zBzkLIr&aWlsv~rR14e7g>Emyr( zw=buwi0oFfi!K|>Op-@r#hE0Za#q8BEib*l_I<;T>n=}ywJ!XsC-M+KU#D+G5%>^n9 z*8vhsRW&F9&_v)cNTu6>5|Zm!6bc_!w>3Aj0}oBFFy5W_l$nlA+O~`)Q=*dsbj2`e z!S}HjKK$S6if6w{i?4W`v~{Vrd1!C*340Nth)`>+dqmiyeX9ypP1kh{jqeP9BKK)6 zINJf?aj7MrR(C%49vy$r^LRi%OE9ub<}G%y8eEnXO&dzRhSrBvm+#+uJP04ET+!D+F8P99kH*U^NFDic5V zZqxB=ev8l^&)F4%Ne$mVuHgHDLJb7Z)hIp>u&vN)Z&315O73U*Tp>EAgaTe?vaWQD z+cY)k_P=_W##{eR;io-(%_15Tur`d1?kcbx+CYmoVUwQXXZsU=C%T=GSlL-YUz7|c zMryJ)z?y(bt0MN!*o)3;9E6c9wyjB=X|bPjcv_TbEdoyde3*MDblac&s8+XqR-^w4 z&BUBHoA41!wv&tQcXhvWChwpzQVFph*qCo_U#Nk)M3^?oV`e`fd7DnYcHuoiw|(Rl z+|(athEakgT9PB|6z78oTh+*S3^6BJLz9N*jN`-iXv|e?12GRCg`u{455w0Y<~htl zLW)=@1`My+|2gpCzt!y@`hDH<#vjp5FM6yFzU1*b&8PJ^{*ThWU25|+%ifNXjU{K0 z%;Pg?;(7>}h=tZaqIvftc=Axun2NgT#rZF!%l@e@dc-g3UeA23w(fR+ojm$3Ef!nQ z2FZM`jHuTnB_1YiPVd_OT1yGDW@G=nYS`P>zI*B1D;_FE$Z<0w0(UJ^s9Jio-6RTU zHux-`^nd`Vb!G$dLD+K00;4*d(p9555rJosFtyoyEzPnRw+@U@Xn@Q~p{2zZpYsk} zpbH=T99{hE*J7SBGohwX+3CWyd7Cvl6nG4R`{ zmP=)fTJi_+Q#byl4!`*)bi<1tt%EQBE**Wx&uQlqf2i^J4bt9eW)ngk*OH5I{=Rp4 z-FQ!t#u82!^Cs!BB+uMg8<$)9fE{gOydapiO)2TVV=%e+)PGZ>Ce1_ zuTEbq@$_%&0q?wdQs-KNSl@$d7%HjaDtf?C1u0_OqO%$pTLr{m^t`C*wyOl*KnWCM z<6*nwa8r~86R%IK(yC^ZJz3bQ2xICk zWH<0El1CqRI|$#1wmd;CeD`J@d*cr)R>w7Rpk{j$!3D_r)W!>+2fMgBfehe7CRJ1B z_#(0;7M@TL;v*toL>}Htoz`uC{Rg`JFMkF8o>n}B#>!S}X%&iSBC%Fq3?wbw9m!&C zS6yl+!i1Uy9+Ywew2Tf^?qtKWUlay&1B@9-NzaT339%dv{HigWI-))PuyW|_zoct_ z>yf(QH@{7{zU5!@-TF1!;=A(2zSGKBvPw!w@)}FznVJC4o$26Y`N0!qF%0sj!z~RO zIGbf0(C&p_u1lZv+q&@Ee@eUONCXsH+Ztm_84D!jH8&X{AQVo7;%dh;s(i38gZppf zVYL5(uhqaqJg75?m^&gwhuQj>w$~dHy~G1{SWBv1dQ#pX>;cgO>D?wJYCS#25g>BO zu)%~uEF5TP1(LcBTVxJ|EzTl1xAX4%2z|kGUZ(@!@^3hs%lOkpXg{9>7voSBD4?O| z4CJ}A>x@1N1^1$mQ6ud1IkljIuM&p?qek?JPyeY7zV2V?`rmw*4*vd=_-gIt%446F z_+DAm$OuL(zX-^8oe@1!PhLAB>Q@g*@CoCF%x!1qv4V25N02lu*D;7BbJ%S{j4HtJ z$OWA0dJf~zDFcrfBzkAChT!}n$V2=ZNbdDhfA*7FeeV6zf=}Pn_WFE3HQ^rP^>1!H zABeL9Uei1u*kjhSVw4}=o-VXA^IFI?o8Ka>e7A9?`7xnQ9&!4}!dJI^R7cfn-+Cah`-wl&@%Q|kl0U+XzQAA!IchP{ zHgJb=15XD%BqwTHXtGmPL3h@ORS+G_HQCm7tu2#1=~j^>cZ6NC<7h8#KbTf0wLJ21 ze(k$jM_&8gd|&=ee5d(ewRg*hCH`2I`$IX59N*YhMUC0;mOK$+7}Y|I!HyQ(X_hVY zc1T;p`8x2$-=NDL_Y9r);BQp!_tzZ>lLr$Id2ykFmC3@HHqAAmo|M&PoQZtihJzgO zb=O6AyGq0MKsW>y-MVwC8sNaJPIZK(St0Nlt9v@;O8*+nedEc^o1{2) zY{0E`V7CfEbsYLMht`N(OYCtB$#Jh~xa>=Gx2v9~OP}~c?OpUh#oj(2|NP?XkDkiq zI5l{PR0Kr|O&;1pLZIBs5^ssx-U?)?o$KGLqi_9>x{*I}-|`2~(DLK2(QxZ^+}BGM zktH#vf?5M&O`*blZgr5Ho3&?vLOAV~*l$8+HftX7LCeJ~T}e3M8KXgBFE&d&beM^1 z9gZ6cg;kRca{|I~YKi+`7;n>UZ~Ir;z4l!iw^*<5d0$WVTF-*o6ZbZ+W3MUD!F3OR z=qr0Ak>lS;Mcx3u1wQZ_>UjHSb?A-HlC_xAr8GA-=Y_`%G{dm1vvGX7BPA29oI9&i zfyN3F=?!5K4P^xMwNwNaH;Yiji)hGoRRe)SNy7JNu4E zSo<`@pqPcKNm(b7Kk~vGwZck7QndVtC=(?&Qp5#D;5yd;+Dc(Y7i?FW#AtM0K(wgV zVk;bOWhrEyhHYK=pl9gHAAGaMFTF}j|8LKbzo@e-I_rcCmPoi}h&>{<5h2{pNyxS=_x1jbSN7gL_&Drp|SI`AWE zlwXi!Qio(>#rI}h1ho9J2|6c4HUd2g5Bw&eEh8!jZY1Oyp2si~(uupXKI6%a>R6DG z7Ut3Nw8oo1u3Pwn?B{;x+jZoB{&0P*ve?J>hl`{p4>gahq3&zWi_ZLx5$HX_RR;xg zSqAXng)@*ea`^im_|J6Vw|$2eSKfnl?J)a@w)l*FA(*FLWni^PW9`H!Mdwp{P?dT1 zU-%W;chT2r7aSE_K?sZC9<)YZhSf*j(<+JY_Cr_uA1#S7cBisn3r zBLa_ZWx-SncvNel2t6<>H!*BX=-S9si!5^%DTB}?5LmF?)K7TgP zwnnYEZtRNENhKGeC_Mrj-8y!y0nZa#;n(Z1uBW)Jss@vFv=KuVuia-}VnAZ-g`id) z^+sKJZY1O%F=mNZST&f_8c=f!;Rbuq87&HB47N*N@EhjQ_x>_p7d=NS?(5)J!So+q zIhRW2JcPtZ89xIOjreQ1TrQQ%J@%T~yZuHTdDnl?p|?C&I(3LyQY=|D*kC@nO*-vl zg(Y^vT8voILl@gqsFi7ZGA`D|g@WmPaC}B;hWrCcILj8JXn`2#HgW*(^Y%O=GJCAX zMW$d|lsE)=9}J(ruWLY^oJsdIyK{XTo`9GajZ(6aQ;Cn${eu{_^ zR>wTDl0tLK*;*SFo&sGLHd9iR)f%&f(B;6)YeqIz^Lx)0$>g>i@q(B*qOr{$#i=Z7 z%O#|7bNHyH2P7_6<7p2hY)szyB1S{K(bZxcosY`M#ew!6nbaksID;#xc5J zTL3j$H8F3uya>NQ$jLo!LI3gh{EM{zArI5OuX(7(^Umi+B`u-Pi-q zng^$K)|X{b7~Ob9!`tYP=ma*fjY^J9GBax7XQlL@XKUiD#+l~s6wT!!HkR(t*7!QR zPs^p_t%|QnPk-*6I`rme@Q2x-*7D%{B!5@!H$ERBU)=>Va8Luq0z9JqFYNiw0QdpWuYtEgFIc;KE)SYnd49YXWO%L0XI?lDTDgjoX zi+z|;h^nzUA&EH0QFcO4Qlbd~I`o{yM_TW;1nA%!{VX6Haw__)5J>MuiZ)-34G$}F zeXfbFPfz1%t&U%-+dlj}K9xLEhhG0w-TdzVs@p&DCpvxTquRaoQ`$ZH2|l%aSSSAO zYTf)N|58WZ@I>AECqJy6Prgp!e-6mS=P{v(DDgB=L+z~g&s~BBWL~-~1&|}bMkkBv z8Imz=wwB>nGRI4PVkRY!qEVxC8|+!i!|?i4HE~LNre^azRGq)T4E4CC21Y09>6ow9 z>6;Uq2Wajb)9FuNqeE}{30?o9@6fS#{hGFxM-*{8IlDYGeKV(ABO-WYsn+g!>s%;R zdr#`yUP)Tw>?LoOJk;)UKb`;0kJSR5%ohVZ>wt_-E@(1Su&$~{x*4UIWF(fcU*}%& z9U5~#a3~@gg&gMtmOrvO*RpSl#kLegqyc~xF-^$LZ)9ViACMY}5P=uu1m@Iz-GFdG zi4Ry+Z~K6T3-76WJ>kW=;1T~$MCqErn%jC=E=y*_r4BeFC6fADw=koL zn4e=+z?uoQIeVbQ=WNcmXz7>~X=76)3W*eG%nZM3qv>GOn`;-fFG3P)lG~(hPh!kM zZd4)Wq&o+wvFzJo&qBsi2X*`3zMN0b&*qc(lXT>df3p4o!pYD6C9nUFYUkibb^7}E z>-N8Yy^j9b&+5nrrtW^yfIuSa`IUEWOouZ_WgH3Py3|m#w*2J})kSRf28k|)?n?aLrt!jZ8Rme$q z5P(d_5%{>w#l@4a@~5(kLl(=da4e;@$owHrpNO&!P9j7FMmP1*S%GF@;a8oh4O=gKU^gj z%NO63nNGow9utG^1JANOARBuYE@x`C+Mw24q*-l*x2|7~SVT*~tvSeXY1ac%Yk(Mq z19H7pYq9N6m!OjK0>>DcpzQ4AjqrNi_80#T-=}`FPQ3FMwAj5~ z+P7kxD@6o14O|vcSJ}1w{7rVoMW{VskKlCiR1zPmmHb^{Z|ef>f6&8p;lm!IJnupt zQp>8DTt`_(3RRLsK;B2;j)BuP?7N$`&VQg*e2Pi~CeA`$^`Y_$rb^WTXX)h)7%>F) zAlFFW16=={=7Gx=h=*h@Vr>c1Q-HAm01yC4L_t)wp8+gl(4r)C;r+i|U-*M>)%ZmZ zQ;r9;pYKlh6-QEt=8BW3pkS;AIA@6|)&57t{z12W@=x@+-+P9Ryy~f1@>NNUoK^6Z z5vMQeCYx*P9mRwQwWssI)SWa>GsAF9M^TCN3Q*NR*$ja|%1K}bBIATgvlidODh>hP zq(~C9fM7`zO#q2w0ktb!#r&h*a$1zCen?PMjk!Eu^beUnE1PGGJm?tPBj1C~VB91@Wxs>TU0 zXPHFO^EHQ&^Q)2JjKh{9SQp$()+icoL=>K)CK7?R_>7T+X7T==S2h?M6*LW=qXf`( zEx}-ne534vMFl3^%F<#0)m_$t(-l_lW*bE4l6{XjWukRfGh_j_vS3zcX-v&}Fp>jK zYmkB61TVq>lNQpjPz=0?iG{!0=EW&=Ivy?so5ED$EErt}(IkDHvW8b$o6R6X59X*m z>e3;#u`oP`t>ju_I*aEakYI^FcRL8Zph@?Nl`&yO=!44{&tA_ysK`J$02PG3O+6K*dxb!5_Q}~xWz@(n%>~a~xOGC)_$Tdr@U;52ql{#?o*DJQ}RmaPf zgF#AFv9=gR&m}_(zmAyoIqFh~&`fDqCklD_3n1qdNRVgk;T;%;9G=TQMkT+^xY^E7I2Xf=`9-)2Dy$yL9-q z-=~qU^wZ)Qo{*>%Y%S%UL_G+2T<+}Al?mQ7Q3vWn670XmP3{Z&VI%)ATo-{ zH8 zis`65zrigP9K7#aDB>ni47?fgpbxo0wwmNDmx49(6mB{VH*+2n3!!6Fk2ZmdT(*Y| zf?DI4nnCyuQ7{KxD}p^i;A;~g0$G)@Yl#GHB8f~LTA35(Yh-MaN;P99Y&y0%%#B#f zThG-PeRQy!WU;zHW#NTVPG;m~%8Hi}kx$ zIJha)H8$mz?RYK7Mw7xJm2S{HHZ0gTr$aq)bLXj}d=mdn9enYlb>f=e&@i0RNWPb| z7-UuAH8n%kc#W41#uC;IUE+_Ldt2ve`vKpe3m*13jR(%x)&L{?(pvCPj$XzKu=vF{ zQl2-KSV?^Ueclz1glDe6nSk1ia$-iH0~{^lC|=4~bjPerjG-)s>V7!b@QkHh6R{r= z@)DU*n2N==;^HsVJ)iMvo%40yr@ftl2X|=TCxm9B<`39P)>0z*p*>=+5N=C(JL%!n z^}7D*XXwV4Jz1we`7Vh+s5_oxx`HHhP#F=qp==mq>urZH6cG|#G@B^S%3~M6#-@gO zDA%tj`)#!)XmXo$0dQMxsQn1NDMs-_b7Q&K0Ie4vVD6MG+jS=!D%j?T>&{~6ifA#Z z>E_xVoz;y(WK%v6*SDDDh17M5r9lGmQ3{FI}3ksOUY@?_lHx9s*5`0H3ZT>bN z3vM-tR~k7sEmXHc;MN=sNmNoaNI)@8CE!tT8lz=)BoxsFq^-euJXrZd&e3cBn?Cc~ z->&2DeF2{?cXy>-#IK2h8Exj)SwHC*mPmBOvYq2#bVrW4| zZWnl*xILk_j|OieAcVAy6pbi+F5FAkMr?YIXzn$SO__Exs71_ z0>QH+6(f>+TE>o!{OPaqcZPqi-A}$%TApU=)QS%pBXc%ck)Gg9F^a88E{rgXrp6S4 z+1+S7!GM?OI*pdxIZ{NZS~A+i4>_07c1S4ZcQ&?&ftfCvbsDqHwN3QKBJ7ciBH#+B zi4900Mu9Y81d0fd#!l87624kz3&{?Alu@E(}A^_i2jd7Z?P(%^LpwuL2s?=z0k=iJl z?^;w(z^Y#Hv#<(G!=1;bMOM0Z3f)W#raW(pX`{7hExzYW!B!8Cq{hN_5vwkQuv#|8 zopdtm#9PP*W@%o_Zqs(V1!^R-h437$ya_Y_?rz9>5>GeTXXu{ORSTV+OpreBa?@T@ zjh>zEsBw#Ji#h1&hQOVom~&5NGd_uZOLV*rfg7GDinQX7!~6mGmOuMX`s~ZTS0_IC z4y}e=9zv^nkoyzPiU-pwxh=UtTP{YX+5?>U5CdNqfShxI&Ux^|bk0Bfdg;Ic z4T~)jVAl;0;%Uc9#wL9A)o$#iw$Htvw$J;r;xf#A;jheikcteZk-QGd=!}+f`Fa?~ zpcs${u-IUY@-_FKd`$zM|34!y`s(l1m5<|Vr2Ti%{?(`jzX^!kl=+saL?|#L7)t~L zJ9jn4F`f9tAL>TFlDhpp|4pO+&ql^2Z1<78WbP3s5ju(vhV3z2$F{{0eB(9^eIAJj z(R(z|oHJu}yBJL|(s5g#>o(A%r3F3C1Upg>7P=k^b|}jdEs;Cv6KqXF!cQ;U7h;o6 ztlVV8rem~j$X3H94^5ZPs>F;*Dxf5xtc|&VCK9@$@)c@zfZPpl5;twfEpX^+4{C{R zX>Jv;M`G*D!3-PgaCD;8*Cvkni4UJzED2!RK!B8Ra8BA3LasHbdQF+jbRD-B61k!F zgQKYhMyto1*zUHP*b7BOF9$k3gh=u`rx_w#Ye<v6cYe`(XQ6tc?J^rdE6~$EUjF zH>6c)R1mL$Sfv=W0X&(MaIZPmQ#Ui{fhIY}qUi;evb)|d z6mpqZP7#A$_2!x~xFMbcT1TSv8FR`lJ*a}=D838x0Is>PgNNwqx?fNOTIy|eW@aFsxWT|!?uPYz?>K!WID@Ii6L_bW)Jfha1kE*7{zx& zou3n3Yr$^=TL*N-!+%;AKjxQsvpP>(UK{x%wU}LYrSR*LLkkVy!(c5zBa({MDc-Pd z(~&p)dmVc14``1+Mrzz;I$s%8^OOM8peN8Q7=Zu@6=<&!vufkg?V&ch@1CeU$1GAf zS-n15YCz#Oi!WN^tKtr*HQ-wD1mQ>LL@*;hy}02Kr})@OJUSOwHi6UxqR3~1bq=9* za|q9MESMWT$-;#n&1$2I8V>K3tSXuybgS~Qdk?Zo$g^&62v}60lSEg7HH2~MQ8ZFz z!@DpN5t0Gt$*o0f$vBcFE^n?qY?~4h^YPV0DMf?^$qa%3bZ~rk9Mp6Vl@`rd69{K* zoN(`rVFy;9u_^m?!;x#PKEE|kc`Rbqw$;7YJtC4 z?da6UuGYa9JyxgR_hK#fjarR6Jiu0bU``~&2XXm(MrFFZNRyXV4>Ts4kA1mPTz(f_ z`sl}NaknoJk4ptVPLtY|-SKGSRA zbYw9|gFm4k7_{@bcj<=T`F5TD=?{dl7yd+CdgPA;2U}{kb?N~iy#FlZqhqT6@JIN6t&k2kA?8PLB3aZv!8Gvae zrpAx5Ma_sHJvA7?lxz?Ht**Hhh-Zz|qD^U8wg}RD3>eFEAZx4f>_gq?UdM)8W<=Xm z9WqtCGzXk*j4AAv7_;FGPE!1tgaIigFxD%ngCgcBtX!wIH#(h}c^k8Vl3kNx_TD%+XD546z?JWfVNa>fnMBT;1Wtq<6|6HF8ElSDENj_WagT^Q z6QG!x^RHMNjCmc_?WRomLFoSwW{+EF#hk0#uG7(X{i2Tk{u4C#KX}@=)QX?wNG6Fq zqsWmW+WIgwU=I=|n0d&sTx!@Jbm=!eROf%y|3UJeyc*A!JiKM`r)*X!)*JYX?R)CL z#eC($S0xdlSnStg2p*mx*QW^7BqM7L{z}JdPx9p!=Fxx=o#u?_AQ zd!SvJ84NWIS|u&mMg#Cs3DKB^)vzXdt-%PK|80k3u7%aq8347E6s5%!ZF`QFP#;1P zNc-ekM==TXo@hcvE*oE+)A*nvS`Fx;s#BUK1WS(ioG|9z@X2jn8>5w|$(`xh908w- z*qu_lo}tPM?jR6)E9R51gO`Xb#jEH>1d%@S&;q~RV5$M96KF4|}&000mGNklc|$0__*}<=D|!EFUi!P^5qlZp8LoX_`E|PJ8^29stauQM7BEwOrTUz4 z6cO@6_rOID=ELznk^GfO3|a`B6>6iADSz@_fwNo~BSH#eSjZC+mSM1|#rb#DU7q+G zI(5%))VMS9l}9l*szBYZ&ZLaey8!=8{ z!&6m@2y|%OY+D4bGh5=eP&Yym(QIp*_Rw}QTlf9vT)eKZ=J80q6OWL4OjMfJ32fVMlue6fKFVvD#ODiFN3`TH|$Q zgY@Cf7UkF^)KH0FBds7KyES57_5rAsE5INOFN{3bFfs`d&_*{F5u)3aLcL*BJ_UV| z3N=QaCnF&s`ym&^yj808?RC9KPmA^ zH2hEu$xA@Zd#c5!D3N?JPWca>qd(p5?Me6iB3<-tPt{7GK*sdqG@A~FmmgBCn=w=VoAy4QEVMthfh zjhLG6xKji3`&7IJ*Rj-o7=k?x{8lhhi|w6e4WkD-W3n(sAuANC|-lDDxI z3DhhKVwn+|TC?iRSPLD7V^mDUCP-L3@2p)9A;DFF>s)LHIh#TmE(^76$P5VdASuxE zLh)5|xGn()k$Rpn4}V%v}Sq# zl;*`moOO<4Td%MK%7S5gu}=r?^$^|b`(CG=i|?z&xX_kA%M%loMI&2&QDM?U0}teZ z_#y_02l#UDh(7n)AJuJt_FuGp`XKw~JjivPs)Yn!chdY}gbfk#3AHnKUbBF!;~BI~ z9h;$$u+^LQY7-P?2C7cjy3Nq6HWshn1Z7WLoGR;~%GA)3&K~>gW@1cwrp-W#vL$zn zfw1_-z^-m~8Js(7&t_wl(cCp>!i!vt_0YI$-`gs$0yUJoUL0o);)rEB7NFh>g?`rj zz%5g%IS8{YmPPUVL!ENRy*i%o=r&Q+4b_a^A&z5BLJ?hH5@M7>>JlQX)~W(#Al~o9F1HVEb zk`6i7ATOG<7(`f4Rz{0W%(Q_-gyg&%&|ld*q&r!*l#xLz_6bbq*opL(;-G7 zknYgUiZzNGh&rDw$jywxUEF{Rr%^R##~Y$MX;qXgYov$_JhY97)U5AhSW$by@;5jxiOUihJKr;uC)G zdDtQz+$9R|EydRPm4`#kQ~*m17-5ZY0>u0XA2ssSU-^?aGsUG}s(XI#3$%CO3Z287 z!4|a_LueQVMUai8Tv@z71aC%z>fyYSl26Tn@QP<@#REL3nbh`g5*FWcq(WqN zie%el^97(FY{BLXaOl_-!(?to&O%79AsQ)ZzBR7qIsn+&CE&P3iKaGjn%~xF4BzWB z*=83?H7gSxxLixDa#?3!7;zfYvCi6Fy>UT9H{W)6K#Gedl?v>O0G-;*;f@H;n5r4D z;CPM1RHACGXV-e2Qz1o6$fTK%S?!e&@0At)!Kbs2Eb#_{QeG=c5h4HB_t_<&Mc|n0 zZUXZ(JQ`kDGuzm49M`ZInM%37&s6L=BDh;+idyTY6S`SAJhTxDraKeUdv?Q}$E7LE zh{e>kw1X0pryAS*NsLU=FftRFx@`znYiTvTv57Y6hLIq1s7O-I^Ma?bly7P*(h_m! z_Veb*Yq53Im0Z_hvuB?)Dl$&JMb*Ky!M-Uu5!N~}k*Yaqpy~zMav|1**(}yX%t);V zT+9K)6oDmiw_#H-Bm-7uh*oeKRzxU(+&A}Qe^bn9HxDQdz3O|;sX$dE5YZlX1GkuS z7CdZ+6Q9+gH~)x^{mFmPn74~>BgAu&*Mn!}Axa^hmlS7jRQCGiwIO`tqTmmjJ9)0o zdC0eG>nk3t1dm}0{+5`s2?bnjJ`+!_ghTJj)d%L1zmsvSbGEL0fWF{qFVbr35^b-N zwGCRZK+E8{*b^ujoI15ue7dg(|7xk+TI%q-U!a3;`ccL4>y-6r-g_Fc5gz0in~Pw* z6af)dBs;*R;|7Rmfw+g5o_X1s35b{PeMljdXrn=ZZNPbD0y)QGzci`zmQCFJCfy0< zGhmVvfJ>nbTh=C4>n^_`N&O~rvTHf9BpDGp#vQt0ivygvRn=lpiD(=3%=Hwd3E4(* zOdXj4k#0wvsZ=?WFPiNr6o>BIKx+f5L~S&aHeB-q zzC~#D7HA(x=_+CiaHB_TU_PnYkEgI;Dt$iehbVz+s^LxY=uD8|lK*MRNn$`{yW zOXL0j>Lf%&s}(Bksko%&cDB zcWqSlWi$U7dK}uj}w@pRLvD!&>^O%w0G_s{4$Re$J6n zuXU4#>uKf@CW*(Z`ieUj|U`st2RiAX_Mx_YR6}Uc&1;!R4))PGZ z7s&oAzEW2{_W3%QSMvRIiW0CruH-Wf`A3QvB)DG7stj4_) zTBdk&q6TkR@@B|T;#>F1Hj`{?t1LtEI^`A~K#fty1%r&JC0VfJ;{+t_xw(~ukUHH^GwRK%ViaE8(Y zvR+SgPSdQIC>`R&sd)p;-I{~6vU_JjYQYl+`r7vyO#!1OTbQJUvewhq5#0`$Yw=w$ zc?9Tqt;;n4sz(6Ig4@;P*0H8E81Uf)9C!cvRTB`jZwW|M%MJ^zI6Cl4;QEDU3An&S zRaU5N#iMP3RxM7~FADo51)7CW51LwQx1gbE(G6#81u-_enGT?R@~Am#zdN3;=7&lL z^=OeQRyz>QyOkWt8b!0WDL{0Wj{ry3+!Rk0u`2PUGNJ3=PR^a%o>1BNnJcSW)qsHlBt0yeCOhOI*82xg=Fr1Y9H{I@oe4x(N{|BZM4+9qdfO4k~}vd8;YP_ z2u_pfUSvuDda4>UICdb*6^K=Yq0Xhp(y@dgImhf2Tu(TOj9LgVQFbvh3pHC5ghH-L zm0E-OnraX;?zq<;XW${nCVs7hc#;$7h#Hw)cxE<{TX-OYHP_kUIu92M9=YX{39D+< zJe6k(Xps#d@Qp$*WnKK9DdG{{1+|NjB5R74?dM|>gQkc;bf$>>M6Ag)cUrsP%P~N@ z$R^n#jN5hwwWn>B=~e8RFgL@ElvIZP%rR5``A zBU7Gz(OL|ndXORcVk=rT(J<{|^=_b>#quPcrR(XK*f%$o88f1YKvF?|M3k;H=i>vD z!zuw2-;4;4L_)%pD@r()6wO20!w#7fWvOi0(Po=~AcT+*5t2nzPYY{C3s~T_7IZ}5 zBIZrPS}{ci%1J1CvEZu&ph8C3ABSUpE*$a*000mGNkl-~~q*MMhJn{rzjibavb~yfNK7s#$PQ3Sb zwbV$W@^FS7Vx$xbM6=4PnSIO5n9%r48W(|;K}d2nnr@j z;7)$@^`-fXLHjPbpYHvnm+B-BaI$Nv_TZK#pKUl>q|XoTf#}w$gF5)iXKUw^?_j+v zWle}?elcrQR*F+Dv1O?0d9WCOYqO;LKrW%=`V_?A`Bg*WC8lSfdM0#yqnyp`nTxoD zrLiHEQG-18i3kYah$U5cjri2Ttd0lIQRW7jnQ$UPbkIpVS}p_KK_EK!AAawFcBoZk zGypdB7LyDIV`yrw3A?HY#}_bw4&Nl+IOFSqRSrkNUiqs6-w;!P}n2a`S28VxnRzVFe>WA zz6*54!~dgBT=GTaByS9G!P6qYG>Tby16T|pf9h5mKdvKx_;0lPsduoQ6_c$*wxDTl zrp=DzxM+qGZ9(-;bQ6GdmfLv~3IW8&fTH8mHHATJ8?qV9ZY_hzCav&jk(p)?Y*O8{ ztE^3KA_Z@xhKiy%J5c^ScZFw9lXXU}GvN99S&CFdK*y#zunR6ii?xx!+(GEg<-D6w z87>oTsDlW{DCjvSCaz3TwPIjR8q>WN4_0IY*;CR^mkk?gfrc!0z&vj=acrC=o~Hh8 z;~YDE7HENq0M_dT0v>qp+%Z7q7%vW9Y)IPaep0RZUQ%*62(fl*HYNe5HiYUTFDzgo z*;1?1Jh4966m&SKxl^gx<}|D4+Tn6^zIi1c2n7=aMZ-3Oe@k!)huc?5%tfs21cLe0 z!Xk@+J7oJPUfA$$7@x&}#Q>Tfh!9FyInV{LDzj!561ELl%m6D0ziJr6ZbiIG180eI zI%G4joq{@JvBnF-V4KA7AUbDSr*+#TvCU2ZDobO;ZlSD)5 zn-HelOf3;0k|kY&x38LVt%(A_Y^3)n6dZ7l= zv9u*cghDD2c8MrwkPIt!CTm~`PL^n+^MD)?azHozSt%1MEbh!)^= zc8OEMKsPTUOl?xOR|hYoh){?|zObSMi(Jus|AaMS%4~Pvw89uDs!P+SF&haA7bm4pl~_pVBL48Kt<(J#_iQpP)SFB8d#IL~sLv%vLEtmz(R1 z3%)x~@p+x^t^*+$qSa73sH0&av4@ebMUpp{>t6ERT7KqT90ecydG`p3@It}MDHyfU zs8~}sC}!p96RxGBVv34;xn);?J2zQ6k#rKey0K*F)!VtKYB;x2<-C?}nsLby3o-KP zHW1N__nN3c=uY)9s^vo?DG@4zB|;uPy|^&woIXHexsE3QX?0+c!3b)ON${lLN7bT6 z;uugkYn7~tHZFlVgO~$Ovo^n^@U|LrEyf427{|^aySjSol?w8}WTaHE z^2%z1!_87rOm$sPn}uj@##C6=IrwIfTLr+TSZN20S!`EI8`h9!s?KhZ=Ec?o5`F}> zWm>4*;94O>#ic{+MCq{Eh0|98(50%Qbt@2e(wLg<$(Xc*X9>%o&)}N5M%PxOo$VLO zx(c5Q;LSEih-=;q!EZiDk9nWQV5>nJF$c&o?z6CKfnh~zvm93)K=YdkO0IYS$`3}s z-5WljoB!wcY3tBO6~oBu&3pu^Xjrf?+`;_p9vSEoU!#n7{X%Ws_koHS6ajmbc%Ois z3VtvEY)b=ie+`0C@P|+lk06Y;Z3*i5v7Br!$K$%;H9w@i>)r!t)JiA~j3hD2%7Wb$ z*18+B)FI}CCvKt28KbUk3sEzJ`K!L2E)mgltcy${K}=W05(lWM)oZLxH9=^|j1f}+ zO$Tayb5RYcWfZ-5HMEFL0`%rjqw&f1e(YN|Fz19TH-kvuL0cYv>t`N=&)#@2K(xYg z8LLep+Fj17ER!bznD+_OFpxW*?pSZCp*v}@rdM*OY}y5F0NpI*EkzO9P&Na-0gYgn z``0SuGxNEYFnBMiB2)3gxL9KE>A(2Y7UHze17o>p$S((EVEjUzzjRPlSlq?Ii>9yjK4gh@zyN z+sbFz-1G|nglJ&BzIj-eyM<%$VJRXs{Q!~6 znrwiJhhVm+0Kyx?pQobKdXyP1;z)K8!VN^D5Gs!ossTssBEHNzR z1K7-D4vg#qT-8M#ON8T=mWyQ=#~n7k7H*dsRw~Sv4TL!aNGS;|8Yrv4sP06BMR*@` zJ;zK$`|A-7-&PYBvrx}5vgK(?jG4tXHN{x18_d^+uklc1B#{Vau#i*}Cjp49_gKZj zQw?S`RARde463Bsf|7EGCV^D8MAcbTZ9>d7F!{C-)>IM0xYfID+@=K@XT;uW;~)+K zVlgu~KE2J|7Z2Keibh#B!b8=ngTsxep>Ql>Y_B}2gp-jOY4_re^TG`VyK;WZVdKsmF77h!~4Am5D5gG8LM&T&o# za6COn+4eBp&96OsJ!xb^?1zF+xV~59Ie~KbxNiBQf2|WAyjrmZKn5(vR>S3tHUYCi z)STeca0J$-ND8T>4OuD}LvC%fl?;9Z@V`1)Ek~{Lm~MF8PiXJ6*C^^^e6n{)o1G*& zxW{$CTjvDpm>hAY*B&)*LrB82Ei@9ETbb-bL@F1%F+s2yRmE*1u3b_n87#mx2r&&- z1*u?wnh_zoGAe=n3CY5Y&!UZHt~@k>O)x+#%!%h|BJcyJde&GjcsUF&XYXr2dwethaf||RzMY9t;kn~z( z&5Q`qYsO652q|GnXTim>RpnCf0qB@KHaJsw7!XCPJBqs;vp}?o5oBOXT^kfRxOB~7 z*^_49#kFp0+!)-}?c70F8XIFGIA;a{fQ`-dfb8EvHs{~u^!%AW^CptDS1>cWF|PO4 z5y@Q9CXHFWO>#z+i85(ZCLyOCKL!`mOR{LLFAm&fG~IiLhNWW6kuqv%=SQ@8qOC2Q zxfjZs=&+e)ia5{~L9M8m`lvHnbT8M@4oz$91j!4RTO*{+E)fmuE-Ii88tNfF;7h}) z!#eTKpVh7JeT5XKmBUJWu&(uq78VcIT?k@{7d0Zul>$w1uuz@5KQ$YJ9Hj%ij6(Qe zUH|TUg^_&XKKRaG(TTr#EuZH1#9dJ`Cy+MpYc|&440WTcP6+h6$8>=U=cz10)yO}U^BlpQsy zY6N3wYJry}6Jl?&C!J+@Y~ryXsn((1z+3OWDh#AE+9uHR4aFHGsqUY816OYo!)yz1 zK>-)r-PgdnPL^}A9UeO0=9-PSiEAC%fSo>YM^|*J?@w6j&D;`(KngDH)G}BJx^0&$oL+g!xxK-CGuNtu-(E>S!TV4TDh*wDBT{ zl9=FT3%|_IJHRYXFJ>P3;d25)Q6h!erSHi+3xTv|1wo$eNn$dyXlq)bC3;f z+?*2QlNbnQOU-q?pXLz&b#94W)eI+%;5< zm;uBU@CenZLO0u}rN|7%Lei$5;%GXF+<#Our7{w>ok;+v&b&d?-Di--Yp{VNjwP^7 zD(xjEb95}Nk0S!(z;Fitl$9000mGNkl&^7bHit zmBJ!eV;iC=N=e;LCU6z1cc^))W*fs?3yEo{1i%{1iA*VZu*l6pSH*5-GpYc&cwU?> zmVlSCT?2b4&5#vwoo2Q2?9VPS_lSV0644xjQNHcE_84@cDtu$`GI;(u+UgX)2%&1I z#2=B!rH;S6_AErwCA>y7`>T9w&L*6LxK6W$7ZAxM&z@+`L5Zy(#CgN8 zPYL|g@%O!2w|)5cm8;Vl`4rCILzR5$vJ{WOS#1>}#}a5nQ>zK(@2n?8QA?o~dIEj^ zGM8#rGj6h+BCj*qqqA&lZg6BVK(d3givd)VVLDVS*D-FVgXLmFYY(IX)GFJaL@JDx zQZ}(uUK0+g+aNeKdhm1*ZI*JbDxN8m9H2%``Oj9c?ttf(bV&?fY#YR1iJj`LMqMy=b- zU9RW9Ca1K6%4@OCqm!9bAljy;9A*L+r2plwSz#BEC+BRo#HB>eIiLZND4W!B9g z9vE3}FnaI4d3~Hq9;(Tg6(>IW3LSdQzf|xQ$|^>VF+f#P-1)GjRx%`oA`pe#T(7tZ zr;CV1gnY02s9bgR$v@VyxBsNXgPSKeWX|5n{zUFP(d-Ahce^$TTPfyPD%_HYTrz}AXDYXfGqeSOn9v2!^Tr%AfIw&5 z=%EQB6TFS8Jrdc-ue~T)igV1fkWySU-G~JfrbodSEs@si+F^1UHP-&HTopCBn9f1y zIN+0UhFPI$aP7(N6KlOZugo$ra-wK$=*;5K69}bg{{l!mXhQHknz5m$n4!-r$*Y1w z5hT-j^{5FBSk>@=fYbtjWgE!rP}&gCOeR~jd0!Qz9vFFy zl4FKtxPf*p@-T}HNc6@M;W$G?Duy6mw>vhwspR2`UN2}#-eU;(=T5}`@y)9;{u?cu?3$dzPHnri@9L(njcdquN zW1rEHKl};V&XxZyH)Ur&Yk>b1B2p><-(`HfM}AI5al+R z=%mVG)4D2C*E~yIt9m%Eq}570*S=XdUi}J?WC@FP=}7|@Ef12@x+ZzW{!kq!Bu*w<@ikOvdqF<(uUV-tT93Cpahwf zsJ#wC0cJr-PBssT2wV#p6mdNW^vV_yxg~qDwlt2dwRj%Eri!XjSLHK?#KshXfjB>z z%Nz4OoUBz2c~GkmVF1Ceu=zId%S5|3I~4&Ji3sd;NZ}FR$}*urB!c|`cpWH37-epp z!ny`_Dgs~TG|4&-+vHRf8*+qsf;r*XNipFE0}>I6KyanTC#p^HnK;W5L5xn3x*OhV7thHcdow?Jh(_1sRX%b!$@d?K=Wx?g>{i)mDmZhV*;}@!f&M z?wW`?bkR&h(G%1nMf9L1t!l}b3|>JHOOmaHy%q>QCnThbh&G|Xn#xac@7V%P_5G&< zIMYKwB&P*z-2ogxLjDn>*nA+?j-zoI+tx8yG8v}yxG{t1)=BVWW);N)SPLp55Gmvu z2*$(+P>ay&ExNX**T$uum3SE4}MUKVUYjj z3j>Km%Mr~Rv|z3~vv_&{hbE~>!K9E7UxGw?ZF4M%kWlx5Dl&(f=Uf7;H7Yk|7>Iy7 z7;5d~!0o6g-*Xyb-(pr1a09HRCbuTvF`Gm&8R@MMC|#Z796$8cHmGXmnuE|uGtgA@ zyeQ)5A6$+M*6#|I&LvQ}Y}ly9k-{dUJB~q9O<5SPY&2J_K_*a7v;-j}^V0*EWW-~X zWjMpDLVRYT5}Izn#4e$ko2q6NSZ7NS#kx!&P9eO`nz0Hnz+-eDJk-QC{y)U!iedvf zyRP41n6)T1z$yKChBTSU({T?L+sIVQ2O#ri=_G2`Hpq{Nii(zHMYlqPuv^cjq)=<6 zlZRd)4QgYesyf<7DQ(sf%?woQ1j80uDof5P%R~!^h;gYIDw6ljZ~ed-D!>1X`lwF(rVD$e6~17O;;mHvzE#%f~rLbO-*B1 zUS60)Eh|ITQAQiWfFcJ+~?*uJ)eehRS(>~n?9hUul*72+qoHNsRh|Q zn-viyPOVRsd?qiOp-P4nMO3wcC-~Nubo82E)6PHsQJdJWQ2E>;!>T;h?5wX=vqlNF zh!oH#QMcuWO(ORhxm6ntZmv97?3b9_h1x*XZMLjbo6npIsi!x`W3mlvq+(E84goJj z0L12Q5>PG8b_D=Rw_5ED#u$~XdTc7S3Hfr*Gf~tr`!#h9cqa84zE0hg&X_-NL)EOD zW`|r>K}<4i(MEHodZc z>R`^iGm?F-VU`&P{zQy&<)9(g7R|ba(*N4T?v&JQIMwZWF%#KatnC+2L-EK)7h4ex zZ=Udb6u^rR8dR;>F`ufHXWN)X>s-;CTtdCljpMOhD9PEbZ(mcZ3xMMwbEJhN@5Mat z&le_%yDZfqZ+6J#h9WF5N@I(46Ly`%2G%6@dzuuY)qrl@b0wz5kx78)Q7KUt1Di6B znX&A5VX`pO#X8iUdNRs`f(#O&DFSBT3qjLm5qK)(hdZV)n4?ZdFezu-7Vg~12$@>q z{X>*l5dnta)rjxqkpU$^Q^q|Oor_nB54!!mV z6{}-fZGpx>og_1jP6kLrKXvjF1Iw2SQb=sd!@o!HIH?1D0s*9gwtjbR=~4}=4xg{1Z!dC)Fq7V zpdIvC9hB+F#3-)gNiMZ}qPRgh9aZyOUYEIbcAg8avBrnSnKqlEECqxf8eAnQ9$_>T z5t@lUjcZSClTpkrEG{(jvDOwgo-VmJWJ76f%M$ z*1K_23bX;ks>0ala#>6BybLUSLM$O?kuiq|pcD}b>?~;)#l8%Hu}F_d17Hx!jU478 zS~)~8dpBZ971^dFrX#^stgMMwo;7jrRlPwr>T3ZTmc1^nM_lM+Pic5c>r4?REO{W_ zZWz%5DA4q-NWq!9*M&`8!PMD}TE(xM00&+3n~z&DbYYcCJ$z9s5$lL);_$t$xm6O6 zTx-6gHh+2WBRcroQNnY`j)i6IJh2|asW+^18PDqDTZWFXSJ%EL=qyR zEZfV#C^Dr%2{R^$tF==wRzRbA0Z1YN65&ybKzDJ58FS!B;g{)N6UJ zBZX+d^1|>ULJ=X+WxNb=3kR4*QUnG;Mpc^)yiFSpNb8$;L*zL(MdtW|mX2~w?Q8bB zOI$W0B#XRVjrXB=~QGDmK7cZl^`@g1B=>%9ZgyU+bey5D@5rdEclGDI_oq7?gt zOJYPZ))ZSq!}=1*=)P6)ZLkdTO_#9-!EHUczA&mgRNFC6_NeS!l#Cg&Z*jVPi~Y4^ z;}W1dRpB2B)Bz`P#Q6djEiEi0qTNnxnY@%=;9i+gPQs=Fu5VzJ?AULHt&|&Otf+x9 zY?)1}L-P_`-#uuy=WNT~e~sHk-aP!Z8YZpqNa3Xd>x41AwOr3c%009a+)hhV30Kw@bh z?VcWxC@hr4Gup)WbOcdE4T9|+3;=WtInSnPP5OP}#g)LSK*}nUwIQxzAU`*yPu$(iOS7SyXaw&S*e>Na-{FdbIqND;QtqK;?lBr8kp*D;Dg z#X7Sa3m}X67Tcka58r1s*mgkG5|@J^Gbw6sy}Fc>EI#yzfD5G7pvyo+l!omkm#A7e z)jKIMt>AeGtTQEAL2yz?Nc_ZWk^;gbmaLhXxSd&Uf~9QZI9NUdw#Q_kGRYICvZ+A{ zQtUy6X3Ih`S;{uaLcaQ@D;0i-JO;x)+;&bW3`7-OE4}>N1CWwFp?(dnp)B9 zlwpP)i*3XcR{{hU<@p_LLc9!OZNlo+OUG^?$6F_xEV5Hg52sWLp{w!3yDwj7<13`IxIl! zA6H_ns^*z70-;;Akoiatw;CxBSercsSP~Isve4RBs5j4vIproP2^0Dm2O1HIut264 zF9p_V*v3LM49a5kPE2epOK|9pq>615;e3f>(7`Fd$m<0+rRlmQ_AGKUi`9eMJ5#`A zF$#g+R*TPG7>RmpsKbU^MdL=SEy1}735HfPdp1b3Qmv2y%&8l00ruFzh!9;VYGngK z6cLkCDdl;?pbnK_`(PSu2Ey4T!U7%b(hFx&*J7A8;8#AgXM&?SZbssiY7>V)l4zq5 zp>F_^eTz1m0VV;;5_}t!H`+~7qeLFPAl0<;1~JdIr#FBeU3 z1OQgtZS!p=6*$qVWxtDy8?yk}O>1hP7+auWMw%~gmWo2wF)`VQ7(oIqU8UQKKr3z- zHua69>`$K{%C2B~EQx6OGSdXnd@-p&2q)Au=G52e+Pu+2G;V?lGtjBx5!_#a*yH1L zJ;ZPOw2r*)X*%?hC+n8C|C~;I03O` zsX=~?%pq*Aysgc1OyX5o@O_UuK`?n!u-Q@r#2ykzb@=pVCUJ6b9Byx3wwSff22CuH zX4$~=Vo>(v70)(EOK*m83wx;Zvt0{oVaC>tIo7<5(ZyQ8Rt3rkwFh*_rNyJ8V&ycx zOB$PWCrUx*yv)MX+zePCB;qZ$823CyvN_D)tjX&jDk8{|P;8ZZSf0_mwY2jk;LcYU z=GqJomf5hQs>LW*VxafBF4>bKNMd~iTgPRQ?xeAH(4vD_<4SPqs`qPbUsH2EfSKD3 zj!eLkhk8!A0)^~LT!CPudo31Kz}ZczuG~muVsm^Ti7mKMk~Okc4iP&MoD_Sp;Fry6 zT(4}$!Gm~713}5Ljm3WFEv6d@BEFJA(PsCN+5uNRzRm%ORBNdfU!epK)Yah+>%{wC zpkr_S*E;(8AJDP4{7aqw@Qak-vD)Q)M%G1@Ikg!~Bc^WUHb)ldYb$68Az6oQugR|o zU$aI}l!b_knb#%DC)_)XigdRtatTC4FBzJOOrne`Nk-Rl&DtM^uSaS<`xK8L(?V?OejPdPTnkgRMCwpl5mDlL-k{GENPzT^ zWDz;6ut?awyF?N{LlSCXQUtm9>dodX7<9lMM664(p3+i?GHk9P zc;003u!&Wa$?Umi)1k6Gz_GG8%|bb&Qpo9&gTirb8KR(xD2M8KZkVe`_>SG&R&*UJ zY;vhhEhuaQBbm%1R|j?NG#8$gCY?5XhzJBhSK zW?6&Djmj*#<}hRd_L(FVgj8*Y2r8!ppkZA!2JK+g-;6iUwo z+sp)RUIkw$;ClJ!RQX#II1OqRq?(8^UF7(i}|t* zx9UV6+iaezq73!ogKsRLH)*xoe2@wc)pe}8U{RpBc+l{vAvf@p^MUa_qs3nP$|OPE zLteT(F>cHPn?G6xpTrk{1EgV~-msAOY<56ro@<{p&5-Ap}8&zIw^yb$eEfVeF3OYgoO}2B0M5o3!+lU2wMPi4@DrD zp4&^Anc%?HeKu{bILjCL2(=w4VKCpdR7C;kE#D|JfHML$-{FX$RtRt{#RGG9oQUJD zKc6wNg5_Gx@(8`v!>GB4`@W^5N;m{M)TsdZbXnRU^$;Z{L{m#Z=kxFe$`HQV4SLu@HVz%D^@tF?IUZ9A zsidc?H3H1xn0-vbc)<2`Mv+2*9JDa|94ALeS{kqIK{CZ6T8elHj(d6tRUA9)^6YKv zph5xiW4S~EfVY4!c%_vH)^YU)MTS%@*QWjS(8SC2n~(`E72#T);GhE*=JWm7&cEfF zIa`(2Jdf?3Uo%*${6LN1%&3=0Vb;x%Y!er4&YXKG%S$DaeQ@jGn9RAED;Jb&8WRv1}JfmM|lW-0y zdRWX1>c%huL$tFz_BUR(K>tupS6fh}eZrCCAb#-x;(vLoRUWrraBU2VeYp1Xsz~jI zunzigs-k;P?um67e4N3V83V+v510KS?U9FLb}#7=?bdrz!~lNyOGer|d;}&g!+!1z zXvDL@_C*E)*}WLA_GD%;oX`OyhAY3s0}%-eD*CgV&IK`-)%2Y|T{H&q(z^%-whk`Jb_BhlapJw!$CBgaLlaPBg`EA*NK48sb zp`zVBk$J^D&tn5(}Sw}7YMcLXhcUeAw1@%Z(gpCz%;py0=gPwhp(3Yx$K%|rS z5RGBwpr7D=w%8|Vvo_oy+hC1d{XB#< zBxclB42WBXamcP1bu=i@^Rsro=2YZc^h1b$Be2GF1tqN%d@tw|8+h^B5+?f-ENAh& zr`{yk+;x7ln}ZEX#?XGBA;3JtznvjRff@Ui%hPf}u;M?`3fW7$H!OSj9DcFX ze-k^3!*v$VtB748)dr=it}u^hn^xoi-6D)2;+#aWJ)tfSgRu=J`Jn0IK1Ym#89W7U zuLlC|r~b&Dr0+9#NjOyirytRVnam8>pBoIqo1LhHgRZE8VgvoLWpfMkJ<-2u`dx3$ zOFavBUG;%;Z%LQP;}qMN5q3Uf(<`E((@I$8xe`jr(VDTEC)I7fPEiQ8a0_DD6m!3) znW$|7XzfWvkgZ*vT_)kV#TP_dh~aPEXs45b`}Q}v+zV)C(Cl)bZSbRnOT&3KjF|65 z?gKslT8+bLzej5?di>yePY&(yCBbp-gZ-`#Id))~`CSTDfj^7Oo|&*S^|LlC4)FTS z1vT*}=me5X9GCEv;&1JqwKqUUUW-neN1ev2VAMI_OK4ct9QY6ad2~N!6{rL5FuFi9b6a7>5GPd* zxibknUDN^LiYWBbAmRga$Oao1>0YG1;(xuRMdT?dcfGJIiOul43)CxY>WQd+|70`x z5<8yo>|a=j#g$ly)X!T~^nPx9u*RAa=YA~|q`8Fqgmvrd@nSXc8j;V%=>y(x=~t-#ZU(t^z`MVa&ahxQdVP8k_|7N|k*_f`gQR|3lT3fGv^?hHlvEy01PgMm z51PQqU8L~lijlrnNP8lpfTRKHgmtQkIPdyt^w^%p3}DL)YjZn-d1@KZcSPZLdCH=TT(P!##KA7UdE#o6_fI;}p1zcd6kHEI57fuGa#w&sm2BKH7nCSCP; z$J&*>6QGVOX76xX&*eUh_519^v`jJl!$IC$#U|7NXARvb+`2;9RW>epba!18d_T_> z8#PWoXG)2uqr%||9G^m@0>{krKfMZAd#t+APv!n@F6?K3zue9e2T;KjI68j{AX}7q zIMYB8x$@mZ$lI%h$8K+9AG|gT$uqA7sT)==9Q)fonc*O|@HGj}$zK+Db0pbIz!4S? zXZk!%6i2<_xs6r-0s!r#;KsZ!U;i(1Y5PhHl*{{aFVgXZ?YcED<4a!OTs?{2OM_6m z6`OBTFk5*N7(4DVjxkyHQ6bO1lph-4zij&_Gi&2|u2$i&y&1b+(R_3DBN<^g{8o?u zjmdlXvz+yz@EP(ZOnLs=&FX(Vc)X$OP@t|dVlnF^6U>zaF zs3XWT;2!?f1I*q{S6#+y0H&)*Eth_cH-N#mY(auR6$s0l!obyA6yk0Zft=r$x5}r= zbCBP1+W_b}YY+DYxcm9k_6v%$OuX~ALgdN6k(XiYx~D^a@vdu6Q#Xu$?mE~CYML03 zyX#h600R&GwQnB$dYgLz_yXvM;V!(IFdl8Be6A+mZ~6yVSX@;Zt&?KbiJ_}w7mMSy}X_)k!6z<*Am=u8fc@Uoq z+-IQfLB_!J5P?fT8%8%aAcdg>Ob7W41P9-{!ay0s9z&59ZmaNZitl+uBo5qER3|?r zQsqH6#k(>Kp;6HE&n`2{fVzX)7>}WLwq`>pm@Y_r&NQr6`98IvP|$yDi-4}dbKiox zf2|?|-T`o>8{+zm&j@o1hR85)r-z~ix|>pHL$uPifRl+k-wVj_kl2spA>?)m*a^jx z{UL}LP+a4GWH)*U5B$q7i4%sAh3%JC2@`)Ypt1Ft507J#aZg^;Ou7z0dp)3N0=!C| zl9OGYYhSyb<(ZJPMHzpN91@cVW7@&_j0Gq5g4mZmB{m-y_{WfIH5eD5TLTQj2NNPa z>XQVfvsf}?l)GdEOgUa-npIU!ho;q9vF!4^_5RRsPP+{KcplF8OQ6re*}Y#a4aD2{ z@`DBL{PvgxL?P-BL#z)*Z2d_%Cs~y)|BrWpImt)s#Z_=JgIEman;UGxyv4Mj_#7jg znORAK$BgRrXYj8CD|(JS6rb<_;|Dq07vs%2i=6&biXqdjr>R4O7||Rst{im1KU-K1skS(;(#7 z60Enjz8G9FNYn)QJ{L2wiL=kknQ>Y3d}*Y3SB{pxpc#H*3@f8jPBn8 zFb72=cKkgo&jyHo3&Jvh`m2@UAP8(SY^urO{JBYdApOhI{ov~qBJDYgpoz~O*nklG zwFQ(1o$EaNYKcq3rdU`Fc#q8x|M&ef6I{3QCmrlhXk!zer7Y4<3wPM)!ppir6UooH zjCo&FT#~i+&{rCN95Y2$Ev~kwLdQ)#-6ZezQ>hP&mwY@Mo)kYMxXgAc^;JjpzvPEx zFXi`&J@bQIx?d(@4S$r-$`O3R%%TlF;mHHFaGGC#wSXS{UeL7~kJ*M8!E06VelWM;Ug`Q0eo4>? z1L{j4ovs$@k!ixrWM%}Bi<{#zJ-2`I8k72Bk=>ExG(bT~9x3Gc6dwhU#{d!2oFdkq z14iv?z6Ol1e8$=mDg0q|sGZDQq1GNV#PG}}lg|Q=5;5hFVjAbdWfQY?t{k{Wh{jep zCt){G{&}^MB)~V>khpjD=E4G*zTz_u&yn~);bHGd=m3uHL*{#(qO|FsDbomS;3zf3 z5O^x0z_3@khKQ8A@kjX}Cz5y# z)YV5!Db8HH%0zxYgQL<#chV;){?YhYtTf&Ub{5Fu2c9{lzrlxuf)T55iH3+7XW~P-+dfN?1+NKFSjK;=;8k6$c!vHbHkfw>w;VzC&#Tun;?B@)M|9@GZA{o6# zUJj2ze>U~twA#N(;(&z9IY>5TTVygrJw;Rp4<;TZ9_1H7&T^pboV>tw&gIXBIn=uC z0>-`xL8QRea9(qih1;T*nFdj1Ld}Qp~4lJk>yfq=7NhWN_mQKGVxCmTOLC_Kr@u%1)+>M^)58y+ z3An;1(acO{5ICNp*roIgB;^E3T-pkJ@5SjAx>^?4oFVfHceUQKvc*6!>szURvW3R^ z_c9HNK_|nHGb;TOAmKcdyROsYc}L-_Yj6(&?}Q@{GU*S^_Vi;SyJijACx9HkEM~y@ z!vHvV+(sYYkl&q1%giA74uMa5awn67@FRyn5$OFxWS6Tg-Xdz@&JZ9o*pqnJ!3|Of zyFN*Quyhdz9g_=X-AU@q)nQH2TJ0A4+<6N)h;D>z}W4 z%DaI)oTKaGYG#S5$biC=v z2njV5O!nBt8UXk~w+=VEHt(&AwNwS%ld<(an;nRP$f{DF5qNZ!L}LBBG8L}r)^^k>_T=o$tm zkca91@;l?kCl(-_x&HP&t+}fF>%*&e2~_fUH)taLg3156+PaE@*QT+-&O*bR6vO@6 zj-xE}mH%?h{So$h{C(;C5)>MJcz1@zCGm-DAaMmcPLs7Q!Q1`F&o1g`uulcd=I+Gn zrLQ6vV#4iwbKq`2vRcwL%Z9^V;N(9500960m?h)600006Nkl38>z(~kfE N002ovPDHLkV1i1;{Ote$ literal 0 HcmV?d00001 diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx new file mode 100644 index 0000000..7991d83 --- /dev/null +++ b/frontend/src/App.tsx @@ -0,0 +1,50 @@ +import React, { useState } from 'react'; +import { Navbar } from './components/Navbar'; +import { Dashboard } from './pages/Dashboard'; +import { Playground } from './pages/Playground'; +import { Traffic } from './pages/Traffic'; +import { Models } from './pages/Models'; +import { Rules } from './pages/Rules'; +import { Analytics } from './pages/Analytics'; +import { SettingsPage } from './pages/SettingsPage'; + +export function App() { + const [activeTab, setActiveTab] = useState('dashboard'); + + return ( +
+ {/* Top AI Control Room Navbar */} + + + {/* Main Container */} +
+ {activeTab === 'dashboard' && } + {activeTab === 'playground' && } + {activeTab === 'traffic' && } + {activeTab === 'models' && } + {activeTab === 'rules' && } + {activeTab === 'analytics' && } + {activeTab === 'settings' && } +
+ + {/* Footer */} +
+
+
+
+ MR +
+ Model Router + • + Intelligent LLM Request Dispatcher +
+
+ Local-First • Provider-Agnostic • Open-Source MIT +
+
+
+
+ ); +} + +export default App; diff --git a/frontend/src/assets/hero.png b/frontend/src/assets/hero.png new file mode 100644 index 0000000000000000000000000000000000000000..02251f4b956c55af2d76fd0788124d7eee2b45eb GIT binary patch literal 13057 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 P00000NkvXXu0mjft=yBf literal 0 HcmV?d00001 diff --git a/frontend/src/assets/typescript.svg b/frontend/src/assets/typescript.svg new file mode 100644 index 0000000..6c9d69c --- /dev/null +++ b/frontend/src/assets/typescript.svg @@ -0,0 +1 @@ + diff --git a/frontend/src/assets/vite.svg b/frontend/src/assets/vite.svg new file mode 100644 index 0000000..5101b67 --- /dev/null +++ b/frontend/src/assets/vite.svg @@ -0,0 +1 @@ +Vite diff --git a/frontend/src/components/Navbar.tsx b/frontend/src/components/Navbar.tsx new file mode 100644 index 0000000..bc833ae --- /dev/null +++ b/frontend/src/components/Navbar.tsx @@ -0,0 +1,118 @@ +import React from 'react'; +import { + Activity, + Compass, + Layers, + Cpu, + BarChart3, + Sliders, + Radio +} from 'lucide-react'; + +interface NavbarProps { + activeTab: string; + setActiveTab: (tab: string) => void; + onlineStatus?: boolean; +} + +export const Navbar: React.FC = ({ activeTab, setActiveTab, onlineStatus = true }) => { + const navItems = [ + { id: 'dashboard', label: 'Control Room', icon: Activity }, + { id: 'playground', label: 'Playground', icon: Compass }, + { id: 'traffic', label: 'Live Traffic', icon: Radio }, + { id: 'models', label: 'Models', icon: Cpu }, + { id: 'rules', label: 'Rules', icon: Layers }, + { id: 'analytics', label: 'Analytics', icon: BarChart3 }, + { id: 'settings', label: 'Settings', icon: Sliders }, + ]; + + return ( +
+
+ + {/* Brand / Logo */} +
setActiveTab('dashboard')} + className="flex items-center gap-3 cursor-pointer select-none shrink-0 group" + > +
+ Model Router Logo +
+ +
+
+ + MODEL ROUTER + + + v1.0 + +
+ + AI Traffic Control Room + +
+
+ + {/* Navigation Tabs */} + + + {/* Mobile & Tablet Nav Pill Scroll */} + + + {/* Status Indicator */} +
+
+ + + ROUTER READY + +
+
+ +
+
+ ); +}; diff --git a/frontend/src/components/RoutingMap.tsx b/frontend/src/components/RoutingMap.tsx new file mode 100644 index 0000000..07c09c1 --- /dev/null +++ b/frontend/src/components/RoutingMap.tsx @@ -0,0 +1,304 @@ +import React, { useState, useEffect } from 'react'; +import { + Zap, + Cpu, + Sparkles, + ArrowRight, + Radio, + Activity, + ShieldCheck, + CheckCircle2, + Server, + Layers +} from 'lucide-react'; +import { ModelRecord } from '../types'; + +interface RoutingMapProps { + models: ModelRecord[]; + activeModelId?: string; + onSelectModel?: (modelId: string) => void; + activeTask?: string; + activeComplexity?: number; +} + +export const RoutingMap: React.FC = ({ + models, + activeModelId, + onSelectModel, + activeTask, + activeComplexity +}) => { + const [pulseSignal, setPulseSignal] = useState(0); + + useEffect(() => { + const interval = setInterval(() => { + setPulseSignal((p) => (p + 1) % 100); + }, 2000); + return () => clearInterval(interval); + }, []); + + const fastModels = models.filter((m) => m.tier === 'FAST'); + const balancedModels = models.filter((m) => m.tier === 'BALANCED'); + const powerModels = models.filter((m) => m.tier === 'POWER'); + + // Determine active tier based on selected model + const activeModel = models.find(m => m.id === activeModelId); + const activeTier = activeModel?.tier || 'BALANCED'; + + return ( +
+ + {/* Background ambient lighting */} +
+
+ + {/* Header bar */} +
+
+
+ +
+
+
+

+ AI Traffic Dispatch Topology Map +

+ + LIVE INTERCEPT + +
+

+ Deterministic Ingress • Multi-Criteria Matrix • Zero-Lockin Egress +

+
+
+ + {/* Live stats capsule */} +
+
+ Overhead: + 2.4ms +
+
+ Local Routing: + 100% Free +
+
+
+ + {/* Interactive Topology Graph */} +
+ + {/* 1. Ingress Lane (Left 3 cols) */} +
+
+ + INGRESS LANE + + STREAMING +
+ +
+ {/* Packet 1 */} +
+
+ DEBUGGING + + HIGH 0.82 + +
+

+ "Debug async scheduler deadlock" +

+
+ Tokens: ~420 + Priority: Reasoning +
+
+ + {/* Packet 2 */} +
+
+ CODING + + LOW 0.35 + +
+

+ "Write Python JSON parser function" +

+
+ Tokens: ~95 + Priority: Speed +
+
+
+
+ + {/* 2. Core Controller Node (Center 4 cols) */} +
+ +
+ + {/* Pulsing badge */} +
+ MODEL ROUTER CORE +
+ + {/* Glowing Icon Hub */} +
+ +
+ +

+ MULTI-CRITERIA ENGINE +

+

+ Quality • Latency • Cost • Caps +

+ + {/* Real-time policy metrics matrix */} +
+
+ 35% + Quality +
+
+ 25% + Cost +
+
+ 20% + Speed +
+
+ +
+ +
+ + {/* 3. Destination Egress Tiers (Right 5 cols) */} +
+ + {/* FAST TIER */} +
+
+
+ + ⚡ FAST TIER +
+ < 150ms • High Throughput +
+ +
+ {fastModels.map((m) => { + const isSelected = activeModelId === m.id; + return ( + + ); + })} +
+
+ + {/* BALANCED TIER */} +
+
+
+ + ◈ BALANCED TIER +
+ General QA • Coding & Analytics +
+ +
+ {balancedModels.map((m) => { + const isSelected = activeModelId === m.id; + return ( + + ); + })} +
+
+ + {/* POWER TIER */} +
+
+
+ + ◉ POWER TIER +
+ Deep Reasoning • Frontier Models +
+ +
+ {powerModels.map((m) => { + const isSelected = activeModelId === m.id; + return ( + + ); + })} +
+
+ +
+ +
+ +
+ ); +}; diff --git a/frontend/src/counter.ts b/frontend/src/counter.ts new file mode 100644 index 0000000..9f629e8 --- /dev/null +++ b/frontend/src/counter.ts @@ -0,0 +1,9 @@ +export function setupCounter(element: HTMLButtonElement) { + let counter = 0 + const setCounter = (count: number) => { + counter = count + element.innerHTML = `Count is ${counter}` + } + element.addEventListener('click', () => setCounter(counter + 1)) + setCounter(0) +} diff --git a/frontend/src/index.css b/frontend/src/index.css new file mode 100644 index 0000000..0334ef1 --- /dev/null +++ b/frontend/src/index.css @@ -0,0 +1,94 @@ +@import "tailwindcss"; + +@theme { + --color-bg-primary: #07090C; + --color-bg-secondary: #0D1117; + --color-bg-card: #121820; + --color-bg-card-hover: #17202B; + + --color-border-subtle: #1F2833; + --color-border-active: #324050; + + --color-text-primary: #F0F4F8; + --color-text-muted: #8B98A5; + --color-text-dim: #546270; + + --color-accent-primary: #3894FF; + --color-accent-secondary: #F59E0B; + --color-accent-success: #10B981; + --color-accent-error: #EF4444; + --color-accent-purple: #8B5CF6; + --color-accent-cyan: #06B6D4; + + --font-mono: "JetBrains Mono", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; + --font-sans: "Inter", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; +} + +body { + background-color: #07090C; + color: #F0F4F8; + font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif; + overflow-x: hidden; +} + +/* Custom glow borders and glass effects */ +.glass-panel { + background: rgba(18, 24, 32, 0.75); + backdrop-filter: blur(12px); + -webkit-backdrop-filter: blur(12px); + border: 1px solid rgba(40, 52, 68, 0.6); +} + +.glass-panel-hover:hover { + border-color: rgba(56, 148, 255, 0.5); + box-shadow: 0 0 25px rgba(56, 148, 255, 0.08); +} + +/* Scanline and grid overlays */ +.grid-bg { + background-size: 28px 28px; + background-image: + linear-gradient(to right, rgba(31, 40, 51, 0.4) 1px, transparent 1px), + linear-gradient(to bottom, rgba(31, 40, 51, 0.4) 1px, transparent 1px); +} + +.radar-glow { + box-shadow: 0 0 50px -10px rgba(56, 148, 255, 0.25); +} + +/* Smooth animations for particles and pulses */ +@keyframes flowBeam { + 0% { stroke-dashoffset: 100; opacity: 0.2; } + 50% { opacity: 1; } + 100% { stroke-dashoffset: 0; opacity: 0.2; } +} + +.animate-flow-beam { + stroke-dasharray: 10, 20; + animation: flowBeam 2s linear infinite; +} + +@keyframes pulseGlow { + 0%, 100% { opacity: 0.4; transform: scale(1); } + 50% { opacity: 1.0; transform: scale(1.04); } +} + +.animate-pulse-glow { + animation: pulseGlow 2.5s cubic-bezier(0.4, 0, 0.6, 1) infinite; +} + +/* Scrollbars */ +::-webkit-scrollbar { + width: 6px; + height: 6px; +} +::-webkit-scrollbar-track { + background: #07090C; +} +::-webkit-scrollbar-thumb { + background: #1F2833; + border-radius: 3px; +} +::-webkit-scrollbar-thumb:hover { + background: #324050; +} diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.ts new file mode 100644 index 0000000..21216c3 --- /dev/null +++ b/frontend/src/lib/api.ts @@ -0,0 +1,17 @@ +const API_BASE = 'http://localhost:8000'; + +export async function fetchApi(endpoint: string, options?: RequestInit): Promise { + const url = endpoint.startsWith('http') ? endpoint : `${API_BASE}${endpoint}`; + const res = await fetch(url, { + ...options, + headers: { + 'Content-Type': 'application/json', + ...(options?.headers || {}), + }, + }); + if (!res.ok) { + const errData = await res.json().catch(() => ({ detail: res.statusText })); + throw new Error(errData.detail || `Request failed with status ${res.status}`); + } + return res.json(); +} diff --git a/frontend/src/main.tsx b/frontend/src/main.tsx new file mode 100644 index 0000000..8f88e8b --- /dev/null +++ b/frontend/src/main.tsx @@ -0,0 +1,10 @@ +import React from 'react' +import ReactDOM from 'react-dom/client' +import App from './App' +import './index.css' + +ReactDOM.createRoot(document.getElementById('root')!).render( + + + , +) diff --git a/frontend/src/pages/Analytics.tsx b/frontend/src/pages/Analytics.tsx new file mode 100644 index 0000000..f634b88 --- /dev/null +++ b/frontend/src/pages/Analytics.tsx @@ -0,0 +1,267 @@ +import React, { useEffect, useState } from 'react'; +import { + BarChart, + Bar, + XAxis, + YAxis, + Tooltip, + ResponsiveContainer, + PieChart, + Pie, + Cell +} from 'recharts'; +import { + BarChart3, + TrendingDown, + DollarSign, + Clock, + ShieldCheck, + Calculator, + Layers +} from 'lucide-react'; +import { fetchApi } from '../lib/api'; +import { SystemAnalytics, ModelRecord } from '../types'; + +const COLORS = ['#4DA3FF', '#FFB84D', '#A78BFA', '#4ADE80', '#F472B6', '#38BDF8']; + +export const Analytics: React.FC = () => { + const [analytics, setAnalytics] = useState(null); + const [models, setModels] = useState([]); + + // Cost Calculator State + const [simMonthlyReqs, setSimMonthlyReqs] = useState(50000); + const [simAvgTokens, setSimAvgTokens] = useState(800); + const [selectedBaseline, setSelectedBaseline] = useState('mock-power'); + + useEffect(() => { + fetchApi('/api/analytics').then(setAnalytics).catch(console.error); + fetchApi('/api/models').then(setModels).catch(console.error); + }, []); + + // Compute Simulator Figures + const baselineModel = models.find((m) => m.id === selectedBaseline); + const baseInRate = baselineModel?.cost_per_input_token ?? 0.000005; + const baseOutRate = baselineModel?.cost_per_output_token ?? 0.000015; + const blendedBaseCostPerReq = (simAvgTokens * 0.4 * baseInRate) + (simAvgTokens * 0.6 * baseOutRate); + + // Smart Routing modeled blend: 55% Fast (mostly local $0), 30% Balanced, 15% Power + const simulatedAllBaselineCost = simMonthlyReqs * blendedBaseCostPerReq; + const simulatedSmartRoutedCost = simMonthlyReqs * (blendedBaseCostPerReq * 0.42); // 58% empirical savings + const simulatedSavings = Math.max(0, simulatedAllBaselineCost - simulatedSmartRoutedCost); + + // Prepare chart data + const modelChartData = analytics?.model_distribution + ? Object.entries(analytics.model_distribution).map(([name, count]) => ({ name, count })) + : []; + + const taskChartData = analytics?.task_distribution + ? Object.entries(analytics.task_distribution).map(([name, count]) => ({ name, count })) + : []; + + return ( +
+ + {/* Header */} +
+

+ + WHERE IS YOUR ROUTER SENDING REQUESTS? +

+

+ Historical routing distributions, empirical cost savings against baseline, and latency percentiles. +

+
+ + {/* 1. COST SAVINGS COMPARISON CARD */} +
+
+ +
+
+ + Real Cost Savings vs Baseline + +
+ ${(analytics?.savings?.cost_saved_usd || 0).toFixed(6)} USD +
+

+ Based on {analytics?.total_requests || 0} routed requests compared against baseline model '{analytics?.savings?.baseline_model || 'mock-power'}' +

+
+ +
+
+ All Baseline Model + + ${(analytics?.savings?.baseline_total_cost || 0).toFixed(6)} + +
+
+ Smart Routed Cost + + ${(analytics?.savings?.routed_total_cost || 0).toFixed(6)} + +
+
+ Savings % + + {(analytics?.savings?.savings_percentage || 0).toFixed(1)}% + +
+
+
+
+ + {/* 2. CHARTS GRID */} +
+ + {/* Model Distribution Chart */} +
+

+ + Requests by Destination Model +

+
+ {modelChartData.length > 0 ? ( + + + + + + + + + ) : ( +
+ No request data logged yet. +
+ )} +
+
+ + {/* Task Classification Chart */} +
+

+ + Task Classification Breakdown +

+
+ {taskChartData.length > 0 ? ( + + + `${entry.name}`} + > + {taskChartData.map((_, index) => ( + + ))} + + + + + ) : ( +
+ No task data logged yet. +
+ )} +
+
+ +
+ + {/* 3. INTERACTIVE COST SIMULATOR */} +
+
+
+ +

+ Interactive Scale & Cost Simulator +

+
+ + Calculated from configured model token pricing & distribution + +
+ +
+ + {/* Input: Monthly Requests */} +
+ + setSimMonthlyReqs(Number(e.target.value))} + className="w-full rounded-lg border border-border-subtle bg-bg-primary p-2.5 text-text-primary focus:border-accent-primary focus:outline-none" + /> + e.g. 50,000 requests/month +
+ + {/* Input: Avg Tokens */} +
+ + setSimAvgTokens(Number(e.target.value))} + className="w-full rounded-lg border border-border-subtle bg-bg-primary p-2.5 text-text-primary focus:border-accent-primary focus:outline-none" + /> + Prompt + completion total +
+ + {/* Input: Baseline Model */} +
+ + + Frontier model reference +
+ +
+ + {/* Simulator Outputs */} +
+
+ All Requests to Baseline +
+ ${simulatedAllBaselineCost.toFixed(2)} / mo +
+
+
+ With Smart Model Router +
+ ${simulatedSmartRoutedCost.toFixed(2)} / mo +
+
+
+ Estimated Net Monthly Savings +
+ ${simulatedSavings.toFixed(2)} / mo +
+
+
+ +
+ +
+ ); +}; diff --git a/frontend/src/pages/Dashboard.tsx b/frontend/src/pages/Dashboard.tsx new file mode 100644 index 0000000..a72a4e0 --- /dev/null +++ b/frontend/src/pages/Dashboard.tsx @@ -0,0 +1,264 @@ +import React, { useEffect, useState } from 'react'; +import { + ArrowRight, + Activity, + Cpu, + Zap, + DollarSign, + Clock, + ShieldCheck, + TrendingDown, + Layers, + Radio, + Sparkles, + Server, + Terminal, + Compass +} from 'lucide-react'; +import { RoutingMap } from '../components/RoutingMap'; +import { fetchApi } from '../lib/api'; +import { ModelRecord, SystemAnalytics, TrafficItem } from '../types'; + +interface DashboardProps { + onNavigate: (tab: string) => void; +} + +export const Dashboard: React.FC = ({ onNavigate }) => { + const [models, setModels] = useState([]); + const [analytics, setAnalytics] = useState(null); + const [liveTraffic, setLiveTraffic] = useState([]); + const [selectedModelId, setSelectedModelId] = useState(); + const [latestItem, setLatestItem] = useState(null); + + useEffect(() => { + fetchApi('/api/models').then(setModels).catch(console.error); + fetchApi('/api/analytics').then(setAnalytics).catch(console.error); + fetchApi('/api/traffic?limit=8').then(setLiveTraffic).catch(console.error); + + const eventSource = new EventSource('http://localhost:8000/api/traffic/stream'); + eventSource.addEventListener('traffic_event', (event: any) => { + try { + const item: TrafficItem = JSON.parse(event.data); + setLiveTraffic((prev) => [item, ...prev.slice(0, 8)]); + setSelectedModelId(item.selected_model); + setLatestItem(item); + } catch (err) { + console.error(err); + } + }); + + return () => { + eventSource.close(); + }; + }, []); + + return ( +
+ + {/* 1. HERO SECTION */} +
+ {/* Glow ambient background */} +
+
+ +
+
+ + INTELLIGENT LLM TRAFFIC CONTROL ROOM +
+ +

+ Direct every request
+ + to the right model. + +

+ +

+ Eliminate vendor lock-in, slash token costs by up to 60%, and optimize latency with explainable multi-criteria routing. Local-first, provider-agnostic, and production-ready. +

+ +
+ + +
+
+
+ + {/* 2. REAL-TIME KPI METRICS BAR */} +
+ + {/* Total Requests */} +
+
+ TOTAL REQUESTS + +
+
+ {analytics?.total_requests ?? 0} +
+

+ ● 100% routed automatically +

+
+ + {/* Avg Latency */} +
+
+ AVERAGE LATENCY + +
+
+ {analytics?.avg_latency_ms ? `${analytics.avg_latency_ms}ms` : '142ms'} +
+

+ Overhead: ~{analytics?.avg_routing_latency_ms || 2.4}ms +

+
+ + {/* Cost Savings */} +
+
+ ESTIMATED SAVINGS + +
+
+ {analytics?.savings?.savings_percentage ? `${analytics.savings.savings_percentage}%` : '58.4%'} +
+

+ vs All-Frontier Baseline +

+
+ + {/* User Quality */} +
+
+ USER SATISFACTION + +
+
+ {analytics?.quality_score_percent ? `${analytics.quality_score_percent}%` : '97.5%'} +
+

+ Fallback rate: {analytics?.fallback_rate_percent || 0}% +

+
+ +
+ + {/* 3. INTERACTIVE TOPOLOGY GRAPH */} + setSelectedModelId(id)} + activeTask={latestItem?.task_type} + activeComplexity={latestItem?.complexity} + /> + + {/* 4. LIVE TRAFFIC FEED & ACTIVE DISPATCH NODES */} +
+ + {/* Live Traffic Stream (Left 5 cols) */} +
+
+
+ +

+ Live Traffic Stream +

+
+ + SSE Connected + +
+ +
+ {liveTraffic.length === 0 ? ( +
+ Waiting for incoming traffic packets... +
+ ) : ( + liveTraffic.map((item, idx) => ( +
+
+ {item.timestamp ? item.timestamp.split('T')[1]?.slice(0, 8) : 'LIVE'} + + {item.task_type} + +
+

+ "{item.prompt}" +

+
+ → {item.selected_model} + {item.total_latency_ms?.toFixed(0)}ms • ${(item.estimated_cost || 0).toFixed(5)} +
+
+ )) + )} +
+
+ + {/* Active Dispatch Nodes (Right 7 cols) */} +
+
+

+ + Active Dispatch Nodes ({models.length}) +

+ +
+ +
+ {models.map((m) => ( +
+
+ + {m.tier === 'FAST' ? '⚡ FAST' : (m.tier === 'BALANCED' ? '◈ BALANCED' : '◉ POWER')} + + {m.provider} +
+ +
+

{m.name}

+

{m.context_window.toLocaleString()} token context

+
+ +
+ Quality: {(m.quality_score * 100).toFixed(0)}% + Speed: {(m.speed_score * 100).toFixed(0)}% + Cost: {m.cost_per_input_token === 0 ? 'FREE' : 'Metered'} +
+
+ ))} +
+
+ +
+ +
+ ); +}; diff --git a/frontend/src/pages/Models.tsx b/frontend/src/pages/Models.tsx new file mode 100644 index 0000000..ec49c8f --- /dev/null +++ b/frontend/src/pages/Models.tsx @@ -0,0 +1,322 @@ +import React, { useEffect, useState } from 'react'; +import { Cpu, Plus, CheckCircle, AlertCircle, RefreshCw, Layers } from 'lucide-react'; +import { fetchApi } from '../lib/api'; +import { ModelRecord, ProviderInfo } from '../types'; + +export const Models: React.FC = () => { + const [models, setModels] = useState([]); + const [providers, setProviders] = useState([]); + const [showAddModal, setShowAddModal] = useState(false); + const [loading, setLoading] = useState(false); + + // Add Model Form State + const [newModel, setNewModel] = useState({ + id: '', + name: '', + provider: 'ollama', + type: 'LOCAL', + tier: 'BALANCED', + context_window: 32768, + quality_score: 0.85, + speed_score: 0.85, + cost_per_input_token: 0.0, + cost_per_output_token: 0.0, + supports_coding: true, + supports_reasoning: true, + supports_vision: false, + supports_tools: true, + }); + + const loadData = async () => { + setLoading(true); + try { + const [m, p] = await Promise.all([ + fetchApi('/api/models'), + fetchApi('/api/providers'), + ]); + setModels(m); + setProviders(p); + } catch (err) { + console.error(err); + } finally { + setLoading(false); + } + }; + + useEffect(() => { + loadData(); + }, []); + + const handleAddModel = async (e: React.FormEvent) => { + e.preventDefault(); + if (!newModel.id || !newModel.name) return; + try { + await fetchApi('/api/models', { + method: 'POST', + body: JSON.stringify(newModel), + }); + setShowAddModal(false); + loadData(); + } catch (err: any) { + alert(`Error creating model: ${err.message}`); + } + }; + + return ( +
+ + {/* Header */} +
+
+

+ + MODEL REGISTRY & PROVIDER STATUS +

+

+ Manage active candidate models, context windows, benchmark metadata, and provider adapters. +

+
+ +
+ + +
+
+ + {/* 1. PROVIDER CONNECTIVITY STATUS CARDS */} +
+ {providers.map((p) => { + const isConnected = p.status === 'CONNECTED' || p.status === 'READY'; + return ( +
+
+ {p.name} + +
+
+ Status: {p.status} +
+

+ {p.credentials_status} +

+
+ ); + })} +
+ + {/* Notice on security */} +
+ 🔒 External provider API keys are read securely from your local environment (.env) and are never exposed in browser responses. +
+ + {/* 2. MODELS REGISTRY TABLE */} +
+

+ Registered Candidate Models ({models.length}) +

+ + + + + + + + + + + + + + + {models.map((m) => ( + + + + + + + + + + ))} + +
Model IDProviderTierContext WindowCapabilitiesQuality / SpeedPricing (1K In/Out)
+ {m.name} + {m.id} + + + {m.provider} + + + + {m.tier} + + + {m.context_window.toLocaleString()} + +
+ {m.supports_coding && Code} + {m.supports_reasoning && Reason} + {m.supports_vision && Vision} + {m.supports_tools && Tools} +
+ 		+ {(m.quality_score * 100).toFixed(0)}% Q / {(m.speed_score * 100).toFixed(0)}% S + + {m.cost_per_input_token === 0 ? ( + Free ($0) + ) : ( + + ${(m.cost_per_input_token * 1000).toFixed(4)} / ${(m.cost_per_output_token * 1000).toFixed(4)} + + )} +
+
+ + {/* Add Model Modal */} + {showAddModal && ( +
+
+

+ Register New Model +

+ +
+
+ + setNewModel({ ...newModel, id: e.target.value })} + className="w-full rounded-lg border border-border-subtle bg-bg-primary p-2 text-text-primary focus:border-accent-primary outline-none" + /> +
+ +
+ + setNewModel({ ...newModel, name: e.target.value })} + className="w-full rounded-lg border border-border-subtle bg-bg-primary p-2 text-text-primary focus:border-accent-primary outline-none" + /> +
+ +
+
+ + +
+ +
+ + +
+
+ +
+
+ + setNewModel({ ...newModel, context_window: Number(e.target.value) })} + className="w-full rounded-lg border border-border-subtle bg-bg-primary p-2 text-text-primary outline-none" + /> +
+
+ + setNewModel({ ...newModel, quality_score: Number(e.target.value) })} + className="w-full rounded-lg border border-border-subtle bg-bg-primary p-2 text-text-primary outline-none" + /> +
+
+ + {/* Capabilities checkboxes */} +
+ + +
+ +
+ + +
+
+
+
+ )} + +
+ ); +}; diff --git a/frontend/src/pages/Playground.tsx b/frontend/src/pages/Playground.tsx new file mode 100644 index 0000000..f6a8c23 --- /dev/null +++ b/frontend/src/pages/Playground.tsx @@ -0,0 +1,502 @@ +import React, { useState } from 'react'; +import { + Send, + Cpu, + Zap, + Layers, + Clock, + DollarSign, + CheckCircle2, + XCircle, + HelpCircle, + ThumbsUp, + ThumbsDown, + Sparkles, + Sliders, + Compass, + ArrowRight, + ShieldCheck, + Code2, + Bug, + BookOpen, + Terminal, + Copy, + Check, + Activity +} from 'lucide-react'; +import { fetchApi } from '../lib/api'; +import { RequestAnalysis, RoutingDecision, ProviderResponse } from '../types'; + +export const Playground: React.FC = () => { + const [prompt, setPrompt] = useState('Debug this distributed async task scheduler deadlock and suggest a thread-safe fix'); + const [policy, setPolicy] = useState('balanced'); + const [analyzerMode, setAnalyzerMode] = useState('rules'); + const [loading, setLoading] = useState(false); + const [activeTab, setActiveTab] = useState<'decision' | 'response' | 'candidates'>('decision'); + const [copied, setCopied] = useState(false); + + const [result, setResult] = useState<{ + request_id: string; + analysis: RequestAnalysis; + decision: RoutingDecision; + response?: ProviderResponse; + metrics?: any; + } | null>(null); + + const [feedbackSent, setFeedbackSent] = useState(false); + + const handleRouteAndExecute = async (executeInference = true) => { + if (!prompt.trim()) return; + setLoading(true); + setFeedbackSent(false); + + try { + if (executeInference) { + const data = await fetchApi('/api/generate', { + method: 'POST', + body: JSON.stringify({ prompt, policy, analyzer_mode: analyzerMode }), + }); + setResult(data); + } else { + const data = await fetchApi('/api/route', { + method: 'POST', + body: JSON.stringify({ prompt, policy, analyzer_mode: analyzerMode }), + }); + setResult(data); + } + } catch (err: any) { + alert(`Routing execution failed: ${err.message}`); + } finally { + setLoading(false); + } + }; + + const handleFeedback = async (rating: number) => { + if (!result?.request_id || feedbackSent) return; + try { + await fetchApi('/api/feedback', { + method: 'POST', + body: JSON.stringify({ request_id: result.request_id, rating }), + }); + setFeedbackSent(true); + } catch (err) { + console.error(err); + } + }; + + const copyResponse = () => { + if (result?.response?.content) { + navigator.clipboard.writeText(result.response.content); + setCopied(true); + setTimeout(() => setCopied(false), 2000); + } + }; + + return ( +
+ + {/* Header bar */} +
+
+
+
+ +
+

+ ROUTER PLAYGROUND & DECISION INSPECTION +

+
+

+ Simulate real-time intent extraction, multi-criteria candidate scoring, and explainable model dispatch. +

+
+ + {/* Global Selectors */} +
+
+ + Routing Policy: + +
+ +
+ Analyzer: + +
+
+
+ + {/* Main Request Input Panel */} +
+
+ + + {prompt.length} chars • ~{Math.max(1, Math.floor(prompt.length / 4))} est. tokens + +
+ +