feat: [SSCA-4164]: remove raw result handling from ToolResultBuilder and update service URLs (#98)

* refactor: remove raw result handling from ToolResultBuilder and update service URLs

* feat: add taskfile for SCS and STO codegen with OpenAPI specs

* feat: implement STO authentication with API key token retrieval

* feat: add OpenAPI spec for SSCA service endpoints

* feat: add openapi spec and logging improvements for auth and events

* refactor: move utility functions to new response package and add SLSA verification endpoints

Author: deepharness

pkg/appseccommons/utility.go

@@ -25,7 +25,8 @@ func CreateBaseResponse(eventType string, tool string) map[string]interface{} {
 		"entity_info": map[string]string{
 			"entity_type": tool,
 		},
-		"type": eventType,
+		"type":        eventType,
+		"description": "THIS EVENT IS NOT INTENDED TO BE USED BY LLM. IT IS ONLY FOR INTERNAL USE.IGNORE THIS EVENT",
 	}
 }
 

pkg/harness/event/builder.go

@@ -15,12 +15,14 @@ const (
 	GenericTableEvent EventType = "table"
 	OPAEvent          EventType = "opa"
 	PromptEvent       EventType = "prompt"
+	RawEvent          EventType = "raw"
 )
 
 var Reg = builder.Registry{
 	string(GenericTableEvent): GenericTableBuilder{},
 	string(OPAEvent):          OPABuilder{},
 	string(PromptEvent):       PromptBuilder{},
+	string(RawEvent):          RawBuilder{},
 }
 
 type GenericTableBuilder struct{}
@@ -94,6 +96,28 @@ func (GenericTableBuilder) Build(raw json.RawMessage, tool string, args ...any)
 
 type OPABuilder struct{}
 
+type RawBuilder struct{}
+
+func (RawBuilder) Build(raw json.RawMessage, tool string, args ...any) string {
+	eventType := string(RawEvent)
+
+	// Create base response with consistent structure
+	env := builder.CreateBaseResponse(eventType, tool)
+	env["description"] = "THIS IS A RAW EVENT.INTENDED TO USE BY LLM TO UNDERSTAND THE TOOL RESPONSE. DO NOT CREATE ANY TABLES FROM THIS EVENT"
+	// Parse the raw JSON into a generic interface
+	var data interface{}
+	if err := json.Unmarshal(raw, &data); err != nil {
+		// Return a safe error response
+		return fmt.Sprintf(`{"type": "%s", "error": "Failed to parse raw data"}`, eventType)
+	}
+
+	// Add raw data to the response
+	env["data"] = data
+
+	// Format the response using the common formatter
+	return builder.FormatEventResponse(eventType, env)
+}
+
 type PromptBuilder struct{}
 
 func (PromptBuilder) Build(raw json.RawMessage, tool string, args ...any) string {

pkg/harness/event/common/builder.go

@@ -0,0 +1,74 @@
+package response
+
+import (
+	"encoding/json"
+	"log/slog"
+
+	builder "github.com/harness/harness-mcp/pkg/harness/event/common"
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+// EventData represents an event with its type, data, and optional arguments
+type EventData struct {
+	EventType string
+	Event     []byte
+	Args      []any
+}
+
+// ToolResultBuilder helps build tool results with multiple events
+type ToolResultBuilder struct {
+	module string
+	events []EventData
+}
+
+// NewToolResultBuilder creates a new ToolResultBuilder with the specified module
+func NewToolResultBuilder(module string) *ToolResultBuilder {
+	return &ToolResultBuilder{
+		module: module,
+		events: []EventData{},
+	}
+}
+
+// AddEvent adds an event to the builder
+func (b *ToolResultBuilder) AddEvent(eventType string, event []byte, args ...any) *ToolResultBuilder {
+	b.events = append(b.events, EventData{
+		EventType: eventType,
+		Event:     event,
+		Args:      args,
+	})
+	return b
+}
+
+// AddStringEvent adds an event with string data to the builder
+func (b *ToolResultBuilder) AddStringEvent(eventType string, event string, args ...any) *ToolResultBuilder {
+	return b.AddEvent(eventType, []byte(event), args...)
+}
+
+// AddPrompts adds prompts as an event to the builder
+func (b *ToolResultBuilder) AddPrompts(prompts []string) *ToolResultBuilder {
+	if len(prompts) > 0 {
+		promptData, err := json.Marshal(prompts)
+		if err != nil {
+			slog.Error("Failed to marshal prompts", "error", err)
+			promptData = []byte("[]")
+		}
+		return b.AddEvent(string(builder.PromptEvent), promptData)
+	}
+	return b
+}
+
+// Build creates a CallToolResult with all the added events
+func (b *ToolResultBuilder) Build() *mcp.CallToolResult {
+	var contents []mcp.Content
+
+	for _, eventData := range b.events {
+		contents = append(contents, mcp.TextContent{
+			Type: "text",
+			Text: builder.Reg.Build(eventData.EventType, eventData.Event, b.module, eventData.Args...),
+		})
+	}
+	slog.Info("Building tool result", "module", b.module, "events", len(b.events))
+	return &mcp.CallToolResult{
+		Content: contents,
+	}
+}

pkg/harness/event/response/utility.go

@@ -2,6 +2,7 @@ package tools
 
 import (
 	"fmt"
+
 	"github.com/harness/harness-mcp/client/scs"
 	generated "github.com/harness/harness-mcp/client/scs/generated"
 	"github.com/mark3labs/mcp-go/mcp"
@@ -28,6 +29,7 @@ func ParseArtifactListParams(request mcp.CallToolRequest) (order string, sort st
 	}
 	sort, _ = OptionalParam[string](request, "sort")
 	page, size, _ = FetchPagination(request)
+	size = 5
 	sortVal = interface{}(sort)
 	return
 }