fix: [ML-1174]: template fixes for mcp (#69)

* add recursive, entity type param to the tool

* address comments

* refactor common code

* remove unused param from api

* fix: [ML-1174]: template fixes for mcp

Author: hingerabhinav

client/dto/audit.go

@@ -80,8 +80,8 @@ type AuditOutputData[T any] struct {
 	PageIndex     int    `json:"pageIndex,omitempty"`
 	HasNext       bool   `json:"hasNext,omitempty"`
 	PageToken     string `json:"pageToken,omitempty"`
-	TotalItems    int    `json:totalItems, omitempty`
-	TotalPages    int    `json:totalPages, omitempty`
+	TotalItems    int    `json:"totalItems,omitempty"`
+	TotalPages    int    `json:"totalPages,omitempty"`
 }
 
 type AuditListItem struct {

client/dto/template.go

@@ -2,9 +2,24 @@ package dto
 
 // TemplateListOptions represents options for listing templates
 type TemplateListOptions struct {
-	SearchTerm       string `json:"search_term,omitempty"`
-	TemplateListType string `json:"template_list_type,omitempty"`
-	PaginationOptions
+	// Pagination parameters
+	Page  int `json:"page,omitempty"`  // Default: 0
+	Limit int `json:"limit,omitempty"` // Default: 30
+
+	// Sorting parameters
+	Sort  string `json:"sort,omitempty"`  // Enum: "identifier" "name" "updated"
+	Order string `json:"order,omitempty"` // Enum: "ASC" "DESC"
+
+	// Filtering parameters
+	SearchTerm string `json:"search_term,omitempty"` // Filter resources having attributes matching with search term
+	Type       string `json:"type,omitempty"`        // Template List Type: Enum: "STABLE_TEMPLATE" "LAST_UPDATES_TEMPLATE" "ALL"
+	Recursive  bool   `json:"recursive,omitempty"`   // Default: false - Specify true if all accessible Templates are to be included
+
+	// List filtering
+	Names       []string `json:"names,omitempty"`        // Template names for filtering
+	Identifiers []string `json:"identifiers,omitempty"`  // Template Ids for Filtering
+	EntityTypes []string `json:"entity_types,omitempty"` // Type of Template - Enum: "Step" "Stage" "Pipeline" "CustomDeployment" "MonitoredService" "SecretManager"
+	ChildTypes  []string `json:"child_types,omitempty"`  // Child types describe the type of Step or stage
 }
 
 // TemplateMetadataSummaryResponse represents a template metadata summary

client/templates.go

@@ -3,6 +3,7 @@ package client
 import (
 	"context"
 	"fmt"
+	"strconv"
 
 	"github.com/harness/harness-mcp/client/dto"
 )
@@ -15,27 +16,64 @@ const (
 )
 
 type TemplateService struct {
-	Client           *Client
-	UseInternalPaths bool
+	Client *Client
 }
 
 func (ts *TemplateService) buildPath(basePath string) string {
 	return basePath
 }
 
-// ListAccount lists templates in the account scope
-func (ts *TemplateService) ListAccount(ctx context.Context, opts *dto.TemplateListOptions) (*dto.TemplateMetaDataList, error) {
-	endpoint := ts.buildPath(templateAccountPath)
-
+// buildTemplateParams converts template list options to query parameters map
+func buildTemplateParams(opts *dto.TemplateListOptions) map[string]string {
 	params := make(map[string]string)
+
+	if opts == nil {
+		opts = &dto.TemplateListOptions{}
+	}
+
+	// Pagination params
+	params["page"] = strconv.Itoa(opts.Page)
+	params["limit"] = strconv.Itoa(opts.Limit)
+
+	// Sorting params
+	if opts.Sort != "" {
+		params["sort"] = opts.Sort
+	}
+	if opts.Order != "" {
+		params["order"] = opts.Order
+	}
+
+	// Filtering params
 	if opts.SearchTerm != "" {
-		params["searchTerm"] = opts.SearchTerm
+		params["search_term"] = opts.SearchTerm
+	}
+	if opts.Type != "" {
+		params["type"] = opts.Type
 	}
-	if opts.TemplateListType != "" {
-		params["templateListType"] = opts.TemplateListType
+	if opts.Recursive {
+		params["recursive"] = "true"
+	}
+
+	appendArrayParams(params, "names", opts.Names)
+	appendArrayParams(params, "identifiers", opts.Identifiers)
+	appendArrayParams(params, "entity_types", opts.EntityTypes)
+	appendArrayParams(params, "child_types", opts.ChildTypes)
+
+	return params
+}
+
+func appendArrayParams(params map[string]string, paramName string, values []string) {
+	for i, value := range values {
+		// Use strconv.Itoa instead of fmt.Sprintf for integer to string conversion
+		key := paramName + "[" + strconv.Itoa(i) + "]"
+		params[key] = value
 	}
-	params["page"] = fmt.Sprintf("%d", opts.Page)
-	params["size"] = fmt.Sprintf("%d", opts.Size)
+}
+
+// ListAccount lists templates in the account scope
+func (ts *TemplateService) ListAccount(ctx context.Context, opts *dto.TemplateListOptions) (*dto.TemplateMetaDataList, error) {
+	endpoint := ts.buildPath(templateAccountPath)
+	params := buildTemplateParams(opts)
 
 	var result dto.TemplateMetaDataList
 	err := ts.Client.Get(ctx, endpoint, params, map[string]string{}, &result)
@@ -49,17 +87,7 @@ func (ts *TemplateService) ListAccount(ctx context.Context, opts *dto.TemplateLi
 // ListOrg lists templates in the organization scope
 func (ts *TemplateService) ListOrg(ctx context.Context, scope dto.Scope, opts *dto.TemplateListOptions) (*dto.TemplateMetaDataList, error) {
 	endpoint := ts.buildPath(fmt.Sprintf(templateOrgPath, scope.OrgID))
-
-	params := make(map[string]string)
-	addScope(scope, params)
-	if opts.SearchTerm != "" {
-		params["searchTerm"] = opts.SearchTerm
-	}
-	if opts.TemplateListType != "" {
-		params["templateListType"] = opts.TemplateListType
-	}
-	params["page"] = fmt.Sprintf("%d", opts.Page)
-	params["size"] = fmt.Sprintf("%d", opts.Size)
+	params := buildTemplateParams(opts)
 
 	var result dto.TemplateMetaDataList
 	err := ts.Client.Get(ctx, endpoint, params, map[string]string{}, &result)
@@ -73,17 +101,7 @@ func (ts *TemplateService) ListOrg(ctx context.Context, scope dto.Scope, opts *d
 // ListProject lists templates in the project scope
 func (ts *TemplateService) ListProject(ctx context.Context, scope dto.Scope, opts *dto.TemplateListOptions) (*dto.TemplateMetaDataList, error) {
 	endpoint := ts.buildPath(fmt.Sprintf(templateProjectPath, scope.OrgID, scope.ProjectID))
-
-	params := make(map[string]string)
-	addScope(scope, params)
-	if opts.SearchTerm != "" {
-		params["searchTerm"] = opts.SearchTerm
-	}
-	if opts.TemplateListType != "" {
-		params["templateListType"] = opts.TemplateListType
-	}
-	params["page"] = fmt.Sprintf("%d", opts.Page)
-	params["size"] = fmt.Sprintf("%d", opts.Size)
+	params := buildTemplateParams(opts)
 
 	var result dto.TemplateMetaDataList
 	err := ts.Client.Get(ctx, endpoint, params, map[string]string{}, &result)

pkg/harness/templates.go

@@ -20,13 +20,17 @@ func ListTemplates(config *config.Config, client *client.TemplateService) (tool
 			mcp.WithString("search_term",
 				mcp.Description("Optional search term to filter templates"),
 			),
-			mcp.WithString("template_list_type",
-				mcp.Description("Type of templates to list (e.g., Step, Stage, Pipeline)"),
+			mcp.WithString("entity_type",
+				mcp.Description("Type of Template - Enum: Step, Stage, Pipeline, CustomDeployment, MonitoredService, SecretManager"),
+				mcp.Enum("Step", "Stage", "Pipeline", "CustomDeployment", "MonitoredService", "SecretManager"),
 			),
 			mcp.WithString("scope",
 				mcp.Description("Scope level to query templates from (account, org, project). If not specified, defaults to project if org_id and project_id are provided, org if only org_id is provided, or account otherwise."),
 				mcp.Enum("account", "org", "project"),
 			),
+			mcp.WithBoolean("recursive",
+				mcp.Description("If true, returns all supported templates at the specified scope. Default: false"),
+			),
 			WithScope(config, false),
 			WithPagination(),
 		),
@@ -43,19 +47,29 @@ func ListTemplates(config *config.Config, client *client.TemplateService) (tool
 				return mcp.NewToolResultError(err.Error()), nil
 			}
 
-			templateListType, err := OptionalParam[string](request, "template_list_type")
+			// Get entity_type parameter if provided
+			entityType, err := OptionalParam[string](request, "entity_type")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			// Get recursive parameter (defaults to false if not provided)
+			recursive, err := OptionalParam[bool](request, "recursive")
 			if err != nil {
 				return mcp.NewToolResultError(err.Error()), nil
 			}
 
 			// Create options object
 			opts := &dto.TemplateListOptions{
-				SearchTerm:       searchTerm,
-				TemplateListType: templateListType,
-				PaginationOptions: dto.PaginationOptions{
-					Page: page,
-					Size: size,
-				},
+				SearchTerm: searchTerm,
+				Page:       page,
+				Limit:      size,
+				Recursive:  recursive,
+			}
+
+			// Add entity_type to EntityTypes array if provided
+			if entityType != "" {
+				opts.EntityTypes = []string{entityType}
 			}
 
 			// Determine scope from parameters

pkg/harness/tools.go

@@ -756,11 +756,8 @@ func registerChaos(config *config.Config, tsg *toolsets.ToolsetGroup) error {
 // registerTemplates registers the templates toolset
 func registerTemplates(config *config.Config, tsg *toolsets.ToolsetGroup) error {
 	// Determine the base URL and secret for templates
-	baseURL := config.BaseURL
+	baseURL := buildServiceURL(config, config.TemplateSvcBaseURL, config.BaseURL, "")
 	secret := config.TemplateSvcSecret
-	if config.Internal {
-		baseURL = config.TemplateSvcBaseURL
-	}
 
 	// Create base client for templates
 	c, err := createClient(baseURL, config, secret)
@@ -769,8 +766,7 @@ func registerTemplates(config *config.Config, tsg *toolsets.ToolsetGroup) error
 	}
 
 	templateClient := &client.TemplateService{
-		Client:           c,
-		UseInternalPaths: config.Internal,
+		Client: c,
 	}
 
 	// Create the templates toolset
@@ -791,7 +787,7 @@ func registerIntelligence(config *config.Config, tsg *toolsets.ToolsetGroup) err
 	secret := config.IntelligenceSvcSecret
 
 	// Create base client for intelligence service
-	c, err := createClient(baseURL, config, secret)
+	c, err := createClientWithIdentity(baseURL, config, secret, aiServiceIdentity)
 	if err != nil {
 		return err
 	}