feat(api)!: add toolset prompts infrastructure

README.md

@@ -294,7 +294,7 @@ pkill -HUP kubernetes-mcp-server
 
 ### MCP Prompts
 
-The server supports MCP prompts for workflow templates. Define custom prompts in `config.toml`:
+1. The server supports MCP prompts for workflow templates. Define custom prompts in `config.toml`:
 
 ```toml
 [[prompts]]
@@ -311,6 +311,8 @@ role = "user"
 content = "Help me with {{resource_name}}"
 ```
 
+2. Toolset prompts implemented by toolset developers (can be disabled with disable_toolset_prompts = true)
+
 See docs/PROMPTS.md for detailed documentation.
 
 ## 🛠️ Tools and Functionalities <a id="tools-and-functionalities"></a>

docs/PROMPTS.md

@@ -59,4 +59,66 @@ Use `{{argument_name}}` placeholders in message content. The template engine rep
 
 ## Configuration File Location
 
-Place your prompts in the `config.toml` file used by the MCP server. Specify the config file path using the `--config` flag when starting the server.
+Place your prompts in the `config.toml` file used by the MCP server. Specify the config file path using the `--config` flag when starting the server.
+
+## Toolset Prompts
+
+Toolsets can provide built-in prompts by implementing the `GetPrompts()` method. This allows toolset developers to ship workflow templates alongside their tools.
+
+### Implementing Toolset Prompts
+
+```go
+func (t *MyToolset) GetPrompts(o internalk8s.Openshift) []api.ServerPrompt {
+    return []api.ServerPrompt{
+        {
+            Prompt: api.Prompt{
+                Name:        "my-workflow",
+                Description: "Custom workflow for my toolset",
+                Arguments: []api.PromptArgument{
+                    {
+                        Name:        "namespace",
+                        Description: "Target namespace",
+                        Required:    true,
+                    },
+                },
+            },
+            Handler: func(params api.PromptHandlerParams) (*api.PromptCallResult, error) {
+                args := params.GetArguments()
+                namespace := args["namespace"]
+
+                // Build messages dynamically based on arguments
+                messages := []api.PromptMessage{
+                    {
+                        Role: "user",
+                        Content: api.PromptContent{
+                            Type: "text",
+                            Text: fmt.Sprintf("Help me with namespace: %s", namespace),
+                        },
+                    },
+                }
+
+                return api.NewPromptCallResult("Workflow description", messages, nil), nil
+            },
+        },
+    }
+}
+```
+
+### Disabling Toolset Prompts
+
+Add `disable_toolset_prompts = true` in your `config.toml` to use only config-defined prompts:
+
+```toml
+disable_toolset_prompts = true
+
+[[prompts]]
+name = "my-custom-prompt"
+# ... rest of config
+```
+
+### Prompt Merging
+
+When both toolset and config prompts exist:
+- Config-defined prompts **override** toolset prompts with the same name
+- This allows administrators to customize built-in workflows
+- Prompts with unique names from both sources are available

pkg/api/toolsets.go

@@ -43,6 +43,9 @@ type Toolset interface {
 	// Will be used to generate documentation and help text.
 	GetDescription() string
 	GetTools(o Openshift) []ServerTool
+	// GetPrompts returns the prompts provided by this toolset.
+	// Returns nil if the toolset doesn't provide any prompts.
+	GetPrompts(o Openshift) []ServerPrompt
 }
 
 type ToolCallRequest interface {

pkg/config/config.go

@@ -81,6 +81,9 @@ type StaticConfig struct {
 	promptsDefined  bool           // Internal: tracks if prompts were defined in config
 	promptsMetadata toml.MetaData  // Internal: metadata for prompts decoding
 
+	// When true, disable toolset-defined prompts (only use config-defined prompts)
+	DisableToolsetPrompts bool `toml:"disable_toolset_prompts,omitempty"`
+
 	// Server instructions to be provided by the MCP server to the MCP client
 	// This can be used to provide specific instructions on how the client should use the server
 	ServerInstructions string `toml:"server_instructions,omitempty"`

pkg/mcp/mcp.go

@@ -167,6 +167,24 @@ func (s *Server) reloadToolsets() error {
 	// Track previously enabled prompts
 	previousPrompts := s.enabledPrompts
 
+	// Build and register prompts from all toolsets
+	applicablePrompts := make([]api.ServerPrompt, 0)
+	s.enabledPrompts = make([]string, 0)
+
+	// Load embedded toolset prompts (unless disabled)
+	if !s.configuration.DisableToolsetPrompts {
+		for _, toolset := range s.configuration.Toolsets() {
+			prompts := toolset.GetPrompts(s.p)
+			if prompts == nil {
+				continue
+			}
+			for _, prompt := range prompts {
+				applicablePrompts = append(applicablePrompts, prompt)
+				s.enabledPrompts = append(s.enabledPrompts, prompt.Prompt.Name)
+			}
+		}
+	}
+
 	// Load config prompts into registry
 	prompts.Clear()
 	if s.configuration.HasPrompts() {
@@ -180,9 +198,12 @@ func (s *Server) reloadToolsets() error {
 	// Get prompts from registry
 	configPrompts := prompts.ConfigPrompts()
 
+	// Merge: config prompts override embedded prompts with same name
+	applicablePrompts = mergePrompts(applicablePrompts, configPrompts)
+
 	// Update enabled prompts list
 	s.enabledPrompts = make([]string, 0)
-	for _, prompt := range configPrompts {
+	for _, prompt := range applicablePrompts {
 		s.enabledPrompts = append(s.enabledPrompts, prompt.Prompt.Name)
 	}
 
@@ -195,8 +216,8 @@ func (s *Server) reloadToolsets() error {
 	}
 	s.server.RemovePrompts(promptsToRemove...)
 
-	// Register all config prompts
-	for _, prompt := range configPrompts {
+	// Register all applicable prompts
+	for _, prompt := range applicablePrompts {
 		mcpPrompt, promptHandler, err := ServerPromptToGoSdkPrompt(s, prompt)
 		if err != nil {
 			return fmt.Errorf("failed to convert prompt %s: %v", prompt.Prompt.Name, err)