feat(mcp): improve tools collection

reduced number of tools

Author: marle3003

mcp/get_http_mock_template.go

@@ -45,7 +45,7 @@ You can:
 
 Typical pattern:
 1. Apply your business logic (e.g., find a resource)
-2. Call generate_http_mock_response with the correct status code
+2. Call mokapi_generate_http_mock_response with the correct status code
 3. Override result.data if needed
 4. Assign result to response
 `,

mcp/get_mokapi_typescript_api.go

@@ -2,7 +2,6 @@ package mcp
 
 import (
 	"context"
-	"fmt"
 
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 )
@@ -12,8 +11,13 @@ type GetMokapiTypeScriptApiInput struct {
 }
 
 type GetMokapiTypeScriptApiOutput struct {
-	Package string `json:"package"`
-	Types   string `json:"types"`
+	Packages []Package `json:"packages"`
+}
+
+type Package struct {
+	Name        string `json:"name"`
+	Description string `json:"description"`
+	Types       string `json:"types"`
 }
 
 func (s *Service) registerGetMokapiTypeScriptApi(server *mcp.Server) {
@@ -22,57 +26,158 @@ func (s *Service) registerGetMokapiTypeScriptApi(server *mcp.Server) {
 		"properties": map[string]any{
 			"package": map[string]any{
 				"type":        "string",
-				"description": "The name of the package to fetch TypeScript definitions for, e.g., 'mokapi/http'",
+				"description": "Filter package by name.",
+				"enum":        []string{"mokapi", "mokapi/http", "mokapi/kafka", "mokapi/faker", "mokapi/file"},
+				"optional":    true,
+			},
+		},
+	}
+
+	outputSchema := map[string]any{
+		"type": "object",
+		"properties": map[string]any{
+			"packages": map[string]any{
+				"type":        "array",
+				"description": "The list of packages",
+				"items": map[string]any{
+					"type":        "object",
+					"description": "The package with the TypeScript types",
+					"properties": map[string]any{
+						"name": map[string]any{
+							"type":        "string",
+							"description": "The name of the package",
+							"enum":        []string{"mokapi", "mokapi/http", "mokapi/kafka", "mokapi/faker", "mokapi/file"},
+						},
+						"description": map[string]any{
+							"type":        "string",
+							"description": "The description of the package",
+						},
+						"types": map[string]any{
+							"type":        "string",
+							"description": "The types of the package",
+						},
+					},
+					"required": []any{"name", "description"},
+				},
 			},
 		},
-		"required": []string{"package"},
+		"required": []string{"packages"},
 	}
 
 	registerTool(server, &mcp.Tool{
 		Name: "mokapi_get_typescript_api",
 		Description: `Returns TypeScript definitions for a specific Mokapi package.
 
-Use this tool after selecting a package via "mokapi_get_typescript_api_list".
+- DISCOVERY: Call without 'package' to get an overview of all available APIs (names and descriptions). 
+- DETAILS: Call with a specific 'name' to get the full type definitions.
 
 The returned types define:
 - Event handler signatures
 - Request and response structures
 - Available properties
 
-Combine this with "get_scenario" to understand correct usage patterns.`,
-		InputSchema: inputSchema,
+Use the returned types to implement the mock script.
+Combine this with "mokapi_get_scenarios" to understand correct usage patterns.`,
+		InputSchema:  inputSchema,
+		OutputSchema: outputSchema,
 	}, s.GetMokapiTypeScriptApi)
 }
 
 func (s *Service) GetMokapiTypeScriptApi(_ context.Context, in GetMokapiTypeScriptApiInput) (GetMokapiTypeScriptApiOutput, error) {
+	if in.Package == "" {
+		return GetMokapiTypeScriptApiOutput{
+			Packages: []Package{
+				{
+					Name: "mokapi",
+					Description: `Mokapi JavaScript API
+This module exposes the core scripting API for Mokapi.
+It allows you to intercept and manipulate protocol events (HTTP, Kafka, LDAP, SMTP),
+schedule jobs, generate mock data, and share state between scripts.`,
+				},
+				{
+					Name: "mokapi/http",
+					Description: `Utilities for sending HTTP requests and handling HTTP interactions within Mokapi scripts.
+Use these functions to simulate client calls, test API integrations, or trigger endpoints from scripts.`,
+				},
+				{
+					Name: "mokapi/kafka",
+					Description: `Utilities for producing and consuming messages on Kafka topics.
+This package allows you to mock message streams, inspect events, and simulate Kafka-based workflows.`,
+				},
+				{
+					Name: "mokapi/faker",
+					Description: `Generates realistic random test data based on JSON schemas or attribute names.
+Use this to populate mock responses or generate dynamic content for API responses.`,
+				},
+				{
+					Name: "mokapi/file",
+					Description: `File system utilities for reading, writing, and manipulating files within Mokapi scripts.
+Useful for mocking file-based APIs, loading fixtures, or storing script state.`,
+				},
+			},
+		}, nil
+	}
+
 	switch in.Package {
 	case "mokapi":
 		return GetMokapiTypeScriptApiOutput{
-			Package: "mokapi",
-			Types:   pkgMokapi,
+			Packages: []Package{
+				{
+					Name: "mokapi",
+					Description: `Mokapi JavaScript API
+This module exposes the core scripting API for Mokapi.
+It allows you to intercept and manipulate protocol events (HTTP, Kafka, LDAP, SMTP),
+schedule jobs, generate mock data, and share state between scripts.`,
+					Types: pkgMokapi,
+				},
+			},
 		}, nil
 	case "mokapi/http":
 		return GetMokapiTypeScriptApiOutput{
-			Package: "mokapi/http",
-			Types:   pkgHttp,
+			Packages: []Package{
+				{
+					Name: "mokapi/http",
+					Description: `Utilities for sending HTTP requests and handling HTTP interactions within Mokapi scripts.
+Use these functions to simulate client calls, test API integrations, or trigger endpoints from scripts.`,
+					Types: pkgHttp,
+				},
+			},
 		}, nil
 	case "mokapi/kafka":
 		return GetMokapiTypeScriptApiOutput{
-			Package: "mokapi/kafka",
-			Types:   pkgKafka,
+			Packages: []Package{
+				{
+					Name: "mokapi/kafka",
+					Description: `Utilities for producing and consuming messages on Kafka topics.
+This package allows you to mock message streams, inspect events, and simulate Kafka-based workflows.`,
+					Types: pkgKafka,
+				},
+			},
 		}, nil
 	case "mokapi/faker":
 		return GetMokapiTypeScriptApiOutput{
-			Package: "mokapi/faker",
-			Types:   pkgFaker,
+			Packages: []Package{
+				{
+					Name: "mokapi/faker",
+					Description: `Generates realistic random test data based on JSON schemas or attribute names.
+Use this to populate mock responses or generate dynamic content for API responses.`,
+					Types: pkgFaker,
+				},
+			},
 		}, nil
 	case "mokapi/file":
 		return GetMokapiTypeScriptApiOutput{
-			Package: "mokapi/file",
-			Types:   pkgFile,
+			Packages: []Package{
+				{
+					Name: "mokapi/file",
+					Description: `File system utilities for reading, writing, and manipulating files within Mokapi scripts.
+Useful for mocking file-based APIs, loading fixtures, or storing script state.`,
+					Types: pkgFile,
+				},
+			},
 		}, nil
 	}
-	return GetMokapiTypeScriptApiOutput{}, fmt.Errorf("unknown Mokapi package: %s", in.Package)
+	return GetMokapiTypeScriptApiOutput{}, nil
 }
 
 const (

mcp/get_mokapi_typescript_list.go

@@ -11,7 +11,7 @@ func (s *Service) registerGetScenarios(server *mcp.Server) {
 		Name: "mokapi_get_scenarios",
 		Description: `Lists available scenarios for generating Mokapi scripts.
 
-Use this tool BEFORE calling template tools (e.g., "get_http_mock_template") 
+Use this tool BEFORE calling template tools (e.g., "mokapi_get_http_mock_template") 
 to discover supported scenarios.
 
 Typical workflow:

mcp/get_scenarios.go

@@ -73,7 +73,7 @@ func (s *Service) registerProduceKafkaMessage(server *mcp.Server) {
 		Name: "mokapi_produce_kafka_message",
 		Description: `Produce a message to a Kafka topic.
 
-Use this tool after retrieving the API specification with 'get_api_spec' to understand available topics and message formats.
+Use this tool after retrieving the API specification with 'mokapi_get_api_spec' to understand available topics and message formats.
 
 Allows sending messages with optional key and headers.`,
 		InputSchema:  inputSchema,

mcp/produce_kafka_message.go

@@ -91,7 +91,7 @@ func (s *Service) registerSendHttpRequest(server *mcp.Server) {
 		Name: "mokapi_send_http_request",
 		Description: `Send an HTTP request to a mocked API.
 
-Use this tool AFTER retrieving the API specification with 'get_api_spec' to understand available endpoints.
+Use this tool AFTER retrieving the API specification with 'mokapi_get_api_spec' to understand available endpoints.
 
 Supports GET, POST, PUT, PATCH, and DELETE requests.
 Returns the full response including status code, headers, and body.`,

mcp/send_http_request.go

@@ -35,7 +35,6 @@ func NewServer(app *runtime.App) http.Handler {
 
 	svc.registerGetEvents(server)
 
-	svc.registerGetMokapiTypeScriptList(server)
 	svc.registerGetMokapiTypeScriptApi(server)
 	svc.registerGetScenarios(server)
 	svc.registerGetHttpMockTemplate(server)

mcp/server.go

@@ -31,15 +31,14 @@ func TestServer(t *testing.T) {
 
 	list, err := session.ListTools(ctx, &gomcp.ListToolsParams{})
 	require.NoError(t, err)
-	require.Len(t, list.Tools, 9)
+	require.Len(t, list.Tools, 8)
 	// alphabetical order
 	require.Equal(t, "mokapi_generate_http_mock_response", list.Tools[0].Name)
 	require.Equal(t, "mokapi_get_api_spec", list.Tools[1].Name)
 	require.Equal(t, "mokapi_get_events", list.Tools[2].Name)
 	require.Equal(t, "mokapi_get_http_mock_template", list.Tools[3].Name)
 	require.Equal(t, "mokapi_get_scenarios", list.Tools[4].Name)
 	require.Equal(t, "mokapi_get_typescript_api", list.Tools[5].Name)
-	require.Equal(t, "mokapi_get_typescript_list", list.Tools[6].Name)
-	require.Equal(t, "mokapi_produce_kafka_message", list.Tools[7].Name)
-	require.Equal(t, "mokapi_send_http_request", list.Tools[8].Name)
+	require.Equal(t, "mokapi_produce_kafka_message", list.Tools[6].Name)
+	require.Equal(t, "mokapi_send_http_request", list.Tools[7].Name)
 }