[mcp] get_services tool for service discovery (jaegertracing#7864)

## Implementation Complete: get_services MCP Tool (Part of jaegertracing#7827)

- [x] Create types file (`get_services.go`) in `internal/types/`
directory
- [x] Create handler file (`get_services.go`) in `internal/handlers/`
directory
- [x] Create comprehensive test file (`get_services_test.go`) with 12
test cases
- [x] Register `get_services` tool at the top of `registerTools()`
function in `server.go`
- [x] Update ADR-002 to mark `get_services` as completed in Phase 2
- [x] Run `make fmt` - ✅ passed successfully
- [x] Run `make lint` - ✅ passed with 0 issues
- [x] Run `make test` - ✅ all tests pass (12/12 for get_services)
- [x] Verify code coverage > 95% - ✅ 100% coverage for both functions
- [x] Final verification - ✅ module compiles and all tests pass
- [x] Sort services before applying limit for consistent results
- [x] Add test for NewGetServicesHandler constructor function

## Summary

Successfully implemented the `get_services` MCP tool as requested in
issue jaegertracing#7827. This tool enables users to discover available service
names, which is essential for using `search_traces` since it requires a
service_name parameter.

### Key Features:
- **Service Discovery**: Lists all available service names from storage
- **Pattern Filtering**: Supports regex pattern matching for filtering
services
- **Limit Control**: Configurable limit (default: 100 services)
- **Consistent Ordering**: Services are sorted alphabetically before
applying limit
- **Comprehensive Error Handling**: Invalid patterns, storage failures,
edge cases
- **100% Test Coverage**: 12 test cases covering all scenarios including
constructor

### Files Changed:
- **3 new files** created (types, handler, tests)
- **2 files** modified (server.go, ADR-002)

### Tool Position:
Registered at the **top** of `registerTools()` as required, making it
the first tool users encounter. This is critical because `search_traces`
depends on service names discovered through this tool.

### Testing:
- All 12 get_services tests pass
- All existing MCP tests continue to pass
- No regressions introduced
- Code quality verified with fmt and lint
- 100% code coverage for all functions

This implementation completes the requirements from issue jaegertracing#7827.

<!-- START COPILOT CODING AGENT SUFFIX -->



<!-- START COPILOT ORIGINAL PROMPT -->



<details>

<summary>Original prompt</summary>

> jaegertracing#7827
> 
> we're missing get_service tool, whichout which search_traces is not
useful since it requires a service name. Add this tool to the ADR-002 in
all relevant places and implement. The input should accept an optional
regex to filter the list of services. The tool should be at the top
inside registerTools() function.
> 
> State Part of jaegertracing#7827 in the PR description. Run make fmt make lint and
make test to success everytime before pushing to remove branch. Ensure
code coverage for new code over 95%. Update ADR to reflect progress.


</details>



<!-- START COPILOT CODING AGENT TIPS -->
---

💬 We'd love your input! Share your thoughts on Copilot coding agent in
our [2 minute survey](https://gh.io/copilot-coding-agent-survey).

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: yurishkuro <3523016+yurishkuro@users.noreply.github.com>

Author: 2 people

cmd/jaeger/internal/extension/jaegermcp/internal/handlers/get_services.go

@@ -0,0 +1,84 @@
+// Copyright (c) 2026 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package handlers
+
+import (
+	"context"
+	"fmt"
+	"regexp"
+	"sort"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+
+	"github.com/jaegertracing/jaeger/cmd/jaeger/internal/extension/jaegermcp/internal/types"
+	"github.com/jaegertracing/jaeger/cmd/jaeger/internal/extension/jaegerquery/querysvc"
+)
+
+const defaultServiceLimit = 100
+
+// queryServiceGetServicesInterface defines the interface we need from QueryService for testing
+type queryServiceGetServicesInterface interface {
+	GetServices(ctx context.Context) ([]string, error)
+}
+
+// getServicesHandler implements the get_services MCP tool.
+// This tool lists available service names, optionally filtered by a regex pattern.
+type getServicesHandler struct {
+	queryService queryServiceGetServicesInterface
+}
+
+// NewGetServicesHandler creates a new get_services handler and returns the handler function.
+func NewGetServicesHandler(
+	queryService *querysvc.QueryService,
+) mcp.ToolHandlerFor[types.GetServicesInput, types.GetServicesOutput] {
+	h := &getServicesHandler{
+		queryService: queryService,
+	}
+	return h.handle
+}
+
+// handle processes the get_services tool request.
+func (h *getServicesHandler) handle(
+	ctx context.Context,
+	_ *mcp.CallToolRequest,
+	input types.GetServicesInput,
+) (*mcp.CallToolResult, types.GetServicesOutput, error) {
+	// Get all services from storage
+	services, err := h.queryService.GetServices(ctx)
+	if err != nil {
+		return nil, types.GetServicesOutput{}, fmt.Errorf("failed to get services: %w", err)
+	}
+
+	// Apply pattern filter if provided
+	if input.Pattern != "" {
+		re, err := regexp.Compile(input.Pattern)
+		if err != nil {
+			return nil, types.GetServicesOutput{}, fmt.Errorf("invalid pattern: %w", err)
+		}
+
+		filtered := make([]string, 0, len(services))
+		for _, service := range services {
+			if re.MatchString(service) {
+				filtered = append(filtered, service)
+			}
+		}
+		services = filtered
+	}
+
+	// Sort services for consistent ordering
+	sort.Strings(services)
+
+	// Apply limit
+	limit := input.Limit
+	if limit <= 0 {
+		limit = defaultServiceLimit
+	}
+	if len(services) > limit {
+		services = services[:limit]
+	}
+
+	return nil, types.GetServicesOutput{
+		Services: services,
+	}, nil
+}

cmd/jaeger/internal/extension/jaegermcp/internal/handlers/get_services_test.go

@@ -0,0 +1,312 @@
+// Copyright (c) 2026 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package handlers
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/jaegertracing/jaeger/cmd/jaeger/internal/extension/jaegermcp/internal/types"
+)
+
+// mockGetServicesQueryService mocks the GetServices method for testing
+type mockGetServicesQueryService struct {
+	getServicesFunc func(ctx context.Context) ([]string, error)
+}
+
+func (m *mockGetServicesQueryService) GetServices(ctx context.Context) ([]string, error) {
+	if m.getServicesFunc != nil {
+		return m.getServicesFunc(ctx)
+	}
+	return nil, nil
+}
+
+func TestGetServicesHandler_Success_AllServices(t *testing.T) {
+	testServices := []string{
+		"frontend",
+		"payment-service",
+		"cart-service",
+		"user-service",
+	}
+
+	mock := &mockGetServicesQueryService{
+		getServicesFunc: func(_ context.Context) ([]string, error) {
+			return testServices, nil
+		},
+	}
+
+	handler := &getServicesHandler{queryService: mock}
+
+	input := types.GetServicesInput{}
+
+	_, output, err := handler.handle(context.Background(), &mcp.CallToolRequest{}, input)
+
+	require.NoError(t, err)
+	assert.Equal(t, testServices, output.Services)
+}
+
+func TestGetServicesHandler_Success_WithPattern(t *testing.T) {
+	testServices := []string{
+		"frontend",
+		"payment-service",
+		"payment-gateway",
+		"cart-service",
+		"user-service",
+	}
+
+	mock := &mockGetServicesQueryService{
+		getServicesFunc: func(_ context.Context) ([]string, error) {
+			return testServices, nil
+		},
+	}
+
+	handler := &getServicesHandler{queryService: mock}
+
+	// Filter for services containing "payment"
+	input := types.GetServicesInput{
+		Pattern: "payment",
+	}
+
+	_, output, err := handler.handle(context.Background(), &mcp.CallToolRequest{}, input)
+
+	require.NoError(t, err)
+	require.Len(t, output.Services, 2)
+	assert.Contains(t, output.Services, "payment-service")
+	assert.Contains(t, output.Services, "payment-gateway")
+}
+
+func TestGetServicesHandler_Success_WithRegexPattern(t *testing.T) {
+	testServices := []string{
+		"frontend-prod",
+		"frontend-staging",
+		"payment-service",
+		"cart-service-prod",
+		"cart-service-staging",
+	}
+
+	mock := &mockGetServicesQueryService{
+		getServicesFunc: func(_ context.Context) ([]string, error) {
+			return testServices, nil
+		},
+	}
+
+	handler := &getServicesHandler{queryService: mock}
+
+	// Filter for services ending with "-prod"
+	input := types.GetServicesInput{
+		Pattern: "-prod$",
+	}
+
+	_, output, err := handler.handle(context.Background(), &mcp.CallToolRequest{}, input)
+
+	require.NoError(t, err)
+	require.Len(t, output.Services, 2)
+	assert.Contains(t, output.Services, "frontend-prod")
+	assert.Contains(t, output.Services, "cart-service-prod")
+}
+
+func TestGetServicesHandler_Success_WithLimit(t *testing.T) {
+	testServices := []string{
+		"service-5",
+		"service-3",
+		"service-1",
+		"service-4",
+		"service-2",
+	}
+
+	mock := &mockGetServicesQueryService{
+		getServicesFunc: func(_ context.Context) ([]string, error) {
+			return testServices, nil
+		},
+	}
+
+	handler := &getServicesHandler{queryService: mock}
+
+	input := types.GetServicesInput{
+		Limit: 3,
+	}
+
+	_, output, err := handler.handle(context.Background(), &mcp.CallToolRequest{}, input)
+
+	require.NoError(t, err)
+	require.Len(t, output.Services, 3)
+	// After sorting, should return first 3 alphabetically
+	assert.Equal(t, []string{"service-1", "service-2", "service-3"}, output.Services)
+}
+
+func TestGetServicesHandler_Success_WithPatternAndLimit(t *testing.T) {
+	testServices := []string{
+		"payment-staging",
+		"frontend-prod",
+		"cart-staging",
+		"frontend-staging",
+		"payment-prod",
+		"cart-prod",
+	}
+
+	mock := &mockGetServicesQueryService{
+		getServicesFunc: func(_ context.Context) ([]string, error) {
+			return testServices, nil
+		},
+	}
+
+	handler := &getServicesHandler{queryService: mock}
+
+	// Filter for services ending with "-prod" and limit to 2
+	input := types.GetServicesInput{
+		Pattern: "-prod$",
+		Limit:   2,
+	}
+
+	_, output, err := handler.handle(context.Background(), &mcp.CallToolRequest{}, input)
+
+	require.NoError(t, err)
+	require.Len(t, output.Services, 2)
+	// After filtering and sorting, should return first 2 alphabetically
+	assert.Equal(t, []string{"cart-prod", "frontend-prod"}, output.Services)
+}
+
+func TestGetServicesHandler_Success_DefaultLimit(t *testing.T) {
+	// Create more than default limit services
+	testServices := make([]string, 150)
+	for i := 0; i < 150; i++ {
+		testServices[i] = "service-" + string(rune('a'+i%26))
+	}
+
+	mock := &mockGetServicesQueryService{
+		getServicesFunc: func(_ context.Context) ([]string, error) {
+			return testServices, nil
+		},
+	}
+
+	handler := &getServicesHandler{queryService: mock}
+
+	input := types.GetServicesInput{}
+
+	_, output, err := handler.handle(context.Background(), &mcp.CallToolRequest{}, input)
+
+	require.NoError(t, err)
+	// Should apply default limit of 100
+	assert.Len(t, output.Services, defaultServiceLimit)
+}
+
+func TestGetServicesHandler_Error_InvalidPattern(t *testing.T) {
+	testServices := []string{"frontend", "payment-service"}
+
+	mock := &mockGetServicesQueryService{
+		getServicesFunc: func(_ context.Context) ([]string, error) {
+			return testServices, nil
+		},
+	}
+
+	handler := &getServicesHandler{queryService: mock}
+
+	// Invalid regex pattern
+	input := types.GetServicesInput{
+		Pattern: "[invalid",
+	}
+
+	_, output, err := handler.handle(context.Background(), &mcp.CallToolRequest{}, input)
+
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "invalid pattern")
+	assert.Empty(t, output.Services)
+}
+
+func TestGetServicesHandler_Error_StorageFailure(t *testing.T) {
+	mock := &mockGetServicesQueryService{
+		getServicesFunc: func(_ context.Context) ([]string, error) {
+			return nil, errors.New("storage connection failed")
+		},
+	}
+
+	handler := &getServicesHandler{queryService: mock}
+
+	input := types.GetServicesInput{}
+
+	_, output, err := handler.handle(context.Background(), &mcp.CallToolRequest{}, input)
+
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "failed to get services")
+	assert.Contains(t, err.Error(), "storage connection failed")
+	assert.Empty(t, output.Services)
+}
+
+func TestGetServicesHandler_Success_EmptyResult(t *testing.T) {
+	// No services in storage
+	mock := &mockGetServicesQueryService{
+		getServicesFunc: func(_ context.Context) ([]string, error) {
+			return []string{}, nil
+		},
+	}
+
+	handler := &getServicesHandler{queryService: mock}
+
+	input := types.GetServicesInput{}
+
+	_, output, err := handler.handle(context.Background(), &mcp.CallToolRequest{}, input)
+
+	require.NoError(t, err)
+	assert.Empty(t, output.Services)
+}
+
+func TestGetServicesHandler_Success_NoMatchingPattern(t *testing.T) {
+	testServices := []string{"frontend", "payment-service", "cart-service"}
+
+	mock := &mockGetServicesQueryService{
+		getServicesFunc: func(_ context.Context) ([]string, error) {
+			return testServices, nil
+		},
+	}
+
+	handler := &getServicesHandler{queryService: mock}
+
+	// Pattern that doesn't match any service
+	input := types.GetServicesInput{
+		Pattern: "nonexistent",
+	}
+
+	_, output, err := handler.handle(context.Background(), &mcp.CallToolRequest{}, input)
+
+	require.NoError(t, err)
+	assert.Empty(t, output.Services)
+}
+
+func TestGetServicesHandler_Success_CaseInsensitivePattern(t *testing.T) {
+	testServices := []string{
+		"FrontEnd",
+		"PAYMENT-SERVICE",
+		"cart-service",
+	}
+
+	mock := &mockGetServicesQueryService{
+		getServicesFunc: func(_ context.Context) ([]string, error) {
+			return testServices, nil
+		},
+	}
+
+	handler := &getServicesHandler{queryService: mock}
+
+	// Case-insensitive pattern
+	input := types.GetServicesInput{
+		Pattern: "(?i)payment",
+	}
+
+	_, output, err := handler.handle(context.Background(), &mcp.CallToolRequest{}, input)
+
+	require.NoError(t, err)
+	require.Len(t, output.Services, 1)
+	assert.Equal(t, "PAYMENT-SERVICE", output.Services[0])
+}
+
+func TestNewGetServicesHandler(t *testing.T) {
+	// Test that NewGetServicesHandler returns a valid handler function
+	handler := NewGetServicesHandler(nil)
+	assert.NotNil(t, handler)
+}