feat(http): support non object JSON payloads in http bodies (#248)

* feat(http): support non object JSON payloads in http bodies

Signed-off-by: Calum Murray <cmurray@redhat.com>

* Update http_invocation.go

Co-authored-by: Nader Ziada <nziada@redhat.com>

---------

Signed-off-by: Calum Murray <cmurray@redhat.com>
Co-authored-by: Nader Ziada <nziada@redhat.com>

Author: Cali0707

CHANGELOG.md

@@ -9,6 +9,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [v0.2.1]
 
+### Added
+- Support for calling HTTP endpoints which require non-object top level JSON types (e.g. JSON array, strings, etc.). (#238)
+
 ### Fixed
 - HTTP invocations which have headers do not also include those variables in the request body/query. (#247)
 

pkg/invocation/http/config.go

@@ -38,6 +38,18 @@ type HttpInvocationConfig struct {
 
 	// The HTTP method to be used for the request (e.g., "GET", "POST").
 	Method string `json:"method,omitempty" jsonschema:"required,enum=GET,enum=POST,enum=PUT,enum=PATCH,enum=DELETE,enum=HEAD"`
+
+	// BodyRoot specifies a dot-separated path to a property whose value should be used as the HTTP request body.
+	// This allows sending non-object request bodies, despite MCP requiring all tool call params to be rooted in
+	// a top-level object.
+	// Mutually exclusive with BodyAsArray
+	BodyRoot string `json:"bodyRoot,omitempty" jsonschema:"optional"`
+
+	// BodyAsArray wraps the entire request body into a JSON array.
+	// For example, if the arguments are {"name": "foo"}, the HTTP body will be [{"name": "foo"}].
+	// This is useful for APIs that expect array inputs but you want to expose a simpler single-item interface.
+	// Mutually exclusive with BodyRoot.
+	BodyAsArray bool `json:"bodyAsArray,omitempty" jsonschema:"optional"`
 }
 
 var _ invocation.InvocationConfig = &HttpInvocationConfig{}
@@ -52,6 +64,11 @@ func (hic *HttpInvocationConfig) Validate() error {
 		return fmt.Errorf("invalid http request method: '%s'", hic.Method)
 	}
 
+	// BodyRoot and BodyAsArray are mutually exclusive
+	if hic.BodyRoot != "" && hic.BodyAsArray {
+		return fmt.Errorf("bodyRoot and bodyAsArray are mutually exclusive")
+	}
+
 	return nil
 }
 
@@ -62,9 +79,11 @@ func (hic *HttpInvocationConfig) DeepCopy() invocation.InvocationConfig {
 	}
 
 	return &HttpInvocationConfig{
-		URL:     hic.URL,
-		Headers: headers,
-		Method:  hic.Method,
+		URL:         hic.URL,
+		Headers:     headers,
+		Method:      hic.Method,
+		BodyRoot:    hic.BodyRoot,
+		BodyAsArray: hic.BodyAsArray,
 	}
 }
 

pkg/invocation/http/factory.go

@@ -67,6 +67,8 @@ func (f *InvokerFactory) CreateInvoker(config invocation.InvocationConfig, primi
 		Method:          hic.Method,
 		InputSchema:     primitive.GetResolvedInputSchema(),
 		URITemplate:     uriTemplate,
+		BodyRoot:        hic.BodyRoot,
+		BodyAsArray:     hic.BodyAsArray,
 	}
 
 	return invoker, nil

pkg/invocation/http/http_invocation.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	nethttp "net/http"
 	neturl "net/url"
+	"strconv"
 	"strings"
 
 	"github.com/google/jsonschema-go/jsonschema"
@@ -29,6 +30,8 @@ type HttpInvoker struct {
 	Method          string                              // Http request method
 	InputSchema     *jsonschema.Resolved                // InputSchema for the tool
 	URITemplate     string                              // MCP URI template (for resource templates only)
+	BodyRoot        string                              // Dot-separated path to extract as the request body
+	BodyAsArray     bool                                // Wrap the entire body in a JSON array
 }
 
 var _ invocation.Invoker = &HttpInvoker{}
@@ -372,6 +375,8 @@ func (hi *HttpInvoker) executeHTTPRequest(
 
 // prepareRequestBody creates a JSON body from the parsed arguments,
 // excluding any variables that are used in the URL template or header templates
+// if BodyRoot is set, it extracts that property's value as the body
+// if BodyAsArray is set, it wraps the entire body in a JSON array
 func (hi *HttpInvoker) prepareRequestBody(parsed map[string]any) ([]byte, error) {
 	varNames := make([]string, 0, len(hi.ParsedTemplate.Variables))
 	for _, v := range hi.ParsedTemplate.Variables {
@@ -384,7 +389,20 @@ func (hi *HttpInvoker) prepareRequestBody(parsed map[string]any) ([]byte, error)
 		}
 	}
 
-	return json.Marshal(deletePathsFromMap(parsed, varNames))
+	var body any = deletePathsFromMap(parsed, varNames)
+
+	if hi.BodyRoot != "" {
+		val, ok := getValueByPath(parsed, hi.BodyRoot)
+		if !ok {
+			return nil, fmt.Errorf("bodyRoot property %q not found in arguments", hi.BodyRoot)
+		}
+		body = val
+	} else if hi.BodyAsArray {
+		// wrap the body in an array
+		body = []any{body}
+	}
+
+	return json.Marshal(body)
 }
 
 // buildRequestComponents builds the URL and headers from request arguments and incoming headers.
@@ -653,3 +671,81 @@ func deletePathFromMap(m map[string]any, path string) {
 		delete(parentMap, keys[len(keys)-2])
 	}
 }
+
+type pathSegment struct {
+	key     string
+	index   int
+	isIndex bool
+}
+
+func getValueByPath(m map[string]any, path string) (any, bool) {
+	segments, err := parsePathSegments(path)
+	if err != nil {
+		return nil, false
+	}
+
+	var current any = m
+
+	for _, seg := range segments {
+		switch v := current.(type) {
+		case map[string]any:
+			if seg.isIndex {
+				return nil, false
+			}
+			var ok bool
+			current, ok = v[seg.key]
+			if !ok {
+				return nil, false
+			}
+		case []any:
+			if !seg.isIndex {
+				return nil, false
+			}
+			if seg.index < 0 || seg.index >= len(v) {
+				return nil, false
+			}
+			current = v[seg.index]
+		default:
+			return nil, false
+		}
+	}
+
+	return current, true
+}
+
+func parsePathSegments(path string) ([]pathSegment, error) {
+	var segments []pathSegment
+	var err error
+
+	for part := range strings.SplitSeq(path, ".") {
+		for len(part) > 0 {
+			bracketStart := strings.Index(part, "[")
+			if bracketStart == -1 {
+				if part != "" {
+					segments = append(segments, pathSegment{key: part})
+				}
+				break
+			}
+
+			if bracketStart > 0 {
+				segments = append(segments, pathSegment{key: part[:bracketStart]})
+			}
+
+			bracketEnd := strings.Index(part, "]")
+			if bracketEnd == -1 || bracketEnd <= bracketStart+1 {
+				return nil, fmt.Errorf("failed to find matching closing bracket for opening bracket")
+			}
+
+			indexStr := part[bracketStart+1 : bracketEnd]
+			var index int64
+			if index, err = strconv.ParseInt(indexStr, 10, 0); err != nil {
+				return nil, fmt.Errorf("failed to parse array index as int: %w", err)
+			}
+
+			segments = append(segments, pathSegment{index: int(index), isIndex: true})
+			part = part[bracketEnd+1:]
+		}
+	}
+
+	return segments, nil
+}