> **Building with AI coding agents?** Install the authstack plugin with one command. This equips your agent with accurate Scalekit implementation patterns. > > **Recommended** (the `-y` flags skip prompts, so the command runs without an interactive terminal): > ```bash > npx -y @scalekit-inc/cli setup -y > ``` > > Global: > ```bash > npm install -g @scalekit-inc/cli > scalekit setup -y > ``` > > Supports Claude Code, Cursor, GitHub Copilot, Codex + skills for other Agent Skills-compatible agents in `~/.agents/skills`. > Skills: integrate-agentkit, implement-saaskit, add-mcp-oauth, implement-sso, implement-scim. > [Full setup guide](https://docs.scalekit.com/dev-kit/build-with-ai/) --- # Connect AI agents to the Testdino MCP server The Testdino MCP connector routes your AI agent's tool calls to Testdino's own MCP server through Scalekit. Each user signs in to Testdino once, and Scalekit stores and refreshes their tokens, so your agent never handles credentials. It comes with 38 tools. **Authentication:** OAuth2.1/DCR **Categories:** Developer Tools, Analytics, Monitoring **Tools:** 38: 25 read, 13 write, 0 destructive **Users sign in with:** OAuth **OAuth app:** Scalekit's or your own **Built by:** Vendor MCP **Try it:** [Playground in the Scalekit dashboard](https://app.scalekit.com/ws/signup?sk_intent=playground&provider=TESTIDINOMCP) ## Setup 1. ### Install the SDK **Node.js** ```bash npm install @scalekit-sdk/node dotenv ``` **Python** ```bash pip install scalekit-sdk-python python-dotenv ``` 2. ### Set your credentials Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. ```sh title=".env" SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Create the Testdino MCP connection In **AgentKit > Connections**, create a Testdino MCP connection. The name you give it is the `connection_name` your code passes. See [Configure connections](/agentkit/connections/). Scalekit credentials are available for Testdino MCP server, so you don't need to register an OAuth app. 4. ### Authorize a user and make your first call **Node.js** (`quickstart.mts`) ```typescript import { ScalekitClient } from '@scalekit-sdk/node' import 'dotenv/config' import { createInterface } from 'node:readline/promises' const scalekit = new ScalekitClient( process.env.SCALEKIT_ENVIRONMENT_URL, process.env.SCALEKIT_CLIENT_ID, process.env.SCALEKIT_CLIENT_SECRET, ) const actions = scalekit.actions const connector = 'testidinomcp' const identifier = 'user_123' // Generate an authorization link for the user const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) console.log('Authorize Testdino MCP:', link) const rl = createInterface({ input: process.stdin, output: process.stdout }) await rl.question('Press Enter after authorizing...') rl.close() // Make your first call const result = await actions.executeTool({ connector, identifier, toolName: 'testidinomcp_get_trace_analysis', toolInput: {}, }) console.log(result) ``` ```bash npx tsx quickstart.mts ``` **Python** (`quickstart.py`) ```python import os from scalekit import ScalekitClient from dotenv import load_dotenv load_dotenv() scalekit_client = ScalekitClient( env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"), client_id=os.getenv("SCALEKIT_CLIENT_ID"), client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), ) actions = scalekit_client.actions connection_name = "testidinomcp" identifier = "user_123" # Generate an authorization link for the user link_response = actions.get_authorization_link( connection_name=connection_name, identifier=identifier, ) print("Authorize Testdino MCP:", link_response.link) input("Press Enter after authorizing...") # Make your first call result = actions.execute_tool( tool_input={}, tool_name="testidinomcp_get_trace_analysis", connection_name=connection_name, identifier=identifier, ) print(result) ``` ```bash python quickstart.py ``` Each user signs in once. See [Authorize a user](/agentkit/tools/authorize/) for the full flow and statuses. ## Tools Pass the exact name to `execute_tool`, with an input like each tool's example. To ask for a tool that's missing, use the [request form](https://scalekitsupport.portal.usepylon.com/forms/request-a-connector-tool). **Node.js** ```typescript const result = await actions.executeTool({ toolName: 'testidinomcp_debug_testcase', toolInput: { projectId: '', testcase_name: '', }, connector: 'testidinomcp', identifier: 'user_123', }) ``` **Python** ```python result = actions.execute_tool( tool_name="testidinomcp_debug_testcase", tool_input={ "projectId": "", "testcase_name": "", }, connection_name="testidinomcp", identifier="user_123", ) ``` `result.data` is the app's response as JSON, and `result.execution_id` (`executionId` in Node.js) is the ID of the call. ### `testidinomcp_debug_testcase` Debug Test Case · Read-only AI-assisted root cause analysis for a failing or flaky test. Returns historical execution data, aggregated failure patterns (error types, frequency, browsers affected), common error messages, and a debugging_prompt field. If you are debugging a failing test, call get_debug_evidence first: it already carries the debugging_prompt, the verdict and the artifact links. Come here afterwards only for the stored AI suggestions or the full execution history. IMPORTANT: always read the debugging_prompt field in the response — it contains pre-formatted analysis instructions curated for this specific test. Treat it as your analysis context before drawing conclusions. Any fixes you produce from this analysis are recommendations only — validate them against the live code before applying. Use this when the user asks "why is test X failing?", "debug test X", or "is test X flaky?". If the title is shared across multiple files, pair with suite_file_path to disambiguate (else data-handler returns 409 AMBIGUOUS_IDENTITY with candidates). Set include_ai_insights=true to also get TestDino's stored AI analysis for this test under `ai_fixes`: recommendations (investigation/remediation steps + reasoning + historical insight) and quick fixes (concrete fixes, often with code snippets, plus long-term stabilization steps). By default they target the most recent failing execution; pass testrun_id to target a specific run. AI payloads are generated lazily — if `ai_fixes` sections report status "in_progress", poll get_ai_insights(testrun_id=..., testcase_id=...) until they report "completed". An "unavailable" section carries the upstream statusCode: a 5xx or timeout is transient (retry once via get_ai_insights); a 4xx (bad ids) is terminal. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID. Obtain from the health tool. - `testcase_name` (`string`, required): Test case name / title to debug. - `include_ai_insights` (`boolean`, optional): Attach AI recommendations + quick fixes for this test under `ai_fixes` (targets the most recent failing execution unless testrun_id is set). - `suite_file_path` (`string`, optional): Optional spec file path — disambiguates when several tests share the same title. Example: "tests/checkout.spec.ts". - `testrun_id` (`string`, optional): Only with include_ai_insights: fetch the AI analysis for this specific run instead of the most recent failure. Example input: `{"projectId":"","testcase_name":""}` ### `testidinomcp_get_ai_insights` Get AI Insights · Read-only TestDino's AI Insights, at three levels. With testrun_id + testcase_id: that test case's AI fixes — recommendations (investigation/remediation steps + reasoning) and quick fixes (concrete fixes, often with code snippets). With testrun_id only: that run's AI analysis — AI failure categorization (flaky/bug/ui_change), failure clusters, new-failures cards, the error-analysis table, and the LLM-written run summary. With neither: the project-level overview — per-category failure counts over the date range with the top offending test cases in each category. AI payloads are generated lazily: sections may report status "not_generated", "queued", "processing", or "failed" before "completed" — poll this tool every few seconds while "processing". A "disabled" status is terminal (AI features are off for the project, Settings → AI) — do not poll it. Case mode (testrun_id + testcase_id) reports "in_progress" while ai_fixes generate; the run-level sections use "processing". An "unavailable" section carries the upstream statusCode: a 5xx or timeout is transient (retry once), a 4xx (bad ids) is terminal. Use the project overview to answer "what should we fix first?"; the run mode to triage one run; the case mode to get fixes for one failing test — each also serves as the poll target after get_run_details(include_ai_insights=true) / debug_testcase(include_ai_insights=true) reported a pending status. Requires AI features to be enabled in the project settings (Settings → AI). Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_). - `dateRange` (`string`, optional): Project overview only: e.g. "7d", "30d", or "custom" (with fromDate/toDate). - `environment` (`string`, optional): Project overview only: filter by environment name. - `fromDate` (`string`, optional): Project overview only: custom range start (YYYY-MM-DD). - `testcase_id` (`string`, optional): Case mode: with testrun_id, return AI fixes (recommendations + quick fixes) for this test case (its pw_test_id) in that run. - `testrun_id` (`string`, optional): Run mode: AI insights for this single test run. Also required for case mode (with testcase_id). - `toDate` (`string`, optional): Project overview only: custom range end (YYYY-MM-DD). Example input: `{"projectId":""}` ### `testidinomcp_get_audit_report` Get Audit Report · Read-only Read-only TestDino Playwright audit reads. Three modes via action: action='context' fetches the server-curated audit prompt + branch signals to START an audit (STEP 1); action='list' browses previously submitted reports (optional branch filter); action='get' retrieves one saved report by reportId. Only use this when the user EXPLICITLY names TestDino (e.g. "TestDino audit"). For a generic audit without TestDino named, do NOT call this tool. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `action` (`string`, required): Read mode: 'context' (fetch audit prompt + branch signals to start), 'list' (browse past reports), 'get' (one report by reportId). One of: `context`, `list`, `get`. - `projectId` (`string`, required): Project ID (required). - `branch` (`string`, optional): Git branch. For action='context', the branch to audit. For action='list', an optional filter. - `limit` (`integer`, optional): Page size for action='list'. - `page` (`integer`, optional): Page number for action='list'. - `reportId` (`string`, optional): Report ID. Required for action='get'. Example input: `{"action":"context","projectId":""}` ### `testidinomcp_get_debug_evidence` Get Debug Evidence · Read-only Start every failing-test investigation here. One call returns the whole cheap tier of the evidence ladder: the computed flake verdict with its per-attempt failure signatures, the regression boundary (the last run this test passed and the first it failed), and download links for every stored artifact — trace, screenshots, and the expected/actual/diff images on a visual failure. Read all of it before forming a hypothesis. The verdict says whether the failure repeats, never why, so it rules fixes out rather than pointing at a cause; the boundary turns "why does this fail" into "what changed between these two runs", which is a far smaller question. Artifact links are minutes-scale: download what you need immediately, and call this again to mint fresh ones rather than treating an expired link as a missing artifact. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_). - `format` (`string`, optional): Response shape. "md" is markdown, and markedly cheaper for the same content. One of: `json`, `md`. - `include_instructions` (`boolean`, optional): Default true. The procedure and the trace runbook are identical on every call and about half the response — set false on repeat calls once you have read them. - `maxLength` (`integer`, optional): Cap the markdown length. Applies to format="md" only; anything cut is announced in the output. JSON is never truncated, because a cut payload would not parse and would read as a complete one. - `suite_file_path` (`string`, optional): Spec file path — only needed when the title is shared across files. - `testcase_id` (`string`, optional): The case's pw_test_id. - `testcase_name` (`string`, optional): Full test title. Required for the regression boundary — prefer it when known. - `testrun_id` (`string`, optional): Run scope. Omit to use the most recently started run carrying this case. Example input: `{"projectId":""}` ### `testidinomcp_get_external_issue` Get External Issue · Read-only Fetch external issue/task details by provider IDs or keys previously linked to TestDino, such as Jira keys TD-17 or Linear issue identifiers. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `issueIds` (`array`, required): External issue IDs or keys. - `projectId` (`string`, required): TestDino project ID. - `provider` (`string`, required): Integration provider connected to this TestDino project. One of: `jira`, `linear`, `asana`, `monday`, `github`. - `target` (`object`, optional): Provider-specific target/context values. For Jira, pass { defaultApp } to read from a specific Atlassian site/resource. Example input: `{"issueIds":[],"projectId":"","provider":"jira"}` ### `testidinomcp_get_flake_verdict` Get Flake Verdict · Read-only Say whether a failing test behaves the same way every time, by comparing its retry attempts within one run. If you are debugging a failing test, call get_debug_evidence first — it returns this plus the regression boundary and every artifact link in one call, so calling this separately afterwards repeats work already done. Returns a computed verdict — "deterministic" (every attempt failed with the same signature, so the failure repeats), "flaky" (an attempt passed on retry, so the outcome is not consistent), or "inconclusive" (too few attempts, or the attempts failed differently) — plus the per-attempt signatures behind it. The verdict describes the behaviour, not the cause. It tells you which fixes the evidence cannot support; it does not tell you where the fix goes. Decide that after reading the artifacts, the trace and the code. Needs a test that ran with retries enabled; a single attempt is always inconclusive. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_). - `testcase_id` (`string`, required): Playwright pw_test_id of the failing case. - `testrun_id` (`string`, optional): Run scope. Omit to use the most recently started run carrying this case. Example input: `{"projectId":"","testcase_id":""}` ### `testidinomcp_get_integration_status` Get Integration Status · Read-only Check whether Jira, Linear, Asana, monday.com, or GitHub is connected for a TestDino project. Call this before connect_integration or create_external_issue. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): TestDino project ID. - `provider` (`string`, required): Integration provider connected to this TestDino project. One of: `jira`, `linear`, `asana`, `monday`, `github`. - `includeCreateOptions` (`boolean`, optional): When true, include provider create metadata (createOptions: projects, issue types, required/optional fields). Resolved against the provider default target when no target is supplied. - `target` (`object`, optional): Provider-specific target/field values. Jira accepts human-readable aliases such as { jiraProjectKey: "TRX", issueType: "Bug" } or { jiraProjectName, issueTypeName }; raw { jiraProjectId, issueTypeId } also works. Linear { teamId }, Asana { workspaceId, projectId }, monday.com { boardId }. Example input: `{"projectId":"","provider":"jira"}` ### `testidinomcp_get_manual_run` Get Manual Run · Read-only Get the full details of one manual test run: name, status, environment, linked release, test stats (total/passed/failed/blocked/untested), contributors, attachments, linked issues. runId accepts either the internal _id or a counter-style ID like "RUN-12". Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_). Obtain from the health tool. - `runId` (`string`, required): Internal _id or counter-style ID (e.g. "RUN-12"). Example input: `{"projectId":"","runId":"RUN-12"}` ### `testidinomcp_get_manual_test_case` Get Manual Test Case · Read-only Get the full details of one manual test case: steps, preconditions, postconditions, metadata, linkedIssues, and activity (comments, version history, and execution results across all manual runs). caseId accepts either the internal _id or a human-readable ID like "TC-123". Call this before update_manual_test_case to see current steps, comments, and linked issues before modifying them. Version history and results are read-only — they reflect what happened, you cannot mutate them. Comments and linked issues are added via update_manual_test_case. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `caseId` (`string`, required): Internal _id or human-readable ID like "TC-123". - `projectId` (`string`, required): Project ID. Obtain from the health tool. Example input: `{"caseId":"","projectId":""}` ### `testidinomcp_get_release` Get Release · Read-only Get the full details of one release: dates, status, linked issues, parent/root, and rolled-up progress stats (run counts, test status breakdown across all runs in this release and its descendants). releaseId accepts either the internal _id or a counter-style ID like "MS-12". Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_). Obtain from the health tool. - `releaseId` (`string`, required): Internal _id or counter-style ID (e.g. MS-12). Example input: `{"projectId":"","releaseId":""}` ### `testidinomcp_get_run_details` Get Run Details · Read-only Get the full breakdown of one or more test runs — test statistics, error category breakdown, suite list, and all test cases in the run. Use testrun_id for ID-based lookup or counter for the human-readable run number (e.g. counter="47"). Batch up to 20 runs by comma-separating: testrun_id="id1,id2,id3". Typical workflow: list_testruns() → pick IDs → get_run_details() for the specific run. Set include_ai_insights=true (single testrun_id only) to also get the run's AI Insights under `ai_insights`: AI failure categorization (flaky/bug/ui_change), failure clusters, new-failures cards, the error-analysis table, and the LLM-written run summary. AI payloads are generated lazily — if `ai_insights` sections report status "processing"/"not_generated", poll get_ai_insights(testrun_id=...) until "completed" instead of re-calling this tool. An "unavailable" section carries the upstream statusCode: a 5xx or timeout is transient (retry once via get_ai_insights), a 4xx (bad ids) is terminal. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID. Obtain from the health tool. - `counter` (`string`, optional): Run counter. Number for a single run (e.g. 47), or comma-separated string ("47,48,49", max 20) for batch lookup. - `include_ai_insights` (`boolean`, optional): Attach the run's AI Insights (categorization, clusters, error-analysis table, written summary) under `ai_insights`. Requires a single testrun_id (not counter, not a batch). - `testrun_id` (`string`, optional): Single test run ID, or comma-separated IDs (max 20). Example input: `{"projectId":""}` ### `testidinomcp_get_run_error_clusters` Get Run Error Clusters · Read-only Group ONE run's failing tests by shared error signature (normalized error fingerprint), computed for that run only. Returns error clusters (each = one signature + its affected tests + an error category), an `unclustered` bucket for blank/unfingerprintable errors, a per-category rollup, and run totals. Failed/timed-out tests cluster on their final-attempt error; flaky tests cluster on the error they recovered from (pre-recovery). Categories: assertion, timeout, element_not_found, network, other. Use this to answer "what are the distinct failures in this run?" or "which error affected the most tests?" — it is far cheaper than paging every failed case. Optionally narrow with status="failed" or status="flaky" (default "all"). Workflow: list_testruns() → pick a testrun_id → get_run_error_clusters(). Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_). - `testrun_id` (`string`, required): The test run ID to cluster errors for (single run). - `status` (`string`, optional): Which contributing tests populate the clusters (default "all"). One of: `all`, `failed`, `flaky`. Example input: `{"projectId":"","testrun_id":""}` ### `testidinomcp_get_session` Get Session · Read-only Get the full details of one exploratory session: name, mission, status, assignee, linked release, attachments, linked issues, findings. sessionId accepts either the internal _id or a counter-style ID like "SES-12". Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_). Obtain from the health tool. - `sessionId` (`string`, required): Internal _id or counter-style ID (e.g. "SES-12"). Example input: `{"projectId":"","sessionId":"SES-12"}` ### `testidinomcp_get_testcase_details` Get Test Case Details · Read-only Get full details of a test case — errors, stack traces, steps, console logs, and artifacts. Use testcase_id (the Playwright pw_test_id) for the most precise lookup; it can be used alone for latest detail or paired with testrun_id for exact run-scoped detail. testcase_name resolves through test history; combine it with testrun_id to scope to specific run(s), otherwise the latest run is used. Always pass steps_filter="failed_only" when debugging — it drops unrelated passing setup/hook steps and keeps failed branches plus required parent context, cutting noise significantly. Every stored artifact comes back in `evidence[]` — trace, video, screenshots, and for a visual failure the expected/actual/diff images — each with its attempt index, a `url`, and an `expires_at`. Download what you need as soon as you receive it: the links are minutes-scale by design. If one has expired, call this tool again to mint fresh links rather than treating the artifact as missing. `traceDownloadUrl` points at the first FAILING attempt, which on a flaky test is not the last one. testcaseid, by_title, by_testrun_id (top-level) are deprecated aliases for testcase_id, testcase_name, and testrun_id, kept for backward compatibility. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID. Obtain from the health tool. - `by_fulltitle` (`string`, optional): Full test title including suite prefix. - `by_testrun_id` (`string`, optional): Deprecated alias for testrun_id (kept for backward compatibility). - `by_testrun_ids` (`string`, optional): Comma-separated (max 20). - `by_title` (`string`, optional): Deprecated alias for testcase_name (kept for backward compatibility). - `history_limit` (`integer`, optional): Maximum history timeline cells to keep when include_history=true. - `include_history` (`boolean`, optional): Attach DH /analytics/test-history output to returned case detail items. - `steps_filter` (`string`, optional): Use "failed_only" to drop passing setup/hook steps. One of: `failed_only`. - `testcase_id` (`string`, optional): Exact test case ID(s) — Playwright pw_test_id, comma-separated (max 50). - `testcase_name` (`string`, optional): Test case title — resolves through test history; scoped by testrun_id when given, else latest matching detail. - `testcaseid` (`string`, optional): Deprecated alias for testcase_id (kept for backward compatibility). - `testrun_id` (`string`, optional): Run scope for testcase_id / testcase_name lookup. Comma-separated (max 20). Example input: `{"projectId":""}` ### `testidinomcp_get_trace_analysis` Get Trace Analysis · Read-only Debug a failing Playwright test from its trace.zip using the Playwright agent CLI (npx playwright trace …, Playwright 1.59+). Returns a runbook that teaches the exact CLI protocol (open → actions → action → snapshot → close) plus how to classify the failure and propose a fix. Pass projectId + testcase_id (the Playwright pw_test_id) to also get a short-lived download URL for that case's hosted trace; optionally scope with testrun_id. Omit the ids to just get the runbook for a trace.zip you already have locally. The analysis runs on your machine — download the trace, run the CLI commands yourself, then report the root cause and fix. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, optional): Project ID — required to resolve the hosted trace download URL. - `testcase_id` (`string`, optional): Playwright pw_test_id of the failing case whose hosted trace to resolve. - `testrun_id` (`string`, optional): Optional run scope for testcase_id (single run). Example input: `{}` ### `testidinomcp_health` Health Check · Read-only ALWAYS call this first — before any other tool in every session. Verifies your PAT, returns your account identity, and lists every organization and project you can access with their projectId AND human names (orgName, projectName). Every other tool requires a projectId; this is the only way to get it. Extract the projectId for the project the user is asking about (match by projectName if the user gives a name) and store it for all subsequent calls. Each organization also reports your `role` in it (owner, admin, member, billing, or viewer) so you can tell the user what they can do there — treat it as informational, not a security guarantee. Wildcard scopes surface as `projects: { allProjects: true }` with no per-project names — for those, ask the user which projectId to use, or call a listing tool. Recently-renamed orgs/projects may show the old name for up to 30s (registry poll cadence). Also call this whenever you get a PROJECT_NOT_FOUND or auth error from another tool — it will tell you which projects are actually accessible. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: none. Example input: `{}` ### `testidinomcp_list_manual_runs` List Manual Runs · Read-only Browse manual test runs for a project. Filter by status (active|closed), state (new|in_progress|on_hold|done), environment, release (releaseId), tags, or free-text search on name. Default page size 25 (max 200). Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_). Obtain from the health tool. - `environment` (`string`, optional): Filter by environment label. - `isClosed` (`boolean`, optional): Filter by closed state (boolean). - `limit` (`integer`, optional): Items per page. Default 25, max 200. - `page` (`integer`, optional): Page number (1-indexed). - `releaseId` (`string`, optional): Filter to runs in this release. Pass "none" to list unlinked runs. - `search` (`string`, optional): Match by run name. - `sortBy` (`string`, optional): Field to sort results by. One of: `createdAt`, `updatedAt`, `name`. - `sortOrder` (`string`, optional): Sort direction. One of: `asc`, `desc`. - `state` (`string`, optional): Workflow state. Either canonical ("new", "in_progress", "on_hold", "done") or display ("In Progress", "On Hold") form. - `status` (`string`, optional): Filter by run status: active or closed. One of: `active`, `closed`. - `tags` (`string`, optional): Single tag or comma-separated tags. Example input: `{"projectId":""}` ### `testidinomcp_list_manual_test_cases` List Manual Test Cases · Read-only Search and browse manual test cases with filters. Use suiteId to scope to a folder, search to match by title or caseId (e.g. "TC-123"), status for active/draft/deprecated, and tags for comma-separated tag filtering. Default limit is 10 — increase it if you need more results. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID. Obtain from the health tool. - `automationStatus` (`string`, optional): Automation status. Values come from Project Settings → Test Case Properties. Defaults: Manual, Automated, To Be Automated. - `behavior` (`string`, optional): Behavior. Values come from Project Settings → Test Case Properties. Defaults: Positive, Negative, Destructive, Not Set. - `layer` (`string`, optional): Layer. Values come from Project Settings → Test Case Properties. Defaults: E2E, API, Unit, Not Set. - `limit` (`integer`, optional): Maximum results to return (default 10, max 1000). - `priority` (`string`, optional): Priority. Values come from Project Settings → Test Case Properties. Defaults: Critical, High, Medium, Low, Not Set. - `search` (`string`, optional): Match by title or caseId (e.g. "TC-123"). - `severity` (`string`, optional): Severity. Values come from Project Settings → Test Case Properties. Defaults: Blocker, Critical, Major, Normal, Minor, Trivial, Not Set. - `status` (`string`, optional): Filter by test case status. One of: `active`, `draft`, `deprecated`. - `suiteId` (`string`, optional): Filter to a specific test suite folder. - `tags` (`string`, optional): Single tag or comma-separated tags. - `time` (`string`, optional): Time filter, e.g. "last 1 hour", "Yesterday", "last 7 days". - `type` (`string`, optional): Type. Values come from Project Settings → Test Case Properties. Defaults: Smoke, Regression, Functional, Integration, E2E, API, Unit, Performance, Security, Accessibility, Usability, Compatibility, Acceptance, Exploratory, Other. Example input: `{"projectId":""}` ### `testidinomcp_list_manual_test_suites` List Manual Test Suites · Read-only Get the test suite folder hierarchy for a project. Returns suite IDs, names, parent relationships, and child counts. Always call this before create_manual_test_case — you need the exact suiteName (case-sensitive) to create a test case. Pass parentSuiteId to list only the direct children of a specific suite. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_). Obtain from the health tool. - `parentSuiteId` (`string`, optional): Filter to direct children of a specific suite. Example input: `{"projectId":""}` ### `testidinomcp_list_releases` List Releases · Read-only Browse releases (milestones) for a project. Supports filtering by type, completion status, parent release, and free-text search on name. Pass parentReleaseId to get only the direct children of a release (releases nest up to 3 levels deep). Default page size is 25 (max 200). Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_). Obtain from the health tool. - `isCompleted` (`boolean`, optional): Filter by completion status. - `limit` (`integer`, optional): Items per page. Default 25, max 200. - `page` (`integer`, optional): Page number (1-indexed). - `parentReleaseId` (`string`, optional): Filter to direct children of a release. - `search` (`string`, optional): Match by release name. - `sortBy` (`string`, optional): Field to sort results by. One of: `createdAt`, `startDate`, `endDate`, `name`. - `sortOrder` (`string`, optional): Sort direction. One of: `asc`, `desc`. - `status` (`string`, optional): Release status (project-specific). - `type` (`string`, optional): Release type. Default options: "release", "version", "sprint", "iteration", "plan", "cycle", "feature". Projects can customize this list. Example input: `{"projectId":""}` ### `testidinomcp_list_run_test_cases` List Run Test Cases · Read-only Get the per-case execution records inside a manual run — what the UI shows as rows in the run's test-case table. Each row carries the test case identity (caseKey like "TC-156", title), the current assignee, and the current result/status ("untested", "passed", "failed", etc.). Filter by assignee (email or User _id) or result/status. Use this before update_run_test_case so you have the rtcRef for each case you want to update. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_). Obtain from the health tool. - `runId` (`string`, required): Internal run _id or counter-style ID (e.g. "RUN-12"). - `assignee` (`string`, optional): Filter by assignee — User _id OR email (server resolves). - `limit` (`integer`, optional): Items per page (default 25, max 200). - `page` (`integer`, optional): 1-indexed page number. - `result` (`string`, optional): Filter by result/status. Display ("Passed") or canonical ("passed") form. - `search` (`string`, optional): Match by case title or caseKey. - `sortBy` (`string`, optional): Field to sort by. One of: `createdAt`, `updatedAt`, `status`, `caseKey`. - `sortOrder` (`string`, optional): Sort direction. One of: `asc`, `desc`. - `status` (`string`, optional): Alias for result. Same normalization rules. Example input: `{"projectId":"","runId":"RUN-12"}` ### `testidinomcp_list_sessions` List Sessions · Read-only Browse exploratory sessions for a project. Filter by status (active|closed), state, sessionType, assignee, release (releaseId), tags, or free-text search on name. Default page size 25 (max 200). Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_). Obtain from the health tool. - `assigneeUserId` (`string`, optional): User _id (e.g. "user_abc...") OR email address — both are accepted. - `isClosed` (`boolean`, optional): Filter to closed sessions. - `limit` (`integer`, optional): Items per page (default 25, max 200). - `page` (`integer`, optional): 1-indexed page number. - `releaseId` (`string`, optional): Filter to sessions in this release. Pass "none" for unlinked. - `search` (`string`, optional): Match by session name. - `sessionType` (`string`, optional): Filter by session type. - `sortBy` (`string`, optional): Field to sort by. One of: `createdAt`, `updatedAt`, `name`. - `sortOrder` (`string`, optional): Sort direction. One of: `asc`, `desc`. - `state` (`string`, optional): Workflow state. Pass canonical ("new", "under_review", "done", "rejected") or display ("Under review") form — server normalizes to lowercase+underscored. - `status` (`string`, optional): Filter by status. One of: `active`, `closed`. - `tags` (`string`, optional): Single tag or comma-separated tags. Example input: `{"projectId":""}` ### `testidinomcp_list_testcase` List Test Cases · Read-only List and filter test cases across runs. Provide at least one run context: by_testrun_id, counter, by_pages, by_branch, by_time_interval, by_environment, by_author, or by_commit. Without a run context the tool returns an empty result with a warning. KEY INSIGHT: when you use by_branch, by_time_interval, by_author, or by_commit, this tool resolves the matching runs internally — you do NOT need to call list_testruns first. Combine filters freely: e.g. by_branch="main" + by_status="failed" + by_time_interval="1d" gives you all failures on main today in one call. Batch up to 20 run IDs with by_testrun_id="id1,id2,id3". Prefer specific filters and pagination over broad result sets. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID. Obtain from the health tool. - `by_artifacts` (`boolean`, optional): Filter to test cases that have artifacts. - `by_attempt_number` (`integer`, optional): Exact retry count filter. 0 means initial/no-retry cases (attempt_count=1), 1 means one retry (attempt_count=2). - `by_author` (`string`, optional): Filter by commit author, resolving matching runs internally. - `by_branch` (`string`, optional): Filter by git branch name. - `by_commit` (`string`, optional): Filter by commit, resolving matching runs internally. - `by_environment` (`string`, optional): Filter by environment label, resolving matching runs internally. - `by_pages` (`integer`, optional): Test-run page for cross-run lookup (1-indexed, newest first). MCP fetches one run-list page and uses up to 20 matching runs. - `by_shard` (`integer`, optional): 1-based shard index — scope results to a single shard of a sharded run. - `by_status` (`string`, optional): Filter by test case status. One of: `passed`, `failed`, `flaky`, `skipped`, `interrupted`, `incomplete`, `running`. - `by_tag` (`string`, optional): Comma-separated tag names. - `by_testrun_id` (`string`, optional): Single test run ID or comma-separated (max 20). - `by_testsuite_id` (`string`, optional): Filter by suite ID. - `by_time_interval` (`string`, optional): Time filter for resolving matching runs, e.g. "1h", "1d", "weekly", "monthly", "last 5 days", or "YYYY-MM-DD,YYYY-MM-DD". - `by_total_runtime` (`string`, optional): Per-test duration filter. Numbers are SECONDS by default; suffix with `ms` for milliseconds. Examples: ">10" (>10s), "<1000ms", ">5s". - `counter` (`string`, optional): Test run counter (alternative to by_testrun_id). Single run only, e.g. 47. Use by_testrun_id for batch lookup. - `limit` (`integer`, optional): Items per page. Data Handler accepts 10, 25, 50, or 100. - `page` (`integer`, optional): 1-indexed page number (default: 1). - `search` (`string`, optional): Search test title or title path. - `sort` (`string`, optional): Case list sort order. One of: `name_asc`, `name_desc`, `duration_asc`, `duration_desc`. Example input: `{"projectId":""}` ### `testidinomcp_list_testruns` List Test Runs · Read-only Browse test runs for a project with optional filters. Use this when you need run-level metadata: pass/fail totals, duration, branch, commit, author, or when you need testrun_id values for follow-up calls. Use specific filters and pagination instead of fetching broad result sets. You do NOT need to call this before list_testcase when you already have branch/time/author filters — list_testcase resolves runs internally. Common time values: "1d", "3d", "weekly", "monthly", or "YYYY-MM-DD,YYYY-MM-DD" for a custom range. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_). Obtain from the health tool. - `by_author` (`string`, optional): Filter by commit author. - `by_branch` (`string`, optional): Filter by git branch name. - `by_commit` (`string`, optional): Filter by commit hash prefix. - `by_environment` (`string`, optional): Filter by CI/deployment environment. - `by_status` (`string`, optional): Filter by run status. One of: `passed`, `failed`, `interrupted`, `incomplete`, `running`. - `by_test_case_tags` (`string`, optional): Comma-separated test case tags contained in the run. - `by_time_interval` (`string`, optional): Time filter: "1h", "1d", "weekly", "monthly", "last 5 days", or "YYYY-MM-DD,YYYY-MM-DD". - `limit` (`integer`, optional): Items per page. Data Handler accepts 10, 25, 50, or 100. - `page` (`integer`, optional): 1-indexed page number (default: 1). - `search` (`string`, optional): Search run commit message, or exact counter when numeric. - `sort` (`string`, optional): Run list sort order. One of: `counter_desc`, `counter_asc`, `duration_asc`, `duration_desc`. Example input: `{"projectId":""}` ### `testidinomcp_verify_fix` Verify Fix · Read-only Check whether a fix actually held for one test, against the run you saw when you proposed it. Splits the test's run history at that baseline and compares after against before, returning "fixed" (passing with no retries since), "not_fixed" (still failing with the same error), "changed_failure" (still failing, but a different error — a new investigation, and only when every failure since carried a comparable fingerprint), "still_failing" (still failing, but the errors cannot be compared, so neither same nor different can be claimed), "unstable" (passing only after retries, which is not fixed), "no_runs_since_baseline", or "baseline_not_found" (the run id is not one this test executed in). Call this after a new run lands. An unchanged error means the fix missed, not that the test is flaky. The baseline run must be one this test actually executed in — an id from another project or another test is rejected rather than answered. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `baseline_run_id` (`string`, required): The run you saw the failure in when you proposed the fix. - `projectId` (`string`, required): Project ID (e.g. project_). - `testcase_name` (`string`, required): Full test title, same identifier debug_testcase takes. - `suite_file_path` (`string`, optional): Spec file path — only needed when the title is shared across files. Example input: `{"baseline_run_id":"","projectId":"","testcase_name":""}` ### `testidinomcp_connect_integration` Connect Integration · Write Start the provider OAuth/connect flow for a TestDino project. The tool first checks current status and returns already_connected instead of starting OAuth when the provider is connected. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `projectId` (`string`, required): TestDino project ID. - `provider` (`string`, required): Integration provider connected to this TestDino project. One of: `jira`, `linear`, `asana`, `monday`, `github`. - `orgId` (`string`, optional): TestDino organization ID. Usually inferred from the PAT scope; pass explicitly if the token spans multiple orgs. Example input: `{"projectId":"","provider":"jira"}` ### `testidinomcp_create_external_issue` Create External Issue · Write Create a provider issue/task/item linked to a TestDino entity. Supported source types include automated and manual runs, test cases, suites, releases, and sessions. Check get_integration_status first for required provider fields. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `projectId` (`string`, required): TestDino project ID. - `provider` (`string`, required): Integration provider connected to this TestDino project. One of: `jira`, `linear`, `asana`, `monday`, `github`. - `source` (`object`, required): TestDino entity to link with the external issue. - `description` (`string`, optional): Issue body/description. Later phases can derive this from source. - `idempotencyKey` (`string`, optional): Caller-provided stable key for retrying the same create request without creating duplicates when supported downstream. - `linkBack` (`boolean`, optional): Whether TestDino should link the created external issue back to the source entity. - `preview` (`boolean`, optional): When true, resolve and return the issue draft without creating anything in the provider. - `summary` (`string`, optional): Issue title. Later phases can derive this from source. - `target` (`object`, optional): Provider-specific target/field values. Jira accepts human-readable aliases such as { jiraProjectKey: "TRX", issueType: "Bug" } or { jiraProjectName, issueTypeName }; raw { jiraProjectId, issueTypeId } also works. Linear { teamId }, Asana { workspaceId, projectId }, monday.com { boardId }. Example input: `{"projectId":"","provider":"jira","source":{}}` ### `testidinomcp_create_manual_run` Create Manual Run · Write Create a new manual test run. Requires write permission. selectionMode controls which test cases are included: "all" (default — every case in the project) or "selected" (use testCaseIds and/or suiteIds to scope). releaseId attaches the run to a release. note accepts rich HTML. IMPORTANT: tags must be a JSON array of strings — e.g. ["smoke","regression"] — NOT the comma-separated form that list_manual_runs accepts as a filter. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `name` (`string`, required): Run name. - `projectId` (`string`, required): Project ID (e.g. project_). Obtain from the health tool. - `attachments` (`array`, optional): Array of attachment objects or URLs. - `environment` (`string`, optional): Environment label, e.g. "Staging". - `forecast` (`number`, optional): Numeric forecast/target for the run. - `includeUnsorted` (`boolean`, optional): Also include cases with no suite when selectionMode="selected". - `linkedIssues` (`array`, optional): Array of linked-issue objects (same shape as list_manual_runs returns). - `links` (`array`, optional): Array of link objects with title and url. - `note` (`string`, optional): Rich HTML note. - `releaseId` (`string`, optional): Attach run to this release. - `selectionMode` (`string`, optional): Default "all". Use "selected" with testCaseIds/suiteIds to scope. One of: `all`, `selected`. - `state` (`string`, optional): Workflow state (default "new"). Either canonical ("in_progress") or display ("In Progress") form — server normalizes to lowercase+underscored. - `suiteIds` (`array`, optional): Suite IDs whose cases are included when selectionMode="selected". - `tags` (`array`, optional): Array of tag strings, e.g. ["smoke","regression"]. NOT a comma-separated string. - `testCaseIds` (`array`, optional): Case IDs to include when selectionMode="selected". Example input: `{"name":"","projectId":""}` ### `testidinomcp_create_manual_test_case` Create Manual Test Case · Write Create a new manual test case. Requires write permission. MANDATORY FIRST STEP: always call list_manual_test_suites() before this tool to get the exact suite name — suiteName must be an exact match, not approximate. Steps default to Classic format (action + expectedResult). Set testStepsDeclarationType="Gherkin" if using Given/When/Then steps. Classic step shape: { action, expectedResult, data, attachments }. Gherkin step shape: { event: "Given"|"When"|"And"|"Then"|"But", stepDescription, attachments }. Use top-level attachments for whole-test-case files, or step.attachments for files tied to a specific step. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `projectId` (`string`, required): Project ID. Obtain from the health tool. - `suiteName` (`string`, required): Target suite name (exact match required — get from list_manual_test_suites first). - `title` (`string`, required): Test case title. - `attachments` (`array`, optional): Whole-test-case attachments as URLs, local paths, or file data objects. - `automationStatus` (`string`, optional): Automation status. Values come from Project Settings → Test Case Properties. Defaults: Manual, Automated, To Be Automated. - `behavior` (`string`, optional): Behavior. Values come from Project Settings → Test Case Properties. Defaults: Positive, Negative, Destructive, Not Set. - `customFields` (`object`, optional): Custom fields defined in project settings. - `description` (`string`, optional): Test case description. - `flags` (`array`, optional): Automation flags/checklist values. - `layer` (`string`, optional): Layer. Values come from Project Settings → Test Case Properties. Defaults: E2E, API, Unit, Not Set. - `postconditions` (`string`, optional): Postconditions for the test case. - `preconditions` (`string`, optional): Preconditions for the test case. - `priority` (`string`, optional): Priority. Values come from Project Settings → Test Case Properties. Defaults: Critical, High, Medium, Low, Not Set. - `severity` (`string`, optional): Severity. Values come from Project Settings → Test Case Properties. Defaults: Blocker, Critical, Major, Normal, Minor, Trivial, Not Set. - `status` (`string`, optional): Status. Values come from Project Settings → Test Case Properties. Defaults: Active, Draft, Deprecated. - `steps` (`array`, optional): Array of test steps. Classic shape: { action, expectedResult, data, attachments }. Gherkin shape: { event: "Given"|"When"|"And"|"Then"|"But", stepDescription, attachments }. - `tags` (`string`, optional): Comma-separated tag names. - `testStepsDeclarationType` (`string`, optional): Step format: "Classic" (action + expectedResult) or "Gherkin" (Given/When/Then). One of: `Classic`, `Gherkin`. - `type` (`string`, optional): Type. Values come from Project Settings → Test Case Properties. Defaults: Smoke, Regression, Functional, Integration, E2E, API, Unit, Performance, Security, Accessibility, Usability, Compatibility, Acceptance, Exploratory, Other. Example input: `{"projectId":"","suiteName":"","title":""}` ### `testidinomcp_create_manual_test_suite` Create Manual Test Suite · Write Create a new test suite folder for organizing manual test cases. Requires write permission. Use parentSuiteId to nest it under an existing suite — get the ID from list_manual_test_suites() first. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `name` (`string`, required): Suite name. - `projectId` (`string`, required): Project ID (e.g. project_<id>). Obtain from the health tool. - `description` (`string`, optional): Optional description for the test suite. - `parentSuiteId` (`string`, optional): ID of the parent suite to nest this suite under. Obtain from list_manual_test_suites(). Example input: `{"name":"<name>","projectId":"<projectId>"}` ### `testidinomcp_create_release` Create Release · Write Create a new release. Requires write permission. Use parentReleaseId to nest under another release (max 3 levels deep). startDate/endDate are ISO date strings. isStarted/isCompleted are independent flags — startedAt/completedAt are recorded separately. branch/environment/buildTarget/testers describe what build the release ships and who tests it (testers must be org members — pass User _ids). Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `name` (`string`, required): Release name. - `projectId` (`string`, required): Project ID (e.g. project_<id>). Obtain from the health tool. - `branch` (`string`, optional): Source branch this release ships from. - `buildTarget` (`object`, optional): Build the release cuts against: { platform: "web"|"ios"|"android"|"api", version, buildNumber, source, deployUrl }. - `completedAt` (`string`, optional): ISO datetime when the release was completed. - `description` (`string`, optional): Optional description for the release. - `endDate` (`string`, optional): End date as ISO date string (e.g. 2026-07-31). - `environment` (`string`, optional): Environment label this release targets, e.g. "Staging". - `isCompleted` (`boolean`, optional): Whether the release is completed. - `isStarted` (`boolean`, optional): Whether the release has started. - `linkedIssues` (`array`, optional): Array of linked-issue objects (same shape as list_releases returns). - `note` (`string`, optional): Rich HTML note. - `parentReleaseId` (`string`, optional): ID of the parent release to nest under (max 3 levels deep). - `startDate` (`string`, optional): Start date as ISO date string (e.g. 2026-07-01). - `startedAt` (`string`, optional): ISO datetime when the release started. - `testers` (`array`, optional): User _ids assigned as testers. Must be members of the org. - `type` (`string`, optional): Release type. Default options: "release", "version", "sprint", "iteration", "plan", "cycle", "feature" (case-insensitive). Example input: `{"name":"<name>","projectId":"<projectId>"}` ### `testidinomcp_create_session` Create Session · Write Create a new exploratory testing session. Requires write permission. mission accepts rich HTML (the high-level charter). assigneeUserId accepts either a User _id ("user_abc...") or an email address — the email is resolved against TestDino users automatically. estimate is in minutes. Findings are not available via MCP — add them in the UI. IMPORTANT: tags must be a JSON array of strings — e.g. ["exploratory","auth"] — NOT the comma-separated form that list_sessions accepts as a filter. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `name` (`string`, required): Session name. - `projectId` (`string`, required): Project ID (e.g. project_<id>). Obtain from the health tool. - `assigneeUserId` (`string`, optional): User _id ("user_abc...") OR email address — both accepted. Email is looked up server-side. - `attachments` (`array`, optional): Array of attachment objects or URLs. - `config` (`string`, optional): Session configuration. - `environment` (`string`, optional): Environment label, e.g. "Staging". - `estimate` (`integer`, optional): Estimate in minutes. - `linkedIssues` (`array`, optional): Array of linked-issue objects (same shape as list_sessions returns). - `mission` (`string`, optional): Rich HTML mission/charter. - `releaseId` (`string`, optional): Attach session to this release. - `sessionType` (`string`, optional): Free-text type, e.g. "Exploratory", "Regression". - `state` (`string`, optional): Workflow state (default "new"). Either canonical ("under_review") or display ("Under review") form — server normalizes to lowercase+underscored. - `tags` (`array`, optional): Array of tag strings, e.g. ["exploratory","auth"]. NOT a comma-separated string. Example input: `{"name":"<name>","projectId":"<projectId>"}` ### `testidinomcp_submit_audit_report` Submit Audit Report · Write FINAL STEP of the TestDino Playwright audit flow — submits a completed audit report. Requires write permission. Call this only AFTER get_audit_report(action='context') and after you have analyzed the local Playwright code and produced findings. score (0-100) and markdownReport are required; include findings, recommendations, reportName, branch, scope, and target as available. orgId is required — resolve it via health() if you do not have it. Every finding MUST include title, summary, and severity (low|medium|high|critical) — incomplete findings are rejected, not stored. category is normalized to a known bucket. target, if sent, accepts only { value, path } as non-empty strings. Use the same branch/scope/target you passed to get_audit_report(action='context') so the report attaches to the right context. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `markdownReport` (`string`, required): Completed markdown report (required). - `projectId` (`string`, required): Project ID (required). - `score` (`number`, required): Final audit score 0-100 (required). - `branch` (`string`, optional): Git branch that was audited. - `findings` (`array`, optional): Structured findings for the completed report. - `orgId` (`string`, optional): Organization ID (required to submit). Resolve via health() if you don't have it. - `recommendations` (`array`, optional): Recommendation strings for the completed report. - `reportName` (`string`, optional): Short human-readable title for the saved report. - `scope` (`string`, optional): Audit scope. Defaults to 'suite'. One of: `testcase`, `feature`, `spec_file`, `suite`. - `target` (`object`, optional): Optional scoped-audit target. Only { value, path } (non-empty strings) are stored — the dashboard reads these; any other key is rejected. Example input: `{"markdownReport":"<markdownReport>","projectId":"<projectId>","score":1}` ### `testidinomcp_update_manual_run` Update Manual Run · Write Modify an existing manual test run. Send only fields you want to change inside the updates object. Requires write permission. Allowed fields: name, note, environment, releaseId, state, forecast, tags, linkedIssues, attachments, links, selectionMode. Pass updates.status="closed" to close the run (same as the UI "Close run" button: freezes it, snapshots remaining cases). This is not reversible via MCP. IMPORTANT: updates.tags must be a JSON array of strings — e.g. ["smoke","regression"] — NOT a comma-separated string. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_<id>). Obtain from the health tool. - `runId` (`string`, required): Internal _id or counter-style ID (e.g. "RUN-12"). - `updates` (`object`, required): Fields to update: name, note, environment, releaseId, state, forecast, tags, linkedIssues, attachments, links, selectionMode. status="closed" closes the run. Example input: `{"projectId":"<projectId>","runId":"RUN-12","updates":{}}` ### `testidinomcp_update_manual_test_case` Update Manual Test Case · Write Modify an existing manual test case. Send only the fields you want to change inside the updates object — omit everything else. Requires write permission. IMPORTANT: steps is a full replacement — passing a steps array overwrites all existing steps. Always call get_manual_test_case() first to read current steps before modifying them. For attachments use the nested shape: { add: ["url-or-path"], remove: ["attachment-id"] } — you can add and remove in the same call. To add comments, pass updates.comments as an array of comment-body strings — each is appended as a new comment. Cap of 20 comments/case is enforced. To link issues, pass updates.issues as an array of ticket keys (e.g. ["PROJ-123","ENG-9"]). Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `caseId` (`string`, required): Internal _id or human-readable ID like "TC-123". - `projectId` (`string`, required): Project ID. Obtain from the health tool. - `updates` (`object`, required): Fields to update: title (alias: name), description, preconditions, postconditions, status, steps (full replacement), priority, severity, type, layer, behavior, automationStatus, tags, flags, attachments {add, remove}, customFields, comments (array of strings to append), issues (array of ticket keys to link via Jira lookup). Example input: `{"caseId":"<caseId>","projectId":"<projectId>","updates":{}}` ### `testidinomcp_update_release` Update Release · Write Modify an existing release. Send only the fields you want to change inside the updates object. Requires write permission. Fields: name, description, note, type, startDate, endDate, isStarted, isCompleted, startedAt, completedAt, linkedIssues, branch, environment, buildTarget, testers, parentReleaseId. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_<id>). Obtain from the health tool. - `releaseId` (`string`, required): Internal _id or counter-style ID (e.g. MS-12). - `updates` (`object`, required): Fields to update: name, description, note, type, startDate, endDate, isStarted, isCompleted, startedAt, completedAt, linkedIssues, branch, environment, buildTarget ({platform,version,buildNumber,source,deployUrl}), testers (User _ids, org members), parentReleaseId. Example input: `{"projectId":"<projectId>","releaseId":"<releaseId>","updates":{}}` ### `testidinomcp_update_run_test_case` Update Run Test Case · Write Update one test case inside a manual run. Two modes: (1) Quick verdict — pass updates.assigneeUserId and/or updates.result/status to assign and set a result. (2) Detailed result — additionally pass updates.comment, updates.linkedIssues, updates.attachments, or updates.stepResults to log a full result entry. NOTE: combining updates.assigneeUserId with any detailed-result field in one call is rejected — make two separate calls. Requires write permission. rtcRef accepts the caseKey ("TC-156"), the internal tcm_rtc_... RTC ID, or the underlying test case _id. Closed runs reject result writes. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_<id>). Obtain from the health tool. - `rtcRef` (`string`, required): Per-case record reference — tcm_rtc_... _id, caseKey ("TC-156"), or underlying test case _id. - `runId` (`string`, required): Internal run _id or counter-style ID (e.g. "RUN-12"). - `updates` (`object`, required): Quick verdict: assigneeUserId (email or _id), result/status (display or canonical), elapsed (seconds). Detailed result: comment (rich HTML), linkedIssues, attachments, stepResults ([{ order, status, comment }]). Example input: `{"projectId":"<projectId>","rtcRef":"<rtcRef>","runId":"RUN-12","updates":{}}` ### `testidinomcp_update_session` Update Session · Write Modify an existing exploratory session. Send only fields you want to change inside the updates object. Requires write permission. Allowed fields: name, mission, sessionType, config, environment, releaseId, assigneeUserId, state, estimate, tags, linkedIssues, attachments. Pass updates.status="closed" to close the session (same as the UI "Close session" button: freezes it, snaps state to the project's "Done" option). This is not reversible via MCP. IMPORTANT: updates.tags must be a JSON array of strings — e.g. ["exploratory","auth"] — NOT a comma-separated string. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `projectId` (`string`, required): Project ID (e.g. project_<id>). Obtain from the health tool. - `sessionId` (`string`, required): Internal _id or counter-style ID (e.g. "SES-12"). - `updates` (`object`, required): Fields to update: name, mission, sessionType, config, environment, releaseId, assigneeUserId, state, estimate, tags, linkedIssues, attachments. status="closed" closes the session. Example input: `{"projectId":"<projectId>","sessionId":"SES-12","updates":{}}` ## Related Other Developer Tools connectors ([all 94](/agentkit/connectors/?category=developer-tools)): - [GitHub](/agentkit/connectors/github/): Scalekit connector, OAuth, 217 tools - [Datadog](/agentkit/connectors/datadog/): Scalekit connector, API key, 105 tools - [Linear](/agentkit/connectors/linear/): Scalekit connector, OAuth, 62 tools --- ## More Scalekit documentation | Resource | What it contains | When to use it | |----------|-----------------|----------------| | [/llms.txt](/llms.txt) | Structured index with routing hints per product area | Start here — find which documentation set covers your topic before loading full content | | [/llms-full.txt](/llms-full.txt) | Complete documentation for all Scalekit products in one file | Use when you need exhaustive context across multiple products or when the topic spans several areas | | [sitemap-0.xml](https://docs.scalekit.com/sitemap-0.xml) | Full URL list of every documentation page | Use to discover specific page URLs you can fetch for targeted, page-level answers |