feat make proxy request-body limit configurable

Signed-off-by: Sanskarzz <sanskar.gur@gmail.com>

Author: Sanskarzz

cmd/thv-operator/api/v1beta1/mcpserver_types.go

@@ -375,6 +375,12 @@ type MCPServerSpec struct {
 	// +optional
 	EndpointPrefix string `json:"endpointPrefix,omitempty"`
 
+	// MaxRequestBodySize is the maximum inbound MCP proxy request body size in bytes.
+	// Zero uses the default limit of 8 MiB.
+	// +kubebuilder:validation:Minimum=0
+	// +optional
+	MaxRequestBodySize int64 `json:"maxRequestBodySize,omitempty"`
+
 	// GroupRef references the MCPGroup this server belongs to.
 	// The referenced MCPGroup must be in the same namespace.
 	// +optional

cmd/thv-operator/controllers/mcpserver_runconfig.go

@@ -151,6 +151,7 @@ func (r *MCPServerReconciler) createRunConfigFromMCPServer(m *mcpv1beta1.MCPServ
 		runner.WithHost(proxyHost),
 		runner.WithTrustProxyHeaders(m.Spec.TrustProxyHeaders),
 		runner.WithEndpointPrefix(m.Spec.EndpointPrefix),
+		runner.WithMaxRequestBodySize(m.Spec.MaxRequestBodySize),
 		runner.WithToolsFilter(toolsFilter),
 		runner.WithEnvVars(envVars),
 		runner.WithVolumes(volumes),

cmd/thv-operator/controllers/mcpserver_runconfig_test.go

@@ -348,6 +348,25 @@ func TestCreateRunConfigFromMCPServer(t *testing.T) {
 				assert.Equal(t, "[]", cedarCfg.Options.EntitiesJSON)
 			},
 		},
+		{
+			name:      "max request body size omitted",
+			mcpServer: v1beta1test.NewMCPServer("body-limit-omitted", "test-ns"),
+			//nolint:thelper // We want to see the error at the specific line
+			expected: func(t *testing.T, config *runner.RunConfig) {
+				assert.Zero(t, config.MaxRequestBodySize)
+			},
+		},
+		{
+			name: "with max request body size",
+			mcpServer: v1beta1test.NewMCPServer("body-limit-configured", "test-ns",
+				v1beta1test.Mutate(func(m *mcpv1beta1.MCPServer) {
+					m.Spec.MaxRequestBodySize = 16 << 20
+				})),
+			//nolint:thelper // We want to see the error at the specific line
+			expected: func(t *testing.T, config *runner.RunConfig) {
+				assert.Equal(t, int64(16<<20), config.MaxRequestBodySize)
+			},
+		},
 	}
 
 	for _, tt := range tests {

cmd/thv-operator/test-integration/mcp-server/mcpserver_bodylimit_validation_test.go

@@ -0,0 +1,33 @@
+// SPDX-FileCopyrightText: Copyright 2025 Stacklok, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package controllers
+
+import (
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+)
+
+var _ = Describe("Schema validation for MCPServer request body limits",
+	Label("k8s", "validation"), func() {
+		It("accepts an omitted value", func() {
+			server := newMinimalMCPServer("mcp-body-limit-omitted", nil)
+			Expect(k8sClient.Create(ctx, server)).To(Succeed())
+		})
+
+		It("accepts a positive value", func() {
+			server := newMinimalMCPServer("mcp-body-limit-positive", nil)
+			server.Spec.MaxRequestBodySize = 16 << 20
+			Expect(k8sClient.Create(ctx, server)).To(Succeed())
+		})
+
+		It("rejects a negative value", func() {
+			server := newMinimalMCPServer("mcp-body-limit-negative", nil)
+			server.Spec.MaxRequestBodySize = -1
+
+			err := k8sClient.Create(ctx, server)
+			Expect(apierrors.IsInvalid(err)).To(BeTrue())
+			Expect(err.Error()).To(ContainSubstring("spec.maxRequestBodySize"))
+		})
+	})

cmd/thv/app/proxy.go

@@ -108,14 +108,18 @@ Dynamic client registration (automatic OAuth client setup):
 	thv proxy my-server --target-uri https://protected-api.com \
 	  --remote-auth --remote-auth-issuer https://auth.example.com`,
 	Args: cobra.ExactArgs(1),
+	PreRunE: func(_ *cobra.Command, _ []string) error {
+		return validateProxyMaxRequestBodySize(proxyMaxRequestBodySize)
+	},
 	RunE: proxyCmdFunc,
 }
 
 var (
-	proxyHost           string
-	proxyPort           int
-	proxyTargetURI      string
-	proxyAllowedOrigins []string
+	proxyHost               string
+	proxyPort               int
+	proxyTargetURI          string
+	proxyAllowedOrigins     []string
+	proxyMaxRequestBodySize int64
 
 	resourceURL string // Explicit resource URL for OAuth discovery endpoint (RFC 9728)
 
@@ -140,6 +144,8 @@ func init() {
 		"Exact-match allowlist for the HTTP Origin header (repeatable). Recommended when binding publicly; "+
 			"loopback binds derive a default allowlist automatically, non-loopback binds log a warning when "+
 			"no value is supplied. Example: https://my-mcp.example.com")
+	proxyCmd.Flags().Int64Var(&proxyMaxRequestBodySize, "max-request-body-size", 0,
+		"Maximum inbound request body size in bytes; zero uses the default (8 MiB)")
 	proxyCmd.Flags().StringVar(
 		&proxyTargetURI,
 		"target-uri",
@@ -238,7 +244,7 @@ func proxyCmdFunc(cmd *cobra.Command, args []string) error {
 	// runner's addBodyLimitMiddleware. See pkg/bodylimit.
 	middlewares = append(middlewares, types.NamedMiddleware{
 		Name:     bodylimit.MiddlewareType,
-		Function: bodylimit.Middleware(bodylimit.DefaultMaxRequestBodySize),
+		Function: bodylimit.Middleware(proxyMaxRequestBodySize),
 	})
 
 	// Origin-header validation (DNS-rebinding protection per MCP 2025-11-25
@@ -323,6 +329,13 @@ func proxyCmdFunc(cmd *cobra.Command, args []string) error {
 	return proxy.Stop(shutdownCtx)
 }
 
+func validateProxyMaxRequestBodySize(maxBytes int64) error {
+	if maxBytes < 0 {
+		return fmt.Errorf("max-request-body-size must be non-negative, got %d", maxBytes)
+	}
+	return nil
+}
+
 // getProxyOIDCConfig returns the OIDC token validator config from CLI flags, or nil if OIDC is not enabled.
 func getProxyOIDCConfig(cmd *cobra.Command) *auth.TokenValidatorConfig {
 	if !IsOIDCEnabled(cmd) {

cmd/thv/app/proxy_test.go

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Stacklok, Inc.
+// SPDX-FileCopyrightText: Copyright 2025 Stacklok, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
 package app
@@ -8,8 +8,37 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
+func TestValidateProxyMaxRequestBodySize(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name      string
+		maxBytes  int64
+		wantError bool
+	}{
+		{name: "zero uses default", maxBytes: 0},
+		{name: "positive value", maxBytes: 16 << 20},
+		{name: "negative value", maxBytes: -1, wantError: true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			err := validateProxyMaxRequestBodySize(tt.maxBytes)
+			if tt.wantError {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), "max-request-body-size must be non-negative")
+				return
+			}
+			require.NoError(t, err)
+		})
+	}
+}
+
 // TestBuildRemoteAuthFlowConfig_Trust covers the trust flags this function
 // derives. The target URIs are IP literals so no DNS lookup is involved.
 func TestBuildRemoteAuthFlowConfig_Trust(t *testing.T) {

cmd/thv/app/run_flags.go

@@ -112,6 +112,9 @@ type RunFlags struct {
 	// SessionTTL is the session inactivity timeout. Zero uses the transport default.
 	SessionTTL time.Duration
 
+	// MaxRequestBodySize is the maximum inbound request body size in bytes. Zero uses the default.
+	MaxRequestBodySize int64
+
 	// Network mode
 	Network string
 
@@ -295,6 +298,8 @@ func AddRunFlags(cmd *cobra.Command, config *RunFlags) {
 			"Use for MCP servers implementing streamable-HTTP stateless mode.")
 	cmd.Flags().DurationVar(&config.SessionTTL, "session-ttl", 0,
 		"Session inactivity timeout (e.g., 30m, 2h); zero uses the default (2h)")
+	cmd.Flags().Int64Var(&config.MaxRequestBodySize, "max-request-body-size", 0,
+		"Maximum inbound request body size in bytes; zero uses the default (8 MiB)")
 	cmd.Flags().StringVar(&config.EndpointPrefix, "endpoint-prefix", "",
 		"Path prefix to prepend to SSE endpoint URLs (e.g., /playwright)")
 	cmd.Flags().StringVar(&config.Network, "network", "",
@@ -707,6 +712,7 @@ func buildRunnerConfig(
 		runner.WithStrictProtocolValidation(runFlags.StrictProtocolValidation),
 		runner.WithStateless(runFlags.Stateless),
 		runner.WithSessionTTL(runFlags.SessionTTL),
+		runner.WithMaxRequestBodySize(runFlags.MaxRequestBodySize),
 		runner.WithEndpointPrefix(runFlags.EndpointPrefix),
 		runner.WithNetworkMode(runFlags.Network),
 		runner.WithK8sPodPatch(runFlags.K8sPodPatch),

cmd/thv/app/run_flags_test.go

@@ -870,3 +870,49 @@ func TestBuildRunnerConfig_NetworkIsolationExplicitWiring(t *testing.T) {
 		})
 	}
 }
+
+// TestBuildRunnerConfig_MaxRequestBodySizeWiring guards the CLI-to-RunConfig
+// handoff for --max-request-body-size. The builder tests cover validation in
+// isolation; this test ensures the command layer does not drop the flag value.
+func TestBuildRunnerConfig_MaxRequestBodySizeWiring(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name      string
+		flagValue string
+		want      int64
+		wantErr   bool
+	}{
+		{name: "zero preserves default semantics", flagValue: "0", want: 0},
+		{name: "positive value is wired", flagValue: "16777216", want: 16 << 20},
+		{name: "negative value is rejected", flagValue: "-1", wantErr: true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			runFlags := &RunFlags{}
+			cmd := &cobra.Command{}
+			AddRunFlags(cmd, runFlags)
+
+			require.NoError(t, cmd.Flags().Set("permission-profile", "none"))
+			require.NoError(t, cmd.Flags().Set("transport", "stdio"))
+			require.NoError(t, cmd.Flags().Set("max-request-body-size", tt.flagValue))
+
+			cfg, err := buildRunnerConfig(
+				t.Context(), runFlags, nil, false, "127.0.0.1", nil, "test:latest", nil,
+				map[string]string{}, &runner.DetachedEnvVarValidator{}, nil, nil, &config.Config{},
+			)
+
+			if tt.wantErr {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), "max-request-body-size must be non-negative")
+				return
+			}
+			require.NoError(t, err)
+			require.NotNil(t, cfg)
+			assert.Equal(t, tt.want, cfg.MaxRequestBodySize)
+		})
+	}
+}

deploy/charts/operator-crds/files/crds/toolhive.stacklok.dev_mcpservers.yaml

@@ -291,6 +291,13 @@ spec:
               image:
                 description: Image is the container image for the MCP server
                 type: string
+              maxRequestBodySize:
+                description: |-
+                  MaxRequestBodySize is the maximum inbound MCP proxy request body size in bytes.
+                  Zero uses the default limit of 8 MiB.
+                format: int64
+                minimum: 0
+                type: integer
               mcpPort:
                 description: MCPPort is the port that MCP server listens to
                 format: int32
@@ -1235,6 +1242,13 @@ spec:
               image:
                 description: Image is the container image for the MCP server
                 type: string
+              maxRequestBodySize:
+                description: |-
+                  MaxRequestBodySize is the maximum inbound MCP proxy request body size in bytes.
+                  Zero uses the default limit of 8 MiB.
+                format: int64
+                minimum: 0
+                type: integer
               mcpPort:
                 description: MCPPort is the port that MCP server listens to
                 format: int32

deploy/charts/operator-crds/templates/toolhive.stacklok.dev_mcpservers.yaml

@@ -294,6 +294,13 @@ spec:
               image:
                 description: Image is the container image for the MCP server
                 type: string
+              maxRequestBodySize:
+                description: |-
+                  MaxRequestBodySize is the maximum inbound MCP proxy request body size in bytes.
+                  Zero uses the default limit of 8 MiB.
+                format: int64
+                minimum: 0
+                type: integer
               mcpPort:
                 description: MCPPort is the port that MCP server listens to
                 format: int32
@@ -1238,6 +1245,13 @@ spec:
               image:
                 description: Image is the container image for the MCP server
                 type: string
+              maxRequestBodySize:
+                description: |-
+                  MaxRequestBodySize is the maximum inbound MCP proxy request body size in bytes.
+                  Zero uses the default limit of 8 MiB.
+                format: int64
+                minimum: 0
+                type: integer
               mcpPort:
                 description: MCPPort is the port that MCP server listens to
                 format: int32