@debugg-ai/debugg-ai-mcp 2.9.7 → 3.0.1

package/dist/types/index.js

@@ -25,7 +25,7 @@ export const TriggerCrawlInputSchema = z.object({
     credentialRole: z.string().optional(),
     username: z.string().optional(),
     password: z.string().optional(),
-    headless: z.boolean().optional(),
+    // headless is intentionally NOT accepted — the MCP always runs headless (D7).
     timeoutSeconds: z.number().int().positive().max(1800, 'timeoutSeconds cannot exceed 1800 (30 min)').optional(),
     repoName: z.string().optional(),
 }).strict();
@@ -220,3 +220,57 @@ export const GetTestSuiteResultsInputSchema = z.object({
     ...suiteIdentifier,
     ...projectIdentifier,
 }).strict();
+// ── Consolidated action-based tool schemas (epic yg7o6: 20 → 8 tools) ─────────
+// Each entity tool takes a required `action` discriminator; params validate
+// per-action. Delete branches carry an optional `confirm` (guarded by D2).
+const _page = z.number().int().min(1).optional();
+const _pageSize = z.number().int().min(1).optional();
+export const ProjectInputSchema = z.discriminatedUnion('action', [
+    z.object({ action: z.literal('get'), uuid: z.string().uuid() }).strict(),
+    z.object({ action: z.literal('list'), q: z.string().min(1).optional(), page: _page, pageSize: _pageSize }).strict(),
+    z.object({
+        action: z.literal('create'),
+        name: z.string().min(1),
+        platform: z.string().min(1),
+        teamUuid: z.string().uuid().optional(),
+        teamName: z.string().min(1).optional(),
+        repoUuid: z.string().uuid().optional(),
+        repoName: z.string().min(1).optional(),
+    }).strict(),
+]).superRefine((v, ctx) => {
+    if (v.action === 'create') {
+        if (v.teamUuid && v.teamName)
+            ctx.addIssue({ code: 'custom', message: 'Provide teamUuid OR teamName, not both.' });
+        if (v.repoUuid && v.repoName)
+            ctx.addIssue({ code: 'custom', message: 'Provide repoUuid OR repoName, not both.' });
+        if (!v.teamUuid && !v.teamName)
+            ctx.addIssue({ code: 'custom', message: 'Must provide teamUuid or teamName.' });
+        if (!v.repoUuid && !v.repoName)
+            ctx.addIssue({ code: 'custom', message: 'Must provide repoUuid or repoName.' });
+    }
+});
+export const EnvironmentInputSchema = z.discriminatedUnion('action', [
+    z.object({ action: z.literal('get'), uuid: z.string().uuid(), projectUuid: z.string().uuid().optional() }).strict(),
+    z.object({ action: z.literal('list'), projectUuid: z.string().uuid().optional(), q: z.string().min(1).optional(), page: _page, pageSize: _pageSize }).strict(),
+    z.object({ action: z.literal('create'), name: z.string().min(1), url: z.string().url('url is required for standard environments'), description: z.string().optional(), projectUuid: z.string().uuid().optional(), credentials: z.array(CredentialSeedSchema).optional() }).strict(),
+    z.object({ action: z.literal('update'), uuid: z.string().uuid(), name: z.string().min(1).optional(), url: z.string().url().optional(), description: z.string().optional(), projectUuid: z.string().uuid().optional(), addCredentials: z.array(CredentialSeedSchema).optional(), updateCredentials: z.array(CredentialUpdateSchema).optional(), removeCredentialIds: z.array(z.string().uuid()).optional() }).strict(),
+    z.object({ action: z.literal('delete'), uuid: z.string().uuid(), projectUuid: z.string().uuid().optional(), confirm: z.boolean().optional() }).strict(),
+]);
+export const TestSuiteInputSchema = z.discriminatedUnion('action', [
+    z.object({ action: z.literal('list'), ...projectIdentifier, search: z.string().optional(), page: _page, pageSize: z.number().int().min(1).max(100).optional() }).strict(),
+    z.object({ action: z.literal('create'), name: z.string().min(1), description: z.string().min(1), ...projectIdentifier }).strict(),
+    z.object({ action: z.literal('run'), ...suiteIdentifier, ...projectIdentifier, targetUrl: z.string().url().optional() }).strict(),
+    z.object({ action: z.literal('results'), ...suiteIdentifier, ...projectIdentifier }).strict(),
+    z.object({ action: z.literal('delete'), ...suiteIdentifier, ...projectIdentifier, confirm: z.boolean().optional() }).strict(),
+]);
+export const TestCaseInputSchema = z.discriminatedUnion('action', [
+    z.object({ action: z.literal('create'), name: z.string().min(1), description: z.string().min(1), agentTaskDescription: z.string().min(1), ...suiteIdentifier, ...projectIdentifier, relativeUrl: z.string().regex(/^\//, 'Must start with /').optional(), maxSteps: z.number().int().min(1).max(100).optional() }).strict(),
+    z.object({ action: z.literal('update'), testUuid: z.string().uuid(), name: z.string().min(1).optional(), description: z.string().min(1).optional(), agentTaskDescription: z.string().min(1).optional() }).strict(),
+    z.object({ action: z.literal('delete'), testUuid: z.string().uuid(), confirm: z.boolean().optional() }).strict(),
+]);
+// NOTE: D6 (recency sort) deferred — the backend listExecutions has no ordering
+// param; threading real sort needs a backend change. Tracked, not shipped here.
+export const ExecutionsInputSchema = z.discriminatedUnion('action', [
+    z.object({ action: z.literal('get'), uuid: z.string().uuid() }).strict(),
+    z.object({ action: z.literal('list'), projectUuid: z.string().uuid().optional(), status: z.string().min(1).optional(), page: _page, pageSize: _pageSize }).strict(),
+]);

package/dist/utils/confirmDestructive.js

@@ -0,0 +1,48 @@
+/**
+ * Destructive-action guard (epic debugg_ai_mcp-yg7o6, decision D2).
+ *
+ * Consolidated entity tools expose a `delete` action. Before any delete runs we
+ * require confirmation:
+ *   - If the client supports elicitation (ctx.elicit present), prompt for it.
+ *   - Otherwise fall back to a required `confirm: true` argument.
+ *
+ * This keeps deletes safe on EVERY client without depending on the elicitation
+ * epic — that epic only has to populate `ctx.elicit`; the confirm-arg path here
+ * ships standalone.
+ */
+/** Action names treated as destructive. Currently just `delete`. */
+export const DESTRUCTIVE_ACTIONS = new Set(['delete']);
+export function isDestructiveAction(action) {
+    return DESTRUCTIVE_ACTIONS.has(action);
+}
+function refusal(error, message) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify({ error, message }, null, 2) }],
+        isError: true,
+    };
+}
+/**
+ * Gate a destructive action.
+ *
+ * @returns `null` to proceed, or a `ToolResponse` (isError) to abort the call.
+ */
+export async function ensureConfirmed(action, label, input, ctx) {
+    if (!isDestructiveAction(action))
+        return null;
+    if (ctx.elicit) {
+        const res = await ctx.elicit({
+            message: `Delete ${label}? This cannot be undone.`,
+            requestedSchema: {
+                type: 'object',
+                properties: { confirm: { type: 'boolean', description: 'Confirm deletion of ' + label } },
+                required: ['confirm'],
+            },
+        });
+        if (res.action === 'accept' && res.content?.confirm === true)
+            return null;
+        return refusal('confirmation_declined', `Deletion of ${label} was not confirmed.`);
+    }
+    if (input.confirm === true)
+        return null;
+    return refusal('confirmation_required', `Refusing to delete ${label} without confirmation. Pass confirm:true, or use an elicitation-capable client.`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@debugg-ai/debugg-ai-mcp",
-  "version": "2.9.7",
+  "version": "3.0.1",
   "description": "Zero-Config, Fully AI-Managed End-to-End Testing for all code gen platforms.",
   "type": "module",
   "bin": {

package/dist/handlers/deleteProjectHandler.js

@@ -1,39 +0,0 @@
-import { Logger } from '../utils/logger.js';
-import { handleExternalServiceError } from '../utils/errors.js';
-import { DebuggAIServerClient } from '../services/index.js';
-import { config } from '../config/index.js';
-const logger = new Logger({ module: 'deleteProjectHandler' });
-function notFound(uuid) {
-    return {
-        content: [{ type: 'text', text: JSON.stringify({
-                    error: 'NotFound',
-                    message: `Project ${uuid} not found.`,
-                    uuid,
-                }, null, 2) }],
-        isError: true,
-    };
-}
-export async function deleteProjectHandler(input, _context) {
-    const start = Date.now();
-    logger.toolStart('delete_project', { uuid: input.uuid });
-    try {
-        const client = new DebuggAIServerClient(config.api.key);
-        await client.init();
-        try {
-            await client.deleteProject(input.uuid);
-            logger.toolComplete('delete_project', Date.now() - start);
-            return {
-                content: [{ type: 'text', text: JSON.stringify({ deleted: true, uuid: input.uuid }, null, 2) }],
-            };
-        }
-        catch (err) {
-            if (err?.statusCode === 404 || err?.response?.status === 404)
-                return notFound(input.uuid);
-            throw err;
-        }
-    }
-    catch (error) {
-        logger.toolError('delete_project', error, Date.now() - start);
-        throw handleExternalServiceError(error, 'DebuggAI', 'delete_project');
-    }
-}

package/dist/handlers/updateProjectHandler.js

@@ -1,45 +0,0 @@
-import { Logger } from '../utils/logger.js';
-import { handleExternalServiceError } from '../utils/errors.js';
-import { DebuggAIServerClient } from '../services/index.js';
-import { config } from '../config/index.js';
-const logger = new Logger({ module: 'updateProjectHandler' });
-function notFound(uuid) {
-    return {
-        content: [{ type: 'text', text: JSON.stringify({
-                    error: 'NotFound',
-                    message: `Project ${uuid} not found.`,
-                    uuid,
-                }, null, 2) }],
-        isError: true,
-    };
-}
-export async function updateProjectHandler(input, _context) {
-    const start = Date.now();
-    logger.toolStart('update_project', {
-        uuid: input.uuid,
-        patchKeys: Object.keys(input).filter(k => k !== 'uuid'),
-    });
-    try {
-        const client = new DebuggAIServerClient(config.api.key);
-        await client.init();
-        try {
-            const project = await client.updateProject(input.uuid, {
-                name: input.name,
-                description: input.description,
-            });
-            logger.toolComplete('update_project', Date.now() - start);
-            return {
-                content: [{ type: 'text', text: JSON.stringify({ updated: true, project }, null, 2) }],
-            };
-        }
-        catch (err) {
-            if (err?.statusCode === 404 || err?.response?.status === 404)
-                return notFound(input.uuid);
-            throw err;
-        }
-    }
-    catch (error) {
-        logger.toolError('update_project', error, Date.now() - start);
-        throw handleExternalServiceError(error, 'DebuggAI', 'update_project');
-    }
-}

package/dist/tools/createEnvironment.js

@@ -1,46 +0,0 @@
-import { CreateEnvironmentInputSchema } from '../types/index.js';
-import { createEnvironmentHandler } from '../handlers/createEnvironmentHandler.js';
-const DESCRIPTION = `Create a new environment under a DebuggAI project. Both name and url are required (backend rejects standard environments without a URL). Optional description. Defaults to the project resolved from the current git repo; pass projectUuid to target a different project (get UUIDs via search_projects).
-
-OPTIONAL credentials seed: pass \`credentials: [{label, username, password, role?}]\` to create login credentials alongside the environment in a single call. Each cred is created best-effort; failures go to \`credentialWarnings\` without blocking env creation. Passwords are write-only and NEVER returned.
-
-Returns the created environment's uuid (and the seeded credentials, if any). Reference the env uuid when running check_app_in_browser.`;
-export function buildCreateEnvironmentTool() {
-    return {
-        name: 'create_environment',
-        title: 'Create Project Environment',
-        description: DESCRIPTION,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: {
-                    type: 'string',
-                    description: 'Short label for the environment (e.g. "staging", "production"). Required.',
-                    minLength: 1,
-                },
-                url: {
-                    type: 'string',
-                    description: 'Base URL for the environment (e.g. https://staging.example.com). Required.',
-                },
-                description: {
-                    type: 'string',
-                    description: 'Optional: free-text description.',
-                },
-                projectUuid: {
-                    type: 'string',
-                    description: 'Optional: UUID of the target project. Defaults to the project resolved from the current git repo.',
-                },
-            },
-            required: ['name', 'url'],
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedCreateEnvironmentTool() {
-    const tool = buildCreateEnvironmentTool();
-    return {
-        ...tool,
-        inputSchema: CreateEnvironmentInputSchema,
-        handler: createEnvironmentHandler,
-    };
-}

package/dist/tools/createProject.js

@@ -1,27 +0,0 @@
-import { CreateProjectInputSchema } from '../types/index.js';
-import { createProjectHandler } from '../handlers/createProjectHandler.js';
-const DESCRIPTION = `Create a new DebuggAI project. Required: name, platform (e.g. "web"), plus a team and a repo. Team and repo each accept EITHER a UUID or a name: pass teamUuid OR teamName, and repoUuid OR repoName. Name resolution does a backend search with case-insensitive exact match (returns AmbiguousMatch with candidates on multiple hits, NotFound on no hit). The repo must be GitHub-linked to the account. Returns {created: true, project: {uuid, name, slug, platform, repoName, ...}}.`;
-export function buildCreateProjectTool() {
-    return {
-        name: 'create_project',
-        title: 'Create Project',
-        description: DESCRIPTION,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Project name. Required.', minLength: 1 },
-                platform: { type: 'string', description: 'Platform (e.g. "web"). Required.', minLength: 1 },
-                teamUuid: { type: 'string', description: 'Team UUID. Provide teamUuid OR teamName, not both.' },
-                teamName: { type: 'string', description: 'Team name (backend-resolved, case-insensitive exact match). Provide teamUuid OR teamName, not both.' },
-                repoUuid: { type: 'string', description: 'GitHub repo UUID. Provide repoUuid OR repoName, not both. Repo must be GitHub-linked.' },
-                repoName: { type: 'string', description: 'GitHub repo name, e.g. "org/repo" (backend-resolved, case-insensitive exact match). Provide repoUuid OR repoName, not both.' },
-            },
-            required: ['name', 'platform'],
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedCreateProjectTool() {
-    const tool = buildCreateProjectTool();
-    return { ...tool, inputSchema: CreateProjectInputSchema, handler: createProjectHandler };
-}

package/dist/tools/deleteEnvironment.js

@@ -1,23 +0,0 @@
-import { DeleteEnvironmentInputSchema } from '../types/index.js';
-import { deleteEnvironmentHandler } from '../handlers/deleteEnvironmentHandler.js';
-const DESCRIPTION = `Delete an environment by UUID. Returns {deleted: true, uuid}. Destructive — cascades per backend behavior (credentials under the env are typically removed). Defaults to the project resolved from the current git repo; pass projectUuid to target a different project. Returns isError:true with NotFound when the uuid doesn't exist or was already deleted.`;
-export function buildDeleteEnvironmentTool() {
-    return {
-        name: 'delete_environment',
-        title: 'Delete Environment',
-        description: DESCRIPTION,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                uuid: { type: 'string', description: 'UUID of the environment to delete. Required.' },
-                projectUuid: { type: 'string', description: 'Optional: UUID of the target project. Defaults to git-auto-detect.' },
-            },
-            required: ['uuid'],
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedDeleteEnvironmentTool() {
-    const tool = buildDeleteEnvironmentTool();
-    return { ...tool, inputSchema: DeleteEnvironmentInputSchema, handler: deleteEnvironmentHandler };
-}

package/dist/tools/deleteProject.js

@@ -1,22 +0,0 @@
-import { DeleteProjectInputSchema } from '../types/index.js';
-import { deleteProjectHandler } from '../handlers/deleteProjectHandler.js';
-const DESCRIPTION = `Delete a project by UUID. Returns {deleted:true, uuid}. **DESTRUCTIVE** — removes the project and its associated environments, credentials, and test history. No undo. Returns isError:true + NotFound when already deleted or uuid doesn't exist.`;
-export function buildDeleteProjectTool() {
-    return {
-        name: 'delete_project',
-        title: 'Delete Project',
-        description: DESCRIPTION,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                uuid: { type: 'string', description: 'UUID of the project to delete. Required.' },
-            },
-            required: ['uuid'],
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedDeleteProjectTool() {
-    const tool = buildDeleteProjectTool();
-    return { ...tool, inputSchema: DeleteProjectInputSchema, handler: deleteProjectHandler };
-}

package/dist/tools/searchEnvironments.js

@@ -1,35 +0,0 @@
-import { SearchEnvironmentsInputSchema } from '../types/index.js';
-import { searchEnvironmentsHandler } from '../handlers/searchEnvironmentsHandler.js';
-const DESCRIPTION = `Search or look up environments, with credentials expanded inline per environment.
-
-Two modes:
-  - uuid mode: {"uuid": "<env-uuid>"} → single env with full detail + its credentials. NotFound if the uuid doesn't exist.
-  - filter mode: omit uuid, optionally {"q": "<keyword>", "projectUuid", "page", "pageSize"} → paginated envs, each with its credentials.
-
-Project resolution: if projectUuid is omitted, the current git repo's origin is auto-resolved to a DebuggAI project. Returns {error:"NoProjectResolved", environments:[]} if neither is available.
-
-Credentials are returned inline per env as {uuid, label, username, role}. Password is NEVER returned — the handler defensively strips it regardless of what the service layer provides.
-
-Response: {project, filter, pageInfo, environments[]} — each environment includes a credentials[] array.`;
-export function buildSearchEnvironmentsTool() {
-    return {
-        name: 'search_environments',
-        title: 'Search Environments',
-        description: DESCRIPTION,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                uuid: { type: 'string', description: 'Environment UUID. Returns single env with credentials inline. Mutually exclusive with projectUuid/q filter params.' },
-                projectUuid: { type: 'string', description: 'Override the auto-detected project. Used in filter mode.' },
-                q: { type: 'string', description: 'Free-text search over environment name. Mutually exclusive with uuid.' },
-                page: { type: 'number', description: 'Page number (1-indexed).' },
-                pageSize: { type: 'number', description: 'Page size (1..200). Default 20.' },
-            },
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedSearchEnvironmentsTool() {
-    const tool = buildSearchEnvironmentsTool();
-    return { ...tool, inputSchema: SearchEnvironmentsInputSchema, handler: searchEnvironmentsHandler };
-}

package/dist/tools/searchExecutions.js

@@ -1,31 +0,0 @@
-import { SearchExecutionsInputSchema } from '../types/index.js';
-import { searchExecutionsHandler } from '../handlers/searchExecutionsHandler.js';
-const DESCRIPTION = `Search or look up workflow executions (history of check_app_in_browser, trigger_crawl, and other workflow runs).
-
-Two modes:
-  - uuid mode: {"uuid": "<execution-uuid>"} → single execution with FULL detail including nodeExecutions, state, errorInfo. NotFound if the uuid doesn't exist.
-  - filter mode: {"status": "completed"|"running"|"failed"|"cancelled", "projectUuid": "...", "page", "pageSize"} → paginated summaries.
-
-Response shape: {filter, pageInfo, executions[]}. Summary items have outcome/status/durationMs/timestamps; uuid-mode items additionally have nodeExecutions + state + errorInfo.`;
-export function buildSearchExecutionsTool() {
-    return {
-        name: 'search_executions',
-        title: 'Search Workflow Executions',
-        description: DESCRIPTION,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                uuid: { type: 'string', description: 'Execution UUID. Returns single execution with full detail. Mutually exclusive with projectUuid/status filters.' },
-                projectUuid: { type: 'string', description: 'Filter by project UUID.' },
-                status: { type: 'string', description: 'Filter by status: completed | running | failed | cancelled | pending.' },
-                page: { type: 'number', description: 'Page number (1-indexed).' },
-                pageSize: { type: 'number', description: 'Page size (1..200). Default 20.' },
-            },
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedSearchExecutionsTool() {
-    const tool = buildSearchExecutionsTool();
-    return { ...tool, inputSchema: SearchExecutionsInputSchema, handler: searchExecutionsHandler };
-}

package/dist/tools/searchProjects.js

@@ -1,30 +0,0 @@
-import { SearchProjectsInputSchema } from '../types/index.js';
-import { searchProjectsHandler } from '../handlers/searchProjectsHandler.js';
-const DESCRIPTION = `Search or look up projects.
-
-Two modes:
-  - uuid mode: pass {"uuid": "<project-uuid>"} → returns that project with the curated detail view (uuid, name, slug, platform, repoName, description, status, language, framework, timestamp, lastMod), or isError:true NotFound.
-  - filter mode: omit uuid, optionally pass {"q": "<keyword>", "page": 1, "pageSize": 20} → returns a paginated list of summaries (uuid, name, slug, repoName).
-
-Response shape is always {filter, pageInfo, projects[]}. uuid mode returns exactly one project; filter mode returns summaries.`;
-export function buildSearchProjectsTool() {
-    return {
-        name: 'search_projects',
-        title: 'Search Projects',
-        description: DESCRIPTION,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                uuid: { type: 'string', description: 'Project UUID. When provided, returns exactly that project with full detail. Mutually exclusive with q.' },
-                q: { type: 'string', description: 'Free-text search (backend-side). Mutually exclusive with uuid.' },
-                page: { type: 'number', description: 'Page number (1-indexed). Default 1.' },
-                pageSize: { type: 'number', description: 'Page size (1..200). Default 20.' },
-            },
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedSearchProjectsTool() {
-    const tool = buildSearchProjectsTool();
-    return { ...tool, inputSchema: SearchProjectsInputSchema, handler: searchProjectsHandler };
-}

package/dist/tools/testSuiteTools.js

@@ -1,183 +0,0 @@
-import { CreateTestSuiteInputSchema, SearchTestSuitesInputSchema, DeleteTestSuiteInputSchema, CreateTestCaseInputSchema, UpdateTestCaseInputSchema, DeleteTestCaseInputSchema, RunTestSuiteInputSchema, GetTestSuiteResultsInputSchema, } from '../types/index.js';
-import { createTestSuiteHandler } from '../handlers/createTestSuiteHandler.js';
-import { searchTestSuitesHandler } from '../handlers/searchTestSuitesHandler.js';
-import { deleteTestSuiteHandler } from '../handlers/deleteTestSuiteHandler.js';
-import { createTestCaseHandler } from '../handlers/createTestCaseHandler.js';
-import { updateTestCaseHandler } from '../handlers/updateTestCaseHandler.js';
-import { deleteTestCaseHandler } from '../handlers/deleteTestCaseHandler.js';
-import { runTestSuiteHandler } from '../handlers/runTestSuiteHandler.js';
-import { getTestSuiteResultsHandler } from '../handlers/getTestSuiteResultsHandler.js';
-const PROJECT_PROPS = {
-    projectUuid: { type: 'string', description: 'Project UUID. Provide projectUuid OR projectName.' },
-    projectName: { type: 'string', description: 'Project name (case-insensitive exact match). Provide projectUuid OR projectName.' },
-};
-const SUITE_PROPS = {
-    suiteUuid: { type: 'string', description: 'Test suite UUID. Provide suiteUuid OR (suiteName + project identifier).' },
-    suiteName: { type: 'string', description: 'Test suite name (case-insensitive exact match). Requires projectUuid or projectName.' },
-};
-// ── create_test_suite ─────────────────────────────────────────────────────────
-export function buildCreateTestSuiteTool() {
-    return {
-        name: 'create_test_suite',
-        title: 'Create Test Suite',
-        description: 'Create a named test suite for a project. A test suite is a collection of test cases that can be run together. Requires name, description, and a project identifier (projectUuid or projectName). Returns {uuid, name, description, runStatus, testsCount}.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Suite name. Required.', minLength: 1 },
-                description: { type: 'string', description: 'Suite description. Required.', minLength: 1 },
-                ...PROJECT_PROPS,
-            },
-            required: ['name', 'description'],
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedCreateTestSuiteTool() {
-    return { ...buildCreateTestSuiteTool(), inputSchema: CreateTestSuiteInputSchema, handler: createTestSuiteHandler };
-}
-// ── search_test_suites ────────────────────────────────────────────────────────
-export function buildSearchTestSuitesTool() {
-    return {
-        name: 'search_test_suites',
-        title: 'Search Test Suites',
-        description: 'List and search test suites for a project. Returns paginated results with suite status, test counts, pass rates, and last run timestamps. Requires a project identifier (projectUuid or projectName). Optional: search text filter, page, pageSize (1-100, default 20).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                ...PROJECT_PROPS,
-                search: { type: 'string', description: 'Optional text filter applied to suite name and description.' },
-                page: { type: 'number', description: 'Page number (default 1).', minimum: 1 },
-                pageSize: { type: 'number', description: 'Results per page (default 20, max 100).', minimum: 1, maximum: 100 },
-            },
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedSearchTestSuitesTool() {
-    return { ...buildSearchTestSuitesTool(), inputSchema: SearchTestSuitesInputSchema, handler: searchTestSuitesHandler };
-}
-// ── delete_test_suite ─────────────────────────────────────────────────────────
-export function buildDeleteTestSuiteTool() {
-    return {
-        name: 'delete_test_suite',
-        title: 'Delete Test Suite',
-        description: 'Disable (soft-delete) a test suite. The suite and its tests are hidden from default list queries but not permanently removed. Accepts suiteUuid directly, or suiteName + project identifier for name-based lookup. Returns {deleted: true, suiteUuid}.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                ...SUITE_PROPS,
-                ...PROJECT_PROPS,
-            },
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedDeleteTestSuiteTool() {
-    return { ...buildDeleteTestSuiteTool(), inputSchema: DeleteTestSuiteInputSchema, handler: deleteTestSuiteHandler };
-}
-// ── create_test_case ──────────────────────────────────────────────────────────
-export function buildCreateTestCaseTool() {
-    return {
-        name: 'create_test_case',
-        title: 'Create Test Case',
-        description: 'Create an individual test case and assign it to a test suite. The test is NOT automatically executed. Requires name, description, agentTaskDescription (the AI agent\'s goal), and suite + project identifiers. Optional: relativeUrl (must start with "/") and maxSteps (1-100). Returns {uuid, name, description, agentTaskDescription, suite, project, runCount}.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Test case name. Required.', minLength: 1 },
-                description: { type: 'string', description: 'Test case description. Required.', minLength: 1 },
-                agentTaskDescription: { type: 'string', description: 'Natural language description of what the AI agent should do and verify. Required.', minLength: 1 },
-                ...SUITE_PROPS,
-                ...PROJECT_PROPS,
-                relativeUrl: { type: 'string', description: 'Optional starting URL path relative to the app root, e.g. "/login". Must start with "/".' },
-                maxSteps: { type: 'number', description: 'Maximum agent steps (1-100).', minimum: 1, maximum: 100 },
-            },
-            required: ['name', 'description', 'agentTaskDescription'],
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedCreateTestCaseTool() {
-    return { ...buildCreateTestCaseTool(), inputSchema: CreateTestCaseInputSchema, handler: createTestCaseHandler };
-}
-// ── update_test_case ──────────────────────────────────────────────────────────
-export function buildUpdateTestCaseTool() {
-    return {
-        name: 'update_test_case',
-        title: 'Update Test Case',
-        description: 'Update a test case\'s name, description, or agentTaskDescription. Requires testUuid. At least one of name, description, or agentTaskDescription must be provided. Returns the updated test case.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                testUuid: { type: 'string', description: 'UUID of the test case to update. Required.' },
-                name: { type: 'string', description: 'New name for the test case.', minLength: 1 },
-                description: { type: 'string', description: 'New description.', minLength: 1 },
-                agentTaskDescription: { type: 'string', description: 'New agent task description.', minLength: 1 },
-            },
-            required: ['testUuid'],
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedUpdateTestCaseTool() {
-    return { ...buildUpdateTestCaseTool(), inputSchema: UpdateTestCaseInputSchema, handler: updateTestCaseHandler };
-}
-// ── delete_test_case ──────────────────────────────────────────────────────────
-export function buildDeleteTestCaseTool() {
-    return {
-        name: 'delete_test_case',
-        title: 'Delete Test Case',
-        description: 'Disable (soft-delete) a test case. The test is hidden from default list queries but not permanently removed. Requires testUuid. Returns {deleted: true, testUuid}.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                testUuid: { type: 'string', description: 'UUID of the test case to delete. Required.' },
-            },
-            required: ['testUuid'],
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedDeleteTestCaseTool() {
-    return { ...buildDeleteTestCaseTool(), inputSchema: DeleteTestCaseInputSchema, handler: deleteTestCaseHandler };
-}
-// ── run_test_suite ────────────────────────────────────────────────────────────
-export function buildRunTestSuiteTool() {
-    return {
-        name: 'run_test_suite',
-        title: 'Run Test Suite',
-        description: 'Trigger all test cases in a suite to run asynchronously. Accepts suiteUuid directly, or suiteName + project identifier. Optional: targetUrl to override the default test target. Returns {suiteUuid, runStatus, testsTriggered, note}. Use get_test_suite_results to poll for results.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                ...SUITE_PROPS,
-                ...PROJECT_PROPS,
-                targetUrl: { type: 'string', description: 'Optional URL to run tests against (overrides default). Must be a full URL.' },
-            },
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedRunTestSuiteTool() {
-    return { ...buildRunTestSuiteTool(), inputSchema: RunTestSuiteInputSchema, handler: runTestSuiteHandler };
-}
-// ── get_test_suite_results ────────────────────────────────────────────────────
-export function buildGetTestSuiteResultsTool() {
-    return {
-        name: 'get_test_suite_results',
-        title: 'Get Test Suite Results',
-        description: 'Fetch a test suite with full per-test results. Returns suite-level status (NEVER_RUN, PENDING, RUNNING, COMPLETED, ERROR), pass rate, last run timestamp, and per-test outcomes (PASS, FAIL, ERROR, TIMEOUT, etc.) with execution times. Accepts suiteUuid directly or suiteName + project identifier.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                ...SUITE_PROPS,
-                ...PROJECT_PROPS,
-            },
-            additionalProperties: false,
-        },
-    };
-}
-export function buildValidatedGetTestSuiteResultsTool() {
-    return { ...buildGetTestSuiteResultsTool(), inputSchema: GetTestSuiteResultsInputSchema, handler: getTestSuiteResultsHandler };
-}