feat(get-server-tools): add GetTools method for retrieve MCPServer.tools

Author: ValeriiStepanets

server/server.go

@@ -493,6 +493,16 @@ func (s *MCPServer) SetTools(tools ...ServerTool) {
 	s.AddTools(tools...)
 }
 
+// GetTools retrieves the currently registered tools
+func (s *MCPServer) GetTools() (map[string]ServerTool, error) {
+	s.toolsMu.RLock()
+	defer s.toolsMu.RUnlock()
+	if s.tools != nil {
+		return s.tools, nil
+	}
+	return nil, nil
+}
+
 // DeleteTools removes tools from the server
 func (s *MCPServer) DeleteTools(names ...string) {
 	s.toolsMu.Lock()

server/server_test.go

@@ -2022,3 +2022,359 @@ func TestMCPServer_ProtocolNegotiation(t *testing.T) {
 		})
 	}
 }
+
+func TestMCPServer_GetTools(t *testing.T) {	t.Run("EmptyServer", func(t *testing.T) {
+		server := NewMCPServer("test-server", "1.0.0")
+		
+		tools, err := server.GetTools()
+		
+		assert.NoError(t, err)
+		assert.NotNil(t, tools)
+		assert.Len(t, tools, 0)
+	})
+
+	t.Run("SingleTool", func(t *testing.T) {
+		server := NewMCPServer("test-server", "1.0.0")
+
+		expectedTool := mcp.Tool{
+			Name:        "test-tool",
+			Description: "A test tool",
+			InputSchema: mcp.ToolInputSchema{
+				Type: "object",
+				Properties: map[string]any{
+					"input": map[string]any{
+						"type":        "string",
+						"description": "Test input",
+					},
+				},
+			},
+		}
+
+		expectedHandler := func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+			return &mcp.CallToolResult{
+				Content: []mcp.Content{
+					mcp.TextContent{
+						Type: "text",
+						Text: "test result",
+					},
+				},
+			}, nil
+		}
+
+		server.AddTool(expectedTool, expectedHandler)
+
+		tools, err := server.GetTools()
+
+		assert.NoError(t, err)
+		assert.NotNil(t, tools)
+		assert.Len(t, tools, 1)
+
+		serverTool, exists := tools["test-tool"]
+		assert.True(t, exists)
+		assert.Equal(t, expectedTool, serverTool.Tool)
+		assert.NotNil(t, serverTool.Handler)
+	})
+
+	t.Run("MultipleTools", func(t *testing.T) {
+		server := NewMCPServer("test-server", "1.0.0")
+
+		tools := []struct {
+			tool    mcp.Tool
+			handler ToolHandlerFunc
+		}{
+			{
+				tool: mcp.Tool{
+					Name:        "tool1",
+					Description: "First tool",
+					InputSchema: mcp.ToolInputSchema{Type: "object"},
+				},
+				handler: func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+					return &mcp.CallToolResult{}, nil
+				},
+			},
+			{
+				tool: mcp.Tool{
+					Name:        "tool2",
+					Description: "Second tool",
+					InputSchema: mcp.ToolInputSchema{Type: "object"},
+				},
+				handler: func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+					return &mcp.CallToolResult{}, nil
+				},
+			},
+			{
+				tool: mcp.Tool{
+					Name:        "tool3",
+					Description: "Third tool",
+					InputSchema: mcp.ToolInputSchema{Type: "object"},
+				},
+				handler: func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+					return &mcp.CallToolResult{}, nil
+				},
+			},
+		}
+
+		// Add tools one by one
+		for _, tool := range tools {
+			server.AddTool(tool.tool, tool.handler)
+		}
+
+		retrievedTools, err := server.GetTools()
+
+		assert.NoError(t, err)
+		assert.NotNil(t, retrievedTools)
+		assert.Len(t, retrievedTools, 3)
+
+		// Verify each tool exists with correct data
+		for _, expectedTool := range tools {
+			serverTool, exists := retrievedTools[expectedTool.tool.Name]
+			assert.True(t, exists, "Tool %s should exist", expectedTool.tool.Name)
+			assert.Equal(t, expectedTool.tool, serverTool.Tool)
+			assert.NotNil(t, serverTool.Handler)
+		}
+	})
+
+	t.Run("AfterToolDeletion", func(t *testing.T) {
+		server := NewMCPServer("test-server", "1.0.0")
+
+		// Add multiple tools
+		server.AddTool(mcp.Tool{Name: "tool1", Description: "Tool 1"}, nil)
+		server.AddTool(mcp.Tool{Name: "tool2", Description: "Tool 2"}, nil)
+		server.AddTool(mcp.Tool{Name: "tool3", Description: "Tool 3"}, nil)
+
+		// Verify all tools exist
+		tools, err := server.GetTools()
+		assert.NoError(t, err)
+		assert.Len(t, tools, 3)
+
+		// Delete one tool
+		server.DeleteTools("tool2")
+
+		// Verify tool is removed
+		tools, err = server.GetTools()
+		assert.NoError(t, err)
+		assert.Len(t, tools, 2)
+
+		_, exists := tools["tool1"]
+		assert.True(t, exists)
+		_, exists = tools["tool2"]
+		assert.False(t, exists)
+		_, exists = tools["tool3"]
+		assert.True(t, exists)
+	})
+
+	t.Run("SetToolsReplacesExisting", func(t *testing.T) {
+		server := NewMCPServer("test-server", "1.0.0")
+
+		// Add initial tools
+		server.AddTool(mcp.Tool{Name: "old-tool1", Description: "Old Tool 1"}, nil)
+		server.AddTool(mcp.Tool{Name: "old-tool2", Description: "Old Tool 2"}, nil)
+
+		// Verify initial tools
+		tools, err := server.GetTools()
+		assert.NoError(t, err)
+		assert.Len(t, tools, 2)
+
+		// Set new tools (should replace existing)
+		newTools := []ServerTool{
+			{
+				Tool: mcp.Tool{Name: "new-tool1", Description: "New Tool 1"},
+				Handler: func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+					return &mcp.CallToolResult{}, nil
+				},
+			},
+			{
+				Tool: mcp.Tool{Name: "new-tool2", Description: "New Tool 2"},
+				Handler: func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+					return &mcp.CallToolResult{}, nil
+				},
+			},
+		}
+		server.SetTools(newTools...)
+
+		// Verify only new tools exist
+		tools, err = server.GetTools()
+		assert.NoError(t, err)
+		assert.Len(t, tools, 2)
+
+		_, exists := tools["old-tool1"]
+		assert.False(t, exists)
+		_, exists = tools["old-tool2"]
+		assert.False(t, exists)
+		_, exists = tools["new-tool1"]
+		assert.True(t, exists)
+		_, exists = tools["new-tool2"]
+		assert.True(t, exists)
+	})
+
+	t.Run("ConcurrentAccess", func(t *testing.T) {
+		server := NewMCPServer("test-server", "1.0.0")
+
+		// Number of goroutines for testing
+		numGoroutines := 100
+		numToolsPerGoroutine := 10
+
+		// Channel to collect results
+		results := make(chan map[string]ServerTool, numGoroutines)
+
+		// Start goroutines that concurrently call GetTools
+		for i := 0; i < numGoroutines; i++ {
+			go func(id int) {
+				// Add some tools specific to this goroutine
+				for j := 0; j < numToolsPerGoroutine; j++ {
+					toolName := fmt.Sprintf("tool-%d-%d", id, j)
+					server.AddTool(mcp.Tool{
+						Name:        toolName,
+						Description: fmt.Sprintf("Tool %d from goroutine %d", j, id),
+					}, nil)
+				}
+
+				// Get tools
+				tools, err := server.GetTools()
+				assert.NoError(t, err)
+				results <- tools
+			}(i)
+		}
+
+		// Collect all results
+		var allResults []map[string]ServerTool
+		for i := 0; i < numGoroutines; i++ {
+			result := <-results
+			allResults = append(allResults, result)
+		}
+
+		// Verify that no data races occurred and all results are valid
+		for _, result := range allResults {
+			assert.NotNil(t, result)
+			// Each result should have at least some tools (may not have all due to timing)
+			assert.Greater(t, len(result), 0)
+		}
+
+		// Final check - get all tools at the end
+		finalTools, err := server.GetTools()
+		assert.NoError(t, err)
+		assert.NotNil(t, finalTools)
+		// Should have exactly numGoroutines * numToolsPerGoroutine tools
+		assert.Equal(t, numGoroutines*numToolsPerGoroutine, len(finalTools))
+	})
+	t.Run("ConsistentResults", func(t *testing.T) {
+		server := NewMCPServer("test-server", "1.0.0")
+		
+		// Add a tool
+		server.AddTool(mcp.Tool{
+			Name:        "test-tool",
+			Description: "Test tool",
+		}, nil)
+		
+		// Get tools multiple times
+		tools1, err1 := server.GetTools()
+		tools2, err2 := server.GetTools()
+		tools3, err3 := server.GetTools()
+		
+		assert.NoError(t, err1)
+		assert.NoError(t, err2)
+		assert.NoError(t, err3)
+		assert.NotNil(t, tools1)
+		assert.NotNil(t, tools2)
+		assert.NotNil(t, tools3)
+		
+		// Verify all calls return consistent results
+		assert.Equal(t, tools1, tools2)
+		assert.Equal(t, tools2, tools3)
+		assert.Equal(t, tools1, tools3)
+		
+		// All should have the same tool
+		assert.Len(t, tools1, 1)
+		assert.Len(t, tools2, 1)
+		assert.Len(t, tools3, 1)
+		
+		assert.Contains(t, tools1, "test-tool")
+		assert.Contains(t, tools2, "test-tool")
+		assert.Contains(t, tools3, "test-tool")
+	})
+
+	t.Run("WithComplexToolSchema", func(t *testing.T) {
+		server := NewMCPServer("test-server", "1.0.0")
+
+		complexTool := mcp.Tool{
+			Name:        "complex-tool",
+			Description: "A complex tool with detailed schema",
+			InputSchema: mcp.ToolInputSchema{
+				Type: "object",
+				Properties: map[string]any{
+					"stringParam": map[string]any{
+						"type":        "string",
+						"description": "A string parameter",
+						"enum":        []string{"option1", "option2", "option3"},
+					},
+					"numberParam": map[string]any{
+						"type":        "number",
+						"description": "A number parameter",
+						"minimum":     0,
+						"maximum":     100,
+					},
+					"objectParam": map[string]any{
+						"type": "object",
+						"properties": map[string]any{
+							"nestedString": map[string]any{
+								"type": "string",
+							},
+							"nestedArray": map[string]any{
+								"type": "array",
+								"items": map[string]any{
+									"type": "integer",
+								},
+							},
+						},
+						"required": []string{"nestedString"},
+					},
+				},
+				Required: []string{"stringParam", "numberParam"},
+			},
+			Annotations: mcp.ToolAnnotation{
+				Title:           "Complex Tool",
+				ReadOnlyHint:    mcp.ToBoolPtr(false),
+				DestructiveHint: mcp.ToBoolPtr(true),
+				IdempotentHint:  mcp.ToBoolPtr(false),
+				OpenWorldHint:   mcp.ToBoolPtr(true),
+			},
+		}
+
+		handler := func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+			return &mcp.CallToolResult{
+				Content: []mcp.Content{
+					mcp.TextContent{
+						Type: "text",
+						Text: "Complex tool executed",
+					},
+				},
+				IsError: false,
+			}, nil
+		}
+
+		server.AddTool(complexTool, handler)
+
+		tools, err := server.GetTools()
+
+		assert.NoError(t, err)
+		assert.NotNil(t, tools)
+		assert.Len(t, tools, 1)
+
+		retrievedTool, exists := tools["complex-tool"]
+		assert.True(t, exists)
+		assert.Equal(t, complexTool, retrievedTool.Tool)
+		assert.NotNil(t, retrievedTool.Handler)
+
+		// Verify the complex schema is preserved
+		assert.Equal(t, "object", retrievedTool.Tool.InputSchema.Type)
+		assert.Contains(t, retrievedTool.Tool.InputSchema.Properties, "stringParam")
+		assert.Contains(t, retrievedTool.Tool.InputSchema.Properties, "numberParam")
+		assert.Contains(t, retrievedTool.Tool.InputSchema.Properties, "objectParam")
+		assert.Equal(t, []string{"stringParam", "numberParam"}, retrievedTool.Tool.InputSchema.Required)
+
+		// Verify annotations
+		assert.Equal(t, "Complex Tool", retrievedTool.Tool.Annotations.Title)
+		assert.NotNil(t, retrievedTool.Tool.Annotations.DestructiveHint)
+		assert.True(t, *retrievedTool.Tool.Annotations.DestructiveHint)
+	})
+}