[feat]:[IDP-6019]: Tools for workflow creation and execution (#116)

* address review comments

* use pipeline yaml in create workflow

* e2e tests

* improve description

* [feat]:[IDP-6019]: Tools for workflow creation and execution

Author: harjas27

client/dto/genai.go

@@ -120,6 +120,14 @@ func (d *DBChangesetParameters) IsStreaming() bool {
 	return d.BaseRequestParameters.Stream
 }
 
+// IDPWorkflowParameters extends BaseRequestParameters for workflow generation
+type IDPWorkflowParameters struct {
+	BaseRequestParameters
+	PipelineInfo string `json:"pipeline_info"`
+	OldWorkflow  string `json:"oldworkflow,omitempty"`
+	ErrorContext string `json:"error_context,omitempty"`
+}
+
 type CapabilityToRun struct {
 	CallID string         `json:"call_id"`
 	Type   string         `json:"type"`

client/dto/idp.go

@@ -217,3 +217,12 @@ type ScorecardScore struct {
 	Score         int    `json:"score"`
 	ScorecardName string `json:"scorecard_name"`
 }
+
+type ExecuteWorkflowRequest struct {
+	Identifier string      `json:"identifier"`
+	Values     interface{} `json:"values,omitempty"`
+}
+
+type ExecuteWorkflowResponse struct {
+	ExecutionID string `json:"id"`
+}

client/genai.go

@@ -16,6 +16,7 @@ import (
 const (
 	aiDevopsChatPath = "chat/platform"
 	dbChangesetPath  = "chat/db-changeset"
+	idpWorkflowPath  = "chat/idp-workflow"
 )
 
 type GenaiService struct {
@@ -112,6 +113,12 @@ func (g *GenaiService) SendDBChangeset(ctx context.Context, scope dto.Scope, req
 	return g.sendGenAIRequest(ctx, dbChangesetPath, scope, request, onProgress...)
 }
 
+// SendIDPWorkflow sends a request to generate idp workflows and returns the response.
+// If request.Stream is true and onProgress is provided, it will handle streaming responses.
+func (g *GenaiService) SendIDPWorkflow(ctx context.Context, scope dto.Scope, request *dto.IDPWorkflowParameters, onProgress ...func(progressUpdate dto.ProgressUpdate) error) (*dto.ServiceChatResponse, error) {
+	return g.sendGenAIRequest(ctx, idpWorkflowPath, scope, request, onProgress...)
+}
+
 // processStreamingResponse handles Server-Sent Events (SSE) streaming responses
 // and accumulates complete events before forwarding them with appropriate event types
 func (g *GenaiService) processStreamingResponse(body io.ReadCloser, finalResponse *dto.ServiceChatResponse, onProgress func(dto.ProgressUpdate) error) error {

client/idp.go

@@ -16,6 +16,7 @@ const (
 	idpListScorecardsPath  = "/v1/scorecards"
 	idpGetScoreSummaryPath = "/v1/scores/summary"
 	idpGetScoresPath       = "/v1/scores"
+	idpExecuteWorkflowPath = "/v2/workflows/execute"
 
 	// Default values for requests
 	defaultKind        = "component,api,resource"
@@ -45,7 +46,7 @@ func (i *IDPService) GetEntity(ctx context.Context, scope dto.Scope, kind string
 
 	response := new(dto.EntityResponse)
 
-	err := i.Client.Get(ctx, path, params, headers, response)
+	err := i.Client.Get(ctx, path, params, map[string]string{}, response)
 	if err != nil {
 		return nil, err
 	}
@@ -78,9 +79,7 @@ func (i *IDPService) ListEntities(ctx context.Context, scope dto.Scope, getEntit
 		params["search_term"] = getEntitiesParams.SearchTerm
 	}
 
-	if getEntitiesParams.Scopes != "" {
-		params["scopes"] = getEntitiesParams.Scopes
-	}
+	params["scopes"] = generateScopeParamVal(scope)
 
 	params["owned_by_me"] = fmt.Sprintf("%v", getEntitiesParams.OwnedByMe)
 	params["favorites"] = fmt.Sprintf("%v", getEntitiesParams.Favorites)
@@ -109,7 +108,7 @@ func (i *IDPService) ListEntities(ctx context.Context, scope dto.Scope, getEntit
 
 	response := make([]dto.EntityResponse, 0)
 
-	err := i.Client.Get(ctx, path, params, headers, &response)
+	err := i.Client.Get(ctx, path, params, map[string]string{}, &response)
 	if err != nil {
 		return nil, err
 	}
@@ -140,7 +139,6 @@ func (i *IDPService) ListScorecards(ctx context.Context, scope dto.Scope) (*[]dt
 	addHarnessAccountToHeaders(scope, headers)
 
 	response := make([]dto.ScorecardResponse, 0)
-
 	err := i.Client.Get(ctx, path, map[string]string{}, headers, &response)
 	if err != nil {
 		return nil, err
@@ -159,7 +157,6 @@ func (i *IDPService) GetScorecardSummary(ctx context.Context, scope dto.Scope, i
 	params["entity_identifier"] = identifier
 
 	response := new(dto.ScorecardSummaryResponse)
-
 	err := i.Client.Get(ctx, path, params, headers, response)
 	if err != nil {
 		return nil, err
@@ -178,7 +175,6 @@ func (i *IDPService) GetScorecardScores(ctx context.Context, scope dto.Scope, id
 	params["entity_identifier"] = identifier
 
 	response := new(dto.ScorecardScoreResponse)
-
 	err := i.Client.Get(ctx, path, params, headers, response)
 	if err != nil {
 		return nil, err
@@ -187,6 +183,36 @@ func (i *IDPService) GetScorecardScores(ctx context.Context, scope dto.Scope, id
 	return response, nil
 }
 
+func (i *IDPService) ExecuteWorkflow(ctx context.Context, scope dto.Scope, identifier string, inputSet map[string]interface{}) (*dto.ExecuteWorkflowResponse, error) {
+	path := idpExecuteWorkflowPath
+
+	headers := make(map[string]string)
+	addHarnessAccountToHeaders(scope, headers)
+
+	params := make(map[string]string)
+	addScope(scope, params)
+
+	_, token, err := i.Client.AuthProvider.GetHeader(ctx)
+	if err != nil {
+		slog.Error("Failed to get auth header", "error", err)
+		return nil, err
+	}
+	inputSet["token"] = token
+	body := new(dto.ExecuteWorkflowRequest)
+	body.Identifier = identifier
+	body.Values = inputSet
+
+	response := new(dto.ExecuteWorkflowResponse)
+
+	err = i.Client.Post(ctx, path, params, body, response)
+	if err != nil {
+		slog.Error("Failed to execute workflow", "error", err)
+		return nil, err
+	}
+
+	return response, nil
+}
+
 func generateScopeParamVal(scope dto.Scope) string {
 	scopeParam := defaultScope
 	if scope.AccountID != "" {

pkg/harness/tools/genai.go

@@ -210,6 +210,9 @@ func createGenAIToolHandler(config *config.Config, client *client.GenaiService,
 		case *dto.DBChangesetParameters:
 			req.Stream = shouldStream
 			response, respErr = client.SendDBChangeset(ctx, scope, req, onProgress)
+		case *dto.IDPWorkflowParameters:
+			req.Stream = shouldStream
+			response, respErr = client.SendIDPWorkflow(ctx, scope, req, onProgress)
 		default:
 			return nil, fmt.Errorf("unsupported request type: %T", requestObj)
 		}
@@ -342,3 +345,72 @@ func DBChangesetTool(config *config.Config, client *client.GenaiService) (tool m
 	})
 	return tool, handler
 }
+
+// GenerateWorflowTool creates a tool for generating idp workflows
+func GenerateWorflowTool(config *config.Config, client *client.GenaiService) (tool mcp.Tool, handler server.ToolHandlerFunc) {
+	// Get common parameters
+	commonParams := getCommonGenAIParameters()
+
+	// Add tool-specific parameters
+	toolParams := append(commonParams,
+		mcp.WithString("pipeline_info",
+			mcp.Required(),
+			mcp.Description("The YAML of the pipeline which is to be used for generating the workflow. Use the get_pipeline tool to retrieve the pipeline YAML."),
+		),
+		mcp.WithString("old_workflow",
+			mcp.Description("Optional existing workflow YAML for updates"),
+		),
+		mcp.WithString("error_context",
+			mcp.Description("Optional error context if this is a retry after an error for a given workflow"),
+		),
+		WithScope(config, false),
+	)
+
+	tool = mcp.NewTool("generate_idp_workflow",
+		append([]mcp.ToolOption{mcp.WithDescription(`
+			Generates the YAML for an IDP Workflow.
+			Usage Guidance:
+			- Use this tool to generate a workflow YAML using a given pipeline.
+			- You must provide the pipline YAML to generate the workflow YAML.
+			`)},
+			toolParams...)...,
+	)
+
+	handler = createGenAIToolHandler(config, client, func(baseParams *dto.BaseRequestParameters, request mcp.CallToolRequest) (interface{}, error) {
+
+		pipelineInfoArg, ok := request.GetArguments()["pipeline_info"]
+		if !ok || pipelineInfoArg == nil {
+			return nil, fmt.Errorf("missing required parameter: pipeline_info")
+		}
+
+		pipelineInfo, ok := pipelineInfoArg.(string)
+		if !ok {
+			return nil, fmt.Errorf("pipeline_info must be a string")
+		}
+
+		oldWorkflowArg, ok := request.GetArguments()["old_workflow"]
+		var oldWorkflow string
+		if ok && oldWorkflowArg != nil {
+			if oc, isString := oldWorkflowArg.(string); isString {
+				oldWorkflow = oc
+			}
+		}
+
+		errorContextArg, ok := request.GetArguments()["error_context"]
+		var errorContext string
+		if ok && errorContextArg != nil {
+			if ec, isString := errorContextArg.(string); isString {
+				errorContext = ec
+			}
+		}
+
+		// Create the IDP Workflow parameters
+		return &dto.IDPWorkflowParameters{
+			BaseRequestParameters: *baseParams,
+			PipelineInfo:          pipelineInfo,
+			OldWorkflow:           oldWorkflow,
+			ErrorContext:          errorContext,
+		}, nil
+	})
+	return tool, handler
+}

pkg/harness/tools/idp.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+
 	"github.com/harness/harness-mcp/client"
 	"github.com/harness/harness-mcp/client/dto"
 	"github.com/harness/harness-mcp/cmd/harness-mcp-server/config"
@@ -13,7 +14,8 @@ import (
 
 func GetEntityTool(config *config.Config, client *client.IDPService) (tool mcp.Tool, handler server.ToolHandlerFunc) {
 	return mcp.NewTool("get_entity",
-			mcp.WithDescription("Get details of a specific entity(services, APIs, user groups, resources) in the Harness IDP Catalog. Entities can represent services, APIs, user groups, resources, and more. The tool returns metadata for the Harness entities matching the filter criteria, including their identifier, scope, kind, reference type (INLINE/GIT), YAML definition, Git details (branch, path, repo), ownership, tags, lifecycle, scorecards, status, and group. Use the list_entities tool to first to get the id."),
+			mcp.WithDescription(`Get details of a specific entity(services, APIs, user groups, resources) in the Harness IDP Catalog. Entities can represent services, APIs, user groups, resources, and more. The tool returns metadata for the Harness entities matching the filter criteria, including their identifier, scope, kind, reference type (INLINE/GIT), YAML definition, Git details (branch, path, repo), ownership, tags, lifecycle, scorecards, status, and group. Use the list_entities tool to first to get the id.
+			Note: If the fetched entity is a workflow, it might contain a token field but that is to be IGNORED.`),
 			WithScope(config, false),
 			mcp.WithString("entity_id",
 				mcp.Required(),
@@ -54,7 +56,8 @@ func GetEntityTool(config *config.Config, client *client.IDPService) (tool mcp.T
 
 func ListEntitiesTool(config *config.Config, client *client.IDPService) (tool mcp.Tool, handler server.ToolHandlerFunc) {
 	return mcp.NewTool("list_entities",
-			mcp.WithDescription("List entities in the Harness Internal Developer Portal Catalog. Entities can represent services, APIs, user groups, resources, and more. The tool returns metadata for the Harness entities matching the filter criteria, including their identifier, scope, kind, reference type (INLINE/GIT), YAML definition, Git details (branch, path, repo), ownership, tags, lifecycle, scorecards, status, and group."),
+			mcp.WithDescription(`List entities in the Harness Internal Developer Portal Catalog. Entities can represent services, APIs, user groups, resources, and more. The tool returns metadata for the Harness entities matching the filter criteria, including their identifier, scope, kind, reference type (INLINE/GIT), YAML definition, Git details (branch, path, repo), ownership, tags, lifecycle, scorecards, status, and group.
+			Note: If the fetched entity is a workflow, it might contain a token field but that is to be IGNORED.`),
 			mcp.WithString("search_term",
 				mcp.Description("Optional search term to filter entities"),
 			),
@@ -290,3 +293,60 @@ func GetScoresTool(config *config.Config, client *client.IDPService) (tool mcp.T
 			return mcp.NewToolResultText(string(r)), nil
 		}
 }
+
+func ExecuteWorkflowTool(config *config.Config, client *client.IDPService) (tool mcp.Tool, handler server.ToolHandlerFunc) {
+	return mcp.NewTool("execute_workflow",
+			mcp.WithDescription(`Execute a workflow in the Harness Internal Developer Portal Catalog. This tool takes in the entity metadata of the workflow and a set of values to be used for the execution.
+			Usage Guidance:
+			- Use the get_entity tool to fetch the workflow details
+			- The set of values provided has to be validated against the input set required by the workflow.
+			- Provide only non-authentication parameters in the values object
+			- All HarnessAuthToken fields should be OMITTED regardless of workflow requirements
+			- Validate other required parameters against the workflow's input set
+			⚠️ IMPORTANT: 
+			- NEVER request or include token values when executing workflows. The system handles authentication automatically - DO NOT prompt users for tokens, even if they appear as required parameters in the workflow definition.
+			- DO NOT execute the workflow if the valueset is not sufficient.`),
+			WithScope(config, false),
+			mcp.WithObject("workflow_details",
+				mcp.Required(),
+				mcp.Description("A json representation of the workflow entity. This json contains the metadata of the workflow(like owner, name, description, ref etc) and a yaml field which should contain the spec.parameters against which the values should be validated. Only the parameters marked required are mandatory."),
+			),
+			mcp.WithObject("identifier",
+				mcp.Required(),
+				mcp.Description("The identifier of the workflow to be executed. This can be extracted from the field identifier of the workflow_details."),
+			),
+			mcp.WithObject("values",
+				mcp.Description("The values to be used for the workflow execution. The values should be in the format of a json object. These values are to be validated against the parameters of the workflow. Do NOT validate the field of type HarnessAuthToken, it is not to be provided in the prompt."),
+			),
+		),
+		func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+			scope, err := FetchScope(config, request, false)
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			_, err = RequiredParam[interface{}](request, "workflow_details")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			identifier, err := RequiredParam[string](request, "identifier")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			values, err := OptionalParam[map[string]interface{}](request, "values")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			data, err := client.ExecuteWorkflow(ctx, scope, identifier, values)
+			if err != nil {
+				return nil, fmt.Errorf("failed to execute workflow: %w", err)
+			}
+
+			r, err := json.Marshal(data)
+			if err != nil {
+				return nil, fmt.Errorf("failed to marshal workflow execution response: %w", err)
+			}
+
+			return mcp.NewToolResultText(string(r)), nil
+		}
+}

pkg/modules/idp.go

@@ -1,11 +1,14 @@
 package modules
 
 import (
+	"fmt"
+
 	"github.com/harness/harness-mcp/client"
 	"github.com/harness/harness-mcp/cmd/harness-mcp-server/config"
 	"github.com/harness/harness-mcp/pkg/harness/tools"
 	"github.com/harness/harness-mcp/pkg/modules/utils"
 	"github.com/harness/harness-mcp/pkg/toolsets"
+	"github.com/mark3labs/mcp-go/server"
 )
 
 // IDPModule implements the Module interface for Internal Developer Portal
@@ -76,15 +79,29 @@ func RegisterInternalDeveloperPortal(config *config.Config, tsg *toolsets.Toolse
 		Client: c,
 	}
 
-	idp := toolsets.NewToolset("Internal Developer Portal", "Harness Internal Developer Portal catalog related tools for managing catalog Entities which represent the core components of your system").
-		AddReadTools(
-			toolsets.NewServerTool(tools.ListEntitiesTool(config, idpClient)),
-			toolsets.NewServerTool(tools.GetEntityTool(config, idpClient)),
-			toolsets.NewServerTool(tools.GetScorecardTool(config, idpClient)),
-			toolsets.NewServerTool(tools.ListScorecardsTool(config, idpClient)),
-			toolsets.NewServerTool(tools.GetScoreSummaryTool(config, idpClient)),
-			toolsets.NewServerTool(tools.GetScoresTool(config, idpClient)),
-		)
+	// Get the GenAI client using the shared method
+	genaiClient, err := GetGenAIClient(config)
+	if err != nil {
+		return fmt.Errorf("failed to create client for genai: %w", err)
+	}
+
+	idpTools := []server.ServerTool{
+		toolsets.NewServerTool(tools.ListEntitiesTool(config, idpClient)),
+		toolsets.NewServerTool(tools.GetEntityTool(config, idpClient)),
+		toolsets.NewServerTool(tools.GetScorecardTool(config, idpClient)),
+		toolsets.NewServerTool(tools.ListScorecardsTool(config, idpClient)),
+		toolsets.NewServerTool(tools.GetScoreSummaryTool(config, idpClient)),
+		toolsets.NewServerTool(tools.GetScoresTool(config, idpClient)),
+		toolsets.NewServerTool(tools.ExecuteWorkflowTool(config, idpClient)),
+	}
+
+	// Add GenerateWorflowTool only if genaiClient is available
+	if genaiClient != nil {
+		idpTools = append(idpTools, toolsets.NewServerTool(tools.GenerateWorflowTool(config, genaiClient)))
+	}
+
+	idp := toolsets.NewToolset("idp", "Harness Internal Developer Portal catalog related tools for managing catalog Entities which represent the core components of your system").
+		AddReadTools(idpTools...)
 
 	// Add toolset to the group
 	tsg.AddToolset(idp)