golf-mcp 0.2.10__py3-none-any.whl → 0.2.12__py3-none-any.whl

golf/__init__.py

@@ -1,9 +1 @@
-__version__ = "0.2.10"
-
-# Import endpoints with fallback for dev mode
-try:
-    # In built wheels, this exists (generated from _endpoints.py.in)
-    from . import _endpoints
-except ImportError:
-    # In editable/dev installs, fall back to env-based values
-    from . import _endpoints_fallback as _endpoints
+__version__ = "0.2.12"

golf/auth/__init__.py

@@ -32,11 +32,9 @@ from .registry import (
 # Re-export for backward compatibility
 from .api_key import configure_api_key, get_api_key_config, is_api_key_configured
 from .helpers import (
-    debug_api_key_context,
     extract_token_from_header,
     get_api_key,
     get_auth_token,
-    get_provider_token,
     set_api_key,
 )
 
@@ -70,11 +68,9 @@ __all__ = [
     "get_api_key_config",
     "is_api_key_configured",
     # Helper functions
-    "debug_api_key_context",
     "extract_token_from_header",
     "get_api_key",
     "get_auth_token",
-    "get_provider_token",
     "set_api_key",
 ]
 

golf/auth/helpers.py

@@ -1,26 +1,12 @@
 """Helper functions for working with authentication in MCP context."""
 
 from contextvars import ContextVar
-from typing import Any
 
-from starlette.requests import Request
 
 # Context variable to store the current request's API key
 _current_api_key: ContextVar[str | None] = ContextVar("current_api_key", default=None)
 
 
-def get_provider_token() -> str | None:
-    """
-    Get a provider token (legacy function - no longer supported in Golf 0.2.x).
-
-    In Golf 0.2.x, use FastMCP's built-in auth providers for OAuth flows.
-    This function returns None and is kept for backwards compatibility.
-    """
-    # Legacy OAuth provider support removed in Golf 0.2.x
-    # Use FastMCP 2.11+ auth providers instead
-    return None
-
-
 def extract_token_from_header(auth_header: str) -> str | None:
     """Extract bearer token from Authorization header.
 
@@ -123,25 +109,6 @@ def get_api_key() -> str | None:
     return None
 
 
-def get_api_key_from_request(request: Request) -> str | None:
-    """Get the API key from a specific request object.
-
-    This is useful when you have direct access to the request object.
-
-    Args:
-        request: The Starlette Request object
-
-    Returns:
-        The API key if available, None otherwise
-    """
-    # Check request state first (set by our middleware)
-    if hasattr(request, "state") and hasattr(request.state, "api_key"):
-        return request.state.api_key
-
-    # Fall back to context variable
-    return _current_api_key.get()
-
-
 def get_auth_token() -> str | None:
     """Get the authorization token from the current request context.
 
@@ -206,52 +173,3 @@ def get_auth_token() -> str | None:
         pass
 
     return None
-
-
-def debug_api_key_context() -> dict[str, Any]:
-    """Debug function to inspect API key context.
-
-    Returns a dictionary with debugging information about the current
-    API key context. Useful for troubleshooting authentication issues.
-
-    Returns:
-        Dictionary with debug information
-    """
-    import asyncio
-    import os
-    import sys
-
-    debug_info = {
-        "context_var_value": _current_api_key.get(),
-        "has_async_task": False,
-        "task_id": None,
-        "main_module_has_storage": False,
-        "main_module_has_context": False,
-        "request_id_from_context": None,
-        "env_vars": {
-            "API_KEY": bool(os.environ.get("API_KEY")),
-            "GOLF_API_KEY_DEBUG": os.environ.get("GOLF_API_KEY_DEBUG", "false"),
-        },
-    }
-
-    try:
-        task = asyncio.current_task()
-        if task:
-            debug_info["has_async_task"] = True
-            debug_info["task_id"] = id(task)
-    except Exception:
-        pass
-
-    try:
-        main_module = sys.modules.get("__main__")
-        if main_module:
-            debug_info["main_module_has_storage"] = hasattr(main_module, "api_key_storage")
-            debug_info["main_module_has_context"] = hasattr(main_module, "request_id_context")
-
-            if hasattr(main_module, "request_id_context"):
-                request_id_context = main_module.request_id_context
-                debug_info["request_id_from_context"] = request_id_context.get()
-    except Exception:
-        pass
-
-    return debug_info

golf/cli/branding.py

@@ -33,7 +33,6 @@ STATUS_ICONS = {
     "building": "🔨",
     "generating": "⚙️",
     "packaging": "📦",
-    "platform": "⛳",
     "server": "🚀",
     "loading": "⭕",
 }
@@ -163,7 +162,7 @@ def get_status_text(status: str, message: str, style: str = "") -> Text:
     elif status == "warning":
         text.append("⚡ ", style=f"bold {GOLF_ORANGE}")
         text.append(f"{icon} {message}", style=f"bold {GOLF_ORANGE}")
-    elif status in ["building", "generating", "packaging", "platform"]:
+    elif status in ["building", "generating", "packaging"]:
         text.append("🔥 ", style=f"bold {GOLF_ORANGE}")
         text.append(f"{icon} {message}", style=f"bold {GOLF_BLUE}")
     else:

golf/cli/main.py

@@ -167,11 +167,9 @@ def build_prod(
 ) -> None:
     """Build a production version for deployment.
 
-    Golf credentials (GOLF_*) are always loaded from .env for build operations
-    (platform registration, resource updates). App environment variables are
-    NOT copied for security - provide them in your deployment environment.
-
-    Your production deployment must include GOLF_* vars for runtime telemetry.
+    Environment variables from .env are loaded for build operations.
+    App environment variables are NOT copied for security - provide them
+    in your deployment environment.
     """
     # Find project root directory
     project_root, config_path = find_project_root()

golf/commands/run.py

@@ -5,7 +5,7 @@ import subprocess
 import sys
 from pathlib import Path
 
-from rich.console import Console
+from rich.console import Console, Group
 from rich.panel import Panel
 from rich.align import Align
 from rich.text import Text
@@ -53,23 +53,35 @@ def run_server(
     server_host = host or settings.host or "localhost"
     server_port = port or settings.port or 3000
 
-    server_content = Text()
-    server_content.append("🚀 ", style=f"bold {GOLF_ORANGE}")
-    server_content.append(f"{STATUS_ICONS['server']} Server starting on ", style=f"bold {GOLF_BLUE}")
-    server_content.append(f"http://{server_host}:{server_port}", style=f"bold {GOLF_GREEN}")
-    server_content.append(" 🚀", style=f"bold {GOLF_ORANGE}")
-    server_content.append("\n")
+    # Create server URL line
+    server_line = Text()
+    server_line.append("🚀 ", style=f"bold {GOLF_ORANGE}")
+    server_line.append(f"{STATUS_ICONS['server']} Server starting on ", style=f"bold {GOLF_BLUE}")
+    server_line.append(f"http://{server_host}:{server_port}", style=f"bold {GOLF_GREEN}")
+
+    # Create content with proper alignment
+    content_lines = [
+        "",  # Empty line at top
+        Align.center(server_line),
+    ]
 
     # Add telemetry status indicator
     if settings.opentelemetry_enabled:
-        server_content.append("📊 Golf telemetry enabled", style=f"dim {GOLF_BLUE}")
-        server_content.append("\n")
-
-    server_content.append("⚡ Press Ctrl+C to stop ⚡", style=f"dim {GOLF_ORANGE}")
+        telemetry_line = Text("📊 OpenTelemetry enabled", style=f"dim {GOLF_BLUE}")
+        content_lines.append(Align.center(telemetry_line))
+
+    # Add empty line and stop instruction
+    content_lines.extend(
+        [
+            "",  # Empty line before stop instruction
+            Align.center(Text("⚡ Press Ctrl+C to stop ⚡", style=f"dim {GOLF_ORANGE}")),
+            "",  # Empty line at bottom
+        ]
+    )
 
     console.print(
         Panel(
-            Align.center(server_content),
+            Group(*content_lines),
             border_style=GOLF_BLUE,
             padding=(1, 2),
             title="[bold]🌐 SERVER READY 🌐[/bold]",

golf/core/builder.py

@@ -16,7 +16,7 @@ from golf.core.builder_auth import generate_auth_code, generate_auth_routes
 from golf.core.builder_telemetry import (
     generate_telemetry_imports,
 )
-from golf.cli.branding import create_build_header, get_status_text, STATUS_ICONS, GOLF_BLUE
+from golf.cli.branding import create_build_header, get_status_text
 from golf.core.config import Settings
 from golf.core.parser import (
     ComponentType,
@@ -645,6 +645,137 @@ class CodeGenerator:
             "",
         ]
 
+    def _generate_readiness_section(self, project_path: Path) -> list[str]:
+        """Generate code section for readiness.py execution during server runtime."""
+        readiness_path = project_path / "readiness.py"
+
+        if not readiness_path.exists():
+            # Only generate default readiness if health checks are explicitly enabled
+            if not self.settings.health_check_enabled:
+                return []
+            return [
+                "# Default readiness check - no custom readiness.py found",
+                "@mcp.custom_route('/ready', methods=[\"GET\"])",
+                "async def readiness_check(request: Request) -> JSONResponse:",
+                '    """Readiness check endpoint for Kubernetes and load balancers."""',
+                '    return JSONResponse({"status": "pass"}, status_code=200)',
+                "",
+            ]
+
+        return [
+            "# Custom readiness check from readiness.py",
+            "from readiness import check as readiness_check_func",
+            "@mcp.custom_route('/ready', methods=[\"GET\"])",
+            "async def readiness_check(request: Request):",
+            '    """Readiness check endpoint for Kubernetes and load balancers."""',
+            "    result = readiness_check_func()",
+            "    if isinstance(result, dict):",
+            "        return JSONResponse(result)",
+            "    return result",
+            "",
+        ]
+
+    def _generate_health_section(self, project_path: Path) -> list[str]:
+        """Generate code section for health.py execution during server runtime."""
+        health_path = project_path / "health.py"
+
+        if not health_path.exists():
+            # Check if legacy health configuration is used
+            if self.settings.health_check_enabled:
+                return [
+                    "# Legacy health check configuration (deprecated)",
+                    "@mcp.custom_route('" + self.settings.health_check_path + '\', methods=["GET"])',
+                    "async def health_check(request: Request) -> PlainTextResponse:",
+                    '    """Health check endpoint for Kubernetes and load balancers."""',
+                    f'    return PlainTextResponse("{self.settings.health_check_response}")',
+                    "",
+                ]
+            else:
+                # If health checks are disabled, return empty (no default health check)
+                return []
+
+        return [
+            "# Custom health check from health.py",
+            "from health import check as health_check_func",
+            "@mcp.custom_route('/health', methods=[\"GET\"])",
+            "async def health_check(request: Request):",
+            '    """Health check endpoint for Kubernetes and load balancers."""',
+            "    result = health_check_func()",
+            "    if isinstance(result, dict):",
+            "        return JSONResponse(result)",
+            "    return result",
+            "",
+        ]
+
+    def _generate_check_function_helper(self) -> list[str]:
+        """Generate helper function to call custom check functions."""
+        return [
+            "# Helper function to call custom check functions",
+            "async def _call_check_function(check_type: str) -> JSONResponse:",
+            '    """Call custom check function and handle errors gracefully."""',
+            "    import importlib.util",
+            "    import traceback",
+            "    from pathlib import Path",
+            "    from datetime import datetime",
+            "    ",
+            "    try:",
+            "        # Load the custom check module",
+            "        module_path = Path(__file__).parent / f'{check_type}.py'",
+            "        if not module_path.exists():",
+            '            return JSONResponse({"status": "pass"}, status_code=200)',
+            "        ",
+            "        spec = importlib.util.spec_from_file_location(f'{check_type}_check', module_path)",
+            "        if spec and spec.loader:",
+            "            module = importlib.util.module_from_spec(spec)",
+            "            spec.loader.exec_module(module)",
+            "            ",
+            "            # Call the check function if it exists",
+            "            if hasattr(module, 'check'):",
+            "                result = module.check()",
+            "                ",
+            "                # Handle different return types",
+            "                if isinstance(result, dict):",
+            "                    # User returned structured response",
+            "                    status_code = result.get('status_code', 200)",
+            "                    response_data = {k: v for k, v in result.items() if k != 'status_code'}",
+            "                elif isinstance(result, bool):",
+            "                    # User returned simple boolean",
+            "                    status_code = 200 if result else 503",
+            "                    response_data = {",
+            '                        "status": "pass" if result else "fail",',
+            '                        "timestamp": datetime.utcnow().isoformat()',
+            "                    }",
+            "                elif result is None:",
+            "                    # User returned nothing - assume success",
+            "                    status_code = 200",
+            '                    response_data = {"status": "pass"}',
+            "                else:",
+            "                    # User returned something else - treat as success message",
+            "                    status_code = 200",
+            "                    response_data = {",
+            '                        "status": "pass",',
+            '                        "message": str(result)',
+            "                    }",
+            "                ",
+            "                return JSONResponse(response_data, status_code=status_code)",
+            "            else:",
+            "                return JSONResponse(",
+            '                    {"status": "fail", "error": f"No check() function found in {check_type}.py"},',
+            "                    status_code=503",
+            "                )",
+            "    ",
+            "    except Exception as e:",
+            "        # Log error and return failure response",
+            "        import sys",
+            '        print(f"Error calling {check_type} check function: {e}", file=sys.stderr)',
+            "        print(traceback.format_exc(), file=sys.stderr)",
+            "        return JSONResponse({",
+            '            "status": "fail",',
+            '            "error": f"Error calling {check_type} check function: {str(e)}"',
+            "        }, status_code=503)",
+            "",
+        ]
+
     def _generate_server(self) -> None:
         """Generate the main server entry point."""
         server_file = self.output_dir / "server.py"
@@ -700,14 +831,31 @@ class CodeGenerator:
             imports.extend(generate_metrics_instrumentation())
             imports.extend(generate_session_tracking())
 
-        # Add health check imports if enabled
-        if self.settings.health_check_enabled:
-            imports.extend(
-                [
-                    "from starlette.requests import Request",
-                    "from starlette.responses import PlainTextResponse",
-                ]
-            )
+        # Add health check imports only when we generate default endpoints
+        readiness_exists = (self.project_path / "readiness.py").exists()
+        health_exists = (self.project_path / "health.py").exists()
+
+        # Only import starlette when we generate default endpoints (not when custom files exist)
+        will_generate_default_readiness = not readiness_exists and self.settings.health_check_enabled
+        will_generate_default_health = not health_exists and self.settings.health_check_enabled
+
+        if will_generate_default_readiness or will_generate_default_health:
+            imports.append("from starlette.requests import Request")
+
+            # Determine response types needed for default endpoints
+            response_types = []
+            if will_generate_default_readiness:
+                response_types.append("JSONResponse")
+            if will_generate_default_health:
+                response_types.append("PlainTextResponse")
+
+            if response_types:
+                imports.append(f"from starlette.responses import {', '.join(response_types)}")
+
+        # Import Request and JSONResponse for custom check routes (they need both)
+        elif readiness_exists or health_exists:
+            imports.append("from starlette.requests import Request")
+            imports.append("from starlette.responses import JSONResponse")
 
         # Get transport-specific configuration
         transport_config = self._get_transport_config(self.settings.transport)
@@ -1199,22 +1347,17 @@ class CodeGenerator:
 
             metrics_route_code = generate_metrics_route(self.settings.metrics_path)
 
-        # Add health check route if enabled
-        health_check_code = []
-        if self.settings.health_check_enabled:
-            health_check_code = [
-                "# Add health check route",
-                "@mcp.custom_route('" + self.settings.health_check_path + '\', methods=["GET"])',
-                "async def health_check(request: Request) -> PlainTextResponse:",
-                '    """Health check endpoint for Kubernetes and load balancers."""',
-                (f'    return PlainTextResponse("{self.settings.health_check_response}")'),
-                "",
-            ]
+        # Generate readiness and health check sections
+        readiness_section = self._generate_readiness_section(self.project_path)
+        health_section = self._generate_health_section(self.project_path)
+
+        # No longer need the check helper function since we use direct imports
+        check_helper_section = []
 
         # Combine all sections
         # Order: imports, env_section, startup_section, auth_setup, server_code (mcp init),
         # early_telemetry_init, early_metrics_init, component_registrations,
-        # metrics_route_code, health_check_code, main_code (run block)
+        # metrics_route_code, check_helper_section, readiness_section, health_section, main_code (run block)
         code = "\n".join(
             imports
             + env_section
@@ -1225,7 +1368,9 @@ class CodeGenerator:
             + early_metrics_init
             + component_registrations
             + metrics_route_code
-            + health_check_code
+            + check_helper_section
+            + readiness_section
+            + health_section
             + main_code
         )
 
@@ -1256,21 +1401,13 @@ def build_project(
         build_env: Build environment ('dev' or 'prod')
         copy_env: Whether to copy environment variables to the built app
     """
-    # Load Golf credentials from .env for build operations (platform registration, etc.)
-    # This happens regardless of copy_env setting to ensure build process works
+    # Load environment variables from .env for build operations
     from dotenv import load_dotenv
 
     project_env_file = project_path / ".env"
     if project_env_file.exists():
-        # Load GOLF_* variables for build process
         load_dotenv(project_env_file, override=False)
 
-        # Only log if we actually found the specific Golf platform credentials
-        has_api_key = "GOLF_API_KEY" in os.environ
-        has_server_id = "GOLF_SERVER_ID" in os.environ
-        if has_api_key and has_server_id:
-            console.print("[dim]Loaded Golf credentials for build operations[/dim]")
-
     # Execute auth.py if it exists (for authentication configuration)
     # Also support legacy pre_build.py for backward compatibility
     auth_path = project_path / "auth.py"
@@ -1427,32 +1564,16 @@ def build_project(
         shutil.copy2(startup_path, dest_path)
         console.print(get_status_text("success", "Startup script copied to build directory"))
 
-    # Platform registration (only for prod builds)
-    if build_env == "prod":
-        console.print()
-        status_msg = f"[{GOLF_BLUE}]{STATUS_ICONS['platform']} Registering with Golf platform and updating resources...[/{GOLF_BLUE}]"
-        with console.status(status_msg):
-            import asyncio
-
-            try:
-                from golf.core.platform import register_project_with_platform
+    # Copy optional check files to build directory
+    readiness_path = project_path / "readiness.py"
+    if readiness_path.exists():
+        shutil.copy2(readiness_path, output_dir)
+        console.print(get_status_text("success", "Readiness script copied to build directory"))
 
-                success = asyncio.run(
-                    register_project_with_platform(
-                        project_path=project_path,
-                        settings=settings,
-                        components=generator.components,
-                    )
-                )
-
-                if success:
-                    console.print(get_status_text("success", "Platform registration completed"))
-                # If success is False, the platform module already printed appropriate warnings
-            except ImportError:
-                console.print(get_status_text("warning", "Platform registration module not available"))
-            except Exception as e:
-                console.print(get_status_text("warning", f"Platform registration failed: {e}"))
-                console.print("[dim]Tip: Ensure GOLF_API_KEY and GOLF_SERVER_ID are available in your .env file[/dim]")
+    health_path = project_path / "health.py"
+    if health_path.exists():
+        shutil.copy2(health_path, output_dir)
+        console.print(get_status_text("success", "Health script copied to build directory"))
 
     # Create a simple README
     readme_content = f"""# {settings.name}
@@ -1483,7 +1604,7 @@ This is a standalone FastMCP server generated by GolfMCP.
 
 # Legacy ProviderConfig removed in Golf 0.2.x - use modern auth configurations
 # Legacy OAuth imports removed in Golf 0.2.x - use FastMCP 2.11+ auth providers
-from golf.auth.helpers import get_provider_token, extract_token_from_header, get_api_key, set_api_key
+from golf.auth.helpers import extract_token_from_header, get_api_key, set_api_key
 from golf.auth.api_key import configure_api_key, get_api_key_config
 from golf.auth.factory import create_auth_provider
 from golf.auth.providers import RemoteAuthConfig, JWTAuthConfig, StaticTokenConfig, OAuthServerConfig

golf/core/builder_auth.py

@@ -121,7 +121,7 @@ def generate_api_key_auth_components(
         "class ApiKeyMiddleware(BaseHTTPMiddleware):",
         "    async def dispatch(self, request: Request, call_next):",
         "        # Debug mode from environment",
-        "        debug = os.environ.get('GOLF_API_KEY_DEBUG', '').lower() == 'true'",
+        "        debug = os.environ.get('API_KEY_DEBUG', '').lower() == 'true'",
         "        ",
         "        # Skip auth for monitoring endpoints",
         "        path = request.url.path",

golf/core/builder_metrics.py

@@ -59,17 +59,6 @@ def generate_metrics_route(metrics_path: str) -> list[str]:
     ]
 
 
-def get_metrics_dependencies() -> list[str]:
-    """Get list of metrics dependencies to add to pyproject.toml.
-
-    Returns:
-        List of package requirements strings
-    """
-    return [
-        "prometheus-client>=0.19.0",
-    ]
-
-
 def generate_metrics_instrumentation() -> list[str]:
     """Generate metrics instrumentation wrapper functions.
 

golf/core/config.py

@@ -83,9 +83,9 @@ class Settings(BaseSettings):
     )
 
     # Health check configuration
-    health_check_enabled: bool = Field(False, description="Enable health check endpoint")
+    health_check_enabled: bool = Field(False, description="Enable health check endpoint (deprecated - use health.py)")
     health_check_path: str = Field("/health", description="Health check endpoint path")
-    health_check_response: str = Field("OK", description="Health check response text")
+    health_check_response: str = Field("OK", description="Health check response text (deprecated - use health.py)")
 
     # HTTP session behaviour
     stateless_http: bool = Field(
@@ -172,24 +172,11 @@ def load_settings(project_path: str | Path) -> Settings:
     if env_file.exists():
         settings = Settings(_env_file=env_file)
 
-        # Auto-enable OpenTelemetry if GOLF_API_KEY is present (from .env file)
-        import os
-
-        if os.environ.get("GOLF_API_KEY"):
-            settings.opentelemetry_enabled = True
-
     # Try to load JSON config file first
     json_config_path = project_path / "golf.json"
     if json_config_path.exists():
         return _load_json_settings(json_config_path, settings)
 
-    # No config file found, use defaults
-    # Auto-enable OpenTelemetry if GOLF_API_KEY is present
-    import os
-
-    if os.environ.get("GOLF_API_KEY"):
-        settings.opentelemetry_enabled = True
-
     return settings
 
 
@@ -206,12 +193,6 @@ def _load_json_settings(path: Path, settings: Settings) -> Settings:
             if hasattr(settings, key):
                 setattr(settings, key, value)
 
-        # Auto-enable OpenTelemetry if GOLF_API_KEY is present and telemetry wasn't explicitly configured
-        import os
-
-        if os.environ.get("GOLF_API_KEY") and "opentelemetry_enabled" not in config_data:
-            settings.opentelemetry_enabled = True
-
         return settings
     except Exception as e:
         console.print(f"[bold red]Error loading JSON config from {path}: {e}[/bold red]")

golf/examples/basic/.env.example

@@ -1,8 +1,4 @@
 # Golf MCP Server Environment Variables
 
-# Golf platform integration
-GOLF_API_KEY="your-golf-api-key"
-GOLF_SERVER_ID="your-server-id"
-
 # Development tokens are configured in auth.py for this example
 # Additional environment variables can be added as needed

golf/telemetry/instrumentation.py

@@ -14,13 +14,6 @@ from collections import OrderedDict
 
 from opentelemetry import baggage, trace
 
-# Import endpoints with fallback for dev mode
-try:
-    # In built wheels, this exists (generated from _endpoints.py.in)
-    from golf import _endpoints  # type: ignore
-except ImportError:
-    # In editable/dev installs, fall back to env-based values
-    from golf import _endpoints_fallback as _endpoints  # type: ignore
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
@@ -69,28 +62,6 @@ def init_telemetry(service_name: str = "golf-mcp-server") -> TracerProvider | No
     """
     global _provider
 
-    # Check for Golf platform integration first
-    golf_api_key = os.environ.get("GOLF_API_KEY")
-    if golf_api_key:
-        # Auto-configure for Golf platform - always use OTLP when Golf API
-        # key is present
-        os.environ["OTEL_TRACES_EXPORTER"] = "otlp_http"
-
-        # Only set endpoint if not already configured (allow user override)
-        if not os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT"):
-            os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = _endpoints.OTEL_ENDPOINT
-
-        # Set Golf platform headers (append to existing if present)
-        existing_headers = os.environ.get("OTEL_EXPORTER_OTLP_HEADERS", "")
-        golf_header = f"X-Golf-Key={golf_api_key}"
-
-        if existing_headers:
-            # Check if Golf key is already in headers
-            if "X-Golf-Key=" not in existing_headers:
-                os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = f"{existing_headers},{golf_header}"
-        else:
-            os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = golf_header
-
     # Check for required environment variables based on exporter type
     exporter_type = os.environ.get("OTEL_TRACES_EXPORTER", "console").lower()
 
@@ -111,13 +82,6 @@ def init_telemetry(service_name: str = "golf-mcp-server") -> TracerProvider | No
         "service.instance.id": os.environ.get("SERVICE_INSTANCE_ID", "default"),
     }
 
-    # Add Golf-specific attributes if available
-    if golf_api_key:
-        golf_server_id = os.environ.get("GOLF_SERVER_ID")
-        if golf_server_id:
-            resource_attributes["golf.server.id"] = golf_server_id
-        resource_attributes["golf.platform.enabled"] = "true"
-
     resource = Resource.create(resource_attributes)
 
     # Create provider

{golf_mcp-0.2.10.dist-info → golf_mcp-0.2.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: golf-mcp
-Version: 0.2.10
+Version: 0.2.12
 Summary: Framework for building MCP servers
 Author-email: Antoni Gmitruk <antoni@golf.dev>
 License-Expression: Apache-2.0
@@ -21,7 +21,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: typer>=0.15.4
 Requires-Dist: rich>=14.0.0
-Requires-Dist: fastmcp<3.0.0,>=2.11.0
+Requires-Dist: fastmcp==2.12.5
 Requires-Dist: pydantic>=2.11.0
 Requires-Dist: pydantic-settings>=2.0.0
 Requires-Dist: python-dotenv>=1.1.0
@@ -197,9 +197,10 @@ from golf.utils import elicit, sample, get_context
 ```
 
 ```bash
-# Automatic telemetry with Golf Platform
-export GOLF_API_KEY="your-key"
-golf run  # ✅ Telemetry enabled automatically
+# Enable OpenTelemetry tracing
+export OTEL_TRACES_EXPORTER="otlp_http"
+export OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4318/v1/traces"
+golf run  # ✅ Telemetry enabled
 ```
 
 **[📚 Complete Documentation →](https://docs.golf.dev)**
@@ -220,7 +221,7 @@ Basic configuration in `golf.json`:
 ```
 
 - **`transport`**: Choose `"sse"`, `"streamable-http"`, or `"stdio"`
-- **`opentelemetry_enabled`**: Auto-enabled with `GOLF_API_KEY`
+- **`opentelemetry_enabled`**: Enable OpenTelemetry tracing
 - **`detailed_tracing`**: Capture input/output (use carefully with sensitive data)
 
 

{golf_mcp-0.2.10.dist-info → golf_mcp-0.2.12.dist-info}/RECORD

@@ -1,32 +1,28 @@
-golf/__init__.py,sha256=KrLUEDZhh_8Gu_JcwZgGUhFN9JR6Sjqt8v46gVPBsmE,307
-golf/_endpoints.py,sha256=-mvAmjx3YtqfAdajO13Kv7LKVBMdqsKqX0_3aCmCK4I,317
-golf/_endpoints.py.in,sha256=MeqcSF6xinnPknpBGF26xA9FYmSYKSWqCFXOSDlXiOA,216
-golf/_endpoints_fallback.py,sha256=CD6m45Ams1A9HVKowY8dCFUDMiFmJ8ZWSwHCENvU5u4,386
-golf/auth/__init__.py,sha256=gx62l8Z72eIldO2LtzKQ2OQVeobrhaSggTzJaZ0hcCo,8279
+golf/__init__.py,sha256=X4KG3FscE5AhbGbcdDDgdDC550CVpxNMwdNLcx6EQ7M,23
+golf/auth/__init__.py,sha256=sYWjWXGR70Ae87znseeBK2YWl8S1-qn_hndKf2xMULk,8173
 golf/auth/api_key.py,sha256=OonqTlG6USJxqK8TlPviJTv7sgYmTVfCxG_JsEjnEM4,2320
 golf/auth/factory.py,sha256=3-il1GbjjZlQfvWUZs-09r61Y_-b5cYEegWF7sY_cUs,13128
-golf/auth/helpers.py,sha256=WoYyjUAQwgDnLvJDvyhuEOmm8w0fQ-ZDqaYxs_lC8nw,8127
+golf/auth/helpers.py,sha256=N5NUGqlBg8rwfYX6zXmsWnjDE2Bh9n1CHeKAqMShToc,5589
 golf/auth/providers.py,sha256=f89WeQUrYopS0GBcTO3yXlqyPQvG7s7GpaiUK2tb2ME,25048
 golf/auth/registry.py,sha256=Rjj7LnWvzEsI1GCnFbFcxpRllrVanD9bumWPaJ1giFQ,7960
 golf/cli/__init__.py,sha256=R8Y8KdD2C8gDo24fXGq-fdWWNeaq3MYjrbaSB8Hb-Hg,45
-golf/cli/branding.py,sha256=ndpy2kVxBzqr4fwsAlh_fbhxqgRPoF6kM3ufP9hg5QI,6896
-golf/cli/main.py,sha256=0TAccbjB9wmB55GmCV3X1CpzaOoMSzpQ-bx2oxi-THw,13536
+golf/cli/branding.py,sha256=OdmCaYVg6g3P8fqSNDlTG8R5CwUTuqSd68BrpPTjKp8,6861
+golf/cli/main.py,sha256=YnppG_I15wfVU-dELgJbGTjESMvXGmBpUds1JkE83Es,13403
 golf/commands/__init__.py,sha256=j2r-0Zg2BSqG7WtZczAtyAsrur7kRQpEN9ZJuoX1XQ8,119
 golf/commands/build.py,sha256=sLq9lSW4naq2vIlBreKI5SGnviQrhBWw13zfOZOKhuM,2293
 golf/commands/init.py,sha256=KkAg_3-KxBDFOcZqUHqcPAkDipykFVaLWpQ2tydnVPk,9617
-golf/commands/run.py,sha256=a8GSwLt6E2cUJespv-u3jbD-rNUMHqF3VArD1uXV-Vk,4299
+golf/commands/run.py,sha256=2fdjqTfzQL-dFOqptkl-K2jel8VWpevAx0somcjNsPI,4576
 golf/core/__init__.py,sha256=4bKeskJ2fPaZqkz2xQScSa3phRLLrmrczwSL632jv-o,52
-golf/core/builder.py,sha256=-iUhj1G5SKSE9kG9Y2glxQPp3b45fqXVrYi3gQGmgbs,69963
-golf/core/builder_auth.py,sha256=SXPCpc5ipntoNqIAIA2ZCeGmEua6QVs7yC3MDtGKAro,8224
-golf/core/builder_metrics.py,sha256=j6Gtgd867o46JbDfSNGNsHt1QtV1XHKUJs1z8r4siQM,8830
+golf/core/builder.py,sha256=ynmzTF1IsF5OTZl0dr-1Mzd8iEVNB-Oxa6RBWBu3DRs,76372
+golf/core/builder_auth.py,sha256=f0w9TmxvNjxglcWY8NGULZJ8mwLqtUFFb2QHzgC0xAk,8219
+golf/core/builder_metrics.py,sha256=wrXdE4_XWx7fUXnp61WU7rCBO-aG-4YzCMV6yO0z9Dg,8594
 golf/core/builder_telemetry.py,sha256=86bp7UlMUN6JyQRrZ5EizovP6AJ_q65OANJTeJXDIKc,3421
-golf/core/config.py,sha256=h8LWKdD-5vS8vRGs1qsCI2d8EbtjIKuXM3rUJ0T7EZ8,7452
+golf/core/config.py,sha256=kL440b8i1dF8jdKeYwZZ04HdotX5CAlTyxR1ZyML-Iw,6850
 golf/core/parser.py,sha256=f9WqmLWlFuXQCObl2Qmna9bp_Bo0p0eIlukzwFaBSzo,43373
-golf/core/platform.py,sha256=0TxLfVPBhBR82aJAQWEJcnkGuQv65C9gYYy7P2foUVk,6662
 golf/core/telemetry.py,sha256=dXoWrgrQpj_HGrl_8TBZmRnuLxFKEn0GSDWQ9qq3ZQM,15686
 golf/core/transformer.py,sha256=iTDNFqdVeOjzl-acdjp8ZaTXss8Eptqu5cs4qLWt9SU,6914
 golf/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-golf/examples/basic/.env.example,sha256=hxl1B9Vo7nCN5dWvTeN6BpOxTwHwPLEQzsnToHhx7nk,256
+golf/examples/basic/.env.example,sha256=Ktdc2Qta05smPItYHnEHhVxYPkq5JJ7i2aI5pOyyQx4,162
 golf/examples/basic/README.md,sha256=p8KMyaNXGZtrbgckW-Thu_5RKXViGiyZ5hHEiJ6Zc-U,3283
 golf/examples/basic/auth.py,sha256=cdPWFU__i8Jw8xI1hgGSobhaC4YIBKsh5LsQY2GS2dw,2789
 golf/examples/basic/golf.json,sha256=327fO4XmvksmZdlYtYPmRcB6TgEVkD1nSvHAuGyWsYA,98
@@ -43,14 +39,14 @@ golf/metrics/__init__.py,sha256=O91y-hj_E9R06gqV8pDZrzHxOIl-1T415Hj9RvFAp3o,283
 golf/metrics/collector.py,sha256=ScKeOyDNawZRMIRYBFqNqmaYAIVJQ2riMu_qOE9ugvU,10967
 golf/metrics/registry.py,sha256=mXQE4Pwf3PopGYjcUu4eGgPDAe085YWcsvcvWk0ny8Q,310
 golf/telemetry/__init__.py,sha256=txSXDBhug5uVMD1KjZszcILMrVTjvTCWlxo7TWwbul8,506
-golf/telemetry/instrumentation.py,sha256=kLWkvw14eCUVawNtGuRRzEqaVcwzLJxk86uvDqW_tOU,57771
+golf/telemetry/instrumentation.py,sha256=qBgSw8KqK_nroOjaeI1HMxaBUPsrIERyzp0ig842nu8,56159
 golf/utilities/__init__.py,sha256=X9iY9yi3agz1GVcn8-qWeOCt8CSSsruHxqPNtiF63TY,530
 golf/utilities/context.py,sha256=DGGvhVe---QMhy0wtdWhNp-_WVk1NvAcOFn0uBKBpYo,1579
 golf/utilities/elicitation.py,sha256=MParZZZsY45s70-KXduHa6IvpWXnLW2FCPfrGijMaHs,5223
 golf/utilities/sampling.py,sha256=88nDv-trBE4gZQbcnMjXl3LW6TiIhv5zR_cuEIGjaIM,7233
-golf_mcp-0.2.10.dist-info/licenses/LICENSE,sha256=5_j2f6fTJmvfmUewzElhkpAaXg2grVoxKouOA8ihV6E,11348
-golf_mcp-0.2.10.dist-info/METADATA,sha256=4YRKbcRjyZfBFPFcnzJ5ZV8hU3enJEVmQy2VumwVlpc,9371
-golf_mcp-0.2.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-golf_mcp-0.2.10.dist-info/entry_points.txt,sha256=5y7rHYM8jGpU-nfwdknCm5XsApLulqsnA37MO6BUTYg,43
-golf_mcp-0.2.10.dist-info/top_level.txt,sha256=BQToHcBUufdyhp9ONGMIvPE40jMEtmI20lYaKb4hxOg,5
-golf_mcp-0.2.10.dist-info/RECORD,,
+golf_mcp-0.2.12.dist-info/licenses/LICENSE,sha256=5_j2f6fTJmvfmUewzElhkpAaXg2grVoxKouOA8ihV6E,11348
+golf_mcp-0.2.12.dist-info/METADATA,sha256=RksLyay82K3poGEAup26_dMaRw06Z9ZnOwC3iFWHel8,9414
+golf_mcp-0.2.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+golf_mcp-0.2.12.dist-info/entry_points.txt,sha256=5y7rHYM8jGpU-nfwdknCm5XsApLulqsnA37MO6BUTYg,43
+golf_mcp-0.2.12.dist-info/top_level.txt,sha256=BQToHcBUufdyhp9ONGMIvPE40jMEtmI20lYaKb4hxOg,5
+golf_mcp-0.2.12.dist-info/RECORD,,

golf/_endpoints.py

@@ -1,6 +0,0 @@
-# Auto-generated at build time by setup.py:build_py
-# This template contains placeholders that are replaced during build
-
-# Platform endpoints
-PLATFORM_API_URL = "https://golf-backend.golf-auth-1.authed-qukc4.ryvn.run/api/resources"
-OTEL_ENDPOINT = "https://golf-backend.golf-auth-1.authed-qukc4.ryvn.run/api/v1/otel"

golf/_endpoints.py.in

@@ -1,6 +0,0 @@
-# Auto-generated at build time by setup.py:build_py
-# This template contains placeholders that are replaced during build
-
-# Platform endpoints
-PLATFORM_API_URL = "{PLATFORM_API_URL}"
-OTEL_ENDPOINT = "{OTEL_ENDPOINT}"

golf/_endpoints_fallback.py

@@ -1,10 +0,0 @@
-"""Fallback endpoints for development/editable installs."""
-
-import os
-
-# These are used when the generated _endpoints.py doesn't exist (dev mode)
-# or when environment variables override the built-in values
-
-PLATFORM_API_URL = os.getenv("GOLF_PLATFORM_API_URL", "http://localhost:8000/api/resources")
-
-OTEL_ENDPOINT = os.getenv("GOLF_OTEL_ENDPOINT", "http://localhost:4318/v1/traces")

golf/core/platform.py

@@ -1,182 +0,0 @@
-"""Platform registration for Golf MCP projects."""
-
-import os
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-import httpx
-from rich.console import Console
-
-from golf import __version__
-from golf.core.config import Settings
-from golf.core.parser import ComponentType, ParsedComponent
-
-# Import endpoints with fallback for dev mode
-try:
-    # In built wheels, this exists (generated from _endpoints.py.in)
-    from golf import _endpoints  # type: ignore
-except ImportError:
-    # In editable/dev installs, fall back to env-based values
-    from golf import _endpoints_fallback as _endpoints  # type: ignore
-
-console = Console()
-
-
-async def register_project_with_platform(
-    project_path: Path,
-    settings: Settings,
-    components: dict[ComponentType, list[ParsedComponent]],
-) -> bool:
-    """Register project with Golf platform during prod build.
-
-    Args:
-        project_path: Path to the project root
-        settings: Project settings
-        components: Parsed components dictionary
-
-    Returns:
-        True if registration succeeded or was skipped, False if failed
-    """
-    # Check if platform integration is enabled
-    api_key = os.getenv("GOLF_API_KEY")
-    if not api_key:
-        return True  # Skip silently if no API key
-
-    # Require explicit server ID
-    server_id = os.getenv("GOLF_SERVER_ID")
-    if not server_id:
-        console.print(
-            "[yellow]Warning: Platform registration skipped - GOLF_SERVER_ID environment variable required[/yellow]"
-        )
-        return True  # Skip registration but don't fail build
-
-    # Build metadata payload
-    metadata = {
-        "project_name": settings.name,
-        "description": settings.description,
-        "server_id": server_id,
-        "components": _build_component_list(components, project_path),
-        "build_timestamp": datetime.utcnow().isoformat(),
-        "golf_version": __version__,
-        "component_counts": _get_component_counts(components),
-        "server_config": {
-            "host": settings.host,
-            "port": settings.port,
-            "transport": settings.transport,
-            "auth_enabled": bool(settings.auth),
-            "telemetry_enabled": settings.opentelemetry_enabled,
-            "health_check_enabled": settings.health_check_enabled,
-        },
-    }
-
-    try:
-        async with httpx.AsyncClient(timeout=10.0) as client:
-            response = await client.post(
-                _endpoints.PLATFORM_API_URL,
-                json=metadata,
-                headers={
-                    "X-Golf-Key": api_key,
-                    "Content-Type": "application/json",
-                    "User-Agent": f"Golf-MCP/{__version__}",
-                },
-            )
-            response.raise_for_status()
-
-        console.print("[green]✓[/green] Registered with Golf platform")
-        return True
-
-    except httpx.TimeoutException:
-        console.print("[yellow]Warning: Platform registration timed out[/yellow]")
-        return False
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 401:
-            console.print("[yellow]Warning: Platform registration failed - invalid API key[/yellow]")
-        elif e.response.status_code == 403:
-            console.print("[yellow]Warning: Platform registration failed - access denied[/yellow]")
-        else:
-            console.print(f"[yellow]Warning: Platform registration failed - HTTP {e.response.status_code}[/yellow]")
-        return False
-    except Exception as e:
-        console.print(f"[yellow]Warning: Platform registration failed: {e}[/yellow]")
-        return False  # Don't fail the build
-
-
-def _build_component_list(
-    components: dict[ComponentType, list[ParsedComponent]],
-    project_path: Path,
-) -> list[dict[str, Any]]:
-    """Convert parsed components to platform format.
-
-    Args:
-        components: Dictionary of parsed components by type
-        project_path: Path to the project root
-
-    Returns:
-        List of component metadata dictionaries
-    """
-    result = []
-
-    for comp_type, comp_list in components.items():
-        for comp in comp_list:
-            # Start with basic component data
-            component_data = {
-                "name": comp.name,
-                "type": comp_type.value,
-                "description": comp.docstring,
-                "entry_function": comp.entry_function,
-                "parent_module": comp.parent_module,
-            }
-
-            # Add file path relative to project root if available
-            if comp.file_path:
-                try:
-                    file_path = Path(comp.file_path)
-                    # Use the provided project_path for relative calculation
-                    rel_path = file_path.relative_to(project_path)
-                    component_data["file_path"] = str(rel_path)
-                except ValueError:
-                    # If relative_to fails, try to find a common path or use filename
-                    component_data["file_path"] = Path(comp.file_path).name
-
-            # Add schema information only if available and not None
-            if hasattr(comp, "input_schema") and comp.input_schema:
-                component_data["input_schema"] = comp.input_schema
-            if hasattr(comp, "output_schema") and comp.output_schema:
-                component_data["output_schema"] = comp.output_schema
-
-            # Add component-specific fields only if they have values
-            if comp_type == ComponentType.RESOURCE:
-                if hasattr(comp, "uri_template") and comp.uri_template:
-                    component_data["uri_template"] = comp.uri_template
-
-            elif comp_type == ComponentType.TOOL:
-                if hasattr(comp, "annotations") and comp.annotations:
-                    component_data["annotations"] = comp.annotations
-
-            # Add parameters only if they exist and are not empty
-            if hasattr(comp, "parameters") and comp.parameters:
-                component_data["parameters"] = comp.parameters
-
-            result.append(component_data)
-
-    return result
-
-
-def _get_component_counts(
-    components: dict[ComponentType, list[ParsedComponent]],
-) -> dict[str, int]:
-    """Get component counts by type.
-
-    Args:
-        components: Dictionary of parsed components by type
-
-    Returns:
-        Dictionary with counts for each component type
-    """
-    return {
-        "tools": len(components.get(ComponentType.TOOL, [])),
-        "resources": len(components.get(ComponentType.RESOURCE, [])),
-        "prompts": len(components.get(ComponentType.PROMPT, [])),
-        "total": sum(len(comp_list) for comp_list in components.values()),
-    }