feat: Add NewToolsetGroupFromTools constructor

Add a new constructor that creates a ToolsetGroup from a list of ServerTools.
Tools are automatically categorized as read or write based on their
ReadOnlyHint annotation, and grouped into toolsets based on the 'toolset'
field in their Meta.

This enables tools to be fully self-describing - registration can now
derive toolset membership and read/write classification directly from
the tool definition.

Author: SamMorrowDrums

pkg/toolsets/toolsets.go

@@ -207,6 +207,75 @@ func NewToolsetGroup(readOnly bool) *ToolsetGroup {
 	}
 }
 
+// ToolsetInfo holds the name and description for a toolset
+type ToolsetInfo struct {
+	Name        string
+	Description string
+}
+
+// NewToolsetGroupFromTools creates a ToolsetGroup from a list of ServerTools.
+// Tools are automatically categorized as read or write based on their ReadOnlyHint annotation.
+// Tools are grouped into toolsets based on the "toolset" field in their Meta.
+// The toolsetInfos map provides descriptions for each toolset name.
+func NewToolsetGroupFromTools(readOnly bool, toolsetInfos map[string]ToolsetInfo, tools ...ServerTool) *ToolsetGroup {
+	tsg := NewToolsetGroup(readOnly)
+
+	// Group tools by toolset name
+	toolsByToolset := make(map[string][]ServerTool)
+	for _, tool := range tools {
+		toolsetName := getToolsetFromMeta(tool.Tool.Meta)
+		if toolsetName == "" {
+			panic(fmt.Sprintf("tool %q has no toolset in Meta", tool.Tool.Name))
+		}
+		toolsByToolset[toolsetName] = append(toolsByToolset[toolsetName], tool)
+	}
+
+	// Create toolsets and add tools
+	for toolsetName, toolsetTools := range toolsByToolset {
+		info, ok := toolsetInfos[toolsetName]
+		if !ok {
+			// Use a default description if not provided
+			info = ToolsetInfo{Name: toolsetName, Description: ""}
+		}
+
+		ts := NewToolset(info.Name, info.Description)
+
+		for _, tool := range toolsetTools {
+			if isReadOnlyTool(tool) {
+				ts.readTools = append(ts.readTools, tool)
+			} else {
+				ts.writeTools = append(ts.writeTools, tool)
+			}
+		}
+
+		tsg.AddToolset(ts)
+	}
+
+	return tsg
+}
+
+// getToolsetFromMeta extracts the toolset name from tool metadata
+func getToolsetFromMeta(meta mcp.Meta) string {
+	if meta == nil {
+		return ""
+	}
+	if toolset, ok := meta["toolset"].(string); ok {
+		return toolset
+	}
+	return ""
+}
+
+// isReadOnlyTool determines if a tool is read-only based on its annotations.
+// A tool is considered read-only only if ReadOnlyHint is explicitly true.
+// Write tools have ReadOnlyHint=false or DestructiveHint=true.
+func isReadOnlyTool(tool ServerTool) bool {
+	if tool.Tool.Annotations == nil {
+		// No annotations means we assume it could write (worst case)
+		return false
+	}
+	return tool.Tool.Annotations.ReadOnlyHint
+}
+
 func (tg *ToolsetGroup) AddDeprecatedToolAliases(aliases map[string]string) {
 	for oldName, newName := range aliases {
 		tg.deprecatedAliases[oldName] = newName

pkg/toolsets/toolsets_test.go

@@ -393,3 +393,209 @@ func TestRegisterSpecificTools(t *testing.T) {
 		t.Error("expected error for non-existent tool")
 	}
 }
+
+// mockToolWithMeta creates a ServerTool with metadata for testing NewToolsetGroupFromTools
+func mockToolWithMeta(name string, toolsetName string, readOnly bool) ServerTool {
+	return ServerTool{
+		Tool: mcp.Tool{
+			Name: name,
+			Meta: mcp.Meta{"toolset": toolsetName},
+			Annotations: &mcp.ToolAnnotations{
+				ReadOnlyHint: readOnly,
+			},
+		},
+		RegisterFunc: func(_ *mcp.Server) {},
+	}
+}
+
+func TestNewToolsetGroupFromTools(t *testing.T) {
+	toolsetInfos := map[string]ToolsetInfo{
+		"repos":  {Name: "repos", Description: "Repository tools"},
+		"issues": {Name: "issues", Description: "Issue tools"},
+	}
+
+	// Create tools with meta containing toolset info
+	tools := []ServerTool{
+		mockToolWithMeta("get_repo", "repos", true),
+		mockToolWithMeta("create_repo", "repos", false),
+		mockToolWithMeta("get_issue", "issues", true),
+		mockToolWithMeta("create_issue", "issues", false),
+		mockToolWithMeta("list_issues", "issues", true),
+	}
+
+	tsg := NewToolsetGroupFromTools(false, toolsetInfos, tools...)
+
+	// Verify toolsets were created
+	if len(tsg.Toolsets) != 2 {
+		t.Fatalf("expected 2 toolsets, got %d", len(tsg.Toolsets))
+	}
+
+	// Verify repos toolset
+	reposToolset, exists := tsg.Toolsets["repos"]
+	if !exists {
+		t.Fatal("expected 'repos' toolset to exist")
+	}
+	if reposToolset.Description != "Repository tools" {
+		t.Errorf("expected repos description 'Repository tools', got '%s'", reposToolset.Description)
+	}
+	if len(reposToolset.readTools) != 1 {
+		t.Errorf("expected 1 read tool in repos, got %d", len(reposToolset.readTools))
+	}
+	if len(reposToolset.writeTools) != 1 {
+		t.Errorf("expected 1 write tool in repos, got %d", len(reposToolset.writeTools))
+	}
+
+	// Verify issues toolset
+	issuesToolset, exists := tsg.Toolsets["issues"]
+	if !exists {
+		t.Fatal("expected 'issues' toolset to exist")
+	}
+	if len(issuesToolset.readTools) != 2 {
+		t.Errorf("expected 2 read tools in issues, got %d", len(issuesToolset.readTools))
+	}
+	if len(issuesToolset.writeTools) != 1 {
+		t.Errorf("expected 1 write tool in issues, got %d", len(issuesToolset.writeTools))
+	}
+}
+
+func TestNewToolsetGroupFromToolsReadOnly(t *testing.T) {
+	toolsetInfos := map[string]ToolsetInfo{
+		"repos": {Name: "repos", Description: "Repository tools"},
+	}
+
+	tools := []ServerTool{
+		mockToolWithMeta("get_repo", "repos", true),
+		mockToolWithMeta("create_repo", "repos", false),
+	}
+
+	// Create with readOnly=true
+	tsg := NewToolsetGroupFromTools(true, toolsetInfos, tools...)
+
+	reposToolset := tsg.Toolsets["repos"]
+	if !reposToolset.readOnly {
+		t.Error("expected toolset to be in read-only mode")
+	}
+
+	// GetActiveTools should only return read tools
+	activeTools := reposToolset.GetActiveTools()
+	if len(activeTools) != 0 {
+		// Toolset is not enabled yet
+		t.Errorf("expected 0 active tools (not enabled), got %d", len(activeTools))
+	}
+
+	reposToolset.Enabled = true
+	activeTools = reposToolset.GetActiveTools()
+	if len(activeTools) != 1 {
+		t.Errorf("expected 1 active tool in read-only mode, got %d", len(activeTools))
+	}
+	if activeTools[0].Tool.Name != "get_repo" {
+		t.Errorf("expected only read tool 'get_repo', got '%s'", activeTools[0].Tool.Name)
+	}
+}
+
+func TestNewToolsetGroupFromToolsPanicsOnMissingToolset(t *testing.T) {
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("expected panic when tool has no toolset in Meta")
+		}
+	}()
+
+	// Tool without toolset in meta
+	tools := []ServerTool{
+		{
+			Tool: mcp.Tool{
+				Name: "bad_tool",
+				Meta: nil, // No meta
+				Annotations: &mcp.ToolAnnotations{
+					ReadOnlyHint: true,
+				},
+			},
+			RegisterFunc: func(_ *mcp.Server) {},
+		},
+	}
+
+	NewToolsetGroupFromTools(false, nil, tools...)
+}
+
+func TestIsReadOnlyTool(t *testing.T) {
+	tests := []struct {
+		name     string
+		tool     ServerTool
+		expected bool
+	}{
+		{
+			name: "read-only tool",
+			tool: ServerTool{
+				Tool: mcp.Tool{
+					Annotations: &mcp.ToolAnnotations{ReadOnlyHint: true},
+				},
+			},
+			expected: true,
+		},
+		{
+			name: "write tool",
+			tool: ServerTool{
+				Tool: mcp.Tool{
+					Annotations: &mcp.ToolAnnotations{ReadOnlyHint: false},
+				},
+			},
+			expected: false,
+		},
+		{
+			name: "no annotations (assume write)",
+			tool: ServerTool{
+				Tool: mcp.Tool{
+					Annotations: nil,
+				},
+			},
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := isReadOnlyTool(tt.tool)
+			if result != tt.expected {
+				t.Errorf("expected %v, got %v", tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestGetToolsetFromMeta(t *testing.T) {
+	tests := []struct {
+		name     string
+		meta     mcp.Meta
+		expected string
+	}{
+		{
+			name:     "valid toolset",
+			meta:     mcp.Meta{"toolset": "repos"},
+			expected: "repos",
+		},
+		{
+			name:     "nil meta",
+			meta:     nil,
+			expected: "",
+		},
+		{
+			name:     "missing toolset key",
+			meta:     mcp.Meta{"other": "value"},
+			expected: "",
+		},
+		{
+			name:     "wrong type for toolset",
+			meta:     mcp.Meta{"toolset": 123},
+			expected: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := getToolsetFromMeta(tt.meta)
+			if result != tt.expected {
+				t.Errorf("expected %q, got %q", tt.expected, result)
+			}
+		})
+	}
+}