Testdino MCP

Live

OAUTH 2.1

TEST ANALYTICS

Developer Tools

Playwright runs, flaky tests, and failure traces sit in TestDino, and test analytics become agent-readable through per-user OAuth 2.1 scoped to the projects that user can open.

  • Acts as the user: run and test-case reads follow the authorizing user's project access, so results stay inside their team.
  • Credentials stay vaulted: AES-256, resolved at request time, never in LLM context.
  • Scoped before every call: User permissions enforced. 90-day audit trail.
Testdino MCP
agent · Acme Q3
Run
Why is checkout.spec.ts flaky on main this week?
S
testidinomcp_debug_testcase
174ms
QA agent
Fails 7 of 41 runs, all on a race waiting for the payment iframe. Median failure adds 4.2s before timeout. Stable on Firefox, flaky on Chromium.
Sources: 41 runs, 1 test case, 7 failures
testidinomcp
41 runs
18:29
Message Claude...

Tools your QA agent reaches for on TestDino, scoped per user.

CALL ANY TOOL
Test analytics for Playwright: run breakdowns, per-case errors and traces, AI root cause on flaky tests, audit reports, manual suites, releases, and exploratory sessions.
testidinomcp_list_manual_runs
List manual runs
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).
Parameters
Name
Type
Required
Description
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.
sortOrder
string
Optional
Sort direction.
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.
tags
string
Optional
Single tag or comma-separated tags.
testidinomcp_get_audit_report
Get audit report
testidinomcp_create_manual_run
Create manual run
testidinomcp_update_manual_run
Update manual run
testidinomcp_list_manual_test_cases
List manual test cases
testidinomcp_get_manual_run
Get manual run
testidinomcp_create_manual_test_case
Create manual test case
testidinomcp_update_manual_test_case
Update manual test case
testidinomcp_list_manual_test_suites
List manual test suites
testidinomcp_get_manual_test_case
Get manual test case
testidinomcp_create_manual_test_suite
Create manual test suite
testidinomcp_update_release
Update release
testidinomcp_list_releases
List releases
testidinomcp_get_release
Get release
testidinomcp_create_release
Create release
testidinomcp_update_run_test_case
Update run test case
testidinomcp_list_run_test_cases
List run test cases
testidinomcp_get_run_details
Get run details
testidinomcp_create_session
Create session
testidinomcp_update_session
Update session
testidinomcp_list_sessions
List sessions
testidinomcp_get_session
Get session
testidinomcp_list_testcase
List testcase
testidinomcp_get_testcase_details
Get testcase details
testidinomcp_list_testruns
List testruns
testidinomcp_debug_testcase
Debug testcase
testidinomcp_health
Health
testidinomcp_submit_audit_report
Submit audit report
Build your Agent
Drop the toolkit in, point it at the user, and your agent can pull run details and debug flaky tests from the first run.
Python · LlamaIndex
import { ScalekitClient } from "@scalekit-sdk/node";
import { DynamicStructuredTool } from "@langchain/core/tools";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { z } from "zod";

const sk = new ScalekitClient(envUrl, clientId, clientSecret);

const { tools } = await sk.tools.listScopedTools("user_123", {
filter: { connectionNames: ["testidinomcp"], toolNames: ["testidinomcp_get_run_details", "testidinomcp_debug_testcase", "testidinomcp_list_manual_runs"] },
pageSize: 100,
});

const lcTools = tools.map((t) => new DynamicStructuredTool({
name: t.tool.definition.name,
description: t.tool.definition.description,
schema: z.object({}).passthrough(),
func: async (args) => {
const { data } = await sk.tools.executeTool({
toolName: t.tool.definition.name,
identifier: "user_123",
params: args,
});
return JSON.stringify(data);
},
}));

const agent = createReactAgent({ llm, tools: lcTools });
import { ScalekitClient } from "@scalekit-sdk/node";
import OpenAI from "openai";

const sk = new ScalekitClient(envUrl, clientId, clientSecret);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
filter: { connectionNames: ["testidinomcp"], toolNames: ["testidinomcp_get_run_details", "testidinomcp_debug_testcase", "testidinomcp_list_manual_runs"] },
pageSize: 100,
});

const llmTools = tools.map((t) => ({
type: "function",
function: {
name: t.tool.definition.name,
description: t.tool.definition.description,
parameters: t.tool.definition.input_schema,
},
}));

const resp = await openai.responses.create({
model: "gpt-4o", input: prompt, tools: llmTools,
});
import { ScalekitClient } from "@scalekit-sdk/node";
import Anthropic from "@anthropic-ai/sdk";

const sk = new ScalekitClient(envUrl, clientId, clientSecret);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
filter: { connectionNames: ["testidinomcp"], toolNames: ["testidinomcp_get_run_details", "testidinomcp_debug_testcase", "testidinomcp_list_manual_runs"] },
pageSize: 100,
});

const llmTools = tools.map((t) => ({
name: t.tool.definition.name,
description: t.tool.definition.description,
input_schema: t.tool.definition.input_schema,
}));

const msg = await anthropic.messages.create({
model: "claude-sonnet-4-6", max_tokens: 1024,
tools: llmTools,
messages: [{ role: "user", content: prompt }],
});
import { Agent } from "@google/adk/agents";
import {
MCPToolset, StreamableHTTPConnectionParams,
} from "@google/adk/tools/mcp";

const toolset = new MCPToolset({
connectionParams: new StreamableHTTPConnectionParams({
url: "https://mcp.scalekit.com/testidinomcp",
headers: { Authorization: `Bearer ${userScopedToken}` },
}),
});

const agent = new Agent({
name: "agent", model: "gemini-2.0-flash",
tools: await toolset.getTools(),
});
Try these prompts
Paste any prompt into your agent to start pulling TestDino results into your workflows.
Failure triage
Copy the prompt
Copied
Why is [spec_file] flaky on main this week?
Copy the prompt
Copied
Show the error category breakdown for run [run_id].
Copy the prompt
Copied
List test cases that failed in the last 3 runs but passed before.
Run reporting
Copy the prompt
Copied
Summarize the latest run for project [project_id].
Copy the prompt
Copied
Compare pass rate across the last 10 runs.
Copy the prompt
Copied
Pull the stack trace and console logs for test case [case_id].
Manual QA
Copy the prompt
Copied
Browse manual test runs still in progress for [project_id].
Copy the prompt
Copied
Create a release for v2.4 and link the open runs.
Copy the prompt
Copied
List exploratory sessions closed this sprint with their missions.
SEE HOW AUTH WORKS
Your users connect once. Their Testdino MCP credentials stay vaulted, every call is scope-checked, and every action is logged.
1
Authorize
Your user connects
Testdino MCP
once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access
Who:
user ‘A’
when:
Once per user
access:
Limited to user
2
Store
Their
Testdino MCP
token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection
vault:
encrypted
scope:
per-user
tokens:
auto-refreshed
3
Resolve
When your agent calls a
Testdino MCP
tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs
speed:
~40ms
check:
before every call
seen by:
nobody
4
Audit
Every
Testdino MCP
tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it
history:
90 days
export:
SIEM-ready
logged:
every call
Test other agents
See the same per-user auth pattern across other connectors.
ENGINEERING
DevOps assistant agent
Poll GitHub for failing checks and stale pull requests, open Linear issues for the ones that need work, and digest to Slack.
ENGINEERING
Auto-release notes agent
Group merged GitHub PRs into structured release notes, publish the page to Notion, and announce the release in Slack.
Why Scalekit
Secure your agent's access. Connectors ship in minutes
Other connector libraries treat auth as a demo afterthought. Scalekit starts with user identity, scope enforcement, and audit.
01.
Shared tokens break per-user analytics
A shared token looks fine in a demo. In production every call looks like a service account. Scalekit resolves the real user credential so attribution, audit, and scope stay accurate.
// shared token
audit → bot_service_account
user_filter → broken

// scalekit
audit → user_abc
scope → enforced ✓
02.
Authentication is not authorization
03.
Multi-tenancy is architectural
04.
Testdino MCP today. Others tomorrow.
“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”
Venu Madhav Kattagoni
Head of Engineering / Von
FAQs
Frequently Asked Questions
Does the agent access Testdino MCP as the user or as a shared key?
As the user. Each workspace member authorizes once and Scalekit resolves their credential at request time. Audit logs attribute every action to that user, not a shared service account.
Where is the Testdino MCP OAuth token stored?
In Scalekit's managed AES-256 token vault, namespaced per tenant. Refresh is automatic. Revocation is a single dashboard action. Tokens never appear in prompts, logs, or LLM context.
Can I limit what the agent is allowed to do in Testdino MCP?
Yes. Pass a tool name filter to listScopedTools so the DevOps agent only sees the subset you authorize. Pre-API-call scope checks block out-of-policy actions before the request reaches Testdino MCP.
What happens when a user revokes Testdino MCP access?
The connection is invalidated on the next tool call. Subsequent requests for that user fail closed with a clear error. Other users in the tenant remain unaffected. The event is logged for audit.
Does the agent get access to every TestDino project?
Only the projects the authorizing user can already open, and only at that user's permission level. Read tools work with read access, while manual-run and release writes need write permission. Scalekit resolves the user's OAuth 2.1 credential per call and logs each one.
Start in your coding agent
Up and running in one command
Install the Scalekit skill in your editor of choice. Connector, auth, tools, prompt, all wired up
Claude Code REPL
/plugin marketplace add scalekit-inc/claude-code-authstack
/plugin install agentkit@scalekit-auth-stack
Cursor Code REPL
# ~/.cursor/mcp.json
{
""mcpServers"": {
""testidinomcp"": {
""url"": ""https://mcp.scalekit.com/testidinomcp"",
""headers"": { ""Authorization"": ""Bearer $SCALEKIT_TOKEN"" }
}
}
}
Codex Code REPL
# ~/.codex/config.toml
[mcp_servers.testidinomcp]
url = ""https://mcp.scalekit.com/testidinomcp""
auth_env = ""SCALEKIT_TOKEN""
Copilot Code REPL
# .vscode/mcp.json
{
""servers"": {
""testidinomcp"": {
""url"": ""https://mcp.scalekit.com/testidinomcp"",
""type"": ""http""
}
}
}