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

Author: taskbot

cmd/thv/app/list.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/stacklok/toolhive/pkg/core"
 	"github.com/stacklok/toolhive/pkg/logger"
+	"github.com/stacklok/toolhive/pkg/transport/types"
 	"github.com/stacklok/toolhive/pkg/workloads"
 )
 
@@ -108,10 +109,14 @@ func printMCPServersOutput(workloadList []core.Workload) error {
 	mcpServers := make(map[string]map[string]string)
 
 	for _, c := range workloadList {
+		// Determine the effective transport type to show to users
+		// This is the transport they actually connect to, not the underlying MCP server transport
+		effectiveTransport := getEffectiveTransportType(c)
+
 		// Add the MCP server to the map
 		mcpServers[c.Name] = map[string]string{
 			"url":  c.URL,
-			"type": c.TransportType.String(),
+			"type": effectiveTransport,
 		}
 	}
 
@@ -157,3 +162,17 @@ func printTextOutput(workloadList []core.Workload) {
 		logger.Errorf("Warning: Failed to flush tabwriter: %v", err)
 	}
 }
+
+// getEffectiveTransportType determines the effective transport type that clients should use
+// This handles the case where stdio MCP servers are proxied through SSE or streamable-http
+func getEffectiveTransportType(workload core.Workload) string {
+	// If the underlying transport is stdio and we have a proxy mode set,
+	// return the proxy mode as that's what clients actually connect to
+	if workload.TransportType == types.TransportTypeStdio && workload.ProxyMode != "" {
+		return workload.ProxyMode
+	}
+
+	// For all other cases (direct sse, streamable-http, or when no proxy mode is set),
+	// return the transport type directly
+	return workload.TransportType.String()
+}

cmd/thv/app/list_test.go

@@ -0,0 +1,70 @@
+package app
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/stacklok/toolhive/pkg/core"
+	"github.com/stacklok/toolhive/pkg/transport/types"
+)
+
+func TestGetEffectiveTransportType(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name              string
+		workload          core.Workload
+		expectedTransport string
+	}{
+		{
+			name: "stdio transport with sse proxy mode should return sse",
+			workload: core.Workload{
+				TransportType: types.TransportTypeStdio,
+				ProxyMode:     "sse",
+			},
+			expectedTransport: "sse",
+		},
+		{
+			name: "stdio transport with streamable-http proxy mode should return streamable-http",
+			workload: core.Workload{
+				TransportType: types.TransportTypeStdio,
+				ProxyMode:     "streamable-http",
+			},
+			expectedTransport: "streamable-http",
+		},
+		{
+			name: "stdio transport with empty proxy mode should return stdio",
+			workload: core.Workload{
+				TransportType: types.TransportTypeStdio,
+				ProxyMode:     "",
+			},
+			expectedTransport: "stdio",
+		},
+		{
+			name: "sse transport should return sse regardless of proxy mode",
+			workload: core.Workload{
+				TransportType: types.TransportTypeSSE,
+				ProxyMode:     "streamable-http", // This shouldn't matter for non-stdio
+			},
+			expectedTransport: "sse",
+		},
+		{
+			name: "streamable-http transport should return streamable-http",
+			workload: core.Workload{
+				TransportType: types.TransportTypeStreamableHTTP,
+				ProxyMode:     "",
+			},
+			expectedTransport: "streamable-http",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			result := getEffectiveTransportType(tt.workload)
+			assert.Equal(t, tt.expectedTransport, result, "Effective transport type should match expected")
+		})
+	}
+}