{
  "notice": "bxzxxr MCP archive: a record of what public MCP servers declared when we listed them (we never call their tools). It is data, not a rating: nothing here says a server is safe, secure, verified or trustworthy, and a server can change after we looked. Secrets we detected are redacted; redacted tool lists are withheld and only their hash is shown.",
  "infrastructure": {
    "host": "mcp.lambdatest.com",
    "site": "lambdatest.com",
    "addresses": [
      {
        "address": "52.71.217.38",
        "endpoints": 1,
        "shared_infrastructure": false,
        "network": {
          "asn": 14618,
          "name": "AMAZON-AES - Amazon.com, Inc.",
          "prefix": "52.70.0.0/15",
          "country": "US"
        }
      }
    ],
    "addresses_recorded": true,
    "address_history": [
      {
        "addresses": [
          "52.71.217.38"
        ],
        "first_seen": "2026-11-21T14:06:02.782Z",
        "last_seen": "2026-11-21T14:06:02.782Z",
        "checks": 1
      }
    ],
    "hosting": [],
    "software": [
      {
        "value": "nginx",
        "evidence": "Server header \"nginx\""
      }
    ],
    "server_info": {
      "name": "TestMu AI MCP",
      "version": "1.0.7",
      "protocol_version": "2025-03-26"
    },
    "headers": {
      "server": "nginx",
      "access-control-allow-origin": "*"
    },
    "auth": null
  },
  "related": {
    "same_address": {
      "total": 0,
      "sample": []
    },
    "same_site": {
      "total": 0,
      "sample": []
    },
    "same_tool_list": {
      "total": 0,
      "sample": []
    },
    "same_publisher": {
      "publisher": "io.github.LambdaTest",
      "total": 0,
      "sample": []
    },
    "same_repository": {
      "repository_url": "https://github.com/LambdaTest/mcp-server-guide",
      "total": 0,
      "sample": []
    },
    "note": "Shared addresses on big platforms (Cloudflare, Vercel and the like) put unrelated servers together; those are marked shared_infrastructure. A match is a pivot, not a link between operators."
  },
  "endpoint": {
    "id": "25407",
    "server_name": "io.github.LambdaTest/mcp",
    "url": "https://mcp.lambdatest.com/mcp",
    "host": "mcp.lambdatest.com",
    "transport": "streamable-http",
    "last_checked_at": "2026-11-21T14:06:02.782Z",
    "last_state": "listed",
    "last_detail": "resources/list failed: The server requires authentication (HTTP 401). The probe only scans servers whose tool list is public.",
    "consecutive_failures": 0,
    "current_sha": "ac57e031f5e6f0dbdded1c119b23a9803b12fb2a69245434f79737a93885269b",
    "first_listed_at": "2026-11-21T14:06:02.782Z",
    "created_at": "2026-11-21T08:35:06.801Z",
    "resolved_addresses": [
      "52.71.217.38"
    ]
  },
  "server": {
    "name": "io.github.LambdaTest/mcp",
    "title": "TestMu AI (formerly LambdaTest)",
    "description": "Agentic AI quality engineering: run, debug and triage tests on real browsers and devices",
    "version": "1.0.7",
    "registry_status": "active",
    "repository_url": "https://github.com/LambdaTest/mcp-server-guide",
    "website_url": "https://www.testmuai.com/mcp",
    "published_at": "2026-10-21T11:09:58.075Z",
    "updated_at": "2026-10-21T11:09:58.075Z",
    "first_seen": "2026-11-21T08:35:06.193Z"
  },
  "other_endpoints": [],
  "intel": {
    "capabilities": [
      "controls-browser",
      "runs-code",
      "writes-files"
    ],
    "evm_addresses": [],
    "chains": [],
    "tokens": [],
    "computed_at": "2026-11-22T15:37:06.504Z"
  },
  "operator": null,
  "needs_sign_in": false,
  "reachability": {
    "window_days": 30,
    "checks": 1,
    "answered": 1,
    "answered_percent": 100,
    "avg_listing_latency_ms": 80,
    "first_check_in_window": "2026-11-21T14:06:02.782Z",
    "consecutive_failures_now": 0,
    "days": [
      {
        "day": "2026-11-21",
        "checks": 1,
        "answered": 1,
        "last_state": "listed"
      }
    ]
  },
  "tool_list": {
    "sha256": "ac57e031f5e6f0dbdded1c119b23a9803b12fb2a69245434f79737a93885269b",
    "tools": 88,
    "resources": 0,
    "prompts": 0,
    "first_seen": "2026-11-21T14:06:02.869Z",
    "tool_names": [
      "upload_app",
      "generateHyperExecuteYAML",
      "answerHyperExecuteQuery",
      "getHyperExecuteJobInfo",
      "getHyperExecuteJobSessions",
      "getAccessibilityReport",
      "analyzeAppViaTunnel",
      "buildLocalAppForAnalysis",
      "getAutomationTestDetails",
      "getAutomationTestCommandLogs",
      "getAutomationTestNetworkLogs",
      "getAutomationTestBrowserConsoleLogs",
      "getAutomationTestSeleniumLogs",
      "automationQuery",
      "updateBuild",
      "stopBuild",
      "deleteBuild",
      "triggerSuiteRun",
      "getSuiteOverview",
      "getSupportedPlatforms",
      "listTunnels",
      "stopTunnel",
      "deleteSession",
      "updateSession",
      "stopSession",
      "getSessionScreenshots",
      "getSessionVideo",
      "getSessionV2CommandLogs",
      "getSessionV2SeleniumLogs",
      "postSessionExceptions",
      "postTestExceptions",
      "getLiveSessionLogs",
      "getOrgConcurrency",
      "getAnalyticsData",
      "getFlakyTests",
      "getTestTrends",
      "getAnalyticsErrors",
      "deletePrerunFile",
      "deleteUserFile",
      "listUploadedApps",
      "deleteUploadedApps",
      "uploadAppVirtualDevice",
      "listDevicesForTesting",
      "getMobileCapabilityGenerator",
      "listMobileBuilds",
      "listMobileSessions",
      "getMobileConcurrency",
      "checkAppProcessingStatus",
      "tm_list_projects",
      "tm_get_test_cases",
      "tm_list_folders",
      "tm_list_modules",
      "tm_list_configurations",
      "tm_get_test_runs",
      "tm_get_milestone",
      "tm_get_coverage_summary",
      "tm_create_project",
      "tm_update_project",
      "tm_create_folder",
      "tm_update_folder",
      "tm_generate_test_cases",
      "tm_create_test_case",
      "tm_update_test_case",
      "tm_create_test_run",
      "tm_update_test_run",
      "tm_record_test_results",
      "tm_create_milestone",
      "tm_update_milestone",
      "tm_link_jira_issue",
      "tm_link_ado_issue",
      "smartui_project_query",
      "smartui_build_query",
      "smartui_comparison_query",
      "smartui_comparison_analyze",
      "smartui_screenshot_upload",
      "smartui_screenshot_review",
      "smartui_baseline_manage",
      "listHyperExecuteJobs",
      "getHyperExecuteJobArtifacts",
      "downloadJobArtifact",
      "getJobArtifactDetail",
      "getHyperExecuteStage",
      "getHyperExecuteStageLogs",
      "getHyperExecuteStageTasks",
      "getHyperExecuteTask",
      "getHyperExecuteTaskLogs",
      "getHyperExecuteJobLiveStream",
      "analyzeHyperExecuteJob"
    ],
    "declared": {
      "tools": [
        {
          "name": "upload_app",
          "title": "Upload App to LambdaTest",
          "description": "Uploads an app to TestMu AI for mobile testing and displays upload status.",
          "inputSchema": {
            "type": "object",
            "required": [
              "name"
            ],
            "properties": {
              "name": {
                "type": "string",
                "description": "Name for the uploaded app"
              },
              "appUrl": {
                "type": "string",
                "description": "URL of the app to upload. Provide this OR appFilePath (exactly one is required)."
              },
              "customId": {
                "type": "string",
                "description": "Custom ID for the app (optional)"
              },
              "visibility": {
                "enum": [
                  "individual",
                  "team",
                  "organization"
                ],
                "type": "string",
                "description": "Visibility setting (optional, default: individual)"
              },
              "appFilePath": {
                "type": "string",
                "description": "Absolute path to the app file (APK, IPA, etc.). Provide this OR appUrl (exactly one is required)."
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "required": [
              "success",
              "message"
            ],
            "properties": {
              "appId": {
                "type": "string",
                "description": "The app ID"
              },
              "error": {
                "type": "string",
                "description": "Error message if upload failed"
              },
              "appUrl": {
                "type": "string",
                "description": "The URL of the uploaded app to use in capabilities"
              },
              "message": {
                "type": "string",
                "description": "Status message"
              },
              "success": {
                "type": "boolean",
                "description": "Whether the upload was successful"
              }
            }
          },
          "annotations": {
            "title": "Upload App to LambdaTest",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "generateHyperExecuteYAML",
          "title": "Generate HyperExecute YAML",
          "description": "Generates a HyperExecute YAML configuration for running tests on TestMu AI's HyperExecute platform.\n\nREQUIRED fields: project (language, framework) and testing (testDiscovery.command, testRunnerCommand)\nAll other fields are OPTIONAL.\n\nSupports multiple languages and frameworks:\n- JavaScript/TypeScript: Playwright, Cypress, WebDriverIO, Puppeteer, Taiko\n- Python: Pytest, Behave, Robot Framework\n- Java: TestNG, JUnit, Cucumber\n- Ruby: RSpec, Capybara\n- C#: NUnit, xUnit, MSTest\n- Mobile (ONLY use appTesting for these): XCUI (iOS), Espresso (Android), Appium\n\nFeatures:\n- Smart framework defaults for common configurations\n- Input validation with security checks\n- Caching and artifact upload configuration\n- Git integration via sourcePayload\n- Mobile app testing support (via optional appTesting field)\n\nThe appTesting field applies to mobile app testing only; web automation (Selenium, Playwright, Cypress, etc.) leaves it out.",
          "inputSchema": {
            "type": "object",
            "required": [
              "project",
              "testing"
            ],
            "properties": {
              "setup": {
                "type": "object",
                "properties": {
                  "env": {
                    "type": "object",
                    "description": "Environment variables",
                    "additionalProperties": {
                      "type": "string"
                    }
                  },
                  "runtime": {
                    "type": "object",
                    "properties": {
                      "version": {
                        "type": "string",
                        "description": "Runtime version, e.g. 20 or 3.11"
                      },
                      "language": {
                        "type": "string",
                        "description": "Runtime to install on the runner, e.g. node, python, java"
                      }
                    },
                    "description": "Runtime configuration"
                  },
                  "cacheKey": {
                    "type": "string",
                    "description": "Cache key pattern"
                  },
                  "preCommands": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    },
                    "description": "Commands to run before tests (e.g., npm install)"
                  },
                  "postCommands": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    },
                    "description": "Commands to run after tests"
                  },
                  "cacheDirectories": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    },
                    "description": "Directories to cache"
                  }
                },
                "description": "Setup configuration (optional)"
              },
              "project": {
                "type": "object",
                "required": [
                  "language",
                  "framework"
                ],
                "properties": {
                  "language": {
                    "enum": [
                      "javascript",
                      "typescript",
                      "python",
                      "java",
                      "ruby",
                      "csharp",
                      "go",
                      "php"
                    ],
                    "type": "string",
                    "description": "Programming language"
                  },
                  "buildTool": {
                    "enum": [
                      "npm",
                      "yarn",
                      "pnpm",
                      "maven",
                      "gradle",
                      "pip",
                      "bundler",
                      "dotnet"
                    ],
                    "type": "string",
                    "description": "Build tool (optional, will be inferred)"
                  },
                  "framework": {
                    "enum": [
                      "playwright",
                      "cypress",
                      "selenium",
                      "webdriverio",
                      "puppeteer",
                      "taiko",
                      "pytest",
                      "behave",
                      "robot",
                      "testng",
                      "junit",
                      "cucumber",
                      "rspec",
                      "capybara",
                      "nunit",
                      "xunit",
                      "mstest",
                      "xcui",
                      "espresso",
                      "appium"
                    ],
                    "type": "string",
                    "description": "Test framework"
                  }
                },
                "description": "Project configuration"
              },
              "testing": {
                "type": "object",
                "required": [
                  "testDiscovery",
                  "testRunnerCommand"
                ],
                "properties": {
                  "testDiscovery": {
                    "type": "object",
                    "required": [
                      "command"
                    ],
                    "properties": {
                      "mode": {
                        "enum": [
                          "dynamic",
                          "static"
                        ],
                        "type": "string",
                        "default": "dynamic",
                        "description": "dynamic discovers tests on the runner at run time; static uses the list found before the run"
                      },
                      "type": {
                        "enum": [
                          "raw",
                          "automatic"
                        ],
                        "type": "string",
                        "default": "raw",
                        "description": "How tests are discovered: raw runs the command as given, automatic lets HyperExecute detect them"
                      },
                      "command": {
                        "type": "string",
                        "description": "Command to discover tests (e.g., find tests -name '*.spec.ts')"
                      }
                    },
                    "description": "How HyperExecute finds the tests to run"
                  },
                  "testRunnerCommand": {
                    "type": "string",
                    "description": "Command to run tests. Use $test placeholder for test identifier."
                  }
                },
                "description": "Test configuration"
              },
              "advanced": {
                "type": "object",
                "description": "Advanced overrides (escape hatch for any HyperExecute field)",
                "additionalProperties": true
              },
              "jobLabel": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Labels for the job"
              },
              "artifacts": {
                "type": "object",
                "properties": {
                  "reports": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "type",
                        "location"
                      ],
                      "properties": {
                        "type": {
                          "enum": [
                            "html",
                            "json",
                            "xml",
                            "zip"
                          ],
                          "type": "string",
                          "description": "Report FORMAT (not framework name). Use 'xml' for most frameworks (Playwright, Cypress, pytest, TestNG, JUnit generate XML reports). Use 'json' for Cucumber/BDD. Valid: html, json, xml, zip"
                        },
                        "location": {
                          "type": "string",
                          "description": "Path to report files"
                        },
                        "frameworkName": {
                          "type": "string",
                          "description": "Framework name for display (e.g., 'Playwright', 'pytest') - NOT the report format"
                        }
                      }
                    },
                    "description": "Report configurations for result parsing"
                  },
                  "uploadPaths": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    },
                    "description": "Paths on the runner to upload as job artifacts, e.g. reports/ or screenshots/"
                  },
                  "mergeArtifacts": {
                    "type": "boolean",
                    "default": true,
                    "description": "Merge the artifacts from all parallel runners into one set"
                  }
                },
                "description": "Artifact configuration (optional)"
              },
              "execution": {
                "type": "object",
                "properties": {
                  "os": {
                    "enum": [
                      "linux",
                      "win",
                      "mac"
                    ],
                    "type": "string",
                    "default": "linux",
                    "description": "Runner operating system"
                  },
                  "tunnel": {
                    "type": "boolean",
                    "description": "Enable LambdaTest tunnel"
                  },
                  "autosplit": {
                    "type": "boolean",
                    "default": true,
                    "description": "Spread the discovered tests across the parallel runners automatically"
                  },
                  "maxRetries": {
                    "type": "integer",
                    "maximum": 5,
                    "minimum": 1,
                    "description": "Retries per failed test when retryOnFailure is on"
                  },
                  "concurrency": {
                    "type": "integer",
                    "default": 4,
                    "maximum": 150,
                    "minimum": 1,
                    "description": "Number of tests run in parallel"
                  },
                  "globalTimeout": {
                    "type": "integer",
                    "description": "Global timeout in minutes"
                  },
                  "retryOnFailure": {
                    "type": "boolean",
                    "default": false,
                    "description": "Retry failed tests"
                  },
                  "testSuiteTimeout": {
                    "type": "integer",
                    "description": "Test suite timeout in minutes"
                  }
                },
                "description": "Execution settings (optional)"
              },
              "appTesting": {
                "type": "object",
                "properties": {
                  "video": {
                    "type": "boolean",
                    "description": "Record a video of each test"
                  },
                  "appPath": {
                    "type": "string",
                    "description": "Path to app file or lt:// URL"
                  },
                  "devices": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    },
                    "description": "Target devices (required if appTesting is used, e.g., 'iPhone 14 Pro-17')"
                  },
                  "deviceLog": {
                    "type": "boolean",
                    "description": "Capture device logs"
                  },
                  "framework": {
                    "enum": [
                      "xcui",
                      "espresso",
                      "appium"
                    ],
                    "type": "string",
                    "description": "Mobile testing framework (required if appTesting is used)"
                  },
                  "networkLog": {
                    "type": "boolean",
                    "description": "Capture network logs"
                  },
                  "testSuitePath": {
                    "type": "string",
                    "description": "Path to test suite"
                  }
                },
                "description": "Mobile app testing configuration (XCUI, Espresso or Appium). Web automation (Selenium, Playwright, Cypress, etc.) leaves it out."
              },
              "sourcePayload": {
                "type": "object",
                "required": [
                  "platform",
                  "link",
                  "ref"
                ],
                "properties": {
                  "ref": {
                    "type": "string",
                    "description": "Branch/tag/commit"
                  },
                  "link": {
                    "type": "string",
                    "description": "Repository URL"
                  },
                  "platform": {
                    "enum": [
                      "git"
                    ],
                    "type": "string",
                    "description": "Source platform; git is the only supported value"
                  },
                  "accessToken": {
                    "type": "string",
                    "description": "Reference to an environment variable that holds the Git token, e.g. ${GIT_TOKEN}; never the token itself"
                  },
                  "gitProvider": {
                    "enum": [
                      "github",
                      "gitlab",
                      "bitbucket",
                      "azure"
                    ],
                    "type": "string",
                    "description": "Git host of the repository"
                  }
                },
                "description": "Git integration: fetches the test code from a remote Git repository. Only needed when the code is not already present locally; local code (the usual case) leaves it out."
              }
            }
          },
          "annotations": {
            "title": "Generate HyperExecute YAML",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "answerHyperExecuteQuery",
          "title": "Answer HyperExecute Question",
          "description": "Answers questions about HyperExecute features, configuration, usage, troubleshooting, and best practices by searching through documentation.",
          "inputSchema": {
            "type": "object",
            "required": [
              "query"
            ],
            "properties": {
              "query": {
                "type": "string",
                "description": "Question about HyperExecute"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Answer HyperExecute Question",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getHyperExecuteJobInfo",
          "title": "Show HyperExecute Job",
          "description": "Fetches and displays information about a HyperExecute job including status, test results, and progress.",
          "inputSchema": {
            "type": "object",
            "required": [
              "jobId"
            ],
            "properties": {
              "jobId": {
                "type": "string",
                "description": "The ID of the HyperExecute job"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Show HyperExecute Job",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getHyperExecuteJobSessions",
          "title": "Show HyperExecute Job Sessions",
          "description": "Fetches and displays session information for a HyperExecute job.",
          "inputSchema": {
            "type": "object",
            "required": [
              "jobId"
            ],
            "properties": {
              "jobId": {
                "type": "string",
                "description": "The ID of the HyperExecute job"
              },
              "limit": {
                "type": "number",
                "description": "Maximum number of sessions to return (default: 10)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Show HyperExecute Job Sessions",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getAccessibilityReport",
          "title": "Get Accessibility Report",
          "description": "Runs an accessibility scan on the given URLs and returns the issues found. Pass urls to start a scan, or testId to re-read a scan that already ran; exactly one of the two. Results arrive in issueDetails: allIssues (most-severe-first, one page at a time), rules (name and reference link per rule id, listed once), pages (every scanned page with its score and issue count), failedRules (per-rule totals for the whole scan) and pagination. Each issue carries its own howToFix and criteria, measured for that element - two issues sharing a rule can have different causes and fixes. While pagination.nextOffset is not null the results are incomplete: call again with the testId from the response plus that offset, keeping the same filters, until it is null. Page with testId, never by passing urls again - that starts a new scan, costs another run, and can return a different set of issues whose offsets do not line up. a11yReportLink is the dashboard URL and needs a login; shareableLink is public and is only returned by the original scan.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "urls": {
                "type": "array",
                "items": {
                  "type": "string",
                  "description": "URL to analyze for accessibility issues"
                },
                "minItems": 1,
                "description": "List of URLs to scan. Starts a new scan. Provide either urls or testId, not both."
              },
              "limit": {
                "type": "number",
                "maximum": 200,
                "minimum": 1,
                "description": "Maximum issues to return in this response (default 50, max 200)."
              },
              "offset": {
                "type": "number",
                "minimum": 0,
                "description": "Index to start from within the filtered, severity-sorted issue list. Pass the nextOffset from a previous response, together with that response's testId, to page through results."
              },
              "testId": {
                "type": "string",
                "description": "Re-read an existing scan by its testId (as returned in a previous response) instead of running a new one. Use this to page through results with offset."
              },
              "pageUrl": {
                "type": "string",
                "description": "Only return issues found on this scanned page. Must exactly match one of the URLs in issueDetails.pages."
              },
              "severity": {
                "enum": [
                  "critical",
                  "serious",
                  "moderate",
                  "minor"
                ],
                "type": "string",
                "description": "Only return issues of this impact level. Omit to get all severities."
              },
              "include_rules": {
                "type": "boolean",
                "description": "Return the full rule catalog (about 11 KB) instead of the default ruleCatalog summary of counts per category and disabled rule ids."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Accessibility Report",
            "readOnlyHint": false,
            "openWorldHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "analyzeAppViaTunnel",
          "title": "Analyze App via Tunnel",
          "description": "Analyzes a locally running app for accessibility via TestMu AI tunnel.",
          "inputSchema": {
            "type": "object",
            "required": [
              "port",
              "tunnelName",
              "tunnelId"
            ],
            "properties": {
              "port": {
                "type": "number",
                "description": "Port where the app is running"
              },
              "tunnelId": {
                "type": "string",
                "description": "Tunnel ID"
              },
              "tunnelName": {
                "type": "string",
                "description": "Tunnel name"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Analyze App via Tunnel",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "buildLocalAppForAnalysis",
          "title": "Build and Analyze App",
          "description": "Returns step-by-step instructions to build and serve a local web app and open a TestMu AI tunnel to it, so its accessibility can then be scanned with analyzeAppViaTunnel. It does not build, run or scan anything itself, and never includes the access key.",
          "inputSchema": {
            "type": "object",
            "required": [
              "codebasePath",
              "port"
            ],
            "properties": {
              "port": {
                "type": "number",
                "maximum": 65535,
                "minimum": 1024,
                "description": "Port to host the app locally"
              },
              "codebasePath": {
                "type": "string",
                "description": "Absolute path to the codebase directory"
              },
              "customBuildCommand": {
                "type": "string",
                "description": "Custom build command (optional, e.g., npm run build)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Build and Analyze App",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getAutomationTestDetails",
          "title": "Get Automation Test Details",
          "description": "Fetches detailed information about an automation test by ID",
          "inputSchema": {
            "type": "object",
            "required": [
              "testId",
              "platform"
            ],
            "properties": {
              "testId": {
                "type": "string",
                "description": "The ID of the automation test"
              },
              "platform": {
                "enum": [
                  "web",
                  "app"
                ],
                "type": "string",
                "description": "Optional: set to \"app\" to fetch details from the mobile API"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Automation Test Details",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getAutomationTestCommandLogs",
          "title": "Get Automation Test Command Logs",
          "description": "Fetches command logs for a specific automation test",
          "inputSchema": {
            "type": "object",
            "required": [
              "testId",
              "platform"
            ],
            "properties": {
              "testId": {
                "type": "string",
                "description": "The ID of the automation test"
              },
              "platform": {
                "enum": [
                  "web",
                  "app"
                ],
                "type": "string",
                "description": "The platform type: \"web\" for browser automation, \"app\" for app automation"
              },
              "sessionId": {
                "type": "string",
                "description": "Required for app platform: the session_id of the app session, a UUID that listMobileSessions and getAutomationTestDetails return (not the test ID)"
              },
              "pageNumber": {
                "type": "number",
                "default": 1,
                "description": "Page number to fetch (default: 1)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Automation Test Command Logs",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getAutomationTestNetworkLogs",
          "title": "Get Automation Test Network Logs",
          "description": "Fetches network logs for a specific automation test",
          "inputSchema": {
            "type": "object",
            "required": [
              "testId",
              "platform"
            ],
            "properties": {
              "testId": {
                "type": "string",
                "description": "The ID of the automation test"
              },
              "platform": {
                "enum": [
                  "web",
                  "app"
                ],
                "type": "string",
                "description": "The platform type: \"web\" for browser automation, \"app\" for app automation"
              },
              "sessionId": {
                "type": "string",
                "description": "Required for app platform: the session_id of the app session, a UUID that listMobileSessions and getAutomationTestDetails return (not the test ID)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Automation Test Network Logs",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getAutomationTestBrowserConsoleLogs",
          "title": "Get Automation Test Browser Console Logs",
          "description": "Fetches Browser Console logs for a specific automation test. Note: Not available for mobile app automation tests.",
          "inputSchema": {
            "type": "object",
            "required": [
              "testId",
              "platform"
            ],
            "properties": {
              "testId": {
                "type": "string",
                "description": "The ID of the automation test"
              },
              "platform": {
                "enum": [
                  "web",
                  "app"
                ],
                "type": "string",
                "description": "The platform type: \"web\" for browser automation, \"app\" for app automation (not supported)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Automation Test Browser Console Logs",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getAutomationTestSeleniumLogs",
          "title": "Get Automation Test Selenium Logs",
          "description": "Fetches Selenium logs (web), Appium logs (mobile/Appium), or instrumentation logs (mobile/XCUI/Espresso) for a specific automation test. Automatically detects XCUI and Espresso tests and fetches the correct log type.",
          "inputSchema": {
            "type": "object",
            "required": [
              "testId",
              "platform"
            ],
            "properties": {
              "testId": {
                "type": "string",
                "description": "The ID of the automation test to fetch logs for"
              },
              "platform": {
                "enum": [
                  "web",
                  "app"
                ],
                "type": "string",
                "description": "The platform type: \"web\" for Selenium logs, \"app\" for Appium/instrumentation logs"
              },
              "sessionId": {
                "type": "string",
                "description": "Required for app platform: the session_id of the app session, a UUID that listMobileSessions and getAutomationTestDetails return (not the test ID)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Automation Test Selenium Logs",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "automationQuery",
          "title": "Automation Query",
          "description": "Read-only query of TestMu AI automation resources: list builds, get one build, list the sessions in a build, fetch test details, and retrieve test logs (command, network, console, selenium, instrumentation). Every combination works on platform \"web\" or \"app\": build list or get, session list or get, test get, and logs get with a logType. List results carry a pagination object; trust it, not result_set.total, which also counts older builds the list no longer returns. logType \"instrumentation\" returns XCUI and Espresso test logs. Renaming, stopping and deleting builds are separate tools: updateBuild, stopBuild and deleteBuild.",
          "inputSchema": {
            "type": "object",
            "required": [
              "resource",
              "action",
              "platform"
            ],
            "properties": {
              "sort": {
                "type": "string",
                "description": "Sort order for build listing (e.g. \"asc\", \"desc\")"
              },
              "limit": {
                "type": "integer",
                "maximum": 100,
                "minimum": 1,
                "description": "Number of results to return, 1 to 100"
              },
              "action": {
                "enum": [
                  "list",
                  "get"
                ],
                "type": "string",
                "description": "The read to perform: list, or get one"
              },
              "offset": {
                "type": "integer",
                "minimum": 0,
                "description": "Offset for pagination; pass the next offset from a previous response"
              },
              "status": {
                "type": "string",
                "description": "Filter builds by status (e.g. \"running\", \"passed\", \"failed\")"
              },
              "testId": {
                "type": "string",
                "description": "Test ID — required for test get and logs get"
              },
              "todate": {
                "type": "string",
                "description": "Filter builds to this date (YYYY-MM-DD, not before fromdate)"
              },
              "buildId": {
                "type": "number",
                "description": "Build ID — required for build get, optional filter for session list"
              },
              "logType": {
                "enum": [
                  "command",
                  "network",
                  "console",
                  "selenium",
                  "instrumentation"
                ],
                "type": "string",
                "description": "Log type — required when resource is \"logs\""
              },
              "fromdate": {
                "type": "string",
                "description": "Filter builds from this date (YYYY-MM-DD, a real calendar date)"
              },
              "platform": {
                "enum": [
                  "web",
                  "app"
                ],
                "type": "string",
                "description": "The platform type: \"web\" for browser automation, \"app\" for mobile app automation"
              },
              "resource": {
                "enum": [
                  "build",
                  "session",
                  "test",
                  "logs"
                ],
                "type": "string",
                "description": "The resource type to query"
              },
              "sessionId": {
                "type": "string",
                "description": "Session ID: required for session get and for app platform log retrieval. Session get also accepts the test ID instead."
              },
              "pageNumber": {
                "type": "integer",
                "minimum": 1,
                "description": "Page number for command log pagination, from 1"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Automation Query",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "updateBuild",
          "title": "Rename Automation Build",
          "description": "Renames a TestMu AI web automation build. Overwrites the current build name.",
          "inputSchema": {
            "type": "object",
            "required": [
              "buildId",
              "name"
            ],
            "properties": {
              "name": {
                "type": "string",
                "description": "New build name"
              },
              "buildId": {
                "type": "number",
                "description": "ID of the build to rename"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Rename Automation Build",
            "readOnlyHint": false,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": true
          }
        },
        {
          "name": "stopBuild",
          "title": "Stop Automation Build",
          "description": "Stops every running test in a TestMu AI web automation build. Running sessions end immediately.",
          "inputSchema": {
            "type": "object",
            "required": [
              "buildId"
            ],
            "properties": {
              "buildId": {
                "type": "number",
                "description": "ID of the build to stop"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Stop Automation Build",
            "readOnlyHint": false,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": true
          }
        },
        {
          "name": "deleteBuild",
          "title": "Delete Automation Build",
          "description": "Permanently deletes a TestMu AI web automation build and its test results. Cannot be undone.",
          "inputSchema": {
            "type": "object",
            "required": [
              "buildId"
            ],
            "properties": {
              "buildId": {
                "type": "number",
                "description": "ID of the build to delete"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Delete Automation Build",
            "readOnlyHint": false,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": true
          }
        },
        {
          "name": "triggerSuiteRun",
          "title": "Trigger Suite Run",
          "description": "Triggers a phone call test run for a specific suite. This will initiate phone calls for all scenarios configured in the suite.",
          "inputSchema": {
            "type": "object",
            "required": [
              "projectId",
              "suiteName"
            ],
            "properties": {
              "projectId": {
                "type": "string",
                "description": "The project ID that contains the suite"
              },
              "suiteName": {
                "type": "string",
                "description": "The name of the suite to trigger"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "properties": {
              "data": {
                "type": "object",
                "description": "Call initiation results"
              },
              "message": {
                "type": "string",
                "description": "Status message"
              },
              "success": {
                "type": "boolean",
                "description": "Whether the call initiation was successful"
              }
            }
          },
          "annotations": {
            "title": "Trigger Suite Run",
            "readOnlyHint": false,
            "openWorldHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "getSuiteOverview",
          "title": "Get Suite Overview",
          "description": "Gets comprehensive suite overview for a project including run counts, latest status, scores, schedule information, and active calls.",
          "inputSchema": {
            "type": "object",
            "required": [
              "projectId"
            ],
            "properties": {
              "projectId": {
                "type": "string",
                "description": "The project ID to get suite overview for"
              }
            },
            "additionalProperties": false
          },
          "outputSchema": {
            "type": "object",
            "properties": {
              "suites": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "name": {
                      "type": "string"
                    },
                    "schedule": {
                      "type": "object",
                      "nullable": true
                    },
                    "run_count": {
                      "type": "number"
                    },
                    "latest_score": {
                      "type": "number",
                      "nullable": true
                    },
                    "latest_status": {
                      "type": "string",
                      "nullable": true
                    },
                    "has_active_calls": {
                      "type": "boolean"
                    }
                  }
                }
              },
              "project_id": {
                "type": "string"
              },
              "scheduled_runs": {
                "type": "array"
              }
            }
          },
          "annotations": {
            "title": "Get Suite Overview",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getSupportedPlatforms",
          "title": "Get Supported Platforms",
          "description": "Lists the OS, browser and device combinations TestMu AI supports, to find valid os, browser and version values for a test configuration. With no filters it returns a compact summary: each desktop OS with its browsers (version count, newest and oldest) and resolutions, and each mobile platform with its device count and OS versions. Set os (and optionally browser) for the full version list, or os=ios / os=android for device names.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "os": {
                "type": "string",
                "description": "OS name to expand, matched case-insensitively as a substring, e.g. \"Windows 11\", \"Sonoma\", \"android\""
              },
              "type": {
                "enum": [
                  "desktop",
                  "mobile"
                ],
                "type": "string",
                "description": "Only desktop OSes or only mobile platforms"
              },
              "browser": {
                "type": "string",
                "description": "Browser to expand on desktop, e.g. \"chrome\", \"firefox\", \"edge\", \"safari\""
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Supported Platforms",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "listTunnels",
          "title": "List Tunnels",
          "description": "Retrieve all active TestMu AI tunnel connections for the account. Useful for checking which tunnels are running before starting a new one or debugging local testing connectivity.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "title": "List Tunnels",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "stopTunnel",
          "title": "Stop Tunnel",
          "description": "Terminate a specific active tunnel connection by tunnel ID. Use this to clean up tunnels that are no longer needed.",
          "inputSchema": {
            "type": "object",
            "required": [
              "tunnelId"
            ],
            "properties": {
              "tunnelId": {
                "type": "string",
                "description": "The ID of the tunnel to stop"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Stop Tunnel",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "deleteSession",
          "title": "Delete Session",
          "description": "Permanently delete a specific automation test session from TestMu AI by session ID.",
          "inputSchema": {
            "type": "object",
            "required": [
              "sessionId"
            ],
            "properties": {
              "sessionId": {
                "type": "string",
                "description": "The session ID to delete"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Delete Session",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "updateSession",
          "title": "Update Session",
          "description": "Update the name or pass/fail status of a test session. Use status_ind to mark tests as passed, failed, error, or skipped from your test framework.",
          "inputSchema": {
            "type": "object",
            "required": [
              "sessionId"
            ],
            "properties": {
              "name": {
                "type": "string",
                "description": "New name for the session"
              },
              "sessionId": {
                "type": "string",
                "description": "The session ID to update"
              },
              "status_ind": {
                "enum": [
                  "passed",
                  "failed",
                  "error",
                  "skipped"
                ],
                "type": "string",
                "description": "Test result status"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Update Session",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "stopSession",
          "title": "Stop Session",
          "description": "Stop an active running test session on TestMu AI.",
          "inputSchema": {
            "type": "object",
            "required": [
              "sessionId"
            ],
            "properties": {
              "sessionId": {
                "type": "string",
                "description": "The session ID to stop"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Stop Session",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "getSessionScreenshots",
          "title": "Get Session Screenshots",
          "description": "Retrieve command-by-command screenshots captured during a test session. Returns screenshot URLs for each step. Web automation (Selenium, Playwright, Cypress) only: an app automation session returns not found; listMobileSessions carries the video and screenshot links of app sessions.",
          "inputSchema": {
            "type": "object",
            "required": [
              "sessionId"
            ],
            "properties": {
              "sessionId": {
                "type": "string",
                "description": "The web automation test ID (e.g. DA-WIN-...) or session ID"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Session Screenshots",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getSessionVideo",
          "title": "Get Session Video",
          "description": "Retrieve the video recording URL for a completed test session. Web automation (Selenium, Playwright, Cypress) only: an app automation session returns not found; listMobileSessions carries the video and screenshot links of app sessions.",
          "inputSchema": {
            "type": "object",
            "required": [
              "sessionId"
            ],
            "properties": {
              "sessionId": {
                "type": "string",
                "description": "The web automation test ID (e.g. DA-WIN-...) or session ID"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Session Video",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getSessionV2CommandLogs",
          "title": "Get Session V2 Command Logs",
          "description": "Retrieve v2 command execution logs for a test session. Returns structured JSON with enhanced detail compared to v1 logs. Web automation (Selenium, Playwright, Cypress) only: an app automation session returns not found; listMobileSessions carries the video and screenshot links of app sessions.",
          "inputSchema": {
            "type": "object",
            "required": [
              "sessionId"
            ],
            "properties": {
              "sessionId": {
                "type": "string",
                "description": "The web automation test ID (e.g. DA-WIN-...) or session ID"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Session V2 Command Logs",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getSessionV2SeleniumLogs",
          "title": "Get Session V2 Selenium Logs",
          "description": "Retrieve v2 Selenium/WebDriver grid request and response logs for a test session. Web automation (Selenium, Playwright, Cypress) only: an app automation session returns not found; listMobileSessions carries the video and screenshot links of app sessions.",
          "inputSchema": {
            "type": "object",
            "required": [
              "sessionId"
            ],
            "properties": {
              "sessionId": {
                "type": "string",
                "description": "The web automation test ID (e.g. DA-WIN-...) or session ID"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Session V2 Selenium Logs",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "postSessionExceptions",
          "title": "Post Session Exceptions",
          "description": "Upload exception/error logs from the client machine for a test session, by session ID. Use this to attach assertion failures or unexpected errors to a session. The result reads the test's exceptions back to confirm they were stored. The automation dashboard may not show exceptions uploaded this way after the test ended.",
          "inputSchema": {
            "type": "object",
            "required": [
              "sessionId",
              "data"
            ],
            "properties": {
              "data": {
                "type": "object",
                "required": [
                  "exception"
                ],
                "properties": {
                  "exception": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    },
                    "minItems": 1,
                    "description": "Exception messages, one string each"
                  }
                },
                "description": "The exceptions to attach: {\"exception\": [\"first message\", \"second message\"]}",
                "additionalProperties": false
              },
              "sessionId": {
                "type": "string",
                "description": "The session ID"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Post Session Exceptions",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "postTestExceptions",
          "title": "Post Test Exceptions",
          "description": "Upload exception logs for a specific test (by test ID) rather than by session ID. The result reads the test's exceptions back to confirm they were stored. The automation dashboard may not show exceptions uploaded this way after the test ended.",
          "inputSchema": {
            "type": "object",
            "required": [
              "testId",
              "data"
            ],
            "properties": {
              "data": {
                "type": "object",
                "required": [
                  "exception"
                ],
                "properties": {
                  "exception": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    },
                    "minItems": 1,
                    "description": "Exception messages, one string each"
                  }
                },
                "description": "The exceptions to attach: {\"exception\": [\"first message\", \"second message\"]}",
                "additionalProperties": false
              },
              "testId": {
                "type": "string",
                "description": "The test ID"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Post Test Exceptions",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getLiveSessionLogs",
          "title": "Get Live Session Logs",
          "description": "Retrieve the request and response log of a test session, while it runs or after it ends. Web automation (Selenium, Playwright, Cypress) only: an app automation session returns not found; listMobileSessions carries the video and screenshot links of app sessions.",
          "inputSchema": {
            "type": "object",
            "required": [
              "sessionId"
            ],
            "properties": {
              "sessionId": {
                "type": "string",
                "description": "The web automation test ID (e.g. DA-WIN-...) or session ID"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Live Session Logs",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getOrgConcurrency",
          "title": "Get Org Concurrency",
          "description": "Retrieve the current concurrency usage and limits for the organization on web automation (Selenium/Cypress).",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Org Concurrency",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getAnalyticsData",
          "title": "Get Analytics Data",
          "description": "Summarises web automation test results in a date range: total tests, passed, failed, completed without a pass/fail mark, pass rate (passed over all tests, as the Insights page shows it), pass rate over tests marked passed or failed, average duration and distinct builds, grouped by status, browser, os, build, device or day. Computed from the automation test list (up to 5000 tests per call; the total is always exact).",
          "inputSchema": {
            "type": "object",
            "properties": {
              "toDate": {
                "type": "string",
                "description": "End date, YYYY-MM-DD. Defaults to today."
              },
              "groupBy": {
                "enum": [
                  "status",
                  "browser",
                  "os",
                  "build",
                  "device",
                  "day"
                ],
                "type": "string",
                "description": "Dimension to group by. Defaults to status."
              },
              "fromDate": {
                "type": "string",
                "description": "Start date, YYYY-MM-DD, within the last 59 days (older results are not served). Defaults to 30 days before toDate."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Analytics Data",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getFlakyTests",
          "title": "Get Flaky Tests",
          "description": "Lists tests that the insights engine marks as flaky (passing and failing intermittently) in a date range, with each test's flake rate, build and environment. Returns only flaky tests, plus how many tests were scanned. Flakiness is only computed for about the last 7 days of tests; the response says how many tests in the range had it.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "limit": {
                "type": "number",
                "description": "Maximum flaky tests to return, 1 to 200. Defaults to 50."
              },
              "toDate": {
                "type": "string",
                "description": "End date, YYYY-MM-DD. Defaults to today."
              },
              "fromDate": {
                "type": "string",
                "description": "Start date, YYYY-MM-DD, within the last 59 days (older results are not served). Defaults to 30 days before toDate."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Flaky Tests",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getTestTrends",
          "title": "Get Test Trends",
          "description": "Daily trend of web automation test results in a date range: for each day, total tests, passed, failed, completed without a pass/fail mark, pass rate (passed over all tests), pass rate over tests marked passed or failed, and average duration.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "toDate": {
                "type": "string",
                "description": "End date, YYYY-MM-DD. Defaults to today."
              },
              "fromDate": {
                "type": "string",
                "description": "Start date, YYYY-MM-DD, within the last 59 days (older results are not served). Defaults to 30 days before toDate."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Test Trends",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getAnalyticsErrors",
          "title": "Get Analytics Errors",
          "description": "Summarises failed and errored web automation tests in a date range: counts by failure category and by status, and the failing tests themselves with build and environment. Failure categories exist only for about the last 7 days of tests; older failures are counted as uncategorised.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "limit": {
                "type": "number",
                "description": "Maximum failing tests to list, 1 to 200. Defaults to 20."
              },
              "toDate": {
                "type": "string",
                "description": "End date, YYYY-MM-DD. Defaults to today."
              },
              "fromDate": {
                "type": "string",
                "description": "Start date, YYYY-MM-DD, within the last 59 days (older results are not served). Defaults to 30 days before toDate."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Analytics Errors",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "deletePrerunFile",
          "title": "Delete Prerun File",
          "description": "Delete an uploaded prerun file by stored TestMu AI file path.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "filePath": {
                "type": "string",
                "description": "Stored path of the pre-run or post-run file, as uploadPrerunFile returns it (<name>/pre/<file> or <name>/post/<file>)"
              },
              "file_path": {
                "type": "string",
                "description": "Stored path of the pre-run or post-run file, as uploadPrerunFile returns it (<name>/pre/<file> or <name>/post/<file>)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Delete Prerun File",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "deleteUserFile",
          "title": "Delete User File",
          "description": "Delete an uploaded user file by stored TestMu AI file path.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "filePath": {
                "type": "string",
                "description": "Key of the stored user file, as uploadUserFile returns it (usually the file name)"
              },
              "file_path": {
                "type": "string",
                "description": "Key of the stored user file, as uploadUserFile returns it (usually the file name)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Delete User File",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "listUploadedApps",
          "title": "List Uploaded Apps",
          "description": "Retrieve all apps uploaded to TestMu AI for mobile testing. Use type=android/ios for real devices, emulator/simulator for virtual devices.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "type": {
                "enum": [
                  "android",
                  "ios",
                  "emulator",
                  "simulator"
                ],
                "type": "string",
                "description": "App type: android/ios for real devices, emulator/simulator for virtual"
              },
              "level": {
                "enum": [
                  "user",
                  "team"
                ],
                "type": "string",
                "description": "Scope: user (default, apps you uploaded) or team (apps across your organization; sent to the API as level=org)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "List Uploaded Apps",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "deleteUploadedApps",
          "title": "Delete Uploaded Apps",
          "description": "Delete one or more uploaded apps from TestMu AI by their app IDs.",
          "inputSchema": {
            "type": "object",
            "required": [
              "appIds"
            ],
            "properties": {
              "appIds": {
                "type": "array",
                "items": {
                  "type": "string",
                  "minLength": 1
                },
                "minItems": 1,
                "description": "Array of app IDs to delete (at least one)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Delete Uploaded Apps",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "uploadAppVirtualDevice",
          "title": "Upload App for Virtual Device",
          "description": "Upload an app (APK for emulator, IPA for simulator) to TestMu AI for virtual device (emulator/simulator) testing.",
          "inputSchema": {
            "type": "object",
            "required": [
              "name"
            ],
            "properties": {
              "name": {
                "type": "string",
                "description": "Name for the uploaded app"
              },
              "appUrl": {
                "type": "string",
                "description": "Public URL of the app to upload (alternative to filePath)"
              },
              "storage": {
                "enum": [
                  "file",
                  "url"
                ],
                "type": "string",
                "description": "Storage method (default: url when appUrl provided)"
              },
              "filePath": {
                "type": "string",
                "description": "Absolute local path to the app file (APK or IPA)"
              },
              "custom_id": {
                "type": "string",
                "description": "Custom identifier for the app"
              },
              "visibility": {
                "enum": [
                  "individual",
                  "team"
                ],
                "type": "string",
                "description": "Access level (default: individual)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Upload App for Virtual Device",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "listDevicesForTesting",
          "title": "List Devices for Testing",
          "description": "Lists the real devices available on TestMu AI for mobile app testing, 50 per page by default. Filter by region, OS, device name or OS version, and page with limit and offset. The text gives the total that matched.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "os": {
                "enum": [
                  "android",
                  "ios"
                ],
                "type": "string",
                "description": "Operating system filter"
              },
              "limit": {
                "type": "integer",
                "maximum": 200,
                "minimum": 1,
                "description": "Devices per page, 1 to 200 (default 50)"
              },
              "offset": {
                "type": "integer",
                "minimum": 0,
                "description": "Devices to skip (default 0)"
              },
              "region": {
                "enum": [
                  "us",
                  "ap",
                  "eu"
                ],
                "type": "string",
                "description": "Device region (default: us)"
              },
              "deviceName": {
                "type": "string",
                "description": "Device name to match, case-insensitively as a substring, e.g. \"Galaxy S24\", \"iPhone 15\", \"Pixel\""
              },
              "platformVersion": {
                "type": "string",
                "description": "OS version to match, e.g. \"14\" (matches 14 and 14.x)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "List Devices for Testing",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getMobileCapabilityGenerator",
          "title": "Get Mobile Capability Generator",
          "description": "Retrieve capability generation data for mobile automation test configuration.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Mobile Capability Generator",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "listMobileBuilds",
          "title": "List Mobile Builds",
          "description": "Lists mobile app automation builds, newest first, 10 per page by default. Page with limit and offset; the result gives the total the API reports. The API returns only builds from the last 90 days, so total can be higher than the builds you can page through.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "limit": {
                "type": "integer",
                "maximum": 100,
                "minimum": 1,
                "description": "Rows per page, 1 to 100 (default 10)"
              },
              "offset": {
                "type": "integer",
                "minimum": 0,
                "description": "Rows to skip (default 0)"
              },
              "status": {
                "type": "string",
                "description": "Only builds with this status, e.g. completed, running, passed, failed"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "List Mobile Builds",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "listMobileSessions",
          "title": "List Mobile Sessions",
          "description": "Lists mobile app automation sessions (tests), newest first, 10 per page by default, with their video, screenshot and log links. Page with limit and offset, or filter by buildId or status; the result gives the total the API reports.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "limit": {
                "type": "integer",
                "maximum": 100,
                "minimum": 1,
                "description": "Rows per page, 1 to 100 (default 10)"
              },
              "offset": {
                "type": "integer",
                "minimum": 0,
                "description": "Rows to skip (default 0)"
              },
              "status": {
                "type": "string",
                "description": "Only sessions with this status, e.g. passed, failed, completed, error"
              },
              "buildId": {
                "type": "string",
                "description": "Only sessions of this build (build_id from listMobileBuilds)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "List Mobile Sessions",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getMobileConcurrency",
          "title": "Get Mobile Concurrency",
          "description": "Retrieve the current concurrency usage and limits for mobile automation (real device testing).",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Mobile Concurrency",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "checkAppProcessingStatus",
          "title": "Check App Processing Status (Real Device)",
          "description": "Check whether an uploaded app has been processed and is ready for features like image injection, network logs, and screenshot unblock on real devices. The TestMu AI API has no read-only status call: this one starts or refreshes the processing for the requested features, so the app's last-updated time changes. An app id that is not among your uploaded apps returns an error.",
          "inputSchema": {
            "type": "object",
            "required": [
              "appId"
            ],
            "properties": {
              "appId": {
                "type": "string",
                "description": "The app ID to check"
              },
              "networkLogsEnabled": {
                "type": "boolean",
                "description": "Check network logs support"
              },
              "imageInjectionEnabled": {
                "type": "boolean",
                "description": "Check image injection support"
              },
              "screenshotUnblockEnabled": {
                "type": "boolean",
                "description": "Check screenshot unblock support"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Check App Processing Status (Real Device)",
            "readOnlyHint": false,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "tm_list_projects",
          "title": "List Test Manager Projects",
          "description": "List all Test Manager projects the authenticated user is allowed to see. Supports keyword search and pagination.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "number",
                "description": "Page number (1-based)"
              },
              "limit": {
                "type": "number",
                "description": "Max results per page (default 25)"
              },
              "search": {
                "type": "string",
                "description": "Filter projects by name keyword"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "List Test Manager Projects",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "tm_get_test_cases",
          "title": "Find / Get Test Cases",
          "description": "Find test cases in a project by filters (folder, priority, automation status, type, tags) and/or search (matches test case ID like TC-123, or title; minimum 3 characters) — returns summaries. Filters combine (AND). Pass case_id instead to get one case's full detail (steps, BDD scenarios, field values).",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "number",
                "description": "Page number (1-based)"
              },
              "tags": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Filter by tags"
              },
              "type": {
                "type": "string",
                "description": "Filter by test type (e.g. Functional, Regression, Smoke & Sanity)"
              },
              "limit": {
                "type": "number",
                "description": "Max results per page"
              },
              "search": {
                "type": "string",
                "description": "Full-text keyword (min 3 chars)"
              },
              "case_id": {
                "type": "string",
                "description": "Test case ID (ULID). When given, returns that case's full detail and all other filters are ignored."
              },
              "priority": {
                "type": "string",
                "description": "Filter by priority (e.g. Lowest, Low, Medium, High, Highest). A value outside the project's priority list is rejected with the valid values."
              },
              "folder_id": {
                "type": "string",
                "description": "Only cases in this folder"
              },
              "project_id": {
                "type": "string",
                "description": "Project ID (ULID). Required unless case_id is given."
              },
              "automation_status": {
                "type": "string",
                "description": "Filter by automation status (e.g. Automated, Not Automated, To Be Automated)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Find / Get Test Cases",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "tm_list_folders",
          "title": "List Folders",
          "description": "Get a folder tree. Test Manager keeps three folder types: Test Cases and Test Runs folders (per project — pass project_id) and Modules folders (organization-level, since modules are shared across projects — no project_id needed). Pick with the tree parameter (default: test-cases). New test-case/test-run folders can be created with tm_create_folder.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "tree": {
                "enum": [
                  "test-cases",
                  "test-runs",
                  "modules"
                ],
                "type": "string",
                "description": "Which folder tree to return (default test-cases). \"modules\" is organization-level."
              },
              "project_id": {
                "type": "string",
                "description": "Project ID (ULID) — required for the test-cases and test-runs trees; not used for modules"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "List Folders",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "tm_list_modules",
          "title": "List Step Modules",
          "description": "List the organization's reusable step Modules (modules are org-level, shared across projects — the same list as the Modules page). Supports name search and pagination. Reference a module by id when creating or editing a test case to include its steps (the Module itself is never changed).",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "number",
                "description": "Page number (1-based)"
              },
              "limit": {
                "type": "number",
                "description": "Max results per page (default 100)"
              },
              "search": {
                "type": "string",
                "description": "Filter modules by name keyword"
              },
              "folder_id": {
                "type": "string",
                "description": "Only modules in this Modules folder (folder ids from tm_list_folders with tree=\"modules\")"
              },
              "include_subfolders": {
                "type": "boolean",
                "description": "With folder_id: also include modules from its subfolders"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "List Step Modules",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "tm_list_configurations",
          "title": "List Run Configurations",
          "description": "List saved run Configurations (reusable platform / browser / OS / device setups). To apply one to a run, pass the configuration's TOP-LEVEL id to tm_create_test_run or tm_update_test_run as configuration_id (NOT the nested environments[].environment_id). Pass run_type to see only the configurations usable for that run type (kaneai vs manual). Each test instance carries exactly one configuration. Configurations are created by humans in the Test Manager UI. They are organization-level (shared by every project), so there is no project filter. Results are paged: the response says how many exist in total; page through them or raise limit to see all.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "number",
                "description": "Page number (1-based)"
              },
              "limit": {
                "type": "number",
                "description": "Max results per page (default 10)"
              },
              "run_type": {
                "enum": [
                  "manual",
                  "kaneai"
                ],
                "type": "string",
                "description": "Only configurations supporting this run type (kane-supported vs manual-supported)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "List Run Configurations",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "tm_get_test_runs",
          "title": "Get Test Runs",
          "description": "Pass run_id to get one test run's detail plus its result summary (instance counts by status — passed / failed / skipped / not started / in progress — and pass rate). Otherwise pass project_id to list runs with optional filters. Every returned run carries run_type (\"kaneai\" or \"manual\") identifying KaneAI runs — the backend stores KaneAI runs with type \"Manual\" (result-entry mode), so use run_type, not type, to tell them apart.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "number",
                "description": "Page number (1-based)"
              },
              "limit": {
                "type": "number",
                "description": "Max results per page"
              },
              "run_id": {
                "type": "string",
                "description": "Test run ID (ULID). When given, returns detail + result summary."
              },
              "search": {
                "type": "string",
                "description": "Search runs by title"
              },
              "status": {
                "type": "string",
                "description": "Filter: Not Started, In Progress, Passed, Failed, Skipped"
              },
              "run_type": {
                "type": "string",
                "description": "Filter: \"kaneai\" (KaneAI runs), \"manual\" (human result-entry runs, KaneAI excluded), or \"automation\" (framework-uploaded runs). Buckets are disjoint."
              },
              "folder_id": {
                "type": "string",
                "description": "Only runs in this folder"
              },
              "project_id": {
                "type": "string",
                "description": "Project ID (ULID). Required when run_id is not given."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Test Runs",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "tm_get_milestone",
          "title": "Get Milestones",
          "description": "Pass milestone_id to get one milestone's detail and live completion progress. Otherwise pass project_id to list the project's milestones.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "project_id": {
                "type": "string",
                "description": "Project ID (ULID). Required when milestone_id is not given."
              },
              "milestone_id": {
                "type": "string",
                "description": "Milestone ID (ULID). When given, returns detail + progress."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Milestones",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "tm_get_coverage_summary",
          "title": "Get Coverage Summary",
          "description": "Test coverage for a project, overall and per folder, computed live from the project's test cases (matches the Test Cases screen). Also answers requirement and traceability coverage: pass jira_id (any Jira issue key, e.g. TE-123: a requirement, user story, epic, ticket or bug) to get that item's test coverage (the test cases linked to it and how many are automated; zero linked cases means uncovered). For a set of requirements, call once per Jira key. A scope with no test cases returns all zeros; a Jira key that does not exist in the connected Jira returns an error.",
          "inputSchema": {
            "type": "object",
            "required": [
              "project_id"
            ],
            "properties": {
              "jira_id": {
                "type": "string",
                "description": "Optional Jira issue key (e.g. TE-123) — scope coverage to the test cases linked to this requirement / user story / epic / ticket (traceability coverage)"
              },
              "folder_id": {
                "type": "string",
                "description": "Optional folder scope"
              },
              "project_id": {
                "type": "string",
                "description": "Project ID (ULID)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Coverage Summary",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "tm_create_project",
          "title": "Create Project",
          "description": "Create a new Test Manager project. Project & Org Instructions (Memory Layer) stay managed in the UI. Deleting projects is not available through this connection.",
          "inputSchema": {
            "type": "object",
            "required": [
              "name"
            ],
            "properties": {
              "name": {
                "type": "string",
                "description": "Project name"
              },
              "tags": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Labels"
              },
              "description": {
                "type": "string",
                "description": "What the project covers"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Create Project",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "tm_update_project",
          "title": "Update Project",
          "description": "Update a project's name, description or tags (fields are merged — only what you pass changes). Project & Org Instructions stay managed in the UI.",
          "inputSchema": {
            "type": "object",
            "required": [
              "project_id"
            ],
            "properties": {
              "name": {
                "type": "string",
                "description": "New name"
              },
              "tags": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Replace tags"
              },
              "project_id": {
                "type": "string",
                "description": "Project ID (ULID)"
              },
              "description": {
                "type": "string",
                "description": "New description"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Update Project",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "tm_create_folder",
          "title": "Create Folder",
          "description": "Create a folder — in a project's Test Cases tree (default) or Test Runs tree (pass project_id), or in the organization-level Modules tree (no project_id needed; module folders are shared across projects). Optionally nest it under an existing parent folder to build folder trees. Deleting folders is not available through this connection.",
          "inputSchema": {
            "type": "object",
            "required": [
              "name"
            ],
            "properties": {
              "name": {
                "type": "string",
                "description": "Folder name"
              },
              "tree": {
                "enum": [
                  "test-cases",
                  "test-runs",
                  "modules"
                ],
                "type": "string",
                "description": "Which folder tree to create in (default test-cases). \"modules\" is organization-level."
              },
              "project_id": {
                "type": "string",
                "description": "Project ID (ULID) — required for the test-cases and test-runs trees; not used for modules"
              },
              "description": {
                "type": "string",
                "description": "Optional description"
              },
              "parent_folder_id": {
                "type": "string",
                "description": "Nest under this existing folder (ULID); omit for top level"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Create Folder",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "tm_update_folder",
          "title": "Update Folder",
          "description": "Rename a folder, change its description, or move it under a different parent folder. Works on all three folder types: per-project Test Cases (default) and Test Runs trees, and the organization-level Modules tree. Moves of test-cases/test-runs folders require project_id; module folders need none.",
          "inputSchema": {
            "type": "object",
            "required": [
              "folder_id"
            ],
            "properties": {
              "name": {
                "type": "string",
                "description": "New name"
              },
              "tree": {
                "enum": [
                  "test-cases",
                  "test-runs",
                  "modules"
                ],
                "type": "string",
                "description": "Which folder tree the folder belongs to (default test-cases). \"modules\" is organization-level."
              },
              "folder_id": {
                "type": "string",
                "description": "Folder ID (ULID)"
              },
              "project_id": {
                "type": "string",
                "description": "Project ID (ULID) — required when moving a test-cases or test-runs folder; not used for modules"
              },
              "description": {
                "type": "string",
                "description": "New description"
              },
              "parent_folder_id": {
                "type": "string",
                "description": "Move under this folder (ULID), or pass \"root\" to make it a top-level folder; cannot be the folder itself or one of its descendants"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Update Folder",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "tm_generate_test_cases",
          "title": "Generate Test Cases with AI",
          "description": "Generate structured test cases from a requirement or prompt using the Test Manager AI generator (applies the project's Memory Layer — Project & Org Instructions — automatically) and file them into the chosen folder. Requirement documents, specs, spreadsheets or screenshots can be attached via files to ground the generation. Volume = test_scenario_limit × per_scenario_test_cases_limit, capped at 50 per call. By default all generated cases are saved into the folder (one sub-folder per scenario); pass auto_save=false to review before saving. The call returns FAST with a request_id (and a browser progress URL) — generation takes ~30-90s in the background; call this tool again with just request_id to check progress, fetch results, or save. Note: consumes AI generation credits.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "files": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "name",
                    "content_base64"
                  ],
                  "properties": {
                    "name": {
                      "type": "string",
                      "description": "File name with extension, e.g. requirements.pdf"
                    },
                    "content_base64": {
                      "type": "string",
                      "description": "File content, base64-encoded"
                    }
                  },
                  "additionalProperties": false
                },
                "maxItems": 5,
                "description": "Optional reference files to ground the generation (requirement docs, specs, data sheets, screenshots). Each item carries the file name and its raw bytes base64-encoded in content_base64. Supported: .pdf, .docx, .txt, .csv, .xlsx, .json, .xml, .jpg, .jpeg, .png, .gif, .bmp, .webp; max 5 files, 10 MB each. Large files are better uploaded in the Test Manager UI, since the base64 content travels in the request. Only used when starting a new generation."
              },
              "prompt": {
                "type": "string",
                "description": "The requirement / instructions to generate test cases from. Required when starting a new generation."
              },
              "jira_ids": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Optional Jira issue keys to use as requirement context"
              },
              "auto_save": {
                "type": "boolean",
                "description": "Save all generated cases into the folder automatically (default true for a NEW generation). Set false to review first — that choice persists across request_id polls (a bare poll never saves it); to save after review, call again with request_id AND auto_save=true."
              },
              "folder_id": {
                "type": "string",
                "description": "Folder to file generated cases into. Required when starting a new generation."
              },
              "project_id": {
                "type": "string",
                "description": "Project ID (ULID). Required when starting a new generation."
              },
              "request_id": {
                "type": "number",
                "description": "Resume/act on an earlier generation: check progress, fetch results, or save them."
              },
              "test_scenario_limit": {
                "type": "number",
                "description": "Max scenarios to generate (default 3)"
              },
              "per_scenario_test_cases_limit": {
                "type": "number",
                "description": "Max test cases per scenario (default 3)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Generate Test Cases with AI",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "tm_create_test_case",
          "title": "Create Test Case",
          "description": "Create a single test case in a project folder, with optional steps and references to existing step Modules (module steps are included; the Module itself is unchanged). For creating many cases from a requirement, prefer tm_generate_test_cases.",
          "inputSchema": {
            "type": "object",
            "required": [
              "project_id",
              "title"
            ],
            "properties": {
              "tags": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Labels"
              },
              "type": {
                "type": "string",
                "description": "e.g. Functional, Regression, Smoke & Sanity"
              },
              "title": {
                "type": "string",
                "description": "Test case title"
              },
              "status": {
                "type": "string",
                "description": "e.g. Live, Unverified, Ready (default per project settings)"
              },
              "priority": {
                "type": "string",
                "description": "Lowest, Low, Medium, High or Highest"
              },
              "folder_id": {
                "type": "string",
                "description": "Folder to file the case into"
              },
              "module_ids": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Existing step Module ids to include (appended as module steps after test_steps)"
              },
              "project_id": {
                "type": "string",
                "description": "Project ID (ULID)"
              },
              "test_steps": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "action"
                  ],
                  "properties": {
                    "action": {
                      "type": "string",
                      "description": "What to do"
                    },
                    "outcome": {
                      "type": "string",
                      "description": "Expected result, shown as the step Outcome in the UI. Use this key: any other step key (such as expected_result) is rejected."
                    },
                    "description": {
                      "type": "string",
                      "description": "Optional extra detail — stored as an additional paragraph of the step text"
                    }
                  },
                  "additionalProperties": false
                },
                "description": "Ordered steps"
              },
              "description": {
                "type": "string",
                "description": "What the case verifies"
              },
              "preconditions": {
                "type": "string",
                "description": "Setup required before the steps"
              },
              "estimated_time": {
                "type": "number",
                "description": "Estimated execution time in minutes"
              },
              "automation_status": {
                "type": "string",
                "description": "Automated, Not Automated or To Be Automated"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Create Test Case",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "tm_update_test_case",
          "title": "Update Test Case",
          "description": "Edit an existing test case (fields are merged — only what you pass changes). test_steps, when given, REPLACE the case's steps; module_ids append module reference steps. Deleting test cases is not available through this connection.",
          "inputSchema": {
            "type": "object",
            "required": [
              "case_id",
              "project_id"
            ],
            "properties": {
              "tags": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Replace tags"
              },
              "type": {
                "type": "string",
                "description": "Test type"
              },
              "title": {
                "type": "string",
                "description": "New title"
              },
              "status": {
                "type": "string",
                "description": "e.g. Live, Archived, Faulty, Ready"
              },
              "case_id": {
                "type": "string",
                "description": "Test case ID (ULID)"
              },
              "priority": {
                "type": "string",
                "description": "Lowest, Low, Medium, High or Highest"
              },
              "folder_id": {
                "type": "string",
                "description": "Move to this folder"
              },
              "module_ids": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Existing step Module ids to append as module steps"
              },
              "project_id": {
                "type": "string",
                "description": "Project ID (ULID)"
              },
              "test_steps": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "action"
                  ],
                  "properties": {
                    "action": {
                      "type": "string",
                      "description": "What to do"
                    },
                    "outcome": {
                      "type": "string",
                      "description": "Expected result, shown as the step Outcome in the UI. Use this key: any other step key (such as expected_result) is rejected."
                    },
                    "description": {
                      "type": "string",
                      "description": "Optional extra detail — stored as an additional paragraph of the step text"
                    }
                  },
                  "additionalProperties": false
                },
                "description": "Replacement steps (omit to keep current steps)"
              },
              "description": {
                "type": "string",
                "description": "New description"
              },
              "preconditions": {
                "type": "string",
                "description": "New preconditions"
              },
              "estimated_time": {
                "type": "number",
                "description": "Estimated minutes"
              },
              "automation_status": {
                "type": "string",
                "description": "Automated, Not Automated or To Be Automated"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Update Test Case",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "tm_create_test_run",
          "title": "Create Test Run",
          "description": "Create a test run from chosen test cases — manual (default) or KaneAI (run_type: \"kaneai\"). Each included test case becomes a TEST RUN INSTANCE — the executable copy of that test inside the run, which carries its own status, remarks and exactly one Configuration. The cases must match the run type: KaneAI runs only take KaneAI-authored cases with completed code generation; manual runs only take manual cases. Optionally attach existing milestones, file into a run folder, and apply a Configuration to all instances (KaneAI configurations must be compatible with each case's platform — web/mobile-app/mobile-browser and iOS/Android).",
          "inputSchema": {
            "type": "object",
            "required": [
              "project_id",
              "title"
            ],
            "properties": {
              "tags": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Labels"
              },
              "title": {
                "type": "string",
                "description": "Run title"
              },
              "assignee": {
                "type": "string",
                "description": "Assign every created instance to this organization member: email, username, or user id. Omit to leave the instances unassigned."
              },
              "run_type": {
                "enum": [
                  "manual",
                  "kaneai"
                ],
                "type": "string",
                "description": "Run type (default manual). \"kaneai\" creates a KaneAI run: only KaneAI-authored test cases can be included, and configurations must be kane-supported and platform-compatible."
              },
              "folder_id": {
                "type": "string",
                "description": "Test-run folder to file the run into"
              },
              "objective": {
                "type": "string",
                "description": "What this run verifies"
              },
              "project_id": {
                "type": "string",
                "description": "Project ID (ULID)"
              },
              "is_sequential": {
                "type": "boolean",
                "description": "KaneAI runs only: execute the instances sequentially (default false)."
              },
              "milestone_ids": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Existing milestone ids to attach the run to"
              },
              "test_case_ids": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Test case ids to include"
              },
              "configuration_id": {
                "type": "number",
                "description": "Apply ONE Configuration to every included test case (the configuration's top-level id from tm_list_configurations)"
              },
              "configuration_ids": {
                "type": "array",
                "items": {
                  "type": "number"
                },
                "description": "Apply MULTIPLE Configurations: each included test case gets one test run instance per configuration (case × configuration), like the UI's Add Configuration checkboxes"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Create Test Run",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "tm_update_test_run",
          "title": "Update Test Run",
          "description": "Update an open test run — overall status (Passed / Failed / Skipped / In Progress), title, objective, milestones, folder, add test cases (each added case becomes a new test run instance; cases must match the run's type — KaneAI or manual), apply a Configuration to the run's instances (configuration_id; on KaneAI runs it must be kane-supported and platform-compatible with the targeted cases), toggle sequential execution (KaneAI runs), or archive it. Only open (active) runs can be updated; a closed/archived run returns a clear message. Adding cases/milestones appends, never replaces.",
          "inputSchema": {
            "type": "object",
            "required": [
              "run_id"
            ],
            "properties": {
              "title": {
                "type": "string",
                "description": "New title"
              },
              "run_id": {
                "type": "string",
                "description": "Test run ID (ULID)"
              },
              "status": {
                "enum": [
                  "Passed",
                  "Failed",
                  "Skipped",
                  "In Progress"
                ],
                "type": "string",
                "description": "Set the run's OVERALL status (independent of per-instance results). Manual runs only — KaneAI run status is managed by KaneAI executions."
              },
              "archive": {
                "type": "boolean",
                "description": "Archive (close) the run"
              },
              "assignee": {
                "type": "string",
                "description": "Assign the run's instances to this organization member: email, username, or user id (\"none\" clears). Scope with apply_to_test_case_ids. Omit to keep the current assignee."
              },
              "folder_id": {
                "type": "string",
                "description": "Move to this run folder"
              },
              "objective": {
                "type": "string",
                "description": "New objective"
              },
              "is_sequential": {
                "type": "boolean",
                "description": "KaneAI runs only: execute the instances sequentially."
              },
              "milestone_ids": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Milestone ids to attach (appended)"
              },
              "configuration_id": {
                "type": "number",
                "description": "Set ONE Configuration on the run's instances (the configuration's top-level id from tm_list_configurations; each instance carries exactly one configuration)"
              },
              "add_test_case_ids": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Test case ids to add to the run (appended)"
              },
              "configuration_ids": {
                "type": "array",
                "items": {
                  "type": "number"
                },
                "description": "APPEND multiple Configurations: each targeted test case gets an additional instance per configuration (case × configuration, like the UI); existing configured instances are untouched"
              },
              "apply_to_test_case_ids": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "With configuration_id or configuration_ids: only apply to these test cases (default: all instances in the run)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Update Test Run",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "tm_record_test_results",
          "title": "Record Test Results (Bulk)",
          "description": "Record execution results on a MANUAL run's TEST RUN INSTANCES (the per-run copies of each test case) — max 500 per request, all-or-nothing (larger requests are rejected with nothing recorded). Manual runs only: KaneAI run results are recorded by KaneAI executions, so manual entry on a KaneAI run is rejected. Target an instance by instance_id, or just pass test_case_id and the instance is resolved automatically. Valid statuses: Passed, Failed, Skipped, Not Started (terminal — run-level \"In Progress\" is set via tm_update_test_run). Re-recording a step status replaces its result: an omitted step remark is cleared; response echoes per-step outcomes. Optional remarks and assignee per result, and per-step results via steps[] (mark individual test steps / BDD scenario rows Passed/Failed/Skipped with remarks, like the UI's per-step Mark Status). Note: this sets INSTANCE statuses; the run's overall status is set separately via tm_update_test_run.",
          "inputSchema": {
            "type": "object",
            "required": [
              "run_id",
              "results"
            ],
            "properties": {
              "run_id": {
                "type": "string",
                "description": "Test run ID (ULID)"
              },
              "results": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "status"
                  ],
                  "properties": {
                    "steps": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "required": [
                          "step"
                        ],
                        "properties": {
                          "step": {
                            "type": "number",
                            "description": "Step number (1-based, in the order shown on the case/instance)"
                          },
                          "status": {
                            "type": "string",
                            "description": "Passed, Failed or Skipped"
                          },
                          "remarks": {
                            "type": "string",
                            "description": "Optional step remark"
                          }
                        },
                        "additionalProperties": false
                      },
                      "description": "Optional per-step results: mark individual test steps (or BDD scenario rows) of this instance, like the UI's per-step Mark Status"
                    },
                    "status": {
                      "type": "string",
                      "description": "Passed, Failed, Skipped or Not Started (instance results are terminal — \"In Progress\" applies only to the run's overall status via tm_update_test_run)"
                    },
                    "remarks": {
                      "type": "string",
                      "description": "Optional note (e.g. failure detail)"
                    },
                    "assignee": {
                      "type": "string",
                      "description": "Assign this instance to an organization member (email, username, or user id; \"none\" clears). Omit to keep the current assignee."
                    },
                    "instance_id": {
                      "type": "number",
                      "description": "Run-instance id (from tm_get_test_runs detail)"
                    },
                    "test_case_id": {
                      "type": "string",
                      "description": "Alternative to instance_id: the test case ULID"
                    }
                  },
                  "additionalProperties": false
                },
                "description": "Results to record (max 500)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Record Test Results (Bulk)",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "tm_create_milestone",
          "title": "Create Milestone",
          "description": "Create a milestone in a project (status: Open), optionally with description, start/end dates, tags, and existing runs attached.",
          "inputSchema": {
            "type": "object",
            "required": [
              "project_id",
              "title"
            ],
            "properties": {
              "tags": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Labels"
              },
              "owner": {
                "type": "string",
                "description": "Milestone owner: an organization member (email, username, or user id). Omit for no owner."
              },
              "title": {
                "type": "string",
                "description": "Milestone title"
              },
              "end_at": {
                "type": "string",
                "description": "End date (YYYY-MM-DD)"
              },
              "start_at": {
                "type": "string",
                "description": "Start date (YYYY-MM-DD)"
              },
              "project_id": {
                "type": "string",
                "description": "Project ID (ULID)"
              },
              "description": {
                "type": "string",
                "description": "What this milestone covers"
              },
              "test_run_ids": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Existing run ids to attach"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Create Milestone",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "tm_update_milestone",
          "title": "Update Milestone",
          "description": "Update a milestone — title, description, dates, tags — or change its status (e.g. mark it Completed). Deleting milestones is not available through this connection.",
          "inputSchema": {
            "type": "object",
            "required": [
              "milestone_id",
              "project_id"
            ],
            "properties": {
              "tags": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Replace tags"
              },
              "owner": {
                "type": "string",
                "description": "Change the milestone Owner — an organization member (email, username, or user id)."
              },
              "title": {
                "type": "string",
                "description": "New title"
              },
              "end_at": {
                "type": "string",
                "description": "End date (YYYY-MM-DD)"
              },
              "status": {
                "type": "string",
                "description": "New status: Open (reopen) or Complete — the UI's two milestone states. \"Active\" and \"Completed\" are accepted as aliases and normalized to Open/Complete (any other stored value hides the milestone from the UI lists)."
              },
              "start_at": {
                "type": "string",
                "description": "Start date (YYYY-MM-DD)"
              },
              "project_id": {
                "type": "string",
                "description": "Project ID (ULID)"
              },
              "description": {
                "type": "string",
                "description": "New description"
              },
              "milestone_id": {
                "type": "string",
                "description": "Milestone ID (ULID)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Update Milestone",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "tm_link_jira_issue",
          "title": "Link Jira Issue",
          "description": "Link a test case, test run, or a run result (instance) to a Jira issue (requirement / user story / epic / bug) — linked test cases are what give the issue its test coverage and traceability. Linking a result also links its case and run. Requires the Jira integration to be set up for the organization — otherwise a clear \"set up Jira first\" message is returned.",
          "inputSchema": {
            "type": "object",
            "required": [
              "entity_type",
              "entity_id",
              "issue_id"
            ],
            "properties": {
              "issue_id": {
                "type": "string",
                "description": "Jira issue key, e.g. TE-123"
              },
              "entity_id": {
                "type": "string",
                "description": "Id of the case (ULID), run (ULID) or instance (number as string)"
              },
              "entity_type": {
                "enum": [
                  "test_case",
                  "test_run",
                  "test_run_instance"
                ],
                "type": "string",
                "description": "What to link"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Link Jira Issue",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "tm_link_ado_issue",
          "title": "Link Azure DevOps Work Item",
          "description": "Link a test case, test run, or a run result (instance) to an Azure DevOps work item (requirement / user story / bug) by its URL — linked test cases are what give the work item its test coverage and traceability. Requires the Azure DevOps integration to be set up for the organization — otherwise a clear \"set up Azure DevOps first\" message is returned.",
          "inputSchema": {
            "type": "object",
            "required": [
              "entity_type",
              "entity_id",
              "project_id",
              "work_item_url"
            ],
            "properties": {
              "entity_id": {
                "type": "string",
                "description": "Id of the case (ULID), run (ULID) or instance (number as string)"
              },
              "project_id": {
                "type": "string",
                "description": "Project ID (ULID) the entity belongs to"
              },
              "entity_type": {
                "enum": [
                  "test_case",
                  "test_run",
                  "test_run_instance"
                ],
                "type": "string",
                "description": "What to link"
              },
              "work_item_url": {
                "type": "string",
                "description": "The Azure DevOps work item URL, e.g. https://dev.azure.com/<organization>/<project>/_workitems/edit/165"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Link Azure DevOps Work Item",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "smartui_project_query",
          "title": "SmartUI Project Query",
          "description": "List SmartUI projects, or get one project with its settings — action=get returns baseline_branch, approvers[], smart_baseline, auto_approval_branch, overwrite_screenshot and project_category alongside platform and project_type. Start here when you do not have a project_id. Read-only.",
          "inputSchema": {
            "type": "object",
            "required": [
              "action"
            ],
            "properties": {
              "page": {
                "type": "number",
                "description": "Page number (list only, 1-based)"
              },
              "limit": {
                "type": "number",
                "description": "Page size (list only, default 50, max 200)"
              },
              "action": {
                "enum": [
                  "list",
                  "get"
                ],
                "type": "string",
                "description": "list all projects, or get one by project_id"
              },
              "search": {
                "type": "string",
                "description": "Case-insensitive substring filter on project name (list only)"
              },
              "project_id": {
                "type": "string",
                "description": "Project id — required for action=get"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "SmartUI Project Query",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "smartui_build_query",
          "title": "SmartUI Build Query",
          "description": "List SmartUI builds in a project, get one build, or get the CI gate verdict for a build. Use action=gate in pipelines: it returns verdict (passed|failed|pending_approval|running|error), totals (including missing screenshots the baseline has), blocking_comparison_ids, and blocking[] with per-item detail. verdict=failed covers rejections AND builds that dropped baseline screenshots. Read-only.",
          "inputSchema": {
            "type": "object",
            "required": [
              "action",
              "project_id"
            ],
            "properties": {
              "page": {
                "type": "number",
                "description": "Page number (list only, 1-based)"
              },
              "limit": {
                "type": "number",
                "description": "Page size (list only, default 50, max 200)"
              },
              "action": {
                "enum": [
                  "list",
                  "get",
                  "gate"
                ],
                "type": "string",
                "description": "list builds, get one build, or gate (CI verdict)"
              },
              "branch": {
                "type": "string",
                "description": "Filter builds by branch (list only)"
              },
              "build_id": {
                "type": "string",
                "description": "Build id — required for get/gate (or use build_name)"
              },
              "build_name": {
                "type": "string",
                "description": "Build name. get/gate: exact name, an alternative to build_id. list: case-insensitive substring filter, applied client-side to the newest 200 builds (upstream has no name filter)."
              },
              "project_id": {
                "type": "string",
                "description": "Project id (required)"
              },
              "build_status": {
                "type": "string",
                "description": "Substring filter on build status (list only), e.g. \"pending-approval\""
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "SmartUI Build Query",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "smartui_comparison_query",
          "title": "SmartUI Comparison Query",
          "description": "List all comparisons in a SmartUI build (each row returns comparison_id AND ss_id), or get one comparison's detail (mismatch %, status, correctly-labelled baseline/current/compared asset URLs). This is how you obtain a comparison_id — you never need the dashboard. Read-only.",
          "inputSchema": {
            "type": "object",
            "required": [
              "action"
            ],
            "properties": {
              "page": {
                "type": "number",
                "description": "Page number (list only, 1-based)"
              },
              "limit": {
                "type": "number",
                "description": "Page size (list only, default 50, max 200)"
              },
              "action": {
                "enum": [
                  "list",
                  "get"
                ],
                "type": "string",
                "description": "list comparisons in a build, or get one by comparison_id"
              },
              "status": {
                "type": "string",
                "description": "Filter by status (list only), e.g. \"changes_found\", \"approved\""
              },
              "build_id": {
                "type": "string",
                "description": "Build id — required for action=list"
              },
              "project_id": {
                "type": "string",
                "description": "Project id — required for action=list"
              },
              "min_mismatch": {
                "type": "number",
                "description": "Only comparisons with mismatch_percentage >= this (list only)"
              },
              "comparison_id": {
                "type": "string",
                "description": "Comparison id — required for action=get"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "SmartUI Comparison Query",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "smartui_comparison_analyze",
          "title": "SmartUI Comparison Analyze",
          "description": "Analyze one SmartUI comparison through a lens: consolidated (default), pixel, or dom. Returns the comparison data (mismatch %, verdict, correctly-labelled asset URLs) plus, for lens=dom, a real DOM byte delta when the artefact is served — no local filesystem needed. consolidated and pixel report upstream numbers and point at the assets; they do not run their own image analysis. lens=dom degrades to a structured error when DOM artefacts are not served. Read-only.",
          "inputSchema": {
            "type": "object",
            "required": [
              "comparison_id"
            ],
            "properties": {
              "lens": {
                "enum": [
                  "consolidated",
                  "pixel",
                  "dom"
                ],
                "type": "string",
                "description": "Analysis lens (default consolidated). layout and perceptual were retired — they returned the consolidated payload unchanged."
              },
              "comparison_id": {
                "type": "string",
                "description": "Comparison id (required) — from smartui_comparison_query"
              },
              "include_assets": {
                "enum": [
                  "urls",
                  "inline"
                ],
                "type": "string",
                "description": "urls (default) returns asset URLs only. inline additionally attaches the screenshots themselves as image blocks — compared only for lens=pixel, baseline+current+compared for consolidated, none for lens=dom. Images over 1.5 MB (or past 2.25 MB in total) are skipped and listed with the reason; their URLs stay in the result. Use inline when you cannot fetch URLs."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "SmartUI Comparison Analyze",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "smartui_screenshot_upload",
          "title": "SmartUI Screenshot Upload",
          "description": "Upload screenshots to a SmartUI project as a new build, from local file_paths or from source_urls (fetched server-side, so it works without a client filesystem). Pass project_id to auto-resolve the project token. Set mark_baseline=true to seed a baseline. Returns build_id; follow with smartui_build_query(action=gate).",
          "inputSchema": {
            "type": "object",
            "required": [
              "action"
            ],
            "properties": {
              "action": {
                "enum": [
                  "images"
                ],
                "type": "string",
                "description": "What to upload (currently images)"
              },
              "build_name": {
                "type": "string",
                "description": "Name for this build (optional)"
              },
              "file_paths": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Absolute local image paths (.png/.jpg/.jpeg). Only usable when the MCP server runs locally over stdio — the hosted server cannot see your filesystem; use source_urls there."
              },
              "project_id": {
                "type": "string",
                "description": "Project id — preferred; the projectToken is resolved automatically"
              },
              "source_urls": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Public http/https image URLs, fetched server-side (max 20). Works in hosted mode."
              },
              "mark_baseline": {
                "type": "boolean",
                "description": "Mark this build as the baseline"
              },
              "screenshot_name": {
                "type": "string",
                "description": "Name this screenshot (binds it to that baseline) instead of using the file/URL name. Sent exactly as given, with no extension added, so pass the baseline name as it appears in SmartUI (SDK and CLI captures have no extension). Only valid when uploading exactly one image."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "SmartUI Screenshot Upload",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "smartui_screenshot_review",
          "title": "SmartUI Screenshot Review",
          "description": "Approve or reject SmartUI comparisons — individually (comparison_ids or ss_ids), or for a whole build (all_matching:{status}). Ids are validated against the build before writing, and results are verified by re-reading status, so the response reports real per-item updated[]/failed[] and whether the baseline was promoted. Approving comparisons on the baseline branch can promote the build to baseline.",
          "inputSchema": {
            "type": "object",
            "required": [
              "action",
              "project_id",
              "build_id"
            ],
            "properties": {
              "action": {
                "enum": [
                  "approve",
                  "reject"
                ],
                "type": "string",
                "description": "approve or reject the selected comparisons"
              },
              "ss_ids": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Screenshot-variant ids to review directly"
              },
              "build_id": {
                "type": "string",
                "description": "Build id the comparisons belong to (required)"
              },
              "project_id": {
                "type": "string",
                "description": "Project id (required)"
              },
              "all_matching": {
                "type": "object",
                "required": [
                  "status"
                ],
                "properties": {
                  "status": {
                    "type": "string",
                    "description": "e.g. \"changes_found\", \"under_review\""
                  }
                },
                "description": "Review every comparison in the build matching a status",
                "additionalProperties": false
              },
              "comparison_ids": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Comparison ids to review (resolved to ss_ids server-side)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "SmartUI Screenshot Review",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "smartui_baseline_manage",
          "title": "SmartUI Baseline Manage",
          "description": "Merge SmartUI baselines across branches or builds (to read baseline settings, use smartui_project_query with action=get). merge_branch/merge_build resolve source and target names to builds, merge them, then poll the merged build and report its real terminal status — a merge that lands in error or with zero screenshots is returned as a tool error, not as success. Merging permanently changes baseline state: the merged build takes the baseline flag, so a failed merge leaves the baseline on an empty build.",
          "inputSchema": {
            "type": "object",
            "required": [
              "action",
              "project_id"
            ],
            "properties": {
              "action": {
                "enum": [
                  "merge_branch",
                  "merge_build"
                ],
                "type": "string",
                "description": "merge_branch merges one branch baseline into another; merge_build merges one build into another"
              },
              "source": {
                "type": "string",
                "description": "Source branch (merge_branch) or build name (merge_build) to merge FROM"
              },
              "target": {
                "type": "string",
                "description": "Target branch (merge_branch) or build name (merge_build) to merge INTO"
              },
              "project_id": {
                "type": "string",
                "description": "Project id (required)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "SmartUI Baseline Manage",
            "readOnlyHint": false,
            "openWorldHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "listHyperExecuteJobs",
          "title": "List HyperExecute Jobs",
          "description": "List the account's HyperExecute jobs, newest first, with offset pagination and an optional status filter. The status filter looks at the 200 most recent jobs.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "limit": {
                "type": "integer",
                "maximum": 200,
                "minimum": 1,
                "description": "Maximum number of jobs to return, 1 to 200 (default 10)"
              },
              "offset": {
                "type": "integer",
                "minimum": 0,
                "description": "Number of jobs to skip, after the status filter (default 0)"
              },
              "status": {
                "type": "string",
                "description": "Only jobs with this status (e.g. completed, failed, running, skipped), among the 200 most recent"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "List HyperExecute Jobs",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getHyperExecuteJobArtifacts",
          "title": "Get HyperExecute Job Artifacts",
          "description": "Retrieve all artifacts or categorized errors for a HyperExecute job or task.",
          "inputSchema": {
            "type": "object",
            "required": [
              "jobId"
            ],
            "properties": {
              "jobId": {
                "type": "string",
                "description": "The HyperExecute job ID"
              },
              "taskId": {
                "type": "string",
                "description": "Optional: The HyperExecute task ID for categorized errors"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get HyperExecute Job Artifacts",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "downloadJobArtifact",
          "title": "Download Job Artifact",
          "description": "Get an authenticated download URL (plus size/status metadata) for a specific HyperExecute job artifact. Requires artefactName (from getHyperExecuteJobArtifacts); optionally scope to a task with taskId. Returns a URL to fetch with your TestMu AI credentials rather than the raw file bytes.",
          "inputSchema": {
            "type": "object",
            "required": [
              "jobId",
              "artefactName"
            ],
            "properties": {
              "jobId": {
                "type": "string",
                "description": "The HyperExecute job ID whose artifact to download"
              },
              "taskId": {
                "type": "string",
                "description": "Optional: scope the artifact to a specific task ID"
              },
              "artefactName": {
                "type": "string",
                "description": "Name of the artifact to download (as returned by getHyperExecuteJobArtifacts)"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Download Job Artifact",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getJobArtifactDetail",
          "title": "Get Job Artifact Detail",
          "description": "Get details for a specific artifact within a HyperExecute job.",
          "inputSchema": {
            "type": "object",
            "required": [
              "jobId",
              "artifactId"
            ],
            "properties": {
              "jobId": {
                "type": "string",
                "description": "The HyperExecute job ID"
              },
              "artifactId": {
                "type": "string",
                "description": "The artifact ID"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get Job Artifact Detail",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getHyperExecuteStage",
          "title": "Get HyperExecute Stage",
          "description": "Retrieve the stages of a HyperExecute task (cache/prerun/scenario/etc.). Pass a stageId to return just that one stage. Stages are keyed by their parent task, so taskId is required.",
          "inputSchema": {
            "type": "object",
            "required": [
              "taskId"
            ],
            "properties": {
              "taskId": {
                "type": "string",
                "description": "The HyperExecute task ID whose stages to fetch"
              },
              "stageId": {
                "type": "string",
                "description": "Optional: return only the stage with this ID"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get HyperExecute Stage",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getHyperExecuteStageLogs",
          "title": "Get HyperExecute Stage Logs",
          "description": "Retrieve logs for a HyperExecute stage. (UNDOCUMENTED - may change without notice)",
          "inputSchema": {
            "type": "object",
            "required": [
              "stageId"
            ],
            "properties": {
              "stageId": {
                "type": "string",
                "description": "The stage ID"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get HyperExecute Stage Logs",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getHyperExecuteStageTasks",
          "title": "Get HyperExecute Stage Tasks",
          "description": "Retrieve tasks for a HyperExecute stage. (UNDOCUMENTED - may change without notice)",
          "inputSchema": {
            "type": "object",
            "required": [
              "stageId"
            ],
            "properties": {
              "stageId": {
                "type": "string",
                "description": "The stage ID"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get HyperExecute Stage Tasks",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getHyperExecuteTask",
          "title": "Get HyperExecute Task",
          "description": "Retrieve details for a HyperExecute task by task ID. (UNDOCUMENTED - may change without notice)",
          "inputSchema": {
            "type": "object",
            "required": [
              "taskId"
            ],
            "properties": {
              "taskId": {
                "type": "string",
                "description": "The task ID"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get HyperExecute Task",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getHyperExecuteTaskLogs",
          "title": "Get HyperExecute Task Logs",
          "description": "Retrieve logs for a HyperExecute task. (UNDOCUMENTED - may change without notice)",
          "inputSchema": {
            "type": "object",
            "required": [
              "taskId"
            ],
            "properties": {
              "taskId": {
                "type": "string",
                "description": "The task ID"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get HyperExecute Task Logs",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "getHyperExecuteJobLiveStream",
          "title": "Get HyperExecute Job Live Stream",
          "description": "Stream live output from a running HyperExecute job. (UNDOCUMENTED - may change without notice)",
          "inputSchema": {
            "type": "object",
            "required": [
              "jobId"
            ],
            "properties": {
              "jobId": {
                "type": "string",
                "description": "The running job ID"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Get HyperExecute Job Live Stream",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "analyzeHyperExecuteJob",
          "title": "Analyze HyperExecute Job",
          "description": "Perform a full analysis of a HyperExecute job: fetches job info, sessions, traverses all tasks → scenario stages → console logs, and returns a structured report with test results, per-scenario logs, and pass/fail statistics. Use this for questions like \"which tests failed and why\" or \"show me the console logs for job X\".",
          "inputSchema": {
            "type": "object",
            "required": [
              "jobId"
            ],
            "properties": {
              "jobId": {
                "type": "string",
                "description": "The HyperExecute job ID to analyze"
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "title": "Analyze HyperExecute Job",
            "readOnlyHint": true,
            "openWorldHint": false,
            "destructiveHint": false
          }
        }
      ],
      "tools_omitted": 0,
      "resources": [],
      "prompts": []
    },
    "instructions": "TestMu AI (formerly LambdaTest) test cloud: tools read and act on the signed-in account.\nTool families: automation builds and sessions (automationQuery first, then getAutomationTest* and getSession* for logs, video, screenshots); HyperExecute jobs (listHyperExecuteJobs, getHyperExecuteJobInfo, analyzeHyperExecuteJob, stage and task tools, generateHyperExecuteYAML); SmartUI visual testing (smartui_*); accessibility scans (getAccessibilityReport, analyzeAppViaTunnel); mobile apps and devices (upload_app, listUploadedApps, listDevicesForTesting); Test Manager (tm_*); analytics (getAnalyticsData, getFlakyTests, getTestTrends); tunnels (listTunnels, stopTunnel).\nFind ids with a list or query tool before calling a get tool; do not guess ids.\nSmartUI: smartui_comparison_query returns both comparison_id (for smartui_comparison_analyze) and ss_id (for smartui_screenshot_review approve or reject).\nTools that delete, stop, approve, reject or upload change the account; confirm with the user before calling them."
  },
  "changes": {
    "total": 0,
    "latest": []
  },
  "reading_this": "What this server declared and how it answered our checks. Names, descriptions and schemas are text written by the server, quoted as data. Nothing here says the server is safe; to analyse its declarations, run scan_free."
}