use hardcoded client name check for ui support

Author: mattdholloway

internal/ghmcp/server.go

@@ -347,15 +347,6 @@ func addUserAgentsMiddleware(cfg github.MCPServerConfig, restClient *gogithub.Cl
 			}
 
 			message := initializeRequest
-
-			// Debug log client capabilities for MCP Apps support diagnosis
-			if message.Params.Capabilities != nil {
-				slog.Info("client capabilities",
-					"experimental", message.Params.Capabilities.Experimental,
-					"client", message.Params.ClientInfo.Name,
-				)
-			}
-
 			userAgent := fmt.Sprintf(
 				"github-mcp-server/%s (%s/%s)",
 				cfg.Version,

pkg/github/helper_test.go

@@ -2,6 +2,7 @@ package github
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"io"
 	"net/http"
@@ -290,6 +291,44 @@ func createMCPRequest(args any) mcp.CallToolRequest {
 	}
 }
 
+// createMCPRequestWithSession creates a CallToolRequest with a ServerSession
+// that has the given client name in its InitializeParams. This is used to test
+// UI capability detection based on ClientInfo.Name.
+func createMCPRequestWithSession(t *testing.T, clientName string, args any) mcp.CallToolRequest {
+	t.Helper()
+
+	argsMap, ok := args.(map[string]interface{})
+	if !ok {
+		argsMap = make(map[string]interface{})
+	}
+	argsJSON, err := json.Marshal(argsMap)
+	require.NoError(t, err)
+
+	srv := mcp.NewServer(&mcp.Implementation{Name: "test"}, nil)
+
+	st, _ := mcp.NewInMemoryTransports()
+	session, err := srv.Connect(context.Background(), st, &mcp.ServerSessionOptions{
+		State: &mcp.ServerSessionState{
+			InitializeParams: &mcp.InitializeParams{
+				ClientInfo: &mcp.Implementation{Name: clientName},
+			},
+		},
+	})
+	require.NoError(t, err)
+
+	// Close the unused client-side transport and session
+	t.Cleanup(func() {
+		_ = session.Close()
+	})
+
+	return mcp.CallToolRequest{
+		Session: session,
+		Params: &mcp.CallToolParamsRaw{
+			Arguments: json.RawMessage(argsJSON),
+		},
+	}
+}
+
 // getTextResult is a helper function that returns a text result from a tool call.
 func getTextResult(t *testing.T, result *mcp.CallToolResult) *mcp.TextContent {
 	t.Helper()

pkg/github/issues.go

@@ -1086,7 +1086,7 @@ Options are:
 			},
 		},
 		[]scopes.Scope{scopes.Repo},
-		func(ctx context.Context, deps ToolDependencies, _ *mcp.CallToolRequest, args map[string]any) (*mcp.CallToolResult, any, error) {
+		func(ctx context.Context, deps ToolDependencies, req *mcp.CallToolRequest, args map[string]any) (*mcp.CallToolResult, any, error) {
 			method, err := RequiredParam[string](args, "method")
 			if err != nil {
 				return utils.NewToolResultError(err.Error()), nil, nil
@@ -1101,21 +1101,20 @@ Options are:
 				return utils.NewToolResultError(err.Error()), nil, nil
 			}
 
-			// When insiders mode is enabled, check if this is a UI form submission.
-			// The UI sends _ui_submitted=true to distinguish form submissions from LLM calls.
-			// Without this flag, return a message so the client can show a form.
-			// If no form is displayed, the model should call again with _ui_submitted=true.
+			// When insiders mode is enabled and the client supports MCP Apps UI,
+			// check if this is a UI form submission. The UI sends _ui_submitted=true
+			// to distinguish form submissions from LLM calls.
 			uiSubmitted, _ := OptionalParam[bool](args, "_ui_submitted")
 
-			if deps.GetFlags(ctx).InsidersMode && !uiSubmitted {
+			if deps.GetFlags(ctx).InsidersMode && clientSupportsUI(req) && !uiSubmitted {
 				if method == "update" {
 					issueNumber, numErr := RequiredInt(args, "issue_number")
 					if numErr != nil {
 						return utils.NewToolResultError("issue_number is required for update method"), nil, nil
 					}
-					return utils.NewToolResultText(fmt.Sprintf("Ready to update issue #%d in %s/%s. The interactive form will be displayed. If no form appears, call this tool again with _ui_submitted set to true to proceed.", issueNumber, owner, repo)), nil, nil
+					return utils.NewToolResultText(fmt.Sprintf("Ready to update issue #%d in %s/%s. The user will review and confirm via the interactive form.", issueNumber, owner, repo)), nil, nil
 				}
-				return utils.NewToolResultText(fmt.Sprintf("Ready to create an issue in %s/%s. The interactive form will be displayed. If no form appears, call this tool again with _ui_submitted set to true to proceed.", owner, repo)), nil, nil
+				return utils.NewToolResultText(fmt.Sprintf("Ready to create an issue in %s/%s. The user will review and confirm via the interactive form.", owner, repo)), nil, nil
 			}
 
 			title, err := OptionalParam[string](args, "title")

pkg/github/issues_test.go

@@ -934,8 +934,7 @@ func Test_CreateIssue(t *testing.T) {
 }
 
 // Test_IssueWrite_InsidersMode_UIGate verifies the insiders mode UI gate
-// behavior: the first call returns a form-ready message, and a subsequent
-// call with _ui_submitted=true executes the action.
+// behavior: UI clients get a form message, non-UI clients execute directly.
 func Test_IssueWrite_InsidersMode_UIGate(t *testing.T) {
 	t.Parallel()
 
@@ -958,8 +957,8 @@ func Test_IssueWrite_InsidersMode_UIGate(t *testing.T) {
 	}
 	handler := serverTool.Handler(deps)
 
-	t.Run("without _ui_submitted returns form message", func(t *testing.T) {
-		request := createMCPRequest(map[string]interface{}{
+	t.Run("UI client without _ui_submitted returns form message", func(t *testing.T) {
+		request := createMCPRequestWithSession(t, "Visual Studio Code - Insiders", map[string]interface{}{
 			"method": "create",
 			"owner":  "owner",
 			"repo":   "repo",
@@ -970,12 +969,10 @@ func Test_IssueWrite_InsidersMode_UIGate(t *testing.T) {
 
 		textContent := getTextResult(t, result)
 		assert.Contains(t, textContent.Text, "Ready to create an issue")
-		assert.Contains(t, textContent.Text, "_ui_submitted",
-			"message should instruct model to retry with _ui_submitted")
 	})
 
-	t.Run("with _ui_submitted executes directly", func(t *testing.T) {
-		request := createMCPRequest(map[string]interface{}{
+	t.Run("UI client with _ui_submitted executes directly", func(t *testing.T) {
+		request := createMCPRequestWithSession(t, "Visual Studio Code - Insiders", map[string]interface{}{
 			"method":        "create",
 			"owner":         "owner",
 			"repo":          "repo",
@@ -989,6 +986,21 @@ func Test_IssueWrite_InsidersMode_UIGate(t *testing.T) {
 		assert.Contains(t, textContent.Text, "https://github.com/owner/repo/issues/1",
 			"tool should return the created issue URL")
 	})
+
+	t.Run("non-UI client executes directly without _ui_submitted", func(t *testing.T) {
+		request := createMCPRequest(map[string]interface{}{
+			"method": "create",
+			"owner":  "owner",
+			"repo":   "repo",
+			"title":  "Test",
+		})
+		result, err := handler(ContextWithDeps(context.Background(), deps), &request)
+		require.NoError(t, err)
+
+		textContent := getTextResult(t, result)
+		assert.Contains(t, textContent.Text, "https://github.com/owner/repo/issues/1",
+			"non-UI client should execute directly")
+	})
 }
 
 func Test_ListIssues(t *testing.T) {

pkg/github/pullrequests.go

@@ -545,7 +545,7 @@ func CreatePullRequest(t translations.TranslationHelperFunc) inventory.ServerToo
 			},
 		},
 		[]scopes.Scope{scopes.Repo},
-		func(ctx context.Context, deps ToolDependencies, _ *mcp.CallToolRequest, args map[string]any) (*mcp.CallToolResult, any, error) {
+		func(ctx context.Context, deps ToolDependencies, req *mcp.CallToolRequest, args map[string]any) (*mcp.CallToolResult, any, error) {
 			owner, err := RequiredParam[string](args, "owner")
 			if err != nil {
 				return utils.NewToolResultError(err.Error()), nil, nil
@@ -555,13 +555,13 @@ func CreatePullRequest(t translations.TranslationHelperFunc) inventory.ServerToo
 				return utils.NewToolResultError(err.Error()), nil, nil
 			}
 
-			// When insiders mode is enabled, check if this is a UI form submission.
-			// The UI sends _ui_submitted=true to distinguish form submissions from LLM calls.
-			// If no form is displayed, the model should call again with _ui_submitted=true.
+			// When insiders mode is enabled and the client supports MCP Apps UI,
+			// check if this is a UI form submission. The UI sends _ui_submitted=true
+			// to distinguish form submissions from LLM calls.
 			uiSubmitted, _ := OptionalParam[bool](args, "_ui_submitted")
 
-			if deps.GetFlags(ctx).InsidersMode && !uiSubmitted {
-				return utils.NewToolResultText(fmt.Sprintf("Ready to create a pull request in %s/%s. The interactive form will be displayed. If no form appears, call this tool again with _ui_submitted set to true to proceed.", owner, repo)), nil, nil
+			if deps.GetFlags(ctx).InsidersMode && clientSupportsUI(req) && !uiSubmitted {
+				return utils.NewToolResultText(fmt.Sprintf("Ready to create a pull request in %s/%s. The user will review and confirm via the interactive form.", owner, repo)), nil, nil
 			}
 
 			// When creating PR, title/head/base are required

pkg/github/pullrequests_test.go

@@ -2173,8 +2173,7 @@ func Test_CreatePullRequest(t *testing.T) {
 }
 
 // Test_CreatePullRequest_InsidersMode_UIGate verifies the insiders mode UI gate
-// behavior: the first call returns a form-ready message, and a subsequent
-// call with _ui_submitted=true executes the action.
+// behavior: UI clients get a form message, non-UI clients execute directly.
 func Test_CreatePullRequest_InsidersMode_UIGate(t *testing.T) {
 	t.Parallel()
 
@@ -2200,8 +2199,8 @@ func Test_CreatePullRequest_InsidersMode_UIGate(t *testing.T) {
 	}
 	handler := serverTool.Handler(deps)
 
-	t.Run("without _ui_submitted returns form message", func(t *testing.T) {
-		request := createMCPRequest(map[string]interface{}{
+	t.Run("UI client without _ui_submitted returns form message", func(t *testing.T) {
+		request := createMCPRequestWithSession(t, "Visual Studio Code", map[string]interface{}{
 			"owner": "owner",
 			"repo":  "repo",
 			"title": "Test PR",
@@ -2213,12 +2212,10 @@ func Test_CreatePullRequest_InsidersMode_UIGate(t *testing.T) {
 
 		textContent := getTextResult(t, result)
 		assert.Contains(t, textContent.Text, "Ready to create a pull request")
-		assert.Contains(t, textContent.Text, "_ui_submitted",
-			"message should instruct model to retry with _ui_submitted")
 	})
 
-	t.Run("with _ui_submitted executes directly", func(t *testing.T) {
-		request := createMCPRequest(map[string]interface{}{
+	t.Run("UI client with _ui_submitted executes directly", func(t *testing.T) {
+		request := createMCPRequestWithSession(t, "Visual Studio Code", map[string]interface{}{
 			"owner":         "owner",
 			"repo":          "repo",
 			"title":         "Test PR",
@@ -2233,6 +2230,22 @@ func Test_CreatePullRequest_InsidersMode_UIGate(t *testing.T) {
 		assert.Contains(t, textContent.Text, "https://github.com/owner/repo/pull/42",
 			"tool should return the created PR URL")
 	})
+
+	t.Run("non-UI client executes directly without _ui_submitted", func(t *testing.T) {
+		request := createMCPRequest(map[string]interface{}{
+			"owner": "owner",
+			"repo":  "repo",
+			"title": "Test PR",
+			"head":  "feature",
+			"base":  "main",
+		})
+		result, err := handler(ContextWithDeps(context.Background(), deps), &request)
+		require.NoError(t, err)
+
+		textContent := getTextResult(t, result)
+		assert.Contains(t, textContent.Text, "https://github.com/owner/repo/pull/42",
+			"non-UI client should execute directly")
+	})
 }
 
 func TestCreateAndSubmitPullRequestReview(t *testing.T) {

pkg/github/ui_capability.go

@@ -2,25 +2,26 @@ package github
 
 import "github.com/modelcontextprotocol/go-sdk/mcp"
 
-// UIExtensionID is the MCP Apps extension identifier used for capability negotiation.
-// Clients advertise MCP Apps support by including this key in their capabilities.
-// See: https://github.com/modelcontextprotocol/ext-apps
-const UIExtensionID = "io.modelcontextprotocol/ui"
-
-// clientSupportsUI checks whether the client that sent this request supports
-// MCP Apps UI rendering. It inspects the client's experimental capabilities
-// for the MCP Apps extension identifier.
+// uiSupportedClients lists client names (from ClientInfo.Name) known to
+// support MCP Apps UI rendering.
 //
-// When the client does not support MCP Apps, tools should skip any UI-gated
-// flow (e.g., interactive forms) and execute the action directly.
+// This is a temporary workaround until the Go SDK adds an Extensions field
+// to ClientCapabilities (see https://github.com/modelcontextprotocol/go-sdk/issues/777).
+// Once that lands, detection should use capabilities.extensions instead.
+var uiSupportedClients = map[string]bool{
+	"Visual Studio Code - Insiders": true,
+	"Visual Studio Code":            true,
+}
+
+// clientSupportsUI reports whether the MCP client that sent this request
+// supports MCP Apps UI rendering, based on its ClientInfo.Name.
 func clientSupportsUI(req *mcp.CallToolRequest) bool {
 	if req == nil || req.Session == nil {
 		return false
 	}
 	params := req.Session.InitializeParams()
-	if params == nil || params.Capabilities == nil {
+	if params == nil || params.ClientInfo == nil {
 		return false
 	}
-	_, ok := params.Capabilities.Experimental[UIExtensionID]
-	return ok
+	return uiSupportedClients[params.ClientInfo.Name]
 }

pkg/github/ui_capability_test.go

@@ -0,0 +1,61 @@
+package github
+
+import (
+	"context"
+	"testing"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_clientSupportsUI(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name       string
+		clientName string
+		want       bool
+	}{
+		{name: "VS Code Insiders", clientName: "Visual Studio Code - Insiders", want: true},
+		{name: "VS Code Stable", clientName: "Visual Studio Code", want: true},
+		{name: "unknown client", clientName: "some-other-client", want: false},
+		{name: "empty client name", clientName: "", want: false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req := createMCPRequestWithSession(t, tt.clientName, nil)
+			assert.Equal(t, tt.want, clientSupportsUI(&req))
+		})
+	}
+
+	t.Run("nil request", func(t *testing.T) {
+		assert.False(t, clientSupportsUI(nil))
+	})
+
+	t.Run("nil session", func(t *testing.T) {
+		req := createMCPRequest(nil)
+		assert.False(t, clientSupportsUI(&req))
+	})
+}
+
+func Test_clientSupportsUI_nilClientInfo(t *testing.T) {
+	t.Parallel()
+
+	srv := mcp.NewServer(&mcp.Implementation{Name: "test"}, nil)
+	st, _ := mcp.NewInMemoryTransports()
+	session, err := srv.Connect(context.Background(), st, &mcp.ServerSessionOptions{
+		State: &mcp.ServerSessionState{
+			InitializeParams: &mcp.InitializeParams{
+				ClientInfo: nil,
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = session.Close() })
+
+	req := mcp.CallToolRequest{Session: session}
+	assert.False(t, clientSupportsUI(&req))
+}