golf-mcp 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

golf/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.9"
+__version__ = "0.1.11"

golf/auth/__init__.py

@@ -11,7 +11,7 @@ from mcp.server.auth.settings import AuthSettings, ClientRegistrationOptions
 
 from .provider import ProviderConfig
 from .oauth import GolfOAuthProvider, create_callback_handler
-from .helpers import get_access_token, get_provider_token, extract_token_from_header, get_api_key, set_api_key
+from .helpers import get_access_token, get_provider_token, extract_token_from_header, get_api_key, set_api_key, debug_api_key_context
 from .api_key import configure_api_key, get_api_key_config, is_api_key_configured
 
 class AuthConfig:

golf/auth/helpers.py

@@ -1,6 +1,6 @@
 """Helper functions for working with authentication in MCP context."""
 
-from typing import Optional
+from typing import Optional, Dict, Any
 from contextvars import ContextVar
 
 # Re-export get_access_token from the MCP SDK
@@ -94,4 +94,114 @@ def get_api_key() -> Optional[str]:
             headers = {"Authorization": f"Bearer {api_key}"}
             ...
     """
-    return _current_api_key.get() 
+    # Try to get directly from HTTP request if available (FastMCP pattern)
+    try:
+        # This follows the FastMCP pattern for accessing HTTP requests
+        from fastmcp.server.dependencies import get_http_request
+        request = get_http_request()
+        
+        if request and hasattr(request, 'state') and hasattr(request.state, 'api_key'):
+            api_key = request.state.api_key
+            return api_key
+        
+        # Get the API key configuration
+        from golf.auth.api_key import get_api_key_config
+        api_key_config = get_api_key_config()
+        
+        if api_key_config and request:
+            # Extract API key from headers
+            header_name = api_key_config.header_name
+            header_prefix = api_key_config.header_prefix
+            
+            # Case-insensitive header lookup
+            api_key = None
+            for k, v in request.headers.items():
+                if k.lower() == header_name.lower():
+                    api_key = v
+                    break
+            
+            # Strip prefix if configured
+            if api_key and header_prefix and api_key.startswith(header_prefix):
+                api_key = api_key[len(header_prefix):]
+            
+            if api_key:
+                return api_key
+    except (ImportError, RuntimeError) as e:
+        # FastMCP not available or not in HTTP context
+        pass
+    except Exception as e:
+        pass
+    
+    # Final fallback: environment variable (for development/testing)
+    import os
+    env_api_key = os.environ.get('API_KEY')
+    if env_api_key:
+        return env_api_key
+    
+    return None
+
+def get_api_key_from_request(request) -> Optional[str]:
+    """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 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 sys
+    import os
+    
+    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:
+        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 = getattr(main_module, 'request_id_context')
+                debug_info["request_id_from_context"] = request_id_context.get()
+    except:
+        pass
+    
+    return debug_info 

golf/cli/main.py

@@ -106,7 +106,7 @@ def build_dev(
     if not project_root:
         console.print("[bold red]Error: No GolfMCP project found in the current directory or any parent directory.[/bold red]")
         console.print("Run 'golf init <project_name>' to create a new project.")
-        track_event("cli_build_failed", {"success": False, "environment": "dev"})
+        track_event("cli_build_failed", {"success": False, "environment": "dev", "error_type": "NoProjectFound", "error_message": "No GolfMCP project found"})
         raise typer.Exit(code=1)
     
     # Load settings from the found project
@@ -124,8 +124,10 @@ def build_dev(
         build_project(project_root, settings, output_dir, build_env="dev", copy_env=True)
         # Track successful build with environment
         track_event("cli_build_success", {"success": True, "environment": "dev"})
-    except Exception:
-        track_event("cli_build_failed", {"success": False, "environment": "dev"})
+    except Exception as e:
+        error_type = type(e).__name__
+        error_message = str(e)
+        track_event("cli_build_failed", {"success": False, "environment": "dev", "error_type": error_type, "error_message": error_message})
         raise
 
 
@@ -142,7 +144,7 @@ def build_prod(
     if not project_root:
         console.print("[bold red]Error: No GolfMCP project found in the current directory or any parent directory.[/bold red]")
         console.print("Run 'golf init <project_name>' to create a new project.")
-        track_event("cli_build_failed", {"success": False, "environment": "prod"})
+        track_event("cli_build_failed", {"success": False, "environment": "prod", "error_type": "NoProjectFound", "error_message": "No GolfMCP project found"})
         raise typer.Exit(code=1)
     
     # Load settings from the found project
@@ -160,8 +162,10 @@ def build_prod(
         build_project(project_root, settings, output_dir, build_env="prod", copy_env=False)
         # Track successful build with environment
         track_event("cli_build_success", {"success": True, "environment": "prod"})
-    except Exception:
-        track_event("cli_build_failed", {"success": False, "environment": "prod"})
+    except Exception as e:
+        error_type = type(e).__name__
+        error_message = str(e)
+        track_event("cli_build_failed", {"success": False, "environment": "prod", "error_type": error_type, "error_message": error_message})
         raise
 
 
@@ -191,7 +195,7 @@ def run(
     if not project_root:
         console.print("[bold red]Error: No GolfMCP project found in the current directory or any parent directory.[/bold red]")
         console.print("Run 'golf init <project_name>' to create a new project.")
-        track_event("cli_run_failed", {"success": False})
+        track_event("cli_run_failed", {"success": False, "error_type": "NoProjectFound", "error_message": "No GolfMCP project found"})
         raise typer.Exit(code=1)
     
     # Load settings from the found project
@@ -207,13 +211,20 @@ def run(
     if not dist_dir.exists():
         if build_first:
             console.print(f"[yellow]Dist directory {dist_dir} not found. Building first...[/yellow]")
-            # Build the project
-            from golf.commands.build import build_project
-            build_project(project_root, settings, dist_dir)
+            try:
+                # Build the project
+                from golf.commands.build import build_project
+                build_project(project_root, settings, dist_dir)
+            except Exception as e:
+                error_type = type(e).__name__
+                error_message = str(e)
+                console.print(f"[bold red]Error building project:[/bold red] {error_message}")
+                track_event("cli_run_failed", {"success": False, "error_type": f"BuildError.{error_type}", "error_message": error_message})
+                raise
         else:
             console.print(f"[bold red]Error: Dist directory {dist_dir} not found.[/bold red]")
             console.print("Run 'golf build' first or use --build to build automatically.")
-            track_event("cli_run_failed", {"success": False})
+            track_event("cli_run_failed", {"success": False, "error_type": "DistNotFound", "error_message": "Dist directory not found"})
             raise typer.Exit(code=1)
     
     try:
@@ -231,13 +242,15 @@ def run(
         if return_code == 0:
             track_event("cli_run_success", {"success": True})
         else:
-            track_event("cli_run_failed", {"success": False})
+            track_event("cli_run_failed", {"success": False, "error_type": "NonZeroExit", "error_message": f"Server exited with code {return_code}"})
         
         # Exit with the same code as the server
         if return_code != 0:
             raise typer.Exit(code=return_code)
-    except Exception:
-        track_event("cli_run_failed", {"success": False})
+    except Exception as e:
+        error_type = type(e).__name__
+        error_message = str(e)
+        track_event("cli_run_failed", {"success": False, "error_type": error_type, "error_message": error_message})
         raise
 
 

golf/commands/init.py

@@ -9,7 +9,7 @@ from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.prompt import Confirm
 
-from golf.core.telemetry import track_event
+from golf.core.telemetry import track_event, track_command
 
 console = Console()
 
@@ -26,72 +26,83 @@ def initialize_project(
         output_dir: Directory where the project will be created
         template: Template to use (basic or api_key)
     """
-    # Validate template
-    valid_templates = ("basic", "api_key")
-    if template not in valid_templates:
-        console.print(f"[bold red]Error:[/bold red] Unknown template '{template}'")
-        console.print(f"Available templates: {', '.join(valid_templates)}")
-        track_event("cli_init_failed", {"success": False})
-        return
-    
-    # Check if directory exists
-    if output_dir.exists():
-        if not output_dir.is_dir():
+    try:
+        # Validate template
+        valid_templates = ("basic", "api_key")
+        if template not in valid_templates:
+            console.print(f"[bold red]Error:[/bold red] Unknown template '{template}'")
+            console.print(f"Available templates: {', '.join(valid_templates)}")
+            track_command("init", success=False, error_type="InvalidTemplate", error_message=f"Unknown template: {template}")
+            return
+        
+        # Check if directory exists
+        if output_dir.exists():
+            if not output_dir.is_dir():
+                console.print(
+                    f"[bold red]Error:[/bold red] '{output_dir}' exists but is not a directory."
+                )
+                track_command("init", success=False, error_type="NotADirectory", error_message="Target exists but is not a directory")
+                return
+            
+            # Check if directory is empty
+            if any(output_dir.iterdir()):
+                if not Confirm.ask(
+                    f"Directory '{output_dir}' is not empty. Continue anyway?",
+                    default=False,
+                ):
+                    console.print("Initialization cancelled.")
+                    track_event("cli_init_cancelled", {"success": False})
+                    return
+        else:
+            # Create the directory
+            output_dir.mkdir(parents=True)
+        
+        # Find template directory within the installed package
+        import golf
+        package_init_file = Path(golf.__file__)
+        # The 'examples' directory is now inside the 'golf' package directory
+        # e.g. golf/examples/basic, so go up one from __init__.py to get to 'golf'
+        template_dir = package_init_file.parent / "examples" / template
+        
+        if not template_dir.exists():
             console.print(
-                f"[bold red]Error:[/bold red] '{output_dir}' exists but is not a directory."
+                f"[bold red]Error:[/bold red] Could not find template '{template}'"
             )
-            track_event("cli_init_failed", {"success": False})
+            track_command("init", success=False, error_type="TemplateNotFound", error_message=f"Template directory not found: {template}")
             return
         
-        # Check if directory is empty
-        if any(output_dir.iterdir()):
-            if not Confirm.ask(
-                f"Directory '{output_dir}' is not empty. Continue anyway?",
-                default=False,
-            ):
-                console.print("Initialization cancelled.")
-                track_event("cli_init_cancelled", {"success": False})
-                return
-    else:
-        # Create the directory
-        output_dir.mkdir(parents=True)
-    
-    # Find template directory within the installed package
-    import golf
-    package_init_file = Path(golf.__file__)
-    # The 'examples' directory is now inside the 'golf' package directory
-    # e.g. golf/examples/basic, so go up one from __init__.py to get to 'golf'
-    template_dir = package_init_file.parent / "examples" / template
-    
-    if not template_dir.exists():
-        console.print(
-            f"[bold red]Error:[/bold red] Could not find template '{template}'"
-        )
-        track_event("cli_init_failed", {"success": False})
-        return
-    
-    # Copy template files
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[bold green]Creating project structure...[/bold green]"),
-        transient=True,
-    ) as progress:
-        progress.add_task("copying", total=None)
+        # Copy template files
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[bold green]Creating project structure...[/bold green]"),
+            transient=True,
+        ) as progress:
+            progress.add_task("copying", total=None)
+            
+            # Copy directory structure
+            _copy_template(template_dir, output_dir, project_name)
         
-        # Copy directory structure
-        _copy_template(template_dir, output_dir, project_name)
-    
-    # Create virtual environment
-    console.print("[bold green]Project initialized successfully![/bold green]")
-    console.print(f"\nTo get started, run:")
-    console.print(f"  cd {output_dir.name}")
-    console.print(f"  golf build dev")
-    
-    # Track successful initialization
-    track_event("cli_init_success", {
-        "success": True,
-        "template": template
-    })
+        # Create virtual environment
+        console.print("[bold green]Project initialized successfully![/bold green]")
+        console.print(f"\nTo get started, run:")
+        console.print(f"  cd {output_dir.name}")
+        console.print(f"  golf build dev")
+        
+        # Track successful initialization
+        track_event("cli_init_success", {
+            "success": True,
+            "template": template
+        })
+    except Exception as e:
+        # Capture error details for telemetry
+        error_type = type(e).__name__
+        error_message = str(e)
+        
+        console.print(f"[bold red]Error during initialization:[/bold red] {error_message}")
+        track_command("init", success=False, error_type=error_type, error_message=error_message)
+        
+        # Re-raise to maintain existing behavior
+        raise
 
 
 def _copy_template(source_dir: Path, target_dir: Path, project_name: str) -> None:

golf/core/builder.py

@@ -20,6 +20,7 @@ from golf.core.parser import (
 from golf.core.transformer import transform_component
 from golf.core.builder_auth import generate_auth_code, generate_auth_routes
 from golf.auth import get_auth_config
+from golf.auth.api_key import get_api_key_config
 from golf.core.builder_telemetry import (
     generate_telemetry_imports,
     get_otel_dependencies
@@ -548,8 +549,7 @@ class CodeGenerator:
         # Add imports section for different transport methods
         if self.settings.transport == "sse":
             imports.append("import uvicorn")
-            imports.append("from fastmcp.server.http import create_sse_app")
-        elif self.settings.transport != "stdio":
+        elif self.settings.transport in ["streamable-http", "http"]:
             imports.append("import uvicorn")
                 
         # Get transport-specific configuration
@@ -735,12 +735,6 @@ class CodeGenerator:
         server_code_lines.append(mcp_instance_line)
         server_code_lines.append("")
         
-        # Add any post-init code from auth
-        post_init_code = []
-        if auth_components.get("has_auth") and auth_components.get("post_init_code"):
-            post_init_code.extend(auth_components["post_init_code"])
-            post_init_code.append("")
-
         # Main entry point with transport-specific app initialization
         main_code = [
             "if __name__ == \"__main__\":",
@@ -764,16 +758,46 @@ class CodeGenerator:
         
         # Transport-specific run methods
         if self.settings.transport == "sse":
+            # Check if we need to add API key middleware for SSE
+            api_key_config = get_api_key_config()
+            if auth_components.get("has_auth") and api_key_config:
+                main_code.extend([
+                    "    # For SSE with API key auth, we need to get the app and add middleware",
+                    "    app = mcp.http_app(transport=\"sse\")",
+                    "    app.add_middleware(ApiKeyMiddleware)",
+                ])
+            else:
+                main_code.extend([
+                    "    # For SSE, get the app to add middleware",
+                    "    app = mcp.http_app(transport=\"sse\")",
+                ])
+            
+            # Add OpenTelemetry middleware to the SSE app if enabled
+            if self.settings.opentelemetry_enabled:
+                main_code.extend([
+                    "    # Apply OpenTelemetry middleware to the SSE app",
+                    "    from opentelemetry.instrumentation.asgi import OpenTelemetryMiddleware",
+                    "    app = OpenTelemetryMiddleware(app)",
+                ])
+            
             main_code.extend([
-                "    # For SSE, FastMCP's run method handles auth integration better",
-                "    mcp.run(transport=\"sse\", host=host, port=port, log_level=\"info\")"
+                "    # Run with the configured app",
+                "    uvicorn.run(app, host=host, port=port, log_level=\"info\")"
             ])
-        elif self.settings.transport == "streamable-http":
+        elif self.settings.transport in ["streamable-http", "http"]:
             main_code.extend([
                 "    # Create HTTP app and run with uvicorn",
                 "    app = mcp.http_app()",
             ])
             
+            # Check if we need to add API key middleware
+            api_key_config = get_api_key_config()
+            if auth_components.get("has_auth") and api_key_config:
+                main_code.extend([
+                    "    # Add API key middleware",
+                    "    app.add_middleware(ApiKeyMiddleware)",
+                ])
+            
             # Add OpenTelemetry middleware to the HTTP app if enabled
             if self.settings.opentelemetry_enabled:
                 main_code.extend([
@@ -800,7 +824,6 @@ class CodeGenerator:
             env_section + 
             auth_setup_code +
             server_code_lines +
-            post_init_code +
             component_registrations +
             main_code
         )

golf/core/builder_auth.py

@@ -145,7 +145,6 @@ def generate_api_key_auth_components(server_name: str, opentelemetry_enabled: bo
         - setup_code: Auth setup code (middleware setup)
         - fastmcp_args: Dict of arguments to add to FastMCP constructor
         - has_auth: Whether auth is configured
-        - post_init_code: Code to run after FastMCP instance is created
     """
     api_key_config = get_api_key_config()
     if not api_key_config:
@@ -153,24 +152,35 @@ def generate_api_key_auth_components(server_name: str, opentelemetry_enabled: bo
             "imports": [],
             "setup_code": [],
             "fastmcp_args": {},
-            "has_auth": False,
-            "post_init_code": []
+            "has_auth": False
         }
     
     auth_imports = [
         "# API key authentication setup",
-        "from golf.auth.helpers import set_api_key",
-        "from golf.auth.api_key import get_api_key_config",
+        "from golf.auth.api_key import get_api_key_config, configure_api_key",
+        "from golf.auth import set_api_key",
         "from starlette.middleware.base import BaseHTTPMiddleware",
         "from starlette.requests import Request",
         "from starlette.responses import JSONResponse",
+        "import os",
     ]
     
     setup_code_lines = [
-        "# Middleware to extract API key from headers",
+        "# Recreate API key configuration from pre_build.py",
+        f"configure_api_key(",
+        f"    header_name={repr(api_key_config.header_name)},",
+        f"    header_prefix={repr(api_key_config.header_prefix)},",
+        f"    required={repr(api_key_config.required)}",
+        f")",
+        "",
+        "# Simplified API key middleware that validates presence",
         "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'",
+        "        ",
         "        api_key_config = get_api_key_config()",
+        "        ",
         "        if api_key_config:",
         "            # Extract API key from the configured header",
         "            header_name = api_key_config.header_name",
@@ -183,109 +193,39 @@ def generate_api_key_auth_components(server_name: str, opentelemetry_enabled: bo
         "                    api_key = v",
         "                    break",
         "            ",
-        "            # Check if API key is required and missing",
+        "            # Process the API key if found",
+        "            if api_key:",
+        "                # Strip prefix if configured",
+        "                if header_prefix and api_key.startswith(header_prefix):",
+        "                    api_key = api_key[len(header_prefix):]",
+        "                ",
+        "                # Store the API key in request state for tools to access",
+        "                request.state.api_key = api_key",
+        "                ",
+        "                # Also store in context variable for tools",
+        "                set_api_key(api_key)",
+        "            ",
+        "            # Check if API key is required but missing",
         "            if api_key_config.required and not api_key:",
         "                return JSONResponse(",
         "                    {'error': 'unauthorized', 'detail': f'Missing required {header_name} header'},",
         "                    status_code=401,",
         "                    headers={'WWW-Authenticate': f'{header_name} realm=\"MCP Server\"'}",
         "                )",
-        "            ",
-        "            # Strip prefix if configured and present",
-        "            if api_key and header_prefix and api_key.startswith(header_prefix):",
-        "                api_key = api_key[len(header_prefix):]",
-        "            elif api_key and header_prefix and api_key_config.required:",
-        "                # Has API key but wrong format when required",
-        "                return JSONResponse(",
-        "                    {'error': 'unauthorized', 'detail': f'Invalid {header_name} format, expected prefix: {header_prefix}'},",
-        "                    status_code=401,",
-        "                    headers={'WWW-Authenticate': f'{header_name} realm=\"MCP Server\"'}",
-        "                )",
-        "            ",
-        "            # Store the API key in context for tools to access",
-        "            set_api_key(api_key)",
         "        ",
         "        # Continue with the request",
-        "        response = await call_next(request)",
-        "        return response",
+        "        return await call_next(request)",
         "",
     ]
     
     # API key auth is handled via middleware, not FastMCP constructor args
     fastmcp_args = {}
     
-    # Code to run after FastMCP instance is created
-    # FastMCP doesn't expose .app directly, so we need to use custom_route
-    # to add a middleware-like functionality
-    post_init_code = [
-        "# API key authentication via custom middleware function",
-        "# Since FastMCP doesn't expose .app, we'll use a different approach",
-        "import functools",
-        "from starlette.responses import JSONResponse",
-        "",
-        "# Store original method references",
-        "_original_call_tool = mcp._mcp_call_tool if hasattr(mcp, '_mcp_call_tool') else None",
-        "_original_read_resource = mcp._mcp_read_resource if hasattr(mcp, '_mcp_read_resource') else None",
-        "_original_get_prompt = mcp._mcp_get_prompt if hasattr(mcp, '_mcp_get_prompt') else None",
-        "",
-        "# Wrapper to extract API key before processing",
-        "def with_api_key_extraction(original_method):",
-        "    @functools.wraps(original_method)",
-        "    async def wrapper(request, *args, **kwargs):",
-        "        # Extract API key from request headers",
-        "        api_key_config = get_api_key_config()",
-        "        if api_key_config and hasattr(request, 'headers'):",
-        "            header_name = api_key_config.header_name",
-        "            header_prefix = api_key_config.header_prefix",
-        "            ",
-        "            # Case-insensitive header lookup",
-        "            api_key = None",
-        "            for k, v in request.headers.items():",
-        "                if k.lower() == header_name.lower():",
-        "                    api_key = v",
-        "                    break",
-        "            ",
-        "            # Check if API key is required and missing",
-        "            if api_key_config.required and not api_key:",
-        "                return JSONResponse(",
-        "                    {'error': 'unauthorized', 'detail': f'Missing required {header_name} header'},",
-        "                    status_code=401,",
-        "                    headers={'WWW-Authenticate': f'{header_name} realm=\"MCP Server\"'}",
-        "                )",
-        "            ",
-        "            # Strip prefix if configured and present",
-        "            if api_key and header_prefix and api_key.startswith(header_prefix):",
-        "                api_key = api_key[len(header_prefix):]",
-        "            elif api_key and header_prefix and api_key_config.required:",
-        "                # Has API key but wrong format when required",
-        "                return JSONResponse(",
-        "                    {'error': 'unauthorized', 'detail': f'Invalid {header_name} format, expected prefix: {header_prefix}'},",
-        "                    status_code=401,",
-        "                    headers={'WWW-Authenticate': f'{header_name} realm=\"MCP Server\"'}",
-        "                )",
-        "            ",
-        "            # Store the API key in context for tools to access",
-        "            set_api_key(api_key)",
-        "        ",
-        "        # Call the original method",
-        "        return await original_method(request, *args, **kwargs)",
-        "    return wrapper",
-        "",
-        "# Wrap the MCP methods if they exist",
-        "if _original_call_tool:",
-        "    mcp._mcp_call_tool = with_api_key_extraction(_original_call_tool)",
-        "if _original_read_resource:",
-        "    mcp._mcp_read_resource = with_api_key_extraction(_original_read_resource)",
-        "if _original_get_prompt:",
-        "    mcp._mcp_get_prompt = with_api_key_extraction(_original_get_prompt)",
-    ]
-    
     return {
         "imports": auth_imports,
         "setup_code": setup_code_lines,
         "fastmcp_args": fastmcp_args,
-        "has_auth": True,
-        "post_init_code": post_init_code
+        "has_auth": True
     }