feat: [CCM-24794]: Add tool call for Estimation of Savings using Commitment Orchestrator (#118)

* Add tool call for Estimation of Savings using Commitment Orchestrator

Author: sandyydk

README.md

@@ -153,6 +153,7 @@ Toolset Name: `ccm`
 - `get_ccm_commitment_coverage`: Get commitment coverage information for an account in Harness Cloud Cost Management
 - `get_ccm_commitment_savings`: Get commitment savings information for an account in Harness Cloud Cost Management
 - `get_ccm_commitment_utilisation`: Get commitment utilisation information for an account in Harness Cloud Cost Management broken down by Reserved Instances and Savings Plans in day wise granularity.
+- `get_ccm_estimated_savings`: Get estimated savings information for a cloud account in Harness Cloud Cost Management
 
 #### Database Operations Toolset
 

client/ccmcommitments.go

@@ -2,26 +2,99 @@ package client
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
+	"sync"
 
 	"github.com/harness/harness-mcp/client/dto"
 )
 
 const (
-	ccmCommitmentMasterAccountsPath = ccmCommitmentBasePath + "/accounts/%s/v1/setup/listMasterAccounts?accountIdentifier=%s"
+	ccmCommitmentEstimatedSavingsPath = ccmCommitmentBasePath + "/accounts/%s/v2/setup/%s/estimated_savings?accountIdentifier=%s"
+
+	defaultTargetCoveragePercentage = 90.0
 )
 
-func (r *CloudCostManagementService) GetCommitmentMasterAccounts(ctx context.Context, scope dto.Scope) (*dto.CCMCommitmentBaseResponse, error) {
-	path := fmt.Sprintf(ccmCommitmentMasterAccountsPath, scope.AccountID, scope.AccountID)
+func (r *CloudCostManagementService) GetEstimatedSavings(ctx context.Context, scope dto.Scope, targetCoverage float64, opts *dto.CCMCommitmentOptions) (*dto.CommitmentEstimatedSavingsResponse, error) {
+	var response dto.CommitmentEstimatedSavingsResponse
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+	errChan := make(chan error, len(opts.CloudAccountIDs))
+
+	// Parse all possible cloud account IDs and run go routines to capture responses
+	for _, cloudAccountID := range opts.CloudAccountIDs {
+		wg.Add(1)
+		go func(accID string) {
+			defer wg.Done()
+
+			remoteResponse, err := r.getEstimatedSavingsResponse(ctx, scope, accID, opts.Service, &targetCoverage)
+			if err != nil {
+				errChan <- err
+				return
+			}
+
+			mu.Lock()
+			response.Data = append(response.Data, &dto.CommitmentEstimatedSavings{
+				CloudAccountID:    accID,
+				AnnualizedSavings: remoteResponse.EstimatedSavings * 12, // Monthly value is extrapolated
+			})
+			mu.Unlock()
+		}(cloudAccountID)
+	}
+
+	// Wait for all goroutines to complete
+	wg.Wait()
+	close(errChan)
+
+	// Check if any errors occurred
+	if len(errChan) > 0 {
+		return nil, <-errChan // Return the first error encountered
+	}
+
+	return &response, nil
+}
+
+func (r *CloudCostManagementService) getEstimatedSavingsResponse(ctx context.Context, scope dto.Scope, cloudAccountID string, service *string, targetCoverage *float64) (*dto.EstimatedSavingsRemoteResponse, error) {
+	path := fmt.Sprintf(ccmCommitmentEstimatedSavingsPath, scope.AccountID, cloudAccountID, scope.AccountID)
 	params := make(map[string]string)
 	addScope(scope, params)
 
-	listMasterAccountsResponse := new(dto.CCMCommitmentBaseResponse)
+	type reqPayload struct {
+		Service        string  `json:"service"`
+		TargetCoverage float64 `json:"target_coverage"`
+	}
+
+	requestPayload := reqPayload{
+		TargetCoverage: defaultTargetCoveragePercentage,
+	}
+
+	if service != nil {
+		requestPayload.Service = *service
+	}
+
+	if targetCoverage != nil {
+		requestPayload.TargetCoverage = *targetCoverage
+	}
+
+	// Temporary slice to hold the strings
+	baseResponse := new(dto.CCMCommitmentBaseResponse)
+
+	err := r.Client.Post(ctx, path, params, requestPayload, baseResponse)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get cloud cost managment estimated savings response with path %s: %w", path, err)
+	}
+
+	responseBytes, err := json.Marshal(baseResponse.Response)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal cloud cost managment estimated savings response with path %s: %w", path, err)
+	}
+
+	var response dto.EstimatedSavingsRemoteResponse
 
-	err := r.Client.Post(ctx, path, params, nil, listMasterAccountsResponse)
+	err = json.Unmarshal(responseBytes, &response)
 	if err != nil {
-		return nil, fmt.Errorf("failed to get cloud cost managment master accounts with path %s: %w", path, err)
+		return nil, fmt.Errorf("failed to unmarshal cloud cost managment estimated savings response with path %s: %w", path, err)
 	}
 
-	return listMasterAccountsResponse, nil
+	return &response, nil
 }

client/dto/ccmcommitments.go

@@ -49,3 +49,19 @@ type ComputeCoveragesDetail struct {
 	Table *ComputeCoveragesDetailTable `json:"table,omitempty"`
 	Chart []*ComputeCoverageChart      `json:"chart,omitempty"`
 }
+
+type CommitmentEstimatedSavings struct {
+	AnnualizedSavings float64 `json:"annualized_savings,omitempty"`
+	CloudAccountID    string  `json:"cloud_account_id,omitempty"`
+}
+
+type CommitmentEstimatedSavingsResponse struct {
+	Data []*CommitmentEstimatedSavings `json:"data,omitempty"`
+}
+
+type EstimatedSavingsRemoteResponse struct {
+	CurrentCoverage  float64 `json:"current_coverage"`
+	TargetCoverage   float64 `json:"target_coverage"`
+	CurrentSavings   float64 `json:"current_savings"`
+	EstimatedSavings float64 `json:"estimated_savings"`
+}

pkg/harness/tools/ccmcommitments.go

@@ -1,8 +1,95 @@
 package tools
 
+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"
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
 const (
-	CCMCommitmentCoverageEventType = "commitment_coverage_sorted"
+	CCMCommitmentCoverageEventType  = "commitment_coverage_sorted"
+	defaultTargetCoveragePercentage = 90.0
 
 	FollowUpGroupCommitmentCoverageByRegionsPrompt = "Help me group commitment coverage by regions"
 	FollowUpGroupCommitmentCoverageBySavingsPrompt = "Help me estimate savings opportunities"
 )
+
+func FetchEstimatedSavingsTool(config *config.Config, client *client.CloudCostManagementService) (tool mcp.Tool, handler server.ToolHandlerFunc) {
+	return mcp.NewTool("get_ccm_commitment_estimated_savings",
+			mcp.WithDescription("Get commitment annualized estimated savings information for provided cloud account(s) in Harness Cloud Cost Management with optionally provided target coverage or else defaults to 90% of target coverage"),
+			mcp.WithString("service",
+				mcp.Description("Optional service to estimate savings for"),
+			),
+			mcp.WithNumber("target_coverage",
+				mcp.Description("Optional target coverage to estimate savings"),
+				mcp.DefaultNumber(defaultTargetCoveragePercentage),
+				mcp.Max(95),
+				mcp.Min(10),
+			),
+			mcp.WithArray("cloud_account_ids",
+				mcp.WithStringItems(),
+				mcp.Description("cloud account IDs to estimate savings for"),
+				mcp.Required(),
+			),
+			WithScope(config, false),
+		),
+		func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+			accountId, err := getAccountID(config, request)
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			params := &dto.CCMCommitmentOptions{}
+			params.AccountIdentifier = &accountId
+
+			// Handle service parameter
+			service, ok, err := OptionalParamOK[string](request, "service")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			if ok && service != "" {
+				params.Service = &service
+			}
+
+			cloudAccountIDs, err := OptionalStringArrayParam(request, "cloud_account_ids")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			if len(cloudAccountIDs) == 0 {
+				return mcp.NewToolResultError("missing required parameter: cloud_account_ids"), nil
+			}
+			params.CloudAccountIDs = cloudAccountIDs
+
+			targetCoverage, ok, err := OptionalParamOK[float64](request, "target_coverage")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			if !ok {
+				targetCoverage = defaultTargetCoveragePercentage
+			}
+
+			scope, err := FetchScope(config, request, false)
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			data, err := client.GetEstimatedSavings(ctx, scope, targetCoverage, params)
+			if err != nil {
+				return mcp.NewToolResultError(fmt.Sprintf("failed to get commitment coverage: %s", err)), nil
+			}
+
+			r, err := json.Marshal(data)
+			if err != nil {
+				return mcp.NewToolResultError(fmt.Sprintf("failed to marshal commitment coverage: %s", err)), nil
+			}
+
+			return mcp.NewToolResultText(string(r)), nil
+		}
+}

pkg/modules/ccm.go

@@ -103,6 +103,7 @@ func RegisterCloudCostManagement(config *config.Config, tsg *toolsets.ToolsetGro
 			toolsets.NewServerTool(tools.FetchCommitmentCoverageTool(config, ccmClient)),
 			toolsets.NewServerTool(tools.FetchCommitmentSavingsTool(config, ccmClient)),
 			toolsets.NewServerTool(tools.FetchCommitmentUtilisationTool(config, ccmClient)),
+			toolsets.NewServerTool(tools.FetchEstimatedSavingsTool(config, ccmClient)),
 		)
 
 	// Add toolset to the group