Delete app

app/.pyfun

@@ -1,313 +0,0 @@
-# =============================================================================
-# .pyfun — PyFundaments App Configuration
-# Single source of truth for app/* modules (provider, models, tools, hub)
-# Part of: Universal MCP Hub on PyFundaments
-# =============================================================================
-# RULES:
-#   - All values in double quotes "value"
-#   - NO secrets here! Keys stay in .env → only ENV-VAR NAMES referenced here
-#   - Comment-out unused sections with #  → keep structure, parsers need it!
-#   - DO NOT DELETE headers or [X_END]   → parsers rely on these markers
-#   - Empty/unused values: ""            → never leave bare =
-# =============================================================================
-# TIERS:
-#   LAZY:       fill [HUB] + one [LLM_PROVIDER.*] only        → works
-#   NORMAL:     + [SEARCH_PROVIDER.*] + [MODELS.*]             → works better
-#   PRODUCTIVE: + [TOOLS] + [FALLBACK] + [HUB_LIMITS]          → full power
-# =============================================================================
-# DO NOT DELETE — file identifier used by all parsers
-[PYFUN_FILE = .pyfun]
-
-# =============================================================================
-# HUB — Core identity & transport config
-# =============================================================================
-[HUB]
-HUB_NAME            = "Universal MCP Hub"
-HUB_VERSION         = "1.0.0"
-HUB_DESCRIPTION     = "Universal MCP Hub built on PyFundaments"
-
-# Transport: stdio (local/Claude Desktop) | sse (HuggingFace/Remote)
-# Override via ENV: MCP_TRANSPORT
-HUB_TRANSPORT       = "stdio"
-HUB_HOST            = "0.0.0.0"
-HUB_PORT            = "7860"
-
-# App mode: mcp | app
-# Override via ENV: APP_MODE
-HUB_MODE            = "mcp"
-
-# HuggingFace Space URL (used as HTTP-Referer for some APIs)
-HUB_SPACE_URL       = ""
-[HUB_END]
-
-# =============================================================================
-# HUB_LIMITS — Request & retry behavior
-# =============================================================================
-[HUB_LIMITS]
-MAX_PARALLEL_REQUESTS   = "5"
-RETRY_COUNT             = "3"
-RETRY_DELAY_SEC         = "2"
-REQUEST_TIMEOUT_SEC     = "60"
-SEARCH_TIMEOUT_SEC      = "30"
-[HUB_LIMITS_END]
-
-# =============================================================================
-# PROVIDERS — All external API providers
-# Secrets stay in .env! Only ENV-VAR NAMES are referenced here.
-# =============================================================================
-[PROVIDERS]
-
-# ── LLM Providers ─────────────────────────────────────────────────────────────
-[LLM_PROVIDERS]
-
-  [LLM_PROVIDER.anthropic]
-  active              = "true"
-  base_url            = "https://api.anthropic.com/v1"
-  env_key             = "ANTHROPIC_API_KEY"       # → .env: ANTHROPIC_API_KEY=sk-ant-...
-  api_version_header  = "2023-06-01"              # anthropic-version header
-  default_model       = "claude-haiku-4-5-20251001"
-  models              = "claude-opus-4-6, claude-sonnet-4-6, claude-haiku-4-5-20251001"
-  fallback_to         = "openrouter"              # if this provider fails → try next
-  [LLM_PROVIDER.anthropic_END]
-
-  [LLM_PROVIDER.gemini]
-  active              = "true"
-  base_url            = "https://generativelanguage.googleapis.com/v1beta"
-  env_key             = "GEMINI_API_KEY"          # → .env: GEMINI_API_KEY=...
-  default_model       = "gemini-2.0-flash"
-  models              = "gemini-2.0-flash, gemini-1.5-pro, gemini-1.5-flash"
-  fallback_to         = "openrouter"
-  [LLM_PROVIDER.gemini_END]
-
-  [LLM_PROVIDER.openrouter]
-  active              = "true"
-  base_url            = "https://openrouter.ai/api/v1"
-  env_key             = "OPENROUTER_API_KEY"      # → .env: OPENROUTER_API_KEY=sk-or-...
-  default_model       = "mistralai/mistral-7b-instruct"
-  models              = "openai/gpt-4o, meta-llama/llama-3-8b-instruct, mistralai/mistral-7b-instruct"
-  fallback_to         = ""                        # last in chain, no further fallback
-  [LLM_PROVIDER.openrouter_END]
-
-  [LLM_PROVIDER.huggingface]
-  active              = "true"
-  base_url            = "https://api-inference.huggingface.co/models"
-  env_key             = "HF_TOKEN"                # → .env: HF_TOKEN=hf_...
-  default_model       = "mistralai/Mistral-7B-Instruct-v0.3"
-  models              = "mistralai/Mistral-7B-Instruct-v0.3, meta-llama/Llama-3.3-70B-Instruct"
-  fallback_to         = ""
-  [LLM_PROVIDER.huggingface_END]
-
-  # ── Add more LLM providers below ──────────────────────────────────────────
-  # [LLM_PROVIDER.mistral]
-  # active            = "false"
-  # base_url          = "https://api.mistral.ai/v1"
-  # env_key           = "MISTRAL_API_KEY"
-  # default_model     = "mistral-large-latest"
-  # models            = "mistral-large-latest, mistral-small-latest"
-  # fallback_to       = ""
-  # [LLM_PROVIDER.mistral_END]
-
-  # [LLM_PROVIDER.openai]
-  # active            = "false"
-  # base_url          = "https://api.openai.com/v1"
-  # env_key           = "OPENAI_API_KEY"
-  # default_model     = "gpt-4o"
-  # models            = "gpt-4o, gpt-4o-mini, gpt-3.5-turbo"
-  # fallback_to       = ""
-  # [LLM_PROVIDER.openai_END]
-
-[LLM_PROVIDERS_END]
-
-# ── Search Providers ───────────────────────────────────────────────────────────
-[SEARCH_PROVIDERS]
-
-  [SEARCH_PROVIDER.brave]
-  active              = "true"
-  base_url            = "https://api.search.brave.com/res/v1/web/search"
-  env_key             = "BRAVE_API_KEY"           # → .env: BRAVE_API_KEY=BSA...
-  default_results     = "5"
-  max_results         = "20"
-  fallback_to         = "tavily"
-  [SEARCH_PROVIDER.brave_END]
-
-  [SEARCH_PROVIDER.tavily]
-  active              = "true"
-  base_url            = "https://api.tavily.com/search"
-  env_key             = "TAVILY_API_KEY"          # → .env: TAVILY_API_KEY=tvly-...
-  default_results     = "5"
-  max_results         = "10"
-  include_answer      = "true"                    # AI-synthesized answer
-  fallback_to         = ""
-  [SEARCH_PROVIDER.tavily_END]
-
-  # ── Add more search providers below ───────────────────────────────────────
-  # [SEARCH_PROVIDER.serper]
-  # active            = "false"
-  # base_url          = "https://google.serper.dev/search"
-  # env_key           = "SERPER_API_KEY"
-  # fallback_to       = ""
-  # [SEARCH_PROVIDER.serper_END]
-
-[SEARCH_PROVIDERS_END]
-
-# ── Web / Action Providers (Webhooks, Bots, Social) ───────────────────────────
-# [WEB_PROVIDERS]
-
-  # [WEB_PROVIDER.discord]
-  # active            = "false"
-  # base_url          = "https://discord.com/api/v10"
-  # env_key           = "BOT_TOKEN"
-  # [WEB_PROVIDER.discord_END]
-
-  # [WEB_PROVIDER.github]
-  # active            = "false"
-  # base_url          = "https://api.github.com"
-  # env_key           = "GITHUB_TOKEN"
-  # [WEB_PROVIDER.github_END]
-
-# [WEB_PROVIDERS_END]
-
-[PROVIDERS_END]
-
-# =============================================================================
-# MODELS — Token & rate limits per model
-# Parser builds: MODELS[provider][model_name] → limits dict
-# =============================================================================
-[MODELS]
-
-  [MODEL.claude-opus-4-6]
-  provider            = "anthropic"
-  context_tokens      = "200000"
-  max_output_tokens   = "32000"
-  requests_per_min    = "5"
-  requests_per_day    = "300"
-  cost_input_per_1k   = "0.015"                  # USD — update as pricing changes
-  cost_output_per_1k  = "0.075"
-  capabilities        = "text, code, analysis, vision"
-  [MODEL.claude-opus-4-6_END]
-
-  [MODEL.claude-sonnet-4-6]
-  provider            = "anthropic"
-  context_tokens      = "200000"
-  max_output_tokens   = "16000"
-  requests_per_min    = "50"
-  requests_per_day    = "1000"
-  cost_input_per_1k   = "0.003"
-  cost_output_per_1k  = "0.015"
-  capabilities        = "text, code, analysis, vision"
-  [MODEL.claude-sonnet-4-6_END]
-
-  [MODEL.claude-haiku-4-5-20251001]
-  provider            = "anthropic"
-  context_tokens      = "200000"
-  max_output_tokens   = "8000"
-  requests_per_min    = "50"
-  requests_per_day    = "2000"
-  cost_input_per_1k   = "0.00025"
-  cost_output_per_1k  = "0.00125"
-  capabilities        = "text, code, fast"
-  [MODEL.claude-haiku-4-5-20251001_END]
-
-  [MODEL.gemini-2.0-flash]
-  provider            = "gemini"
-  context_tokens      = "1000000"
-  max_output_tokens   = "8192"
-  requests_per_min    = "15"
-  requests_per_day    = "1500"
-  cost_input_per_1k   = "0.00010"
-  cost_output_per_1k  = "0.00040"
-  capabilities        = "text, code, vision, audio"
-  [MODEL.gemini-2.0-flash_END]
-
-  [MODEL.gemini-1.5-pro]
-  provider            = "gemini"
-  context_tokens      = "2000000"
-  max_output_tokens   = "8192"
-  requests_per_min    = "2"
-  requests_per_day    = "50"
-  cost_input_per_1k   = "0.00125"
-  cost_output_per_1k  = "0.00500"
-  capabilities        = "text, code, vision, audio, long-context"
-  [MODEL.gemini-1.5-pro_END]
-
-  [MODEL.mistral-7b-instruct]
-  provider            = "openrouter"
-  context_tokens      = "32000"
-  max_output_tokens   = "4096"
-  requests_per_min    = "60"
-  requests_per_day    = "10000"
-  cost_input_per_1k   = "0.00006"
-  cost_output_per_1k  = "0.00006"
-  capabilities        = "text, code, fast, cheap"
-  [MODEL.mistral-7b-instruct_END]
-
-[MODELS_END]
-
-# =============================================================================
-# TOOLS — Tool definitions + provider mapping
-# Tools are registered in mcp.py only if their provider ENV key exists!
-# =============================================================================
-[TOOLS]
-
-  [TOOL.llm_complete]
-  active              = "true"
-  description         = "Send prompt to any configured LLM provider"
-  provider_type       = "llm"
-  default_provider    = "anthropic"
-  timeout_sec         = "60"
-  [TOOL.llm_complete_END]
-
-  [TOOL.web_search]
-  active              = "true"
-  description         = "Search the web via configured search provider"
-  provider_type       = "search"
-  default_provider    = "brave"
-  timeout_sec         = "30"
-  [TOOL.web_search_END]
-
-  [TOOL.db_query]
-  active              = "true"
-  description         = "Execute SELECT queries on connected database (read-only)"
-  provider_type       = "db"
-  readonly            = "true"
-  timeout_sec         = "10"
-  [TOOL.db_query_END]
-
-  # ── Future tools ──────────────────────────────────────────────────────────
-  # [TOOL.image_gen]
-  # active            = "false"
-  # description       = "Generate images via configured provider"
-  # provider_type     = "image"
-  # default_provider  = ""
-  # timeout_sec       = "120"
-  # [TOOL.image_gen_END]
-
-  # [TOOL.code_exec]
-  # active            = "false"
-  # description       = "Execute sandboxed code snippets"
-  # provider_type     = "sandbox"
-  # timeout_sec       = "30"
-  # [TOOL.code_exec_END]
-
-[TOOLS_END]
-
-# =============================================================================
-# DB_SYNC — Internal SQLite config for app/* IPC
-# This is NOT the cloud DB — that lives in .env → DATABASE_URL
-# =============================================================================
-[DB_SYNC]
-SQLITE_PATH         = "app/.hub_state.db"       # internal state, never commit!
-SYNC_INTERVAL_SEC   = "30"                       # how often to flush to SQLite
-MAX_CACHE_ENTRIES   = "1000"
-[DB_SYNC_END]
-
-# =============================================================================
-# DEBUG — app/* debug behavior (fundaments debug stays in .env)
-# =============================================================================
-[DEBUG]
-DEBUG               = "ON"                       # ON | OFF
-DEBUG_LEVEL         = "FULL"                     # FULL | WARN | ERROR
-LOG_FILE            = "hub_debug.log"
-LOG_REQUESTS        = "true"                     # log every provider request
-LOG_RESPONSES       = "false"                    # careful: may log sensitive data!
-[DEBUG_END]

app/__init__.py

@@ -1 +0,0 @@
-

app/app.py

@@ -1,224 +0,0 @@
-# =============================================================================
-# app/app.py
-# Universal MCP Hub (Sandboxed) - based on PyFundaments Architecture
-# Copyright 2026 - Volkan Kücükbudak
-# Apache License V. 2 + ESOL 1.1
-# Repo: https://github.com/VolkanSah/Universal-MCP-Hub-sandboxed
-# =============================================================================
-# ARCHITECTURE NOTE:
-#   This file is the Orchestrator of the sandboxed app/* layer.
-#   It is ONLY started by main.py (the "Guardian").
-#   All fundament services are injected via the `fundaments` dictionary.
-#   Direct execution is blocked by design.
-#
-# SANDBOX RULES:
-#   - fundaments dict is ONLY unpacked inside start_application()
-#   - fundaments are NEVER stored globally or passed to other app/* modules
-#   - app/* modules read their own config from app/.pyfun
-#   - app/* internal state/IPC uses app/db_sync.py (SQLite) — NOT postgresql.py
-#   - Secrets stay in .env → Guardian reads them → never touched by app/*
-# =============================================================================
-
-from quart import Quart, request, jsonify  # async Flask — ASGI compatible
-import logging
-from hypercorn.asyncio import serve        # ASGI server — async native, replaces waitress
-from hypercorn.config import Config        # hypercorn config
-import threading                           # for future tools that need own threads
-import requests                            # sync HTTP for future tool workers
-import time
-from datetime import datetime
-import asyncio
-from typing import Dict, Any, Optional
-
-# =============================================================================
-# Import app/* modules — MINIMAL BUILD (uncomment when module is ready)
-# Each module reads its own config from app/.pyfun independently.
-# NO fundaments passed into these modules!
-# =============================================================================
-from . import mcp                   # MCP transport layer (SSE via Quart route)
-from . import config as app_config  # app/.pyfun parser — used only in app/*
-# from . import providers    # API provider registry — reads app/.pyfun
-# from . import models       # Model config + token/rate limits — reads app/.pyfun
-# from . import tools        # MCP tool definitions + provider mapping — reads app/.pyfun
-# from . import db_sync      # Internal SQLite IPC — app/* state & communication
-#                            # db_sync ≠ postgresql.py! Cloud DB is Guardian-only.
-
-# Future modules (uncomment when ready):
-# from . import discord_api  # Discord bot integration
-# from . import hf_hooks     # HuggingFace Space hooks
-# from . import git_hooks    # GitHub/GitLab webhook handler
-# from . import web_api      # Generic REST API handler
-
-# =============================================================================
-# Loggers — one per module for clean log filtering
-# =============================================================================
-logger        = logging.getLogger('application')
-logger_mcp    = logging.getLogger('mcp')
-logger_config = logging.getLogger('config')
-# logger_tools     = logging.getLogger('tools')
-# logger_providers = logging.getLogger('providers')
-# logger_models    = logging.getLogger('models')
-# logger_db_sync   = logging.getLogger('db_sync')
-
-# =============================================================================
-# Quart app instance
-# =============================================================================
-app = Quart(__name__)
-START_TIME = datetime.utcnow()
-
-# =============================================================================
-# Quart Routes
-# =============================================================================
-
-@app.route("/", methods=["GET"])
-async def health_check():
-    """
-    Health check endpoint.
-    Used by HuggingFace Spaces and monitoring systems to verify the app is running.
-    """
-    uptime = datetime.utcnow() - START_TIME
-    return jsonify({
-        "status": "running",
-        "service": "Universal MCP Hub",
-        "uptime_seconds": int(uptime.total_seconds()),
-    })
-
-
-@app.route("/api", methods=["POST"])
-async def api_endpoint():
-    """
-    Generic REST API endpoint for direct tool invocation.
-    Accepts JSON: { "tool": "tool_name", "params": { ... } }
-    Auth and validation handled by tools layer.
-    """
-    # TODO: implement tool dispatch via tools.invoke()
-    data = await request.get_json()
-    return jsonify({"status": "not_implemented", "received": data}), 501
-
-
-@app.route("/crypto", methods=["POST"])
-async def crypto_endpoint():
-    """
-    Encrypted API endpoint.
-    Encryption handled by app/* layer — no direct fundaments access here.
-    """
-    # TODO: implement via app/* encryption wrapper
-    data = await request.get_json()
-    return jsonify({"status": "not_implemented"}), 501
-
-
-@app.route("/mcp", methods=["GET", "POST"])
-async def mcp_endpoint():
-    """
-    MCP SSE Transport endpoint — routed through Quart/hypercorn.
-    All MCP traffic passes through here — enables interception, logging,
-    auth checks, rate limiting, payload transformation before reaching MCP.
-    """
-    return await mcp.handle_request(request)
-
-
-# Future routes (uncomment when ready):
-# @app.route("/discord", methods=["POST"])
-# async def discord_interactions():
-#     """Discord interactions endpoint — signature verification via discord_api module."""
-#     pass
-
-# @app.route("/webhook/hf", methods=["POST"])
-# async def hf_webhook():
-#     """HuggingFace Space event hooks."""
-#     pass
-
-# @app.route("/webhook/git", methods=["POST"])
-# async def git_webhook():
-#     """GitHub / GitLab webhook handler."""
-#     pass
-
-
-
-
-
-# =============================================================================
-# Main entry point — called exclusively by Guardian (main.py)
-# =============================================================================
-async def start_application(fundaments: Dict[str, Any]) -> None:
-    """
-    Main entry point for the sandboxed app layer.
-    Called exclusively by main.py after all fundament services are initialized.
-
-    Args:
-        fundaments: Dictionary of initialized services from Guardian (main.py).
-                    Services are unpacked here and NEVER stored globally or
-                    passed into other app/* modules.
-    """
-    logger.info("Application starting...")
-
-    # =========================================================================
-    # Unpack fundaments — ONLY here, NEVER elsewhere in app/*
-    # These are the 6 fundament services from fundaments/*
-    # =========================================================================
-    config_service          = fundaments["config"]          # fundaments/config_handler.py
-    db_service              = fundaments["db"]              # fundaments/postgresql.py — None if not configured
-    encryption_service      = fundaments["encryption"]      # fundaments/encryption.py — None if keys not set
-    access_control_service  = fundaments["access_control"]  # fundaments/access_control.py — None if no DB
-    user_handler_service    = fundaments["user_handler"]    # fundaments/user_handler.py — None if no DB
-    security_service        = fundaments["security"]        # fundaments/security.py — None if deps missing
-
-    # --- Log active fundament services ---
-    if encryption_service:
-        logger.info("Encryption service active.")
-
-    if user_handler_service and security_service:
-        logger.info("Auth services active (user_handler + security).")
-
-    if access_control_service and security_service:
-        logger.info("Access control active.")
-
-    if db_service and not user_handler_service:
-        logger.info("Database-only mode active (e.g. ML pipeline).")
-
-    if not db_service:
-        logger.info("Database-free mode active (e.g. Discord bot, API client).")
-
-    # =========================================================================
-    # Initialize app/* internal services — MINIMAL BUILD
-    # Uncomment each line when the module is ready!
-    # =========================================================================
-    # db_sync.initialize()    # SQLite IPC store for app/* — unrelated to postgresql.py
-    # providers.initialize()  # reads app/.pyfun [LLM_PROVIDERS] [SEARCH_PROVIDERS]
-    # models.initialize()     # reads app/.pyfun [MODELS]
-    # tools.initialize()      # reads app/.pyfun [TOOLS]
-
-    # --- Initialize MCP (registers tools, prepares SSE handler) ---
-    await mcp.initialize()
-
-    # --- Read PORT from app/.pyfun [HUB] ---
-    port = int(app_config.get_hub().get("HUB_PORT", "7860"))
-
-    # --- Configure hypercorn ---
-    config = Config()
-    config.bind = [f"0.0.0.0:{port}"]
-
-    logger.info(f"Starting hypercorn on port {port}...")
-    logger.info("All services running.")
-
-    # --- Run hypercorn — blocks until shutdown ---
-    await serve(app, config)
-
-
-# =============================================================================
-# Direct execution guard
-# =============================================================================
-if __name__ == '__main__':
-    print("WARNING: Running app.py directly. Fundament modules might not be correctly initialized.")
-    print("Please run 'python main.py' instead for proper initialization.")
-
-    test_fundaments = {
-        "config":           None,
-        "db":               None,
-        "encryption":       None,
-        "access_control":   None,
-        "user_handler":     None,
-        "security":         None,
-    }
-
-    asyncio.run(start_application(test_fundaments))

app/config.py

@@ -1,293 +0,0 @@
-# =============================================================================
-# app/config.py
-# .pyfun parser for app/* modules
-# Universal MCP Hub (Sandboxed) - based on PyFundaments Architecture
-# Copyright 2026 - Volkan Kücükbudak
-# Apache License V. 2 + ESOL 1.1
-# =============================================================================
-# USAGE in any app/* module:
-#   from . import config
-#   cfg = config.get()
-#   providers = cfg["LLM_PROVIDERS"]
-# =============================================================================
-# USAGE
-# in providers.py
-# from . import config
-
-# active = config.get_active_llm_providers()
-# → { "anthropic": { "base_url": "...", "env_key": "ANTHROPIC_API_KEY", ... }, ... }
-# =============================================================================
-# in models.py  
-# from . import config
-
-# anthropic_models = config.get_models_for_provider("anthropic")
-# =============================================================================
-# in tools.py
-# from . import config
-
-# active_tools = config.get_active_tools()
-# =============================================================================
-import os
-import logging
-from typing import Dict, Any, Optional
-
-logger = logging.getLogger('app.config')
-
-# Path to .pyfun — lives in app/ next to this file
-PYFUN_PATH = os.path.join(os.path.dirname(__file__), ".pyfun")
-
-# Internal cache — loaded once at first get()
-_cache: Optional[Dict[str, Any]] = None
-
-
-def _parse_value(value: str) -> str:
-    """Strip quotes and inline comments from a value."""
-    value = value.strip()
-    # Remove inline comment
-    if " #" in value:
-        value = value[:value.index(" #")].strip()
-    # Strip surrounding quotes
-    if value.startswith('"') and value.endswith('"'):
-        value = value[1:-1]
-    return value
-
-
-def _parse() -> Dict[str, Any]:
-    """
-    Parses the app/.pyfun file into a nested dictionary.
-
-    Structure:
-        [SECTION]
-            [SUBSECTION]
-                [BLOCK.name]
-                key = "value"
-                [BLOCK.name_END]
-            [SUBSECTION_END]
-        [SECTION_END]
-
-    Returns nested dict:
-        {
-            "HUB": { "HUB_NAME": "...", ... },
-            "LLM_PROVIDERS": {
-                "anthropic": { "active": "true", "base_url": "...", ... },
-                "gemini":    { ... },
-            },
-            "MODELS": {
-                "claude-opus-4-6": { "provider": "anthropic", ... },
-            },
-            ...
-        }
-    """
-    if not os.path.isfile(PYFUN_PATH):
-        logger.critical(f".pyfun not found at: {PYFUN_PATH}")
-        raise FileNotFoundError(f".pyfun not found at: {PYFUN_PATH}")
-
-    result: Dict[str, Any] = {}
-
-    # Parser state
-    section: Optional[str]      = None   # e.g. "HUB", "PROVIDERS"
-    subsection: Optional[str]   = None   # e.g. "LLM_PROVIDERS"
-    block_type: Optional[str]   = None   # e.g. "LLM_PROVIDER", "MODEL", "TOOL"
-    block_name: Optional[str]   = None   # e.g. "anthropic", "claude-opus-4-6"
-
-    with open(PYFUN_PATH, "r", encoding="utf-8") as f:
-        for raw_line in f:
-            line = raw_line.strip()
-
-            # Skip empty lines and full-line comments
-            if not line or line.startswith("#"):
-                continue
-
-            # Skip file identifier
-            if line.startswith("[PYFUN_FILE"):
-                continue
-
-            # --- Block END markers (most specific first) ---
-            if line.endswith("_END]") and "." in line:
-                # e.g. [LLM_PROVIDER.anthropic_END] or [MODEL.claude-opus-4-6_END]
-                block_type = None
-                block_name = None
-                continue
-
-            if line.endswith("_END]") and not "." in line:
-                # e.g. [LLM_PROVIDERS_END], [HUB_END], [MODELS_END]
-                inner = line[1:-1].replace("_END", "")
-                if subsection and inner == subsection:
-                    subsection = None
-                elif section and inner == section:
-                    section = None
-                continue
-
-            # --- Block START markers ---
-            if line.startswith("[") and line.endswith("]"):
-                inner = line[1:-1]
-
-                # Named block: [LLM_PROVIDER.anthropic] or [MODEL.claude-opus-4-6]
-                if "." in inner:
-                    parts = inner.split(".", 1)
-                    block_type = parts[0]   # e.g. LLM_PROVIDER, MODEL, TOOL
-                    block_name = parts[1]   # e.g. anthropic, claude-opus-4-6
-
-                    # Determine which top-level key to store under
-                    if block_type == "LLM_PROVIDER":
-                        result.setdefault("LLM_PROVIDERS", {})
-                        result["LLM_PROVIDERS"].setdefault(block_name, {})
-                    elif block_type == "SEARCH_PROVIDER":
-                        result.setdefault("SEARCH_PROVIDERS", {})
-                        result["SEARCH_PROVIDERS"].setdefault(block_name, {})
-                    elif block_type == "WEB_PROVIDER":
-                        result.setdefault("WEB_PROVIDERS", {})
-                        result["WEB_PROVIDERS"].setdefault(block_name, {})
-                    elif block_type == "MODEL":
-                        result.setdefault("MODELS", {})
-                        result["MODELS"].setdefault(block_name, {})
-                    elif block_type == "TOOL":
-                        result.setdefault("TOOLS", {})
-                        result["TOOLS"].setdefault(block_name, {})
-                    continue
-
-                # Subsection: [LLM_PROVIDERS], [SEARCH_PROVIDERS] etc.
-                if section and not subsection:
-                    subsection = inner
-                    result.setdefault(inner, {})
-                    continue
-
-                # Top-level section: [HUB], [PROVIDERS], [MODELS] etc.
-                section = inner
-                result.setdefault(inner, {})
-                continue
-
-            # --- Key = Value ---
-            if "=" in line:
-                key, _, val = line.partition("=")
-                key = key.strip()
-                val = _parse_value(val)
-
-                # Strip provider prefix from key (e.g. "anthropic.base_url" → "base_url")
-                if block_name and key.startswith(f"{block_name}."):
-                    key = key[len(block_name) + 1:]
-
-                # Store in correct location
-                if block_type and block_name:
-                    if block_type == "LLM_PROVIDER":
-                        result["LLM_PROVIDERS"][block_name][key] = val
-                    elif block_type == "SEARCH_PROVIDER":
-                        result["SEARCH_PROVIDERS"][block_name][key] = val
-                    elif block_type == "WEB_PROVIDER":
-                        result["WEB_PROVIDERS"][block_name][key] = val
-                    elif block_type == "MODEL":
-                        result["MODELS"][block_name][key] = val
-                    elif block_type == "TOOL":
-                        result["TOOLS"][block_name][key] = val
-                elif section:
-                    result[section][key] = val
-
-    logger.info(f".pyfun loaded. Sections: {list(result.keys())}")
-    return result
-
-
-def load() -> Dict[str, Any]:
-    """Force (re)load of .pyfun — clears cache."""
-    global _cache
-    _cache = _parse()
-    return _cache
-
-
-def get() -> Dict[str, Any]:
-    """
-    Returns parsed .pyfun config as nested dict.
-    Loads and caches on first call — subsequent calls return cache.
-    """
-    global _cache
-    if _cache is None:
-        _cache = _parse()
-    return _cache
-
-
-def get_section(section: str) -> Dict[str, Any]:
-    """
-    Returns a specific top-level section.
-    Returns empty dict if section not found.
-    """
-    return get().get(section, {})
-
-
-def get_llm_providers() -> Dict[str, Any]:
-    """Returns all LLM providers (active and inactive)."""
-    return get().get("LLM_PROVIDERS", {})
-
-
-def get_active_llm_providers() -> Dict[str, Any]:
-    """Returns only LLM providers where active = 'true'."""
-    return {
-        name: cfg
-        for name, cfg in get_llm_providers().items()
-        if cfg.get("active", "false").lower() == "true"
-    }
-
-
-def get_search_providers() -> Dict[str, Any]:
-    """Returns all search providers."""
-    return get().get("SEARCH_PROVIDERS", {})
-
-
-def get_active_search_providers() -> Dict[str, Any]:
-    """Returns only search providers where active = 'true'."""
-    return {
-        name: cfg
-        for name, cfg in get_search_providers().items()
-        if cfg.get("active", "false").lower() == "true"
-    }
-
-
-def get_models() -> Dict[str, Any]:
-    """Returns all model definitions."""
-    return get().get("MODELS", {})
-
-
-def get_models_for_provider(provider_name: str) -> Dict[str, Any]:
-    """Returns all models for a specific provider."""
-    return {
-        name: cfg
-        for name, cfg in get_models().items()
-        if cfg.get("provider", "") == provider_name
-    }
-
-
-def get_tools() -> Dict[str, Any]:
-    """Returns all tool definitions."""
-    return get().get("TOOLS", {})
-
-
-def get_active_tools() -> Dict[str, Any]:
-    """Returns only tools where active = 'true'."""
-    return {
-        name: cfg
-        for name, cfg in get_tools().items()
-        if cfg.get("active", "false").lower() == "true"
-    }
-
-
-def get_hub() -> Dict[str, Any]:
-    """Returns [HUB] section."""
-    return get_section("HUB")
-
-
-def get_limits() -> Dict[str, Any]:
-    """Returns [HUB_LIMITS] section."""
-    return get_section("HUB_LIMITS")
-
-
-def get_db_sync() -> Dict[str, Any]:
-    """Returns [DB_SYNC] section."""
-    return get_section("DB_SYNC")
-
-
-def get_debug() -> Dict[str, Any]:
-    """Returns [DEBUG] section."""
-    return get_section("DEBUG")
-
-
-def is_debug() -> bool:
-    """Returns True if DEBUG = 'ON' in .pyfun."""
-    return get_debug().get("DEBUG", "OFF").upper() == "ON"

app/db_sync.py

@@ -1 +0,0 @@
-

app/mcp.py

@@ -1,379 +0,0 @@
-# =============================================================================
-# app/mcp.py
-# Universal MCP Hub (Sandboxed) - based on PyFundaments Architecture
-# Copyright 2026 - Volkan Kücükbudak
-# Apache License V. 2 + ESOL 1.1
-# Repo: https://github.com/VolkanSah/Universal-MCP-Hub-sandboxed
-# =============================================================================
-# ARCHITECTURE NOTE:
-#   This file lives exclusively in app/ and is ONLY started by app/app.py.
-#   NO direct access to fundaments/*, .env, or Guardian (main.py).
-#   All config comes from app/.pyfun via app/config.py.
-#
-#   MCP SSE transport runs through Quart/hypercorn via /mcp route.
-#   All MCP traffic can be intercepted, logged, and transformed in app.py
-#   before reaching the MCP handler — this is by design.
-#
-# TOOL REGISTRATION PRINCIPLE:
-#   Tools are only registered if their required ENV key exists.
-#   No key = no tool = no crash. Server always starts, just with fewer tools.
-#   ENV key NAMES come from app/.pyfun — values are never touched here.
-# =============================================================================
-
-import asyncio
-import logging
-import os
-from typing import Dict, Any
-
-from . import config as app_config  # reads app/.pyfun — only config source for app/*
-# from . import polymarket
-
-logger = logging.getLogger('mcp')
-
-# Global MCP instance — initialized once via initialize()
-_mcp = None
-
-
-async def initialize() -> None:
-    """
-    Initializes the MCP instance and registers all tools.
-    Called once by app/app.py during startup.
-    No fundaments passed in — sandboxed.
-    """
-    global _mcp
-
-    logger.info("MCP Hub initializing...")
-
-    hub_cfg = app_config.get_hub()
-
-    try:
-        from mcp.server.fastmcp import FastMCP
-    except ImportError:
-        logger.critical("FastMCP not installed. Run: pip install mcp")
-        raise
-
-    _mcp = FastMCP(
-        name=hub_cfg.get("HUB_NAME", "Universal MCP Hub"),
-        instructions=(
-            f"{hub_cfg.get('HUB_DESCRIPTION', 'Universal MCP Hub on PyFundaments')} "
-            "Use list_active_tools to see what is currently available."
-        )
-    )
-
-    # --- Register tools ---
-    _register_llm_tools(_mcp)
-    _register_search_tools(_mcp)
-    # _register_db_tools(_mcp)   # uncomment when db_sync is ready
-    _register_system_tools(_mcp)
-    _register_polymarket_tools(_mcp)
-
-    logger.info("MCP Hub initialized.")
-
-
-async def handle_request(request) -> None:
-    """
-    Handles incoming MCP SSE requests routed through Quart /mcp endpoint.
-    This is the interceptor point — add auth, logging, rate limiting here.
-    """
-    if _mcp is None:
-        logger.error("MCP not initialized — call initialize() first.")
-        from quart import jsonify
-        return jsonify({"error": "MCP not initialized"}), 503
-
-    # --- Interceptor hooks (add as needed) ---
-    # logger.debug(f"MCP request: {request.method} {request.path}")
-    # await _check_auth(request)
-    # await _rate_limit(request)
-    # await _log_payload(request)
-
-    # --- Forward to FastMCP SSE handler ---
-    return await _mcp.handle_sse(request)
-
-
-# =============================================================================
-# Tool registration helpers
-# =============================================================================
-
-def _register_llm_tools(mcp) -> None:
-    """Register LLM tools based on active providers in app/.pyfun + ENV key check."""
-    active = app_config.get_active_llm_providers()
-
-    for name, cfg in active.items():
-        env_key = cfg.get("env_key", "")
-        if not env_key or not os.getenv(env_key):
-            logger.info(f"LLM provider '{name}' skipped — ENV key '{env_key}' not set.")
-            continue
-
-        if name == "anthropic":
-            import httpx
-            _key       = os.getenv(env_key)
-            _api_ver   = cfg.get("api_version_header", "2023-06-01")
-            _base_url  = cfg.get("base_url", "https://api.anthropic.com/v1")
-            _def_model = cfg.get("default_model", "claude-haiku-4-5-20251001")
-
-            @mcp.tool()
-            async def anthropic_complete(
-                prompt: str,
-                model: str = _def_model,
-                max_tokens: int = 1024
-            ) -> str:
-                """Send a prompt to Anthropic Claude."""
-                async with httpx.AsyncClient() as client:
-                    r = await client.post(
-                        f"{_base_url}/messages",
-                        headers={
-                            "x-api-key": _key,
-                            "anthropic-version": _api_ver,
-                            "content-type": "application/json"
-                        },
-                        json={
-                            "model": model,
-                            "max_tokens": max_tokens,
-                            "messages": [{"role": "user", "content": prompt}]
-                        },
-                        timeout=60.0
-                    )
-                    r.raise_for_status()
-                    return r.json()["content"][0]["text"]
-
-            logger.info(f"Tool registered: anthropic_complete (model: {_def_model})")
-
-        elif name == "gemini":
-            import httpx
-            _key       = os.getenv(env_key)
-            _base_url  = cfg.get("base_url", "https://generativelanguage.googleapis.com/v1beta")
-            _def_model = cfg.get("default_model", "gemini-2.0-flash")
-
-            @mcp.tool()
-            async def gemini_complete(
-                prompt: str,
-                model: str = _def_model,
-                max_tokens: int = 1024
-            ) -> str:
-                """Send a prompt to Google Gemini."""
-                async with httpx.AsyncClient() as client:
-                    r = await client.post(
-                        f"{_base_url}/models/{model}:generateContent",
-                        params={"key": _key},
-                        json={
-                            "contents": [{"parts": [{"text": prompt}]}],
-                            "generationConfig": {"maxOutputTokens": max_tokens}
-                        },
-                        timeout=60.0
-                    )
-                    r.raise_for_status()
-                    return r.json()["candidates"][0]["content"]["parts"][0]["text"]
-
-            logger.info(f"Tool registered: gemini_complete (model: {_def_model})")
-
-        elif name == "openrouter":
-            import httpx
-            _key       = os.getenv(env_key)
-            _base_url  = cfg.get("base_url", "https://openrouter.ai/api/v1")
-            _def_model = cfg.get("default_model", "mistralai/mistral-7b-instruct")
-            _referer   = os.getenv("APP_URL", "https://huggingface.co")
-
-            @mcp.tool()
-            async def openrouter_complete(
-                prompt: str,
-                model: str = _def_model,
-                max_tokens: int = 1024
-            ) -> str:
-                """Send a prompt via OpenRouter (100+ models)."""
-                async with httpx.AsyncClient() as client:
-                    r = await client.post(
-                        f"{_base_url}/chat/completions",
-                        headers={
-                            "Authorization": f"Bearer {_key}",
-                            "HTTP-Referer": _referer,
-                            "content-type": "application/json"
-                        },
-                        json={
-                            "model": model,
-                            "max_tokens": max_tokens,
-                            "messages": [{"role": "user", "content": prompt}]
-                        },
-                        timeout=60.0
-                    )
-                    r.raise_for_status()
-                    return r.json()["choices"][0]["message"]["content"]
-
-            logger.info(f"Tool registered: openrouter_complete (model: {_def_model})")
-
-        elif name == "huggingface":
-            import httpx
-            _key       = os.getenv(env_key)
-            _base_url  = cfg.get("base_url", "https://api-inference.huggingface.co/models")
-            _def_model = cfg.get("default_model", "mistralai/Mistral-7B-Instruct-v0.3")
-
-            @mcp.tool()
-            async def hf_inference(
-                prompt: str,
-                model: str = _def_model,
-                max_tokens: int = 512
-            ) -> str:
-                """Send a prompt to HuggingFace Inference API."""
-                async with httpx.AsyncClient() as client:
-                    r = await client.post(
-                        f"{_base_url}/{model}/v1/chat/completions",
-                        headers={
-                            "Authorization": f"Bearer {_key}",
-                            "content-type": "application/json"
-                        },
-                        json={
-                            "model": model,
-                            "max_tokens": max_tokens,
-                            "messages": [{"role": "user", "content": prompt}]
-                        },
-                        timeout=120.0
-                    )
-                    r.raise_for_status()
-                    return r.json()["choices"][0]["message"]["content"]
-
-            logger.info(f"Tool registered: hf_inference (model: {_def_model})")
-
-        else:
-            logger.info(f"LLM provider '{name}' has no tool handler yet — skipped.")
-
-
-def _register_search_tools(mcp) -> None:
-    """Register search tools based on active providers in app/.pyfun + ENV key check."""
-    active = app_config.get_active_search_providers()
-
-    for name, cfg in active.items():
-        env_key = cfg.get("env_key", "")
-        if not env_key or not os.getenv(env_key):
-            logger.info(f"Search provider '{name}' skipped — ENV key '{env_key}' not set.")
-            continue
-
-        if name == "brave":
-            import httpx
-            _key         = os.getenv(env_key)
-            _base_url    = cfg.get("base_url", "https://api.search.brave.com/res/v1/web/search")
-            _def_results = int(cfg.get("default_results", "5"))
-            _max_results = int(cfg.get("max_results", "20"))
-
-            @mcp.tool()
-            async def brave_search(query: str, count: int = _def_results) -> str:
-                """Search the web via Brave Search API."""
-                async with httpx.AsyncClient() as client:
-                    r = await client.get(
-                        _base_url,
-                        headers={
-                            "Accept": "application/json",
-                            "X-Subscription-Token": _key
-                        },
-                        params={"q": query, "count": min(count, _max_results)},
-                        timeout=30.0
-                    )
-                    r.raise_for_status()
-                    results = r.json().get("web", {}).get("results", [])
-                    if not results:
-                        return "No results found."
-                    return "\n\n".join([
-                        f"{i}. {res.get('title', '')}\n   {res.get('url', '')}\n   {res.get('description', '')}"
-                        for i, res in enumerate(results, 1)
-                    ])
-
-            logger.info("Tool registered: brave_search")
-
-        elif name == "tavily":
-            import httpx
-            _key         = os.getenv(env_key)
-            _base_url    = cfg.get("base_url", "https://api.tavily.com/search")
-            _def_results = int(cfg.get("default_results", "5"))
-            _incl_answer = cfg.get("include_answer", "true").lower() == "true"
-
-            @mcp.tool()
-            async def tavily_search(query: str, max_results: int = _def_results) -> str:
-                """AI-optimized web search via Tavily."""
-                async with httpx.AsyncClient() as client:
-                    r = await client.post(
-                        _base_url,
-                        json={
-                            "api_key": _key,
-                            "query": query,
-                            "max_results": max_results,
-                            "include_answer": _incl_answer
-                        },
-                        timeout=30.0
-                    )
-                    r.raise_for_status()
-                    data = r.json()
-                    parts = []
-                    if data.get("answer"):
-                        parts.append(f"Summary: {data['answer']}")
-                    for res in data.get("results", []):
-                        parts.append(
-                            f"- {res['title']}\n  {res['url']}\n  {res.get('content', '')[:200]}..."
-                        )
-                    return "\n\n".join(parts)
-
-            logger.info("Tool registered: tavily_search")
-
-        else:
-            logger.info(f"Search provider '{name}' has no tool handler yet — skipped.")
-
-
-def _register_system_tools(mcp) -> None:
-    """System tools — always registered, no ENV key required."""
-
-    @mcp.tool()
-    def list_active_tools() -> Dict[str, Any]:
-        """Show active providers and configured integrations (key names only, never values)."""
-        llm    = app_config.get_active_llm_providers()
-        search = app_config.get_active_search_providers()
-        hub    = app_config.get_hub()
-        return {
-            "hub":                    hub.get("HUB_NAME", "Universal MCP Hub"),
-            "version":                hub.get("HUB_VERSION", ""),
-            "active_llm_providers":   [n for n, c in llm.items()    if os.getenv(c.get("env_key", ""))],
-            "active_search_providers":[n for n, c in search.items() if os.getenv(c.get("env_key", ""))],
-        }
-    logger.info("Tool registered: list_active_tools")
-
-    @mcp.tool()
-    def health_check() -> Dict[str, str]:
-        """Health check for monitoring and HuggingFace Spaces."""
-        return {"status": "ok", "service": "Universal MCP Hub"}
-    logger.info("Tool registered: health_check")
-
-
-
-# 3. Neue Funktion — analog zu _register_search_tools():
-def _register_polymarket_tools(mcp) -> None:
-    """Polymarket tools — no ENV key needed, Gamma API is public."""
-
-    @mcp.tool()
-    async def get_markets(category: str = None, limit: int = 20) -> list:
-        """Get active prediction markets, optional category filter."""
-        return await polymarket.get_markets(category=category, limit=limit)
-
-    @mcp.tool()
-    async def trending_markets(limit: int = 10) -> list:
-        """Get top trending markets by trading volume."""
-        return await polymarket.trending_markets(limit=limit)
-
-    @mcp.tool()
-    async def analyze_market(market_id: str) -> dict:
-        """LLM analysis of a single market. Fallback if no LLM key set."""
-        return await polymarket.analyze_market(market_id)
-
-    @mcp.tool()
-    async def summary_report(category: str = None) -> dict:
-        """Summary report for a category or all markets."""
-        return await polymarket.summary_report(category=category)
-
-    @mcp.tool()
-    async def polymarket_cache_info() -> dict:
-        """Cache status, available categories, LLM availability."""
-        return await polymarket.get_cache_info()
-
-    logger.info("Tools registered: polymarket (5 tools)")
-
-
-# =============================================================================
-# Direct execution guard
-# =============================================================================
-if __name__ == '__main__':
-    print("WARNING: Run via main.py, not directly.")

app/models.py

@@ -1 +0,0 @@
-

app/polymarket.py

@@ -1,611 +0,0 @@
-# =============================================================================
-# app/polymarket.py
-# Polymarket Analysis Tool — Single File Module
-# Part of: Universal MCP Hub (Sandboxed) - based on PyFundaments Architecture
-# Copyright 2026 - Volkan Kücükbudak
-# Apache License V. 2 + ESOL 1.1
-# Repo: https://github.com/VolkanSah/Universal-MCP-Hub-sandboxed
-# =============================================================================
-# ARCHITECTURE NOTE:
-#   This file lives exclusively in app/ and is ONLY registered by app/mcp.py.
-#   NO direct access to fundaments/*, .env, or Guardian (main.py).
-#   All config comes from app/.pyfun via app/config.py.
-#
-# LAZY INIT PRINCIPLE:
-#   initialize() is called on first tool use — NOT during startup.
-#   This keeps startup fast and avoids crashes if Gamma API is unreachable.
-#
-# SANDBOX RULES:
-#   - SQLite cache is app/* internal state — NOT postgresql.py (Guardian-only)
-#   - LLM calls are optional — gracefully skipped if no provider key is set
-#   - No global state leaks outside this file
-#   - Read-Only access to Polymarket — no transactions, no auth needed
-# =============================================================================
-
-import asyncio
-import aiosqlite
-import aiohttp
-import logging
-import json
-import os
-from datetime import datetime, timezone
-from typing import Optional
-
-logger = logging.getLogger("polymarket")
-
-# =============================================================================
-# Constants
-# =============================================================================
-
-GAMMA_API       = "https://gamma-api.polymarket.com"
-CACHE_DB        = "SQLITE_PATH"
-FETCH_INTERVAL  = 300       # seconds — 5 min between API pulls
-MARKET_LIMIT    = 100       # max markets per fetch (rate limit friendly)
-PRICE_DECIMALS  = 2         # rounding for probability display
-
-# Gamma API uses its own tag/category system.
-# We map their tags to our simplified categories for filtering.
-CATEGORY_MAP = {
-    "politics":   ["politics", "elections", "government", "trump", "us-politics"],
-    "crypto":     ["crypto", "bitcoin", "ethereum", "defi", "web3"],
-    "economics":  ["economics", "inflation", "fed", "interest-rates", "finance"],
-    "energy":     ["energy", "oil", "gas", "renewables", "climate"],
-    "tech":       ["technology", "ai", "spacex", "elon-musk", "science"],
-    "sports":     ["sports", "football", "soccer", "nba", "nfl", "esports"],
-    "world":      ["world", "geopolitics", "war", "nato", "china", "russia"],
-}
-
-# =============================================================================
-# Internal State — lazy init guard
-# =============================================================================
-
-_initialized    = False
-_scheduler_task = None   # asyncio background task handle
-
-# =============================================================================
-# SECTION 1 — Init (Lazy)
-# =============================================================================
-
-async def initialize() -> None:
-    """
-    Lazy initializer — called on first tool use.
-    Sets up SQLite cache and starts background scheduler.
-    Idempotent — safe to call multiple times.
-    """
-    global _initialized, _scheduler_task
-
-    if _initialized:
-        return
-
-    logger.info("Polymarket module initializing (lazy)...")
-
-    await _init_cache()
-
-    # Start background scheduler as asyncio task
-    if _scheduler_task is None or _scheduler_task.done():
-        _scheduler_task = asyncio.create_task(_scheduler_loop())
-        logger.info(f"Scheduler started — fetching every {FETCH_INTERVAL}s.")
-
-    _initialized = True
-    logger.info("Polymarket module ready.")
-
-
-# =============================================================================
-# SECTION 2 — SQLite Cache (app/* internal, NOT postgresql.py!)
-# =============================================================================
-
-async def _init_cache() -> None:
-    """Create SQLite tables if they don't exist."""
-    async with aiosqlite.connect(CACHE_DB) as db:
-        await db.execute("""
-            CREATE TABLE IF NOT EXISTS markets (
-                id          TEXT PRIMARY KEY,
-                slug        TEXT,
-                question    TEXT,
-                category    TEXT,
-                probability REAL,
-                volume      REAL,
-                liquidity   REAL,
-                end_date    TEXT,
-                active      INTEGER,
-                data        TEXT,
-                fetched_at  TEXT
-            )
-        """)
-        await db.execute("""
-            CREATE INDEX IF NOT EXISTS idx_category ON markets(category);
-        """)
-        await db.execute("""
-            CREATE INDEX IF NOT EXISTS idx_active ON markets(active);
-        """)
-        await db.commit()
-    logger.info("Cache initialized.")
-
-
-async def _store_markets(markets: list) -> None:
-    """Upsert markets into SQLite cache."""
-    if not markets:
-        return
-
-    now = datetime.now(timezone.utc).isoformat()
-
-    async with aiosqlite.connect(CACHE_DB) as db:
-        for m in markets:
-            category = _categorize_market(m)
-            prob     = _extract_probability(m)
-
-            await db.execute("""
-                INSERT OR REPLACE INTO markets
-                    (id, slug, question, category, probability, volume, liquidity, end_date, active, data, fetched_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            """, (
-                str(m.get("id", "")),
-                m.get("slug", ""),
-                m.get("question", ""),
-                category,
-                prob,
-                float(m.get("volume", 0) or 0),
-                float(m.get("liquidity", 0) or 0),
-                m.get("endDate", ""),
-                1 if m.get("active", False) else 0,
-                json.dumps(m),
-                now,
-            ))
-        await db.commit()
-
-    logger.info(f"Cached {len(markets)} markets.")
-
-
-async def _get_cached_markets(
-    category: Optional[str] = None,
-    active_only: bool = True,
-    limit: int = 50
-) -> list:
-    """Retrieve markets from SQLite cache with optional filters."""
-    async with aiosqlite.connect(CACHE_DB) as db:
-        db.row_factory = aiosqlite.Row
-
-        conditions = []
-        params     = []
-
-        if active_only:
-            conditions.append("active = 1")
-
-        if category and category.lower() in CATEGORY_MAP:
-            conditions.append("category = ?")
-            params.append(category.lower())
-
-        where = f"WHERE {' AND '.join(conditions)}" if conditions else ""
-
-        params.append(limit)
-        cursor = await db.execute(
-            f"SELECT * FROM markets {where} ORDER BY volume DESC LIMIT ?",
-            params
-        )
-        rows = await cursor.fetchall()
-        return [dict(r) for r in rows]
-
-
-async def _get_market_by_id(market_id: str) -> Optional[dict]:
-    """Retrieve a single market by ID from cache."""
-    async with aiosqlite.connect(CACHE_DB) as db:
-        db.row_factory = aiosqlite.Row
-        cursor = await db.execute(
-            "SELECT * FROM markets WHERE id = ?", (market_id,)
-        )
-        row = await cursor.fetchone()
-        return dict(row) if row else None
-
-
-async def _get_cache_stats() -> dict:
-    """Return basic cache statistics."""
-    async with aiosqlite.connect(CACHE_DB) as db:
-        cursor = await db.execute("SELECT COUNT(*) FROM markets WHERE active = 1")
-        active = (await cursor.fetchone())[0]
-        cursor = await db.execute("SELECT MAX(fetched_at) FROM markets")
-        last   = (await cursor.fetchone())[0]
-    return {"active_markets": active, "last_fetch": last}
-
-
-# =============================================================================
-# SECTION 3 — Fetcher (Gamma API — Read Only, no auth)
-# =============================================================================
-
-async def _fetch_from_api(limit: int = MARKET_LIMIT) -> list:
-    """
-    Fetch active markets from Polymarket Gamma API.
-    Read-Only — no auth, no transactions.
-    """
-    params = {
-        "active":   "true",
-        "archived": "false",
-        "closed":   "false",
-        "limit":    limit,
-        "order":    "volume",
-        "ascending":"false",
-    }
-
-    async with aiohttp.ClientSession() as session:
-        async with session.get(
-            f"{GAMMA_API}/markets",
-            params=params,
-            timeout=aiohttp.ClientTimeout(total=30)
-        ) as resp:
-            resp.raise_for_status()
-            data = await resp.json()
-            logger.info(f"Fetched {len(data)} markets from Gamma API.")
-            return data
-
-
-async def _scheduler_loop() -> None:
-    """
-    Background task — polls Gamma API every FETCH_INTERVAL seconds.
-    Runs indefinitely inside asyncio event loop.
-    """
-    logger.info("Scheduler loop started.")
-
-    while True:
-        try:
-            markets = await _fetch_from_api()
-            await _store_markets(markets)
-        except aiohttp.ClientError as e:
-            logger.warning(f"Gamma API fetch failed (network): {e}")
-        except Exception as e:
-            logger.error(f"Scheduler error: {e}")
-
-        await asyncio.sleep(FETCH_INTERVAL)
-
-
-# =============================================================================
-# SECTION 4 — Filter & Categorization
-# =============================================================================
-
-def _categorize_market(market: dict) -> str:
-    """
-    Map a Polymarket market to our simplified category system.
-    Uses tags array from Gamma API response.
-    Falls back to 'other' if no match found.
-    """
-    tags = []
-
-    # Gamma API returns tags as list of dicts or strings
-    for t in market.get("tags", []):
-        if isinstance(t, dict):
-            tags.append(t.get("slug", "").lower())
-            tags.append(t.get("label", "").lower())
-        elif isinstance(t, str):
-            tags.append(t.lower())
-
-    # Also check question text for keywords
-    question = market.get("question", "").lower()
-
-    for category, keywords in CATEGORY_MAP.items():
-        for kw in keywords:
-            if kw in tags or kw in question:
-                return category
-
-    return "other"
-
-
-def _extract_probability(market: dict) -> float:
-    """
-    Extract YES probability from market data.
-    Polymarket stores outcome prices as probability (0.0 - 1.0).
-    Returns probability as percentage (0-100).
-    """
-    try:
-        # outcomePrices is a JSON string like '["0.73", "0.27"]'
-        prices = market.get("outcomePrices")
-        if isinstance(prices, str):
-            prices = json.loads(prices)
-        if prices and len(prices) > 0:
-            return round(float(prices[0]) * 100, PRICE_DECIMALS)
-    except (ValueError, TypeError, json.JSONDecodeError):
-        pass
-    return 0.0
-
-
-def _format_market_simple(market: dict) -> dict:
-    """
-    Format a market for human-readable output.
-    Used by all public tools for consistent output.
-    """
-    prob = market.get("probability", 0.0)
-
-    # Simple plain-language probability label
-    if prob >= 80:
-        sentiment = "sehr wahrscheinlich"
-    elif prob >= 60:
-        sentiment = "wahrscheinlich"
-    elif prob >= 40:
-        sentiment = "ungewiss"
-    elif prob >= 20:
-        sentiment = "unwahrscheinlich"
-    else:
-        sentiment = "sehr unwahrscheinlich"
-
-    return {
-        "id":          market.get("id"),
-        "question":    market.get("question"),
-        "category":    market.get("category"),
-        "probability": f"{prob}%",
-        "sentiment":   sentiment,
-        "volume_usd":  f"${market.get('volume', 0):,.0f}",
-        "liquidity":   f"${market.get('liquidity', 0):,.0f}",
-        "end_date":    market.get("end_date", ""),
-        "slug":        market.get("slug", ""),
-        "url":         f"https://polymarket.com/event/{market.get('slug', '')}",
-    }
-
-
-# =============================================================================
-# SECTION 5 — LLM Adapter (Optional — graceful fallback if no key)
-# =============================================================================
-
-async def _llm_analyze(prompt: str) -> Optional[str]:
-    """
-    Send prompt to available LLM provider.
-    Checks for API keys in order: Anthropic → OpenRouter → HuggingFace.
-    Returns None if no provider is available — caller handles fallback.
-    """
-    # --- Anthropic Claude ---
-    anthropic_key = os.getenv("ANTHROPIC_API_KEY")
-    if anthropic_key:
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.post(
-                    "https://api.anthropic.com/v1/messages",
-                    headers={
-                        "x-api-key":           anthropic_key,
-                        "anthropic-version":   "2023-06-01",
-                        "content-type":        "application/json",
-                    },
-                    json={
-                        "model":      "claude-haiku-4-5-20251001",
-                        "max_tokens": 512,
-                        "messages":   [{"role": "user", "content": prompt}],
-                    },
-                    timeout=aiohttp.ClientTimeout(total=30)
-                ) as resp:
-                    resp.raise_for_status()
-                    data = await resp.json()
-                    return data["content"][0]["text"]
-        except Exception as e:
-            logger.warning(f"Anthropic LLM call failed: {e}")
-
-    # --- OpenRouter fallback ---
-    openrouter_key = os.getenv("OPENROUTER_API_KEY")
-    if openrouter_key:
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.post(
-                    "https://openrouter.ai/api/v1/chat/completions",
-                    headers={
-                        "Authorization": f"Bearer {openrouter_key}",
-                        "content-type":  "application/json",
-                    },
-                    json={
-                        "model":      "mistralai/mistral-7b-instruct",
-                        "max_tokens": 512,
-                        "messages":   [{"role": "user", "content": prompt}],
-                    },
-                    timeout=aiohttp.ClientTimeout(total=30)
-                ) as resp:
-                    resp.raise_for_status()
-                    data = await resp.json()
-                    return data["choices"][0]["message"]["content"]
-        except Exception as e:
-            logger.warning(f"OpenRouter LLM call failed: {e}")
-
-    # --- HuggingFace fallback ---
-    hf_key = os.getenv("HF_API_KEY")
-    if hf_key:
-        try:
-            model = "mistralai/Mistral-7B-Instruct-v0.3"
-            async with aiohttp.ClientSession() as session:
-                async with session.post(
-                    f"https://api-inference.huggingface.co/models/{model}/v1/chat/completions",
-                    headers={
-                        "Authorization": f"Bearer {hf_key}",
-                        "content-type":  "application/json",
-                    },
-                    json={
-                        "model":      model,
-                        "max_tokens": 512,
-                        "messages":   [{"role": "user", "content": prompt}],
-                    },
-                    timeout=aiohttp.ClientTimeout(total=60)
-                ) as resp:
-                    resp.raise_for_status()
-                    data = await resp.json()
-                    return data["choices"][0]["message"]["content"]
-        except Exception as e:
-            logger.warning(f"HuggingFace LLM call failed: {e}")
-
-    logger.info("No LLM provider available — returning None.")
-    return None
-
-
-# =============================================================================
-# SECTION 6 — Public Tools (registered by mcp.py)
-# =============================================================================
-
-async def get_markets(
-    category: Optional[str] = None,
-    limit: int = 20
-) -> list:
-    """
-    MCP Tool: Get active prediction markets from cache.
-
-    Args:
-        category: Filter by category. Options: politics, crypto, economics,
-                  energy, tech, sports, world, other. None = all categories.
-        limit:    Max number of markets to return (default 20, max 100).
-
-    Returns:
-        List of formatted market dicts with human-readable probability.
-    """
-    await initialize()
-
-    limit   = min(limit, 100)
-    markets = await _get_cached_markets(category=category, limit=limit)
-
-    if not markets:
-        return [{"info": "No markets in cache yet. Try again in 30 seconds."}]
-
-    return [_format_market_simple(m) for m in markets]
-
-
-async def trending_markets(limit: int = 10) -> list:
-    """
-    MCP Tool: Get top trending markets by trading volume.
-
-    Args:
-        limit: Number of trending markets to return (default 10).
-
-    Returns:
-        List of top markets sorted by volume descending.
-    """
-    await initialize()
-
-    markets = await _get_cached_markets(active_only=True, limit=limit)
-
-    if not markets:
-        return [{"info": "No markets in cache yet. Try again in 30 seconds."}]
-
-    return [_format_market_simple(m) for m in markets]
-
-
-async def analyze_market(market_id: str) -> dict:
-    """
-    MCP Tool: Get LLM analysis of a single prediction market.
-    Falls back to structured data summary if no LLM key is configured.
-
-    Args:
-        market_id: Polymarket market ID from get_markets() results.
-
-    Returns:
-        Dict with market data + LLM analysis (or structured fallback).
-    """
-    await initialize()
-
-    market = await _get_market_by_id(market_id)
-
-    if not market:
-        return {"error": f"Market '{market_id}' not found in cache."}
-
-    formatted = _format_market_simple(market)
-
-    # Build LLM prompt
-    prompt = (
-        f"Analysiere diesen Prediction Market kurz und präzise:\n\n"
-        f"Frage: {market.get('question')}\n"
-        f"Wahrscheinlichkeit YES: {formatted['probability']}\n"
-        f"Handelsvolumen: {formatted['volume_usd']}\n"
-        f"Kategorie: {market.get('category')}\n"
-        f"Läuft bis: {market.get('end_date', 'unbekannt')}\n\n"
-        f"Erkläre in 2-3 Sätzen was der Markt aussagt und was das für "
-        f"Alltagsentscheidungen bedeuten könnte. Keine Finanzberatung."
-    )
-
-    analysis = await _llm_analyze(prompt)
-
-    if analysis:
-        formatted["analysis"] = analysis
-    else:
-        # Structured fallback — no LLM needed
-        prob = market.get("probability", 0)
-        formatted["analysis"] = (
-            f"Der Markt bewertet '{market.get('question')}' mit "
-            f"{prob}% Wahrscheinlichkeit. "
-            f"Für eine KI-Analyse bitte LLM Provider API Key konfigurieren."
-        )
-
-    return formatted
-
-
-async def summary_report(category: Optional[str] = None) -> dict:
-    """
-    MCP Tool: Generate a summary report for a category or all markets.
-    Uses LLM if available, falls back to structured statistics.
-
-    Args:
-        category: Category to summarize. None = all active markets.
-
-    Returns:
-        Dict with statistics and optional LLM narrative summary.
-    """
-    await initialize()
-
-    markets = await _get_cached_markets(category=category, limit=50)
-
-    if not markets:
-        return {"error": "No markets in cache yet. Try again in 30 seconds."}
-
-    # --- Build statistics (always available, no LLM needed) ---
-    probs      = [m["probability"] for m in markets if m.get("probability")]
-    avg_prob   = round(sum(probs) / len(probs), 1) if probs else 0
-    total_vol  = sum(m.get("volume", 0) for m in markets)
-
-    # Top 3 by volume
-    top3 = [_format_market_simple(m) for m in markets[:3]]
-
-    stats = {
-        "category":       category or "all",
-        "market_count":   len(markets),
-        "avg_probability":f"{avg_prob}%",
-        "total_volume":   f"${total_vol:,.0f}",
-        "top_markets":    top3,
-        "generated_at":   datetime.now(timezone.utc).isoformat(),
-    }
-
-    # --- LLM narrative (optional) ---
-    market_list = "\n".join([
-        f"- {m.get('question')} ({m.get('probability', 0)}% YES, Vol: ${m.get('volume', 0):,.0f})"
-        for m in markets[:10]
-    ])
-
-    prompt = (
-        f"Erstelle eine kurze Zusammenfassung (3-4 Sätze) der aktuellen "
-        f"Prediction Market Lage{' für ' + category if category else ''}:\n\n"
-        f"{market_list}\n\n"
-        f"Was sind die auffälligsten Trends? Sachlich, keine Finanzberatung."
-    )
-
-    narrative = await _llm_analyze(prompt)
-    if narrative:
-        stats["narrative"] = narrative
-
-    return stats
-
-
-async def get_cache_info() -> dict:
-    """
-    MCP Tool: Get cache status and available categories.
-    Useful for debugging and monitoring.
-
-    Returns:
-        Dict with cache stats and available category list.
-    """
-    await initialize()
-
-    cache_stats = await _get_cache_stats()
-
-    return {
-        **cache_stats,
-        "fetch_interval_seconds": FETCH_INTERVAL,
-        "available_categories":   list(CATEGORY_MAP.keys()) + ["other"],
-        "gamma_api":              GAMMA_API,
-        "llm_available":          any([
-            os.getenv("ANTHROPIC_API_KEY"),
-            os.getenv("OPENROUTER_API_KEY"),
-            os.getenv("HF_API_KEY"),
-        ]),
-    }
-
-
-# =============================================================================
-# Direct execution guard
-# =============================================================================
-if __name__ == "__main__":
-    print("WARNING: Run via main.py → app.py → mcp.py, not directly.")

app/provider.py

@@ -1 +0,0 @@
-

app/tools.py

@@ -1 +0,0 @@
-