GithubBackup/httprunner
1
0
Fork 0
mirror of https://github.com/httprunner/httprunner.git synced 2026-07-25 07:47:12 +08:00
Code Issues Packages Projects Releases Wiki Activity

change: upgrade eino sdk

Browse Source
This commit is contained in:
lilong.129
2025-07-03 21:47:45 +08:00
parent 9d73af4f62
commit 58ce7efb8b
17 changed files with 284 additions and 246 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
uixt/ai/env.go
View File

@@ -6,11 +6,12 @@ import (
"time"
"github.com/cloudwego/eino-ext/components/model/openai"
"github.com/pkg/errors"
"github.com/rs/zerolog/log"
"github.com/httprunner/httprunner/v5/code"
"github.com/httprunner/httprunner/v5/internal/config"
"github.com/httprunner/httprunner/v5/uixt/option"
"github.com/pkg/errors"
"github.com/rs/zerolog/log"
)
// LLM model config env variables
@@ -80,6 +81,7 @@ func getServiceEnvPrefix(modelType option.LLMServiceType) string {
// It first tries to get service-specific config, then falls back to default config
// Model name is derived from the service type, no need for separate MODEL_NAME env var
func getModelConfigFromEnv(modelType option.LLMServiceType) (baseURL, apiKey, modelName string, err error) {
log.Info().Str("modelType", string(modelType)).Msg("getModelConfigFromEnv")
servicePrefix := getServiceEnvPrefix(modelType)
// Try to get service-specific configuration first

8
uixt/mcp_server.go
View File

@@ -163,13 +163,7 @@ func BuildMCPCallToolRequest(toolName option.ActionName, arguments map[string]an
extractActionOptionsToArguments(action.GetOptions(), arguments)
return mcp.CallToolRequest{
Params: struct {
Name string `json:"name"`
Arguments map[string]any `json:"arguments,omitempty"`
Meta *struct {
ProgressToken mcp.ProgressToken `json:"progressToken,omitempty"`
} `json:"_meta,omitempty"`
}{
Params: mcp.CallToolParams{
Name: string(toolName),
Arguments: arguments,
},

187
uixt/mcp_server_test.go
View File

@@ -3,10 +3,11 @@ package uixt
import (
"testing"
"github.com/httprunner/httprunner/v5/internal/json"
"github.com/httprunner/httprunner/v5/uixt/option"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/httprunner/httprunner/v5/internal/json"
"github.com/httprunner/httprunner/v5/uixt/option"
)
func TestNewMCPServer(t *testing.T) {
@@ -154,7 +155,7 @@ func TestIgnoreNotFoundErrorOption(t *testing.T) {
assert.NoError(t, err, "Should convert action to request without error")
// Verify that ignore_NotFoundError option is included in arguments
args := request.Params.Arguments
args := request.GetArguments()
assert.Equal(t, true, args["ignore_NotFoundError"], "ignore_NotFoundError should be true")
assert.Equal(t, 2, args["max_retry_times"], "max_retry_times should be 2")
assert.Equal(t, 1, args["index"], "index should be 1")
@@ -211,7 +212,7 @@ func TestToolListAvailableDevices(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_ListAvailableDevices), request.Params.Name)
assert.Empty(t, request.Params.Arguments)
assert.Empty(t, request.GetArguments())
}
// TestToolSelectDevice tests the ToolSelectDevice implementation
@@ -264,9 +265,10 @@ func TestToolTapXY(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_TapXY), request.Params.Name)
assert.Equal(t, 0.5, request.Params.Arguments["x"])
assert.Equal(t, 0.6, request.Params.Arguments["y"])
assert.Equal(t, 1.5, request.Params.Arguments["duration"])
args := request.GetArguments()
assert.Equal(t, 0.5, args["x"])
assert.Equal(t, 0.6, args["y"])
assert.Equal(t, 1.5, args["duration"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -302,9 +304,10 @@ func TestToolTapAbsXY(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_TapAbsXY), request.Params.Name)
assert.Equal(t, 100.0, request.Params.Arguments["x"])
assert.Equal(t, 200.0, request.Params.Arguments["y"])
assert.Equal(t, 2.0, request.Params.Arguments["duration"])
args := request.GetArguments()
assert.Equal(t, 100.0, args["x"])
assert.Equal(t, 200.0, args["y"])
assert.Equal(t, 2.0, args["duration"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -345,12 +348,13 @@ func TestToolTapByOCR(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_TapByOCR), request.Params.Name)
assert.Equal(t, "test_text", request.Params.Arguments["text"])
assert.Equal(t, true, request.Params.Arguments["ignore_NotFoundError"])
assert.Equal(t, 3, request.Params.Arguments["max_retry_times"])
assert.Equal(t, 1, request.Params.Arguments["index"])
assert.Equal(t, true, request.Params.Arguments["regex"])
assert.Equal(t, true, request.Params.Arguments["tap_random_rect"])
args := request.GetArguments()
assert.Equal(t, "test_text", args["text"])
assert.Equal(t, true, args["ignore_NotFoundError"])
assert.Equal(t, 3, args["max_retry_times"])
assert.Equal(t, 1, args["index"])
assert.Equal(t, true, args["regex"])
assert.Equal(t, true, args["tap_random_rect"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -389,10 +393,11 @@ func TestToolTapByCV(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_TapByCV), request.Params.Name)
assert.Equal(t, "", request.Params.Arguments["imagePath"])
assert.Equal(t, true, request.Params.Arguments["ignore_NotFoundError"])
assert.Equal(t, 2, request.Params.Arguments["max_retry_times"])
assert.Equal(t, true, request.Params.Arguments["tap_random_rect"])
args := request.GetArguments()
assert.Equal(t, "", args["imagePath"])
assert.Equal(t, true, args["ignore_NotFoundError"])
assert.Equal(t, 2, args["max_retry_times"])
assert.Equal(t, true, args["tap_random_rect"])
}
// TestToolDoubleTapXY tests the ToolDoubleTapXY implementation
@@ -417,8 +422,9 @@ func TestToolDoubleTapXY(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_DoubleTapXY), request.Params.Name)
assert.Equal(t, 0.3, request.Params.Arguments["x"])
assert.Equal(t, 0.7, request.Params.Arguments["y"])
args := request.GetArguments()
assert.Equal(t, 0.3, args["x"])
assert.Equal(t, 0.7, args["y"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -455,9 +461,10 @@ func TestToolSwipe(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(directionAction)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_Swipe), request.Params.Name)
assert.Equal(t, "up", request.Params.Arguments["direction"])
assert.Equal(t, 1.5, request.Params.Arguments["duration"])
assert.Equal(t, 0.5, request.Params.Arguments["pressDuration"])
args := request.GetArguments()
assert.Equal(t, "up", args["direction"])
assert.Equal(t, 1.5, args["duration"])
assert.Equal(t, 0.5, args["pressDuration"])
// Test ConvertActionToCallToolRequest with coordinate params
coordinateAction := option.MobileAction{
@@ -471,12 +478,13 @@ func TestToolSwipe(t *testing.T) {
request, err = tool.ConvertActionToCallToolRequest(coordinateAction)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_Swipe), request.Params.Name)
assert.Equal(t, 0.1, request.Params.Arguments["from_x"])
assert.Equal(t, 0.2, request.Params.Arguments["from_y"])
assert.Equal(t, 0.8, request.Params.Arguments["to_x"])
assert.Equal(t, 0.9, request.Params.Arguments["to_y"])
assert.Equal(t, 2.0, request.Params.Arguments["duration"])
assert.Equal(t, 1.0, request.Params.Arguments["pressDuration"])
args = request.GetArguments()
assert.Equal(t, 0.1, args["from_x"])
assert.Equal(t, 0.2, args["from_y"])
assert.Equal(t, 0.8, args["to_x"])
assert.Equal(t, 0.9, args["to_y"])
assert.Equal(t, 2.0, args["duration"])
assert.Equal(t, 1.0, args["pressDuration"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -521,9 +529,10 @@ func TestToolSwipeDirection(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_SwipeDirection), request.Params.Name)
assert.Equal(t, "up", request.Params.Arguments["direction"])
assert.Equal(t, 1.0, request.Params.Arguments["duration"])
assert.Equal(t, 0.5, request.Params.Arguments["pressDuration"])
args := request.GetArguments()
assert.Equal(t, "up", args["direction"])
assert.Equal(t, 1.0, args["duration"])
assert.Equal(t, 0.5, args["pressDuration"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -560,12 +569,13 @@ func TestToolSwipeCoordinate(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_SwipeCoordinate), request.Params.Name)
assert.Equal(t, 0.1, request.Params.Arguments["from_x"])
assert.Equal(t, 0.2, request.Params.Arguments["from_y"])
assert.Equal(t, 0.8, request.Params.Arguments["to_x"])
assert.Equal(t, 0.9, request.Params.Arguments["to_y"])
assert.Equal(t, 2.0, request.Params.Arguments["duration"])
assert.Equal(t, 1.0, request.Params.Arguments["pressDuration"])
args := request.GetArguments()
assert.Equal(t, 0.1, args["from_x"])
assert.Equal(t, 0.2, args["from_y"])
assert.Equal(t, 0.8, args["to_x"])
assert.Equal(t, 0.9, args["to_y"])
assert.Equal(t, 2.0, args["duration"])
assert.Equal(t, 1.0, args["pressDuration"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -604,10 +614,11 @@ func TestToolSwipeToTapApp(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_SwipeToTapApp), request.Params.Name)
assert.Equal(t, "WeChat", request.Params.Arguments["appName"])
assert.Equal(t, true, request.Params.Arguments["ignore_NotFoundError"])
assert.Equal(t, 3, request.Params.Arguments["max_retry_times"])
assert.Equal(t, 1, request.Params.Arguments["index"])
args := request.GetArguments()
assert.Equal(t, "WeChat", args["appName"])
assert.Equal(t, true, args["ignore_NotFoundError"])
assert.Equal(t, 3, args["max_retry_times"])
assert.Equal(t, 1, args["index"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -646,10 +657,11 @@ func TestToolSwipeToTapText(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_SwipeToTapText), request.Params.Name)
assert.Equal(t, "Submit", request.Params.Arguments["text"])
assert.Equal(t, true, request.Params.Arguments["ignore_NotFoundError"])
assert.Equal(t, 2, request.Params.Arguments["max_retry_times"])
assert.Equal(t, true, request.Params.Arguments["regex"])
args := request.GetArguments()
assert.Equal(t, "Submit", args["text"])
assert.Equal(t, true, args["ignore_NotFoundError"])
assert.Equal(t, 2, args["max_retry_times"])
assert.Equal(t, true, args["regex"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -688,11 +700,12 @@ func TestToolSwipeToTapTexts(t *testing.T) {
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_SwipeToTapTexts), request.Params.Name)
texts, ok := request.Params.Arguments["texts"].([]string)
args := request.GetArguments()
texts, ok := args["texts"].([]string)
require.True(t, ok)
assert.Equal(t, []string{"OK", "确定", "Submit"}, texts)
assert.Equal(t, true, request.Params.Arguments["ignore_NotFoundError"])
assert.Equal(t, true, request.Params.Arguments["regex"])
assert.Equal(t, true, args["ignore_NotFoundError"])
assert.Equal(t, true, args["regex"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -728,11 +741,12 @@ func TestToolDrag(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_Drag), request.Params.Name)
assert.Equal(t, 0.1, request.Params.Arguments["from_x"])
assert.Equal(t, 0.2, request.Params.Arguments["from_y"])
assert.Equal(t, 0.8, request.Params.Arguments["to_x"])
assert.Equal(t, 0.9, request.Params.Arguments["to_y"])
assert.Equal(t, 2500.0, request.Params.Arguments["duration"]) // converted to milliseconds
args := request.GetArguments()
assert.Equal(t, 0.1, args["from_x"])
assert.Equal(t, 0.2, args["from_y"])
assert.Equal(t, 0.8, args["to_x"])
assert.Equal(t, 0.9, args["to_y"])
assert.Equal(t, 2500.0, args["duration"]) // converted to milliseconds
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -765,7 +779,7 @@ func TestToolInput(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_Input), request.Params.Name)
assert.Equal(t, "Hello World", request.Params.Arguments["text"])
assert.Equal(t, "Hello World", request.GetArguments()["text"])
}
// TestToolScreenShot tests the ToolScreenShot implementation
@@ -790,7 +804,7 @@ func TestToolScreenShot(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_ScreenShot), request.Params.Name)
assert.Empty(t, request.Params.Arguments)
assert.Empty(t, request.GetArguments())
}
// TestToolGetScreenSize tests the ToolGetScreenSize implementation
@@ -815,7 +829,7 @@ func TestToolGetScreenSize(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_GetScreenSize), request.Params.Name)
assert.Empty(t, request.Params.Arguments)
assert.Empty(t, request.GetArguments())
}
// TestToolPressButton tests the ToolPressButton implementation
@@ -840,7 +854,7 @@ func TestToolPressButton(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_PressButton), request.Params.Name)
assert.Equal(t, "HOME", request.Params.Arguments["button"])
assert.Equal(t, "HOME", request.GetArguments()["button"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -873,7 +887,7 @@ func TestToolHome(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_Home), request.Params.Name)
assert.Empty(t, request.Params.Arguments)
assert.Empty(t, request.GetArguments())
}
// TestToolBack tests the ToolBack implementation
@@ -898,7 +912,7 @@ func TestToolBack(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_Back), request.Params.Name)
assert.Empty(t, request.Params.Arguments)
assert.Empty(t, request.GetArguments())
}
// TestToolListPackages tests the ToolListPackages implementation
@@ -923,7 +937,7 @@ func TestToolListPackages(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_ListPackages), request.Params.Name)
assert.Empty(t, request.Params.Arguments)
assert.Empty(t, request.GetArguments())
}
// TestToolLaunchApp tests the ToolLaunchApp implementation
@@ -948,7 +962,7 @@ func TestToolLaunchApp(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_AppLaunch), request.Params.Name)
assert.Equal(t, "com.example.app", request.Params.Arguments["packageName"])
assert.Equal(t, "com.example.app", request.GetArguments()["packageName"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -981,7 +995,7 @@ func TestToolTerminateApp(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_AppTerminate), request.Params.Name)
assert.Equal(t, "com.example.app", request.Params.Arguments["packageName"])
assert.Equal(t, "com.example.app", request.GetArguments()["packageName"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -1014,7 +1028,7 @@ func TestToolAppInstall(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_AppInstall), request.Params.Name)
assert.Equal(t, "https://example.com/app.apk", request.Params.Arguments["appUrl"])
assert.Equal(t, "https://example.com/app.apk", request.GetArguments()["appUrl"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -1047,7 +1061,7 @@ func TestToolAppUninstall(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_AppUninstall), request.Params.Name)
assert.Equal(t, "com.example.app", request.Params.Arguments["packageName"])
assert.Equal(t, "com.example.app", request.GetArguments()["packageName"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -1080,7 +1094,7 @@ func TestToolAppClear(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_AppClear), request.Params.Name)
assert.Equal(t, "com.example.app", request.Params.Arguments["packageName"])
assert.Equal(t, "com.example.app", request.GetArguments()["packageName"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -1113,7 +1127,7 @@ func TestToolSleep(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_Sleep), request.Params.Name)
assert.Equal(t, 2.5, request.Params.Arguments["seconds"])
assert.Equal(t, 2.5, request.GetArguments()["seconds"])
}
// TestToolSleepMS tests the ToolSleepMS implementation
@@ -1138,7 +1152,7 @@ func TestToolSleepMS(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_SleepMS), request.Params.Name)
assert.Equal(t, int64(1500), request.Params.Arguments["milliseconds"])
assert.Equal(t, int64(1500), request.GetArguments()["milliseconds"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -1172,7 +1186,7 @@ func TestToolSleepRandom(t *testing.T) {
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_SleepRandom), request.Params.Name)
params, ok := request.Params.Arguments["params"].([]float64)
params, ok := request.GetArguments()["params"].([]float64)
require.True(t, ok)
assert.Equal(t, []float64{1.0, 3.0}, params)
@@ -1207,7 +1221,7 @@ func TestToolSetIme(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_SetIme), request.Params.Name)
assert.Equal(t, "com.google.android.inputmethod.latin", request.Params.Arguments["ime"])
assert.Equal(t, "com.google.android.inputmethod.latin", request.GetArguments()["ime"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -1240,7 +1254,7 @@ func TestToolGetSource(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_GetSource), request.Params.Name)
assert.Equal(t, "com.example.app", request.Params.Arguments["packageName"])
assert.Equal(t, "com.example.app", request.GetArguments()["packageName"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -1273,7 +1287,7 @@ func TestToolClosePopups(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_ClosePopups), request.Params.Name)
assert.Empty(t, request.Params.Arguments)
assert.Empty(t, request.GetArguments())
}
// TestToolAIAction tests the ToolAIAction implementation
@@ -1298,7 +1312,7 @@ func TestToolAIAction(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_AIAction), request.Params.Name)
assert.Equal(t, "Click on the login button", request.Params.Arguments["prompt"])
assert.Equal(t, "Click on the login button", request.GetArguments()["prompt"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -1331,7 +1345,7 @@ func TestToolAIQuery(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_Query), request.Params.Name)
assert.Equal(t, "What is displayed on the screen?", request.Params.Arguments["prompt"])
assert.Equal(t, "What is displayed on the screen?", request.GetArguments()["prompt"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -1364,7 +1378,7 @@ func TestToolFinished(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_Finished), request.Params.Name)
assert.Equal(t, "Task completed successfully", request.Params.Arguments["content"])
assert.Equal(t, "Task completed successfully", request.GetArguments()["content"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -1397,7 +1411,7 @@ func TestToolWebLoginNoneUI(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_WebLoginNoneUI), request.Params.Name)
assert.Empty(t, request.Params.Arguments)
assert.Empty(t, request.GetArguments())
}
// TestToolSecondaryClick tests the ToolSecondaryClick implementation
@@ -1422,8 +1436,9 @@ func TestToolSecondaryClick(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_SecondaryClick), request.Params.Name)
assert.Equal(t, 0.5, request.Params.Arguments["x"])
assert.Equal(t, 0.6, request.Params.Arguments["y"])
args := request.GetArguments()
assert.Equal(t, 0.5, args["x"])
assert.Equal(t, 0.6, args["y"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -1456,7 +1471,7 @@ func TestToolHoverBySelector(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_HoverBySelector), request.Params.Name)
assert.Equal(t, "#login-button", request.Params.Arguments["selector"])
assert.Equal(t, "#login-button", request.GetArguments()["selector"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -1489,7 +1504,7 @@ func TestToolTapBySelector(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_TapBySelector), request.Params.Name)
assert.Equal(t, "//button[@id='submit']", request.Params.Arguments["selector"])
assert.Equal(t, "//button[@id='submit']", request.GetArguments()["selector"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -1522,7 +1537,7 @@ func TestToolSecondaryClickBySelector(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_SecondaryClickBySelector), request.Params.Name)
assert.Equal(t, ".context-menu-trigger", request.Params.Arguments["selector"])
assert.Equal(t, ".context-menu-trigger", request.GetArguments()["selector"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -1555,7 +1570,7 @@ func TestToolWebCloseTab(t *testing.T) {
request, err := tool.ConvertActionToCallToolRequest(action)
assert.NoError(t, err)
assert.Equal(t, string(option.ACTION_WebCloseTab), request.Params.Name)
assert.Equal(t, 1, request.Params.Arguments["tabIndex"])
assert.Equal(t, 1, request.GetArguments()["tabIndex"])
// Test ConvertActionToCallToolRequest with invalid params
invalidAction := option.MobileAction{
@@ -1583,7 +1598,7 @@ func TestPreMarkOperationConfiguration(t *testing.T) {
request, err := tapTool.ConvertActionToCallToolRequest(actionWithPreMark)
assert.NoError(t, err)
assert.Equal(t, true, request.Params.Arguments["pre_mark_operation"])
assert.Equal(t, true, request.GetArguments()["pre_mark_operation"])
// Test conversion without pre_mark_operation
actionWithoutPreMark := option.MobileAction{
@@ -1595,7 +1610,7 @@ func TestPreMarkOperationConfiguration(t *testing.T) {
request2, err := tapTool.ConvertActionToCallToolRequest(actionWithoutPreMark)
assert.NoError(t, err)
// Should not have pre_mark_operation in arguments when false
_, exists := request2.Params.Arguments["pre_mark_operation"]
_, exists := request2.GetArguments()["pre_mark_operation"]
assert.False(t, exists)
}

17
uixt/mcp_tools_ai.go
View File

@@ -32,12 +32,13 @@ func (t *ToolStartToGoal) Options() []mcp.ToolOption {
func (t *ToolStartToGoal) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -88,12 +89,13 @@ func (t *ToolAIAction) Options() []mcp.ToolOption {
func (t *ToolAIAction) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -145,12 +147,13 @@ func (t *ToolAIQuery) Options() []mcp.ToolOption {
func (t *ToolAIQuery) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -205,7 +208,7 @@ func (t *ToolFinished) Options() []mcp.ToolOption {
func (t *ToolFinished) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(request.GetArguments())
if err != nil {
return nil, err
}

29
uixt/mcp_tools_app.go
View File

@@ -33,7 +33,7 @@ func (t *ToolListPackages) Options() []mcp.ToolOption {
func (t *ToolListPackages) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
driverExt, err := setupXTDriver(ctx, request.GetArguments())
if err != nil {
return nil, err
}
@@ -78,12 +78,13 @@ func (t *ToolLaunchApp) Options() []mcp.ToolOption {
func (t *ToolLaunchApp) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -137,12 +138,13 @@ func (t *ToolTerminateApp) Options() []mcp.ToolOption {
func (t *ToolTerminateApp) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -201,12 +203,13 @@ func (t *ToolAppInstall) Options() []mcp.ToolOption {
func (t *ToolAppInstall) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -255,12 +258,13 @@ func (t *ToolAppUninstall) Options() []mcp.ToolOption {
func (t *ToolAppUninstall) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -309,12 +313,13 @@ func (t *ToolAppClear) Options() []mcp.ToolOption {
func (t *ToolAppClear) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -364,7 +369,7 @@ func (t *ToolGetForegroundApp) Options() []mcp.ToolOption {
func (t *ToolGetForegroundApp) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
driverExt, err := setupXTDriver(ctx, request.GetArguments())
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}

9
uixt/mcp_tools_button.go
View File

@@ -32,12 +32,13 @@ func (t *ToolPressButton) Options() []mcp.ToolOption {
func (t *ToolPressButton) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -84,7 +85,7 @@ func (t *ToolHome) Options() []mcp.ToolOption {
func (t *ToolHome) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
driverExt, err := setupXTDriver(ctx, request.GetArguments())
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
@@ -125,7 +126,7 @@ func (t *ToolBack) Options() []mcp.ToolOption {
func (t *ToolBack) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
driverExt, err := setupXTDriver(ctx, request.GetArguments())
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}

13
uixt/mcp_tools_device.go
View File

@@ -109,7 +109,7 @@ func (t *ToolSelectDevice) Options() []mcp.ToolOption {
func (t *ToolSelectDevice) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
driverExt, err := setupXTDriver(ctx, request.GetArguments())
if err != nil {
return nil, err
}
@@ -155,7 +155,8 @@ func (t *ToolScreenRecord) Options() []mcp.ToolOption {
func (t *ToolScreenRecord) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, err
}
@@ -163,19 +164,19 @@ func (t *ToolScreenRecord) Implement() server.ToolHandlerFunc {
// Parse options from arguments
var opts []option.ActionOption
if duration, ok := request.Params.Arguments["duration"].(float64); ok && duration > 0 {
if duration, ok := arguments["duration"].(float64); ok && duration > 0 {
opts = append(opts, option.WithDuration(duration))
}
if path, ok := request.Params.Arguments["screenRecordPath"].(string); ok && path != "" {
if path, ok := arguments["screenRecordPath"].(string); ok && path != "" {
opts = append(opts, option.WithScreenRecordPath(path))
}
if audio, ok := request.Params.Arguments["screenRecordWithAudio"].(bool); ok && audio {
if audio, ok := arguments["screenRecordWithAudio"].(bool); ok && audio {
opts = append(opts, option.WithScreenRecordAudio(true))
}
if scrcpy, ok := request.Params.Arguments["screenRecordWithScrcpy"].(bool); ok && scrcpy {
if scrcpy, ok := arguments["screenRecordWithScrcpy"].(bool); ok && scrcpy {
opts = append(opts, option.WithScreenRecordScrcpy(true))
}

10
uixt/mcp_tools_input.go
View File

@@ -31,12 +31,13 @@ func (t *ToolInput) Options() []mcp.ToolOption {
func (t *ToolInput) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -89,12 +90,13 @@ func (t *ToolSetIme) Options() []mcp.ToolOption {
func (t *ToolSetIme) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}

9
uixt/mcp_tools_screen.go
View File

@@ -31,7 +31,7 @@ func (t *ToolScreenShot) Options() []mcp.ToolOption {
func (t *ToolScreenShot) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
driverExt, err := setupXTDriver(ctx, request.GetArguments())
if err != nil {
return nil, err
}
@@ -75,7 +75,7 @@ func (t *ToolGetScreenSize) Options() []mcp.ToolOption {
func (t *ToolGetScreenSize) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
driverExt, err := setupXTDriver(ctx, request.GetArguments())
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
@@ -121,12 +121,13 @@ func (t *ToolGetSource) Options() []mcp.ToolOption {
func (t *ToolGetSource) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}

40
uixt/mcp_tools_swipe.go
View File

@@ -37,7 +37,7 @@ func (t *ToolSwipe) Options() []mcp.ToolOption {
func (t *ToolSwipe) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
// Check if it's direction-based swipe (has "direction" parameter)
if _, exists := request.Params.Arguments["direction"]; exists {
if _, exists := request.GetArguments()["direction"]; exists {
// Delegate to ToolSwipeDirection
directionTool := &ToolSwipeDirection{}
return directionTool.Implement()(ctx, request)
@@ -104,12 +104,13 @@ func (t *ToolSwipeDirection) Options() []mcp.ToolOption {
func (t *ToolSwipeDirection) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -212,12 +213,13 @@ func (t *ToolSwipeCoordinate) Options() []mcp.ToolOption {
func (t *ToolSwipeCoordinate) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -298,12 +300,13 @@ func (t *ToolSwipeToTapApp) Options() []mcp.ToolOption {
func (t *ToolSwipeToTapApp) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -355,12 +358,13 @@ func (t *ToolSwipeToTapText) Options() []mcp.ToolOption {
func (t *ToolSwipeToTapText) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -413,12 +417,13 @@ func (t *ToolSwipeToTapTexts) Options() []mcp.ToolOption {
func (t *ToolSwipeToTapTexts) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -481,21 +486,22 @@ func (t *ToolDrag) Options() []mcp.ToolOption {
func (t *ToolDrag) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
// Validate required parameters - check if coordinates are provided (not just non-zero)
_, hasFromX := request.Params.Arguments["from_x"]
_, hasFromY := request.Params.Arguments["from_y"]
_, hasToX := request.Params.Arguments["to_x"]
_, hasToY := request.Params.Arguments["to_y"]
_, hasFromX := arguments["from_x"]
_, hasFromY := arguments["from_y"]
_, hasToX := arguments["to_x"]
_, hasToY := arguments["to_y"]
if !hasFromX || !hasFromY || !hasToX || !hasToY {
return nil, fmt.Errorf("from_x, from_y, to_x, and to_y coordinates are required")
}

25
uixt/mcp_tools_touch.go
View File

@@ -33,12 +33,13 @@ func (t *ToolTapXY) Options() []mcp.ToolOption {
func (t *ToolTapXY) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -105,12 +106,13 @@ func (t *ToolTapAbsXY) Options() []mcp.ToolOption {
func (t *ToolTapAbsXY) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -176,12 +178,13 @@ func (t *ToolTapByOCR) Options() []mcp.ToolOption {
func (t *ToolTapByOCR) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -236,12 +239,13 @@ func (t *ToolTapByCV) Options() []mcp.ToolOption {
func (t *ToolTapByCV) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -294,12 +298,13 @@ func (t *ToolDoubleTapXY) Options() []mcp.ToolOption {
func (t *ToolDoubleTapXY) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}

8
uixt/mcp_tools_utility.go
View File

@@ -38,7 +38,7 @@ func (t *ToolSleep) Options() []mcp.ToolOption {
func (t *ToolSleep) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
seconds, ok := request.Params.Arguments["seconds"]
seconds, ok := request.GetArguments()["seconds"]
if !ok {
log.Warn().Msg("seconds parameter is required, using default value 5.0 seconds")
seconds = 5.0
@@ -120,7 +120,7 @@ func (t *ToolSleepMS) Options() []mcp.ToolOption {
func (t *ToolSleepMS) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
milliseconds, ok := request.Params.Arguments["milliseconds"]
milliseconds, ok := request.GetArguments()["milliseconds"]
if !ok {
log.Warn().Msg("milliseconds parameter is required, using default value 1000 milliseconds")
milliseconds = 1000
@@ -208,7 +208,7 @@ func (t *ToolSleepRandom) Options() []mcp.ToolOption {
func (t *ToolSleepRandom) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(request.GetArguments())
if err != nil {
return nil, err
}
@@ -252,7 +252,7 @@ func (t *ToolClosePopups) Options() []mcp.ToolOption {
func (t *ToolClosePopups) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
driverExt, err := setupXTDriver(ctx, request.GetArguments())
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}

30
uixt/mcp_tools_web.go
View File

@@ -34,12 +34,13 @@ func (t *ToolWebLoginNoneUI) Options() []mcp.ToolOption {
func (t *ToolWebLoginNoneUI) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -96,12 +97,13 @@ func (t *ToolSecondaryClick) Options() []mcp.ToolOption {
func (t *ToolSecondaryClick) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -159,12 +161,13 @@ func (t *ToolHoverBySelector) Options() []mcp.ToolOption {
func (t *ToolHoverBySelector) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -215,12 +218,13 @@ func (t *ToolTapBySelector) Options() []mcp.ToolOption {
func (t *ToolTapBySelector) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -271,12 +275,13 @@ func (t *ToolSecondaryClickBySelector) Options() []mcp.ToolOption {
func (t *ToolSecondaryClickBySelector) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}
@@ -327,12 +332,13 @@ func (t *ToolWebCloseTab) Options() []mcp.ToolOption {
func (t *ToolWebCloseTab) Implement() server.ToolHandlerFunc {
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
arguments := request.GetArguments()
driverExt, err := setupXTDriver(ctx, arguments)
if err != nil {
return nil, fmt.Errorf("setup driver failed: %w", err)
}
unifiedReq, err := parseActionOptions(request.Params.Arguments)
unifiedReq, err := parseActionOptions(arguments)
if err != nil {
return nil, err
}

8
uixt/sdk.go
View File

@@ -230,13 +230,7 @@ func (dExt *XTDriver) CallMCPTool(ctx context.Context,
// Call MCP tool
req := mcp.CallToolRequest{
Params: struct {
Name string `json:"name"`
Arguments map[string]any `json:"arguments,omitempty"`
Meta *struct {
ProgressToken mcp.ProgressToken `json:"progressToken,omitempty"`
} `json:"_meta,omitempty"`
}{
Params: mcp.CallToolParams{
Name: toolName,
Arguments: arguments,
},