feat: wire up GetMe and ForkRepository to use typed inputs

- GetMe: GetMeInput (empty struct for tool with no parameters)
- ForkRepository: ForkRepositoryInput

Updated tests and toolsnaps for both tools.

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

Author: Copilot

pkg/github/__toolsnaps__/fork_repository.snap

@@ -12,7 +12,7 @@
     "properties": {
       "organization": {
         "type": "string",
-        "description": "Organization to fork to"
+        "description": "Organization to fork to (defaults to authenticated user)"
       },
       "owner": {
         "type": "string",
@@ -22,7 +22,8 @@
         "type": "string",
         "description": "Repository name"
       }
-    }
+    },
+    "additionalProperties": false
   },
   "name": "fork_repository"
 }

pkg/github/__toolsnaps__/get_me.snap

@@ -4,6 +4,9 @@
     "title": "Get my user profile"
   },
   "description": "Get details of the authenticated GitHub user. Use this when a request is about the user's own profile for GitHub. Or when information is missing to build other tool calls.",
-  "inputSchema": null,
+  "inputSchema": {
+    "type": "object",
+    "additionalProperties": false
+  },
   "name": "get_me"
 }

pkg/github/context_tools.go

@@ -35,16 +35,17 @@ type UserDetails struct {
 }
 
 // GetMe creates a tool to get details of the authenticated user.
-func GetMe(getClient GetClientFn, t translations.TranslationHelperFunc) (mcp.Tool, mcp.ToolHandlerFor[map[string]any, any]) {
+func GetMe(getClient GetClientFn, t translations.TranslationHelperFunc) (mcp.Tool, mcp.ToolHandlerFor[GetMeInput, any]) {
 	return mcp.Tool{
 			Name:        "get_me",
 			Description: t("TOOL_GET_ME_DESCRIPTION", "Get details of the authenticated GitHub user. Use this when a request is about the user's own profile for GitHub. Or when information is missing to build other tool calls."),
 			Annotations: &mcp.ToolAnnotations{
 				Title:        t("TOOL_GET_ME_USER_TITLE", "Get my user profile"),
 				ReadOnlyHint: true,
 			},
+			InputSchema: GetMeInput{}.MCPSchema(),
 		},
-		mcp.ToolHandlerFor[map[string]any, any](func(ctx context.Context, _ *mcp.CallToolRequest, _ map[string]any) (*mcp.CallToolResult, any, error) {
+		mcp.ToolHandlerFor[GetMeInput, any](func(ctx context.Context, _ *mcp.CallToolRequest, _ GetMeInput) (*mcp.CallToolResult, any, error) {
 			client, err := getClient(ctx)
 			if err != nil {
 				return utils.NewToolResultErrorFromErr("failed to get GitHub client", err), nil, nil

pkg/github/context_tools_test.go

@@ -48,7 +48,6 @@ func Test_GetMe(t *testing.T) {
 	tests := []struct {
 		name               string
 		stubbedGetClientFn GetClientFn
-		requestArgs        map[string]any
 		expectToolError    bool
 		expectedUser       *github.User
 		expectedToolErrMsg string
@@ -63,7 +62,6 @@ func Test_GetMe(t *testing.T) {
 					),
 				),
 			),
-			requestArgs:     map[string]any{},
 			expectToolError: false,
 			expectedUser:    mockUser,
 		},
@@ -77,16 +75,12 @@ func Test_GetMe(t *testing.T) {
 					),
 				),
 			),
-			requestArgs: map[string]any{
-				"reason": "Testing API",
-			},
 			expectToolError: false,
 			expectedUser:    mockUser,
 		},
 		{
 			name:               "getting client fails",
 			stubbedGetClientFn: stubGetClientFnErr("expected test error"),
-			requestArgs:        map[string]any{},
 			expectToolError:    true,
 			expectedToolErrMsg: "failed to get GitHub client: expected test error",
 		},
@@ -100,7 +94,6 @@ func Test_GetMe(t *testing.T) {
 					),
 				),
 			),
-			requestArgs:        map[string]any{},
 			expectToolError:    true,
 			expectedToolErrMsg: "expected test failure",
 		},
@@ -110,8 +103,8 @@ func Test_GetMe(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			_, handler := GetMe(tc.stubbedGetClientFn, translations.NullTranslationHelper)
 
-			request := createMCPRequest(tc.requestArgs)
-			result, _, _ := handler(context.Background(), &request, tc.requestArgs)
+			// Call handler with empty typed input
+			result, _, _ := handler(context.Background(), nil, GetMeInput{})
 			textContent := getTextResult(t, result)
 
 			if tc.expectToolError {

pkg/github/repositories.go

@@ -755,95 +755,62 @@ func GetFileContents(getClient GetClientFn, getRawClient raw.GetRawClientFn, t t
 }
 
 // ForkRepository creates a tool to fork a repository.
-func ForkRepository(getClient GetClientFn, t translations.TranslationHelperFunc) (mcp.Tool, mcp.ToolHandlerFor[map[string]any, any]) {
-	tool := mcp.Tool{
-		Name:        "fork_repository",
-		Description: t("TOOL_FORK_REPOSITORY_DESCRIPTION", "Fork a GitHub repository to your account or specified organization"),
-		Annotations: &mcp.ToolAnnotations{
-			Title:        t("TOOL_FORK_REPOSITORY_USER_TITLE", "Fork repository"),
-			ReadOnlyHint: false,
-		},
-		InputSchema: &jsonschema.Schema{
-			Type: "object",
-			Properties: map[string]*jsonschema.Schema{
-				"owner": {
-					Type:        "string",
-					Description: "Repository owner",
-				},
-				"repo": {
-					Type:        "string",
-					Description: "Repository name",
-				},
-				"organization": {
-					Type:        "string",
-					Description: "Organization to fork to",
-				},
+func ForkRepository(getClient GetClientFn, t translations.TranslationHelperFunc) (mcp.Tool, mcp.ToolHandlerFor[ForkRepositoryInput, any]) {
+	return mcp.Tool{
+			Name:        "fork_repository",
+			Description: t("TOOL_FORK_REPOSITORY_DESCRIPTION", "Fork a GitHub repository to your account or specified organization"),
+			Annotations: &mcp.ToolAnnotations{
+				Title:        t("TOOL_FORK_REPOSITORY_USER_TITLE", "Fork repository"),
+				ReadOnlyHint: false,
 			},
-			Required: []string{"owner", "repo"},
+			InputSchema: ForkRepositoryInput{}.MCPSchema(),
 		},
-	}
+		func(ctx context.Context, _ *mcp.CallToolRequest, input ForkRepositoryInput) (*mcp.CallToolResult, any, error) {
+			opts := &github.RepositoryCreateForkOptions{}
+			if input.Organization != "" {
+				opts.Organization = input.Organization
+			}
 
-	handler := mcp.ToolHandlerFor[map[string]any, any](func(ctx context.Context, _ *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
-		}
-		repo, err := RequiredParam[string](args, "repo")
-		if err != nil {
-			return utils.NewToolResultError(err.Error()), nil, nil
-		}
-		org, err := OptionalParam[string](args, "organization")
-		if err != nil {
-			return utils.NewToolResultError(err.Error()), nil, nil
-		}
+			client, err := getClient(ctx)
+			if err != nil {
+				return nil, nil, fmt.Errorf("failed to get GitHub client: %w", err)
+			}
+			forkedRepo, resp, err := client.Repositories.CreateFork(ctx, input.Owner, input.Repo, opts)
+			if err != nil {
+				// Check if it's an acceptedError. An acceptedError indicates that the update is in progress,
+				// and it's not a real error.
+				if resp != nil && resp.StatusCode == http.StatusAccepted && isAcceptedError(err) {
+					return utils.NewToolResultText("Fork is in progress"), nil, nil
+				}
+				return ghErrors.NewGitHubAPIErrorResponse(ctx,
+					"failed to fork repository",
+					resp,
+					err,
+				), nil, nil
+			}
+			defer func() { _ = resp.Body.Close() }()
 
-		opts := &github.RepositoryCreateForkOptions{}
-		if org != "" {
-			opts.Organization = org
-		}
+			if resp.StatusCode != http.StatusAccepted {
+				body, err := io.ReadAll(resp.Body)
+				if err != nil {
+					return nil, nil, fmt.Errorf("failed to read response body: %w", err)
+				}
+				return utils.NewToolResultError(fmt.Sprintf("failed to fork repository: %s", string(body))), nil, nil
+			}
 
-		client, err := getClient(ctx)
-		if err != nil {
-			return nil, nil, fmt.Errorf("failed to get GitHub client: %w", err)
-		}
-		forkedRepo, resp, err := client.Repositories.CreateFork(ctx, owner, repo, opts)
-		if err != nil {
-			// Check if it's an acceptedError. An acceptedError indicates that the update is in progress,
-			// and it's not a real error.
-			if resp != nil && resp.StatusCode == http.StatusAccepted && isAcceptedError(err) {
-				return utils.NewToolResultText("Fork is in progress"), nil, nil
+			// Return minimal response with just essential information
+			minimalResponse := MinimalResponse{
+				ID:  fmt.Sprintf("%d", forkedRepo.GetID()),
+				URL: forkedRepo.GetHTMLURL(),
 			}
-			return ghErrors.NewGitHubAPIErrorResponse(ctx,
-				"failed to fork repository",
-				resp,
-				err,
-			), nil, nil
-		}
-		defer func() { _ = resp.Body.Close() }()
 
-		if resp.StatusCode != http.StatusAccepted {
-			body, err := io.ReadAll(resp.Body)
+			r, err := json.Marshal(minimalResponse)
 			if err != nil {
-				return nil, nil, fmt.Errorf("failed to read response body: %w", err)
+				return nil, nil, fmt.Errorf("failed to marshal response: %w", err)
 			}
-			return utils.NewToolResultError(fmt.Sprintf("failed to fork repository: %s", string(body))), nil, nil
-		}
-
-		// Return minimal response with just essential information
-		minimalResponse := MinimalResponse{
-			ID:  fmt.Sprintf("%d", forkedRepo.GetID()),
-			URL: forkedRepo.GetHTMLURL(),
-		}
 
-		r, err := json.Marshal(minimalResponse)
-		if err != nil {
-			return nil, nil, fmt.Errorf("failed to marshal response: %w", err)
+			return utils.NewToolResultText(string(r)), nil, nil
 		}
-
-		return utils.NewToolResultText(string(r)), nil, nil
-	})
-
-	return tool, handler
 }
 
 // DeleteFile creates a tool to delete a file in a GitHub repository.

pkg/github/repositories_test.go

@@ -335,8 +335,9 @@ func Test_ForkRepository(t *testing.T) {
 	tool, _ := ForkRepository(stubGetClientFn(mockClient), translations.NullTranslationHelper)
 	require.NoError(t, toolsnaps.Test(tool.Name, tool))
 
-	schema, ok := tool.InputSchema.(*jsonschema.Schema)
-	require.True(t, ok, "InputSchema should be *jsonschema.Schema")
+	// Get schema from the input type's MCPSchema() method
+	schema := ForkRepositoryInput{}.MCPSchema()
+	require.NotNil(t, schema, "MCPSchema should return a schema")
 
 	assert.Equal(t, "fork_repository", tool.Name)
 	assert.NotEmpty(t, tool.Description)
@@ -362,7 +363,7 @@ func Test_ForkRepository(t *testing.T) {
 	tests := []struct {
 		name           string
 		mockedClient   *http.Client
-		requestArgs    map[string]interface{}
+		input          ForkRepositoryInput
 		expectError    bool
 		expectedRepo   *github.Repository
 		expectedErrMsg string
@@ -375,9 +376,9 @@ func Test_ForkRepository(t *testing.T) {
 					mockResponse(t, http.StatusAccepted, mockForkedRepo),
 				),
 			),
-			requestArgs: map[string]interface{}{
-				"owner": "owner",
-				"repo":  "repo",
+			input: ForkRepositoryInput{
+				Owner: "owner",
+				Repo:  "repo",
 			},
 			expectError:  false,
 			expectedRepo: mockForkedRepo,
@@ -393,9 +394,9 @@ func Test_ForkRepository(t *testing.T) {
 					}),
 				),
 			),
-			requestArgs: map[string]interface{}{
-				"owner": "owner",
-				"repo":  "repo",
+			input: ForkRepositoryInput{
+				Owner: "owner",
+				Repo:  "repo",
 			},
 			expectError:    true,
 			expectedErrMsg: "failed to fork repository",
@@ -408,11 +409,8 @@ func Test_ForkRepository(t *testing.T) {
 			client := github.NewClient(tc.mockedClient)
 			_, handler := ForkRepository(stubGetClientFn(client), translations.NullTranslationHelper)
 
-			// Create call request
-			request := createMCPRequest(tc.requestArgs)
-
-			// Call handler
-			result, _, err := handler(context.Background(), &request, tc.requestArgs)
+			// Call handler with typed input
+			result, _, err := handler(context.Background(), nil, tc.input)
 
 			// Verify results
 			if tc.expectError {