return the proxy mode in the server type for stdio (#1975)

* return the proxy mode in the server type for stdio

when we run a server via stdio, we wrap it into a proxy,
exposing via sse or streamable-http. So show this as the
server type, instead of the stdio type

Closes: #1717

* changes from review

* fix ci

---------

Co-authored-by: taskbot <[email protected]>

Author: yrobla

cmd/thv/app/list.go

@@ -111,7 +111,7 @@ func printMCPServersOutput(workloadList []core.Workload) error {
 		// Add the MCP server to the map
 		mcpServers[c.Name] = map[string]string{
 			"url":  c.URL,
-			"type": c.TransportType.String(),
+			"type": c.ProxyMode,
 		}
 	}
 

docs/server/docs.go

@@ -27,7 +27,9 @@ type Workload struct {
 	ToolType string `json:"tool_type"`
 	// TransportType is the type of transport used for this workload.
 	TransportType types.TransportType `json:"transport_type"`
-	// ProxyMode is the proxy mode for stdio transport (sse or streamable-http).
+	// ProxyMode is the proxy mode that clients should use to connect.
+	// For stdio transports, this will be the proxy mode (sse or streamable-http).
+	// For direct transports (sse/streamable-http), this will be the same as TransportType.
 	ProxyMode string `json:"proxy_mode,omitempty"`
 	// Status is the current status of the workload.
 	Status runtime.WorkloadStatus `json:"status"`

docs/server/swagger.json

@@ -1154,6 +1154,9 @@ func (d *defaultManager) getRemoteWorkloadsFromState(
 			)
 		}
 
+		// Calculate the effective proxy mode that clients should use
+		effectiveProxyMode := types.GetEffectiveProxyMode(transportType, string(runConfig.ProxyMode))
+
 		// Create a workload from the run configuration
 		workload := core.Workload{
 			Name:          name,
@@ -1162,7 +1165,7 @@ func (d *defaultManager) getRemoteWorkloadsFromState(
 			URL:           proxyURL,
 			Port:          runConfig.Port,
 			TransportType: transportType,
-			ProxyMode:     string(runConfig.ProxyMode),
+			ProxyMode:     effectiveProxyMode,
 			ToolType:      "remote",
 			Group:         runConfig.Group,
 			CreatedAt:     workloadStatus.CreatedAt,

docs/server/swagger.yaml

@@ -0,0 +1,72 @@
+package types
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/stacklok/toolhive/pkg/transport/types"
+)
+
+func TestGetEffectiveProxyMode(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name              string
+		transportType     types.TransportType
+		proxyMode         string
+		expectedProxyMode string
+	}{
+		{
+			name:              "stdio transport with sse proxy mode should return sse",
+			transportType:     types.TransportTypeStdio,
+			proxyMode:         "sse",
+			expectedProxyMode: "sse",
+		},
+		{
+			name:              "stdio transport with streamable-http proxy mode should return streamable-http",
+			transportType:     types.TransportTypeStdio,
+			proxyMode:         "streamable-http",
+			expectedProxyMode: "streamable-http",
+		},
+		{
+			name:              "stdio transport with empty proxy mode should return empty",
+			transportType:     types.TransportTypeStdio,
+			proxyMode:         "",
+			expectedProxyMode: "",
+		},
+		{
+			name:              "sse transport should return sse",
+			transportType:     types.TransportTypeSSE,
+			proxyMode:         "",
+			expectedProxyMode: "sse",
+		},
+		{
+			name:              "streamable-http transport should return streamable-http",
+			transportType:     types.TransportTypeStreamableHTTP,
+			proxyMode:         "",
+			expectedProxyMode: "streamable-http",
+		},
+		{
+			name:              "sse transport ignores provided proxy mode",
+			transportType:     types.TransportTypeSSE,
+			proxyMode:         "some-value",
+			expectedProxyMode: "sse",
+		},
+		{
+			name:              "stdio transport with invalid proxy mode should return the invalid mode",
+			transportType:     types.TransportTypeStdio,
+			proxyMode:         "invalid-mode",
+			expectedProxyMode: "invalid-mode",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			result := GetEffectiveProxyMode(tt.transportType, tt.proxyMode)
+			assert.Equal(t, tt.expectedProxyMode, result, "Effective proxy mode should match expected")
+		})
+	}
+}

pkg/core/workload.go

@@ -95,14 +95,17 @@ func WorkloadFromContainerInfo(container *runtime.ContainerInfo) (core.Workload,
 		return core.Workload{}, err
 	}
 
+	// Calculate the effective proxy mode that clients should use
+	effectiveProxyMode := GetEffectiveProxyMode(tType, runConfig.ProxyMode)
+
 	// Translate to the domain model.
 	return core.Workload{
 		Name:          name, // Use the calculated workload name (base name), not container name
 		Package:       container.Image,
 		URL:           url,
 		ToolType:      toolType,
 		TransportType: tType,
-		ProxyMode:     runConfig.ProxyMode,
+		ProxyMode:     effectiveProxyMode,
 		Status:        container.State,
 		StatusContext: container.Status,
 		CreatedAt:     container.Created,
@@ -111,3 +114,16 @@ func WorkloadFromContainerInfo(container *runtime.ContainerInfo) (core.Workload,
 		Group:         runConfig.Group,
 	}, nil
 }
+
+// GetEffectiveProxyMode determines the effective proxy mode that clients should use
+// For stdio transports, this returns the proxy mode (sse or streamable-http)
+// For direct transports (sse/streamable-http), this returns the transport type as the proxy mode
+func GetEffectiveProxyMode(transportType types.TransportType, proxyMode string) string {
+	// If the underlying transport is stdio, return the proxy mode (could be empty)
+	if transportType == types.TransportTypeStdio {
+		return proxyMode
+	}
+
+	// For direct transports (sse, streamable-http), return the transport type as the proxy mode
+	return transportType.String()
+}