golf-mcp 0.1.16__py3-none-any.whl → 0.1.18__py3-none-any.whl

golf/telemetry/instrumentation.py

@@ -29,6 +29,15 @@ 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 and not os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT"):
+        # Auto-configure for Golf platform
+        os.environ["OTEL_TRACES_EXPORTER"] = "otlp_http"
+        os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = "http://localhost:8000/api/v1/otel"
+        os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = f"X-Golf-Key={golf_api_key}"
+        print("[INFO] Auto-configured OpenTelemetry for Golf platform ingestion")
+
     # Check for required environment variables based on exporter type
     exporter_type = os.environ.get("OTEL_TRACES_EXPORTER", "console").lower()
 
@@ -37,7 +46,8 @@ def init_telemetry(service_name: str = "golf-mcp-server") -> TracerProvider | No
         endpoint = os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT")
         if not endpoint:
             print(
-                "[WARNING] OpenTelemetry tracing is disabled: OTEL_EXPORTER_OTLP_ENDPOINT is not set for OTLP HTTP exporter"
+                "[WARNING] OpenTelemetry tracing is disabled: "
+                "OTEL_EXPORTER_OTLP_ENDPOINT is not set for OTLP HTTP exporter"
             )
             return None
 
@@ -47,6 +57,14 @@ def init_telemetry(service_name: str = "golf-mcp-server") -> TracerProvider | No
         "service.version": os.environ.get("SERVICE_VERSION", "1.0.0"),
         "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
@@ -71,6 +89,10 @@ def init_telemetry(service_name: str = "golf-mcp-server") -> TracerProvider | No
             exporter = OTLPSpanExporter(
                 endpoint=endpoint, headers=header_dict if header_dict else None
             )
+
+            # Log successful configuration for Golf platform
+            if golf_api_key:
+                print(f"[INFO] OpenTelemetry configured for Golf platform: {endpoint}")
         else:
             # Default to console exporter
             exporter = ConsoleSpanExporter(out=sys.stderr)
@@ -113,21 +135,6 @@ def init_telemetry(service_name: str = "golf-mcp-server") -> TracerProvider | No
         traceback.print_exc()
         raise
 
-    # Create a test span to verify everything is working
-    try:
-        test_tracer = provider.get_tracer("golf.telemetry.test", "1.0.0")
-        with test_tracer.start_as_current_span("startup.test") as span:
-            span.set_attribute("test", True)
-            span.set_attribute("service.name", service_name)
-            span.set_attribute("exporter.type", exporter_type)
-            span.set_attribute(
-                "endpoint", os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT", "not set")
-            )
-    except Exception:
-        import traceback
-
-        traceback.print_exc()
-
     return provider
 
 
@@ -154,14 +161,12 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
 
     tracer = get_tracer()
 
-    # Add debug logging
-    print(
-        f"[TELEMETRY DEBUG] Instrumenting tool: {tool_name} (function: {func.__name__})"
-    )
-
     @functools.wraps(func)
     async def async_wrapper(*args, **kwargs):
-        print(f"[TELEMETRY DEBUG] Executing async tool: {tool_name}")
+        # Record metrics timing
+        import time
+
+        start_time = time.time()
 
         # Create a more descriptive span name
         span_name = f"mcp.tool.{tool_name}.execute"
@@ -205,52 +210,9 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
             if session_id_from_baggage:
                 span.set_attribute("mcp.session.id", session_id_from_baggage)
 
-            # Add tool arguments as span attributes (be careful with sensitive data)
-            for i, arg in enumerate(args):
-                if isinstance(arg, str | int | float | bool) or arg is None:
-                    span.set_attribute(f"mcp.tool.arg.{i}", str(arg))
-                elif hasattr(arg, "__dict__"):
-                    # For objects, just record the type
-                    span.set_attribute(f"mcp.tool.arg.{i}.type", type(arg).__name__)
-
-            # Add named arguments with better naming
-            for key, value in kwargs.items():
-                if key != "ctx":
-                    if value is None:
-                        span.set_attribute(f"mcp.tool.input.{key}", "null")
-                    elif isinstance(value, str | int | float | bool):
-                        span.set_attribute(f"mcp.tool.input.{key}", str(value))
-                    elif isinstance(value, list | tuple):
-                        span.set_attribute(f"mcp.tool.input.{key}.count", len(value))
-                        span.set_attribute(f"mcp.tool.input.{key}.type", "array")
-                    elif isinstance(value, dict):
-                        span.set_attribute(f"mcp.tool.input.{key}.count", len(value))
-                        span.set_attribute(f"mcp.tool.input.{key}.type", "object")
-                        # Only show first few keys to avoid exceeding attribute limits
-                        if len(value) > 0 and len(value) <= 5:
-                            keys_list = list(value.keys())[:5]
-                            # Limit key length and join
-                            truncated_keys = [
-                                str(k)[:20] + "..." if len(str(k)) > 20 else str(k)
-                                for k in keys_list
-                            ]
-                            span.set_attribute(
-                                f"mcp.tool.input.{key}.sample_keys",
-                                ",".join(truncated_keys),
-                            )
-                    else:
-                        # For other types, at least record the type
-                        span.set_attribute(
-                            f"mcp.tool.input.{key}.type", type(value).__name__
-                        )
-
             # Add event for tool execution start
             span.add_event("tool.execution.started", {"tool.name": tool_name})
 
-            print(
-                f"[TELEMETRY DEBUG] Tool span created: {span_name} (span_id: {span.get_span_context().span_id:016x})"
-            )
-
             try:
                 result = await func(*args, **kwargs)
                 span.set_status(Status(StatusCode.OK))
@@ -258,6 +220,19 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
                 # Add event for successful completion
                 span.add_event("tool.execution.completed", {"tool.name": tool_name})
 
+                # Record metrics for successful execution
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+                    metrics_collector.increment_tool_execution(tool_name, "success")
+                    metrics_collector.record_tool_duration(
+                        tool_name, time.time() - start_time
+                    )
+                except ImportError:
+                    # Metrics not available, continue without metrics
+                    pass
+
                 # Capture result metadata with better structure
                 if result is not None:
                     if isinstance(result, str | int | float | bool):
@@ -288,9 +263,6 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
                     # For any result, record its type
                     span.set_attribute("mcp.tool.result.class", type(result).__name__)
 
-                print(
-                    f"[TELEMETRY DEBUG] Tool execution completed successfully: {tool_name}"
-                )
                 return result
             except Exception as e:
                 span.record_exception(e)
@@ -305,12 +277,26 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
                         "error.message": str(e),
                     },
                 )
-                print(f"[TELEMETRY DEBUG] Tool execution failed: {tool_name} - {e}")
+
+                # Record metrics for failed execution
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+                    metrics_collector.increment_tool_execution(tool_name, "error")
+                    metrics_collector.increment_error("tool", type(e).__name__)
+                except ImportError:
+                    # Metrics not available, continue without metrics
+                    pass
+
                 raise
 
     @functools.wraps(func)
     def sync_wrapper(*args, **kwargs):
-        print(f"[TELEMETRY DEBUG] Executing sync tool: {tool_name}")
+        # Record metrics timing
+        import time
+
+        start_time = time.time()
 
         # Create a more descriptive span name
         span_name = f"mcp.tool.{tool_name}.execute"
@@ -354,52 +340,9 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
             if session_id_from_baggage:
                 span.set_attribute("mcp.session.id", session_id_from_baggage)
 
-            # Add tool arguments as span attributes (be careful with sensitive data)
-            for i, arg in enumerate(args):
-                if isinstance(arg, str | int | float | bool) or arg is None:
-                    span.set_attribute(f"mcp.tool.arg.{i}", str(arg))
-                elif hasattr(arg, "__dict__"):
-                    # For objects, just record the type
-                    span.set_attribute(f"mcp.tool.arg.{i}.type", type(arg).__name__)
-
-            # Add named arguments with better naming
-            for key, value in kwargs.items():
-                if key != "ctx":
-                    if value is None:
-                        span.set_attribute(f"mcp.tool.input.{key}", "null")
-                    elif isinstance(value, str | int | float | bool):
-                        span.set_attribute(f"mcp.tool.input.{key}", str(value))
-                    elif isinstance(value, list | tuple):
-                        span.set_attribute(f"mcp.tool.input.{key}.count", len(value))
-                        span.set_attribute(f"mcp.tool.input.{key}.type", "array")
-                    elif isinstance(value, dict):
-                        span.set_attribute(f"mcp.tool.input.{key}.count", len(value))
-                        span.set_attribute(f"mcp.tool.input.{key}.type", "object")
-                        # Only show first few keys to avoid exceeding attribute limits
-                        if len(value) > 0 and len(value) <= 5:
-                            keys_list = list(value.keys())[:5]
-                            # Limit key length and join
-                            truncated_keys = [
-                                str(k)[:20] + "..." if len(str(k)) > 20 else str(k)
-                                for k in keys_list
-                            ]
-                            span.set_attribute(
-                                f"mcp.tool.input.{key}.sample_keys",
-                                ",".join(truncated_keys),
-                            )
-                    else:
-                        # For other types, at least record the type
-                        span.set_attribute(
-                            f"mcp.tool.input.{key}.type", type(value).__name__
-                        )
-
             # Add event for tool execution start
             span.add_event("tool.execution.started", {"tool.name": tool_name})
 
-            print(
-                f"[TELEMETRY DEBUG] Tool span created: {span_name} (span_id: {span.get_span_context().span_id:016x})"
-            )
-
             try:
                 result = func(*args, **kwargs)
                 span.set_status(Status(StatusCode.OK))
@@ -407,6 +350,19 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
                 # Add event for successful completion
                 span.add_event("tool.execution.completed", {"tool.name": tool_name})
 
+                # Record metrics for successful execution
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+                    metrics_collector.increment_tool_execution(tool_name, "success")
+                    metrics_collector.record_tool_duration(
+                        tool_name, time.time() - start_time
+                    )
+                except ImportError:
+                    # Metrics not available, continue without metrics
+                    pass
+
                 # Capture result metadata with better structure
                 if result is not None:
                     if isinstance(result, str | int | float | bool):
@@ -437,9 +393,6 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
                     # For any result, record its type
                     span.set_attribute("mcp.tool.result.class", type(result).__name__)
 
-                print(
-                    f"[TELEMETRY DEBUG] Tool execution completed successfully: {tool_name}"
-                )
                 return result
             except Exception as e:
                 span.record_exception(e)
@@ -454,7 +407,18 @@ def instrument_tool(func: Callable[..., T], tool_name: str) -> Callable[..., T]:
                         "error.message": str(e),
                     },
                 )
-                print(f"[TELEMETRY DEBUG] Tool execution failed: {tool_name} - {e}")
+
+                # Record metrics for failed execution
+                try:
+                    from golf.metrics import get_metrics_collector
+
+                    metrics_collector = get_metrics_collector()
+                    metrics_collector.increment_tool_execution(tool_name, "error")
+                    metrics_collector.increment_error("tool", type(e).__name__)
+                except ImportError:
+                    # Metrics not available, continue without metrics
+                    pass
+
                 raise
 
     # Return appropriate wrapper based on function type
@@ -701,16 +665,6 @@ def instrument_prompt(func: Callable[..., T], prompt_name: str) -> Callable[...,
             if session_id_from_baggage:
                 span.set_attribute("mcp.session.id", session_id_from_baggage)
 
-            # Add prompt arguments
-            for key, value in kwargs.items():
-                if key != "ctx":
-                    if isinstance(value, str | int | float | bool) or value is None:
-                        span.set_attribute(f"mcp.prompt.arg.{key}", str(value))
-                    else:
-                        span.set_attribute(
-                            f"mcp.prompt.arg.{key}.type", type(value).__name__
-                        )
-
             # Add event for prompt generation start
             span.add_event("prompt.generation.started", {"prompt.name": prompt_name})
 
@@ -805,16 +759,6 @@ def instrument_prompt(func: Callable[..., T], prompt_name: str) -> Callable[...,
             if session_id_from_baggage:
                 span.set_attribute("mcp.session.id", session_id_from_baggage)
 
-            # Add prompt arguments
-            for key, value in kwargs.items():
-                if key != "ctx":
-                    if isinstance(value, str | int | float | bool) or value is None:
-                        span.set_attribute(f"mcp.prompt.arg.{key}", str(value))
-                    else:
-                        span.set_attribute(
-                            f"mcp.prompt.arg.{key}.type", type(value).__name__
-                        )
-
             # Add event for prompt generation start
             span.add_event("prompt.generation.started", {"prompt.name": prompt_name})
 
@@ -897,13 +841,64 @@ async def telemetry_lifespan(mcp_instance):
         from starlette.requests import Request
 
         class SessionTracingMiddleware(BaseHTTPMiddleware):
+            def __init__(self, app):
+                super().__init__(app)
+                # Track seen sessions to count unique sessions
+                self.seen_sessions = set()
+                # Track session start times for duration calculation
+                self.session_start_times = {}
+
             async def dispatch(self, request: Request, call_next):
+                # Record HTTP request timing
+                import time
+
+                start_time = time.time()
+
                 # Extract session ID from query params or headers
                 session_id = request.query_params.get("session_id")
                 if not session_id:
                     # Check headers as fallback
                     session_id = request.headers.get("x-session-id")
 
+                # Track session metrics
+                if session_id:
+                    current_time = time.time()
+
+                    # Record new session if we haven't seen this session ID before
+                    if session_id not in self.seen_sessions:
+                        self.seen_sessions.add(session_id)
+                        self.session_start_times[session_id] = current_time
+                        try:
+                            from golf.metrics import get_metrics_collector
+
+                            metrics_collector = get_metrics_collector()
+                            metrics_collector.increment_session()
+                        except ImportError:
+                            pass
+                    else:
+                        # Update session duration (time since first request)
+                        if session_id in self.session_start_times:
+                            duration = (
+                                current_time - self.session_start_times[session_id]
+                            )
+                            try:
+                                from golf.metrics import get_metrics_collector
+
+                                metrics_collector = get_metrics_collector()
+                                metrics_collector.record_session_duration(duration)
+                            except ImportError:
+                                pass
+
+                    # Clean up old session data periodically
+                    if len(self.seen_sessions) > 10000:
+                        # Keep only the most recent 5000 sessions
+                        recent_sessions = list(self.seen_sessions)[-5000:]
+                        self.seen_sessions = set(recent_sessions)
+                        # Clean up start times for removed sessions
+                        for old_session in list(self.session_start_times.keys()):
+                            if old_session not in self.seen_sessions:
+                                self.session_start_times.pop(old_session, None)
+
                 # Create a descriptive span name based on the request
                 method = request.method
                 path = request.url.path
@@ -979,6 +974,29 @@ async def telemetry_lifespan(mcp_instance):
                             },
                         )
 
+                        # Record HTTP request metrics
+                        try:
+                            from golf.metrics import get_metrics_collector
+
+                            metrics_collector = get_metrics_collector()
+
+                            # Clean up path for metrics (remove query params, normalize)
+                            clean_path = path.split("?")[0]  # Remove query parameters
+                            if clean_path.startswith("/"):
+                                clean_path = (
+                                    clean_path[1:] or "root"
+                                )  # Remove leading slash, handle root
+
+                            metrics_collector.increment_http_request(
+                                method, response.status_code, clean_path
+                            )
+                            metrics_collector.record_http_duration(
+                                method, clean_path, time.time() - start_time
+                            )
+                        except ImportError:
+                            # Metrics not available, continue without metrics
+                            pass
+
                         return response
                     except Exception as e:
                         span.record_exception(e)
@@ -994,6 +1012,25 @@ async def telemetry_lifespan(mcp_instance):
                                 "error.message": str(e),
                             },
                         )
+
+                        # Record HTTP error metrics
+                        try:
+                            from golf.metrics import get_metrics_collector
+
+                            metrics_collector = get_metrics_collector()
+
+                            # Clean up path for metrics
+                            clean_path = path.split("?")[0]
+                            if clean_path.startswith("/"):
+                                clean_path = clean_path[1:] or "root"
+
+                            metrics_collector.increment_http_request(
+                                method, 500, clean_path
+                            )  # Assume 500 for exceptions
+                            metrics_collector.increment_error("http", type(e).__name__)
+                        except ImportError:
+                            pass
+
                         raise
                     finally:
                         if token:
@@ -1004,16 +1041,13 @@ async def telemetry_lifespan(mcp_instance):
             app = getattr(mcp_instance, "app", getattr(mcp_instance, "_app", None))
             if app and hasattr(app, "add_middleware"):
                 app.add_middleware(SessionTracingMiddleware)
-                print("[TELEMETRY DEBUG] Added SessionTracingMiddleware to FastMCP app")
 
         # Also try to instrument FastMCP's internal handlers
         if hasattr(mcp_instance, "_tool_manager") and hasattr(
             mcp_instance._tool_manager, "tools"
         ):
-            print(
-                f"[TELEMETRY DEBUG] Found {len(mcp_instance._tool_manager.tools)} tools in FastMCP"
-            )
             # The tools should already be instrumented when they were registered
+            pass
 
         # Try to patch FastMCP's request handling to ensure context propagation
         if hasattr(mcp_instance, "handle_request"):
@@ -1026,10 +1060,9 @@ async def telemetry_lifespan(mcp_instance):
                     return await original_handle_request(*args, **kwargs)
 
             mcp_instance.handle_request = traced_handle_request
-            print("[TELEMETRY DEBUG] Patched FastMCP handle_request method")
 
-    except Exception as e:
-        print(f"[TELEMETRY DEBUG] Error setting up telemetry middleware: {e}")
+    except Exception:
+        # Silently continue if middleware setup fails
         import traceback
 
         traceback.print_exc()

{golf_mcp-0.1.16.dist-info → golf_mcp-0.1.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: golf-mcp
-Version: 0.1.16
+Version: 0.1.18
 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>=2.0.0
+Requires-Dist: fastmcp<2.6.0,>=2.0.0
 Requires-Dist: pydantic>=2.11.0
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: black>=24.10.0
@@ -34,6 +34,8 @@ Requires-Dist: opentelemetry-sdk>=1.33.1; extra == "telemetry"
 Requires-Dist: opentelemetry-instrumentation-asgi>=0.40b0; extra == "telemetry"
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=0.40b0; extra == "telemetry"
 Requires-Dist: wrapt>=1.17.0; extra == "telemetry"
+Provides-Extra: metrics
+Requires-Dist: prometheus-client>=0.22.1; extra == "metrics"
 Dynamic: license-file
 
 <div align="center">
@@ -128,7 +130,7 @@ A Golf project initialized with `golf init` will have a structure similar to thi
 
 -   **`golf.json`**: Configures server name, port, transport, telemetry, and other build settings.
 -   **`tools/`**, **`resources/`**, **`prompts/`**: Contain your Python files, each defining a single component. These directories can also contain nested subdirectories to further organize your components (e.g., `tools/payments/charge.py`). The module docstring of each file serves as the component's description.
-    -   Component IDs are automatically derived from their file path. For example, `tools/hello.py` becomes `hello`, and a nested file like `tools/payments/submit.py` would become `submit-payments` (filename, followed by reversed parent directories under the main category, joined by hyphens).
+    -   Component IDs are automatically derived from their file path. For example, `tools/hello.py` becomes `hello`, and a nested file like `tools/payments/submit.py` would become `submit_payments` (filename, followed by reversed parent directories under the main category, joined by underscores).
 -   **`common.py`** (not shown, but can be placed in subdirectories like `tools/payments/common.py`): Used to share code (clients, models, etc.) among components in the same subdirectory.
 
 ## Example: Defining a Tool
@@ -178,6 +180,10 @@ The `golf.json` file is the heart of your Golf project configuration. Here's wha
                                       // - "streamable-http": HTTP with streaming support
                                       // - "stdio": Standard I/O (for CLI integration)
   
+  // HTTP Transport Configuration (optional)
+  "stateless_http": false,            // Make streamable-http transport stateless (new session per request)
+                                      // When true, server restarts won't break existing client connections
+  
   // Health Check Configuration (optional)
   "health_check_enabled": false,      // Enable health check endpoint for Kubernetes/load balancers
   "health_check_path": "/health",     // HTTP path for health check endpoint
@@ -198,6 +204,7 @@ The `golf.json` file is the heart of your Golf project configuration. Here's wha
   - `"streamable-http"` provides HTTP streaming for traditional API clients
   - `"stdio"` enables integration with command-line tools and scripts
 - **`host` & `port`**: Control where your server listens. Use `"127.0.0.1"` for local development or `"0.0.0.0"` to accept external connections.
+- **`stateless_http`**: When true, makes the streamable-http transport stateless by creating a new session for each request. This ensures that server restarts don't break existing client connections, making the server truly stateless.
 - **`health_check_enabled`**: When true, enables a health check endpoint for Kubernetes readiness/liveness probes and load balancers
 - **`health_check_path`**: Customizable path for the health check endpoint (defaults to "/health")
 - **`health_check_response`**: Customizable response text for successful health checks (defaults to "OK")

{golf_mcp-0.1.16.dist-info → golf_mcp-0.1.18.dist-info}/RECORD

@@ -1,28 +1,30 @@
-golf/__init__.py,sha256=yF88-8vL8keLe6gCTumymw0UoMkWkSrJnzLru4zBCLQ,23
+golf/__init__.py,sha256=6BiuMUkhwQp6bzUZSF8np8F1NwCltEtK0sPBF__tepU,23
 golf/auth/__init__.py,sha256=Rj4yUngJklk6xrDCrxqLTtoDAMzF1HcTvy_l8wREeao,4103
 golf/auth/api_key.py,sha256=LiIraLiH2v7s3yavidaI6BDlAEfK8XnWF15QmaJn9G4,2378
 golf/auth/helpers.py,sha256=ZogdcHM7J2PN6cL6F6OLZ3gyoUR3dwAFDxOJQ2DW_bc,6526
 golf/auth/oauth.py,sha256=-TYcMA4ULWNQacmUvzek2uQVMJpRT3hXC_d5D2k9c44,31156
 golf/auth/provider.py,sha256=3loeYrkNwIRDvyUkf8gbcCRJSiKiVXgE_rMGCSCr5mk,3802
 golf/cli/__init__.py,sha256=R8Y8KdD2C8gDo24fXGq-fdWWNeaq3MYjrbaSB8Hb-Hg,45
-golf/cli/main.py,sha256=izB2DW4uLtY-twcacMjsBDtywbXaAIhV1EQdgiso2LE,13495
+golf/cli/main.py,sha256=3qexjKNL8vYg-48ATYcwW4-Wv45l3VxntW-mSqDAbEc,13958
 golf/commands/__init__.py,sha256=GKtIEm7EPQWRgot73RPZPWegwN7Zm0bHtUJbR63FNiw,83
 golf/commands/build.py,sha256=jhdxB5EwwCC_8PgqdXLUKuBpnycjh0gft3_7EuTo6ro,2319
-golf/commands/init.py,sha256=0QoiDt5ERErh2X7l1EozkMgX4voFk4EMY7BDyI7s-vc,8186
+golf/commands/init.py,sha256=DUAvGqOUapWdF2cgWPscqHRvyOZDiajR0F0Wkn_jm-k,10355
 golf/commands/run.py,sha256=xsiG5LZw4qVt3cRTTfIoWP4Bf4AxNBBJKx0NNfoua40,2884
 golf/core/__init__.py,sha256=4bKeskJ2fPaZqkz2xQScSa3phRLLrmrczwSL632jv-o,52
-golf/core/builder.py,sha256=EUYGGWM7aMGTe5W8ronstrXxA5ej1mURh3RzD2frZ1U,52560
-golf/core/builder_auth.py,sha256=6oGw1HsHdtAjfbJKoyakBrFp2v6FgrO1hFuLR9thiY4,13821
+golf/core/builder.py,sha256=flsXnlwOTUhXFMpmZwoxWgnK_oLj4zpSyqcKuDnXezw,59526
+golf/core/builder_auth.py,sha256=nGgyMTiRAqaNfh1FSvoFe6oTVq9RgfMf9JoFGAv2_do,14050
+golf/core/builder_metrics.py,sha256=j6Gtgd867o46JbDfSNGNsHt1QtV1XHKUJs1z8r4siQM,8830
 golf/core/builder_telemetry.py,sha256=jobFgRSspLQLuitL4ytk6asSUdTqYcDxGY3sTjkrZd4,2654
-golf/core/config.py,sha256=GhR9TFzkHbPTPF27-VkoFlI5_anNYyHFW2-dpJeGIzE,7009
-golf/core/parser.py,sha256=Yq4mXUwRub4iC7wOUiei8PUnb2TdcnzGHE_BW5PhkT8,21583
-golf/core/telemetry.py,sha256=xehArzw3-MVXGA6L1JaxSiX5XIDWDpKfhQUZhX1zjiM,14895
+golf/core/config.py,sha256=6yPtwzVTJauufEnrfUbxsz69H8jC0Ra427oDaRM0-xE,7397
+golf/core/parser.py,sha256=BQRus1O9zmzSmyavwLVfN8BpYFkbrWUDrgQ7yrYfAKw,42457
+golf/core/platform.py,sha256=Z2yEi6ilmQCLC_uAD_oZdVO0WvkL4tsyw7sx0vHhysI,6440
+golf/core/telemetry.py,sha256=CjZ7urbizaRjyFiVBjfGW8V4PmNCG1_quk3FvbVTcjw,15772
 golf/core/transformer.py,sha256=_0nM42M41oM9zw_XxPVVS6MErdBSw2B5lULC7_UFLfU,5287
 golf/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 golf/examples/api_key/.env,sha256=15dewTdeJEMAIuzQmh1SFc1zEN6PwryWgAc14IV02lY,90
-golf/examples/api_key/.env.example,sha256=zKXwnfCHdmycsESR8z5b8-rvYnaN3SagxrwL6B_VGjA,215
-golf/examples/api_key/README.md,sha256=nuc4YIspX_eokoArylBv6rKPv5P8BTq__2YaInidrUk,2892
-golf/examples/api_key/golf.json,sha256=y8I43-28eqYW5x2CTdNsb7FaYaDsfcXiUzbyyKF7qto,362
+golf/examples/api_key/.env.example,sha256=fvM_r9xLoiJ_41ZbcDc_EQ48uyxwb7zf0gP_bhQroEY,29
+golf/examples/api_key/README.md,sha256=wRcgwYArwiRcjL6GKEOkPVQal7L37WnREa_rwhrIE10,2892
+golf/examples/api_key/golf.json,sha256=V7atsB5T706bBlkZ5iVBPIhAA6_3Ba3dN6NOyVaV06g,214
 golf/examples/api_key/pre_build.py,sha256=-12HGLV70sQcPhgN51zx25uN2o48JeFvTByzF2ayYp4,471
 golf/examples/api_key/tools/issues/create.py,sha256=51X0uGaisUMfMkmJCskArpefpnxZ4fnT4T_f7HhqQdU,2721
 golf/examples/api_key/tools/issues/list.py,sha256=Egl2o1YVSU8Iigu8XO_iK1-Pn1OnFL3j6LOzaG10rTI,2720
@@ -30,9 +32,9 @@ golf/examples/api_key/tools/repos/list.py,sha256=9JTRLFzA7GwMYAaLjpOD85uXxv0JI4H
 golf/examples/api_key/tools/search/code.py,sha256=3quEIzrl0i_DM1fjszTcrzaAqMC7p0TZY99NL5GceKY,2993
 golf/examples/api_key/tools/users/get.py,sha256=VF-hdUkba2_DqKSC_F7vqtbx0EXAK06wUFBEluKqLIA,2470
 golf/examples/basic/.env,sha256=CqdcvPXopWppurJ3bBjT2dODlKUrLv629BHnOy8zBkM,247
-golf/examples/basic/.env.example,sha256=k_wpsqp0oRLLRw520NL3VrbJx4KDZclczYBW1YUgjvw,214
+golf/examples/basic/.env.example,sha256=fqMyaQ7pc9KHFcT4vChBO4AEGrbW7PVXOfqbrCO6j9Q,157
 golf/examples/basic/README.md,sha256=-mY3R6AAnkXT9FPkALDrJtdf9IyKDvuqjsrLAMTLRYI,2663
-golf/examples/basic/golf.json,sha256=wHG_00A4a8IX0nDkZNi08DN0Ax7VHgVtKOOViXgPBu0,314
+golf/examples/basic/golf.json,sha256=8DiRIXmWolrILmbHzEG2tK-ZVwu1W2qBXRLz75XEjAs,166
 golf/examples/basic/pre_build.py,sha256=AG1N_sKd1UUtHPL7sw1v3YGOcZPQvoa9xcL79S9qjGI,1037
 golf/examples/basic/prompts/welcome.py,sha256=Qs_OsXdyPNw_cDZU7cnG4a0ZMzka6LF7vmPfax4cmKM,790
 golf/examples/basic/resources/current_time.py,sha256=hxhV7vGoiOv-DMXVNSVax_jkPoYR3CR9q5PpWYkdliI,1157
@@ -45,11 +47,14 @@ golf/examples/basic/tools/hello.py,sha256=s7Soiq9Wn7oKIvA6Hid8UKB14iyR7HZppIbIT4
 golf/examples/basic/tools/payments/charge.py,sha256=PIYdFV90hu35H1veLI8ueuYwebzrr5SCTX-x6lxRmU4,1800
 golf/examples/basic/tools/payments/common.py,sha256=hfyuQRIjrQfSqGjyY55W6pZSD5jL6O0geCE0DGx0v10,1302
 golf/examples/basic/tools/payments/refund.py,sha256=Qpl4GWvUw-L06oGQMbBzG8pikfCWfBCFcpkRiDOzmyQ,1607
+golf/metrics/__init__.py,sha256=O91y-hj_E9R06gqV8pDZrzHxOIl-1T415Hj9RvFAp3o,283
+golf/metrics/collector.py,sha256=iyRszP8TAAigyOsUFTGdKN8Xeob36LhUvXW9tntJrbA,7617
+golf/metrics/registry.py,sha256=mXQE4Pwf3PopGYjcUu4eGgPDAe085YWcsvcvWk0ny8Q,310
 golf/telemetry/__init__.py,sha256=ESGCg5HKwTCIfID1e_K7EE0bOWkSzMidlLtdqQgBd0w,396
-golf/telemetry/instrumentation.py,sha256=_p26XYLylpH42m7ztJSreqjZRUiXF1GmPPsOtksIQ28,44483
-golf_mcp-0.1.16.dist-info/licenses/LICENSE,sha256=5_j2f6fTJmvfmUewzElhkpAaXg2grVoxKouOA8ihV6E,11348
-golf_mcp-0.1.16.dist-info/METADATA,sha256=gpn7ea7CCDSDeDQwX3AQD5dEQYRQleMWVaimhrC7wK0,12361
-golf_mcp-0.1.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-golf_mcp-0.1.16.dist-info/entry_points.txt,sha256=5y7rHYM8jGpU-nfwdknCm5XsApLulqsnA37MO6BUTYg,43
-golf_mcp-0.1.16.dist-info/top_level.txt,sha256=BQToHcBUufdyhp9ONGMIvPE40jMEtmI20lYaKb4hxOg,5
-golf_mcp-0.1.16.dist-info/RECORD,,
+golf/telemetry/instrumentation.py,sha256=Sn7KBJSCf0Kih9ILEdminR0HggpbOlBKToJhnC4PmZE,44934
+golf_mcp-0.1.18.dist-info/licenses/LICENSE,sha256=5_j2f6fTJmvfmUewzElhkpAaXg2grVoxKouOA8ihV6E,11348
+golf_mcp-0.1.18.dist-info/METADATA,sha256=w8GR9q2Ln0UzWTXRFG6XdA1EzbAVUsF7D0tq1nEMqd4,12956
+golf_mcp-0.1.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+golf_mcp-0.1.18.dist-info/entry_points.txt,sha256=5y7rHYM8jGpU-nfwdknCm5XsApLulqsnA37MO6BUTYg,43
+golf_mcp-0.1.18.dist-info/top_level.txt,sha256=BQToHcBUufdyhp9ONGMIvPE40jMEtmI20lYaKb4hxOg,5
+golf_mcp-0.1.18.dist-info/RECORD,,