@alternative-path/qa-path-mcp 1.0.0

package/dist/tools/auth-tools.js

@@ -0,0 +1,66 @@
+import { jsonResponse } from "../utils/mcp-response.js";
+import { API_KEY } from "../constants.js";
+export class AuthTools {
+    apiClient;
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    getTools() {
+        return [
+            {
+                name: "check_auth_status",
+                description: "Check if the MCP server is currently authenticated with the API. When authenticated, returns the logged-in user (id, username, user_email).",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        ];
+    }
+    handles(name) {
+        return name === "check_auth_status";
+    }
+    async handle(name, args) {
+        if (name === "check_auth_status") {
+            return await this.checkAuthStatus(args);
+        }
+        throw new Error(`Unknown auth tool: ${name}`);
+    }
+    async checkAuthStatus(args) {
+        const isAuthenticated = this.apiClient.getIsAuthenticated();
+        if (!isAuthenticated) {
+            return jsonResponse({
+                authenticated: false,
+                message: `MCP server is not authenticated. Set ${API_KEY} and restart the MCP server.`,
+            });
+        }
+        try {
+            const response = await this.apiClient.get("auth/getCurrentLoggedInUser");
+            const user = response.data?.user;
+            const roles = user?.roles;
+            const roleNames = Array.isArray(roles)
+                ? roles.map((r) => (typeof r === "string" ? r : r.name ?? String(r)))
+                : undefined;
+            return jsonResponse({
+                authenticated: true,
+                message: "MCP server is authenticated",
+                user: user
+                    ? {
+                        id: user.id,
+                        username: user.username,
+                        user_email: user.user_email,
+                        roles: roleNames ?? user.roles,
+                    }
+                    : undefined,
+            });
+        }
+        catch (error) {
+            return jsonResponse({
+                authenticated: false,
+                message: `Session may have expired or could not retrieve user. Set ${API_KEY} and restart the MCP server.`,
+                error: error?.message || String(error),
+            });
+        }
+    }
+}
+//# sourceMappingURL=auth-tools.js.map

package/dist/tools/auth-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-tools.js","sourceRoot":"","sources":["../../src/tools/auth-tools.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE1C,MAAM,OAAO,SAAS;IACA;IAApB,YAAoB,SAAoB;QAApB,cAAS,GAAT,SAAS,CAAW;IAAG,CAAC;IAE5C,QAAQ;QACN,OAAO;YACL;gBACE,IAAI,EAAE,mBAAmB;gBACzB,WAAW,EACT,6IAA6I;gBAC/I,WAAW,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE,EAAE;iBACf;aACF;SACF,CAAC;IACJ,CAAC;IAED,OAAO,CAAC,IAAY;QAClB,OAAO,IAAI,KAAK,mBAAmB,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,IAAY,EAAE,IAAS;QAClC,IAAI,IAAI,KAAK,mBAAmB,EAAE,CAAC;YACjC,OAAO,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAC1C,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,sBAAsB,IAAI,EAAE,CAAC,CAAC;IAChD,CAAC;IAEO,KAAK,CAAC,eAAe,CAAC,IAAS;QACrC,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,kBAAkB,EAAE,CAAC;QAE5D,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,OAAO,YAAY,CAAC;gBAClB,aAAa,EAAE,KAAK;gBACpB,OAAO,EACL,wCAAwC,OAAO,8BAA8B;aAChF,CAAC,CAAC;QACL,CAAC;QAED,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAYtC,6BAA6B,CAAC,CAAC;YAElC,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;YACjC,MAAM,KAAK,GAAG,IAAI,EAAE,KAAK,CAAC;YAC1B,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;gBACpC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAE,CAAuB,CAAC,IAAI,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC5F,CAAC,CAAC,SAAS,CAAC;YACd,OAAO,YAAY,CAAC;gBAClB,aAAa,EAAE,IAAI;gBACnB,OAAO,EAAE,6BAA6B;gBACtC,IAAI,EAAE,IAAI;oBACR,CAAC,CAAC;wBACE,EAAE,EAAE,IAAI,CAAC,EAAE;wBACX,QAAQ,EAAE,IAAI,CAAC,QAAQ;wBACvB,UAAU,EAAE,IAAI,CAAC,UAAU;wBAC3B,KAAK,EAAE,SAAS,IAAI,IAAI,CAAC,KAAK;qBAC/B;oBACH,CAAC,CAAC,SAAS;aACd,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,OAAO,YAAY,CAAC;gBAClB,aAAa,EAAE,KAAK;gBACpB,OAAO,EACL,4DAA4D,OAAO,8BAA8B;gBACnG,KAAK,EAAE,KAAK,EAAE,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC;aACvC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;CACF"}

package/dist/tools/automation-tools.d.ts

@@ -0,0 +1,28 @@
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { ApiClient } from "../api-client.js";
+import { ProjectContextService } from "../services/project-context-service.js";
+export declare class AutomationTools {
+    private apiClient;
+    private projectContext;
+    constructor(apiClient: ApiClient, projectContext: ProjectContextService);
+    getTools(): Tool[];
+    handles(name: string): boolean;
+    handle(name: string, args: any): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    private getCurrentUserInfo;
+    private getOrganizationServiceUrl;
+    private formatInstructions;
+    private runExecutionOverWebSocket;
+    private generateNlpScript;
+    private formatToolOutput;
+    private parseExecutionTime;
+    private parseStatus;
+    private sanitizeForJSON;
+    private formattedResponse;
+    private jsonResponse;
+}
+//# sourceMappingURL=automation-tools.d.ts.map

package/dist/tools/automation-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automation-tools.d.ts","sourceRoot":"","sources":["../../src/tools/automation-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAO/E,qBAAa,eAAe;IAExB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,cAAc;gBADd,SAAS,EAAE,SAAS,EACpB,cAAc,EAAE,qBAAqB;IAG/C,QAAQ,IAAI,IAAI,EAAE;IAqClB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIxB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG;;;;;;YAOtB,kBAAkB;YAkBlB,yBAAyB;IAgBvC,OAAO,CAAC,kBAAkB;YASZ,yBAAyB;YAqKzB,iBAAiB;IA6M/B,OAAO,CAAC,gBAAgB;IAuDxB,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,WAAW;IAanB,OAAO,CAAC,eAAe;IAyBvB,OAAO,CAAC,iBAAiB;IAyBzB,OAAO,CAAC,YAAY;CAGrB"}

package/dist/tools/automation-tools.js

@@ -0,0 +1,541 @@
+import { textResponse } from "../utils/mcp-response.js";
+import { io } from "socket.io-client";
+const WS_PATH = "/test-automation/socket.io/";
+const EXECUTION_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+export class AutomationTools {
+    apiClient;
+    projectContext;
+    constructor(apiClient, projectContext) {
+        this.apiClient = apiClient;
+        this.projectContext = projectContext;
+    }
+    getTools() {
+        return [
+            {
+                name: "generate_nlp_script",
+                description: "Generate an automation script from NLP instructions using the Script Creator flow: runs the AI agent to interpret and execute the instructions, then saves the generated script to the specified test case. Returns execution logs and test steps in the response (not streamed in real time). Requires modelId (UUID). If the user provided a model by name, call list_llm_models first, map the name to the id from the response, then call this tool with that modelId.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        nlpInstructions: {
+                            type: "string",
+                            description: "NLP instructions (one per line or newline-separated). Example: 'open https://example.com\\nClick on Login\\nEnter username and password'",
+                        },
+                        modelId: {
+                            type: "string",
+                            description: "ID of the AI model to use for automation (required). Get ids from list_llm_models. If the user gave a model by name, call list_llm_models and map the name to the id, then pass it here.",
+                        },
+                        testCaseId: {
+                            type: "string",
+                            description: "UUID of the test case where the generated automation script will be saved (required for save step).",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project set via 'set_active_project'. " +
+                                "If no active project is set, the tool will return an error with instructions on how to set one.",
+                        },
+                    },
+                    required: ["nlpInstructions", "testCaseId"],
+                },
+            },
+        ];
+    }
+    handles(name) {
+        return name === "generate_nlp_script";
+    }
+    async handle(name, args) {
+        if (name === "generate_nlp_script") {
+            return await this.generateNlpScript(args);
+        }
+        throw new Error(`Unknown automation tool: ${name}`);
+    }
+    async getCurrentUserInfo() {
+        const response = await this.apiClient.get("auth/getCurrentLoggedInUser");
+        const user = response.data?.user;
+        if (!user?.id) {
+            throw new Error("Could not get current user. Please ensure you are logged in.");
+        }
+        if (!user.org_id) {
+            throw new Error("Organization ID is required but not found in user session. Please ensure you are logged in with a valid user account.");
+        }
+        return {
+            userId: user.id,
+            organizationId: user.org_id,
+        };
+    }
+    async getOrganizationServiceUrl(projectId) {
+        try {
+            const url = projectId
+                ? `organization/getServiceUrl?projectId=${projectId}`
+                : `organization/getServiceUrl`;
+            const response = await this.apiClient.get(url);
+            return response.data?.agentServiceUrl;
+        }
+        catch (error) {
+            // If organization service URL fetch fails, return undefined to use default
+            return undefined;
+        }
+    }
+    formatInstructions(nlpInstructions) {
+        // Match frontend format: split into array of {id, text} objects
+        const lines = nlpInstructions
+            .split(/\r?\n/)
+            .map((s) => s.trim())
+            .filter(Boolean);
+        return lines.map((text, i) => ({ id: i + 1, text }));
+    }
+    async runExecutionOverWebSocket(params) {
+        const { instructionsArray, modelId, projectId, userId, organizationId, wsUrl: providedWsUrl } = params;
+        const wsUrl = providedWsUrl;
+        if (!wsUrl || typeof wsUrl !== "string" || wsUrl.trim() === "") {
+            throw new Error("WebSocket URL is required for automation. Ensure the organization service returns agentServiceUrl.");
+        }
+        let origin;
+        try {
+            origin = new URL(wsUrl).origin;
+        }
+        catch {
+            throw new Error("Could not derive Origin from WebSocket URL. Ensure the organization service returns a valid agentServiceUrl.");
+        }
+        const uniqueId = `mcp_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+        const executionLogs = [];
+        const testSteps = [];
+        let tokenUsage = null;
+        const urlsToTry = [wsUrl];
+        try {
+            const baseUrl = this.apiClient.client?.defaults?.baseURL;
+            if (baseUrl)
+                urlsToTry.push(baseUrl);
+        }
+        catch (_) { }
+        let cookieString = "";
+        for (const u of urlsToTry) {
+            try {
+                const c = await this.apiClient.getCookieStringForUrl(u);
+                if (c && c.length > cookieString.length)
+                    cookieString = c;
+            }
+            catch (_) { }
+        }
+        return new Promise((resolve) => {
+            let socket = null;
+            let replayPlan = null;
+            let testCompleteResult = null;
+            let resolved = false;
+            const finish = (err) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                if (socket) {
+                    socket.removeAllListeners();
+                    socket.disconnect();
+                }
+                if (err) {
+                    resolve({ plan: null, error: err, executionLogs, testSteps, tokenUsage });
+                }
+                else {
+                    resolve({
+                        plan: replayPlan || testCompleteResult?.testPlan,
+                        error: testCompleteResult?.error,
+                        executionLogs,
+                        testSteps,
+                        tokenUsage,
+                    });
+                }
+            };
+            const timeout = setTimeout(() => {
+                finish("Execution timed out (5 minutes). The automation agent may still be running.");
+            }, EXECUTION_TIMEOUT_MS);
+            try {
+                const socketOptions = {
+                    path: WS_PATH,
+                    transports: ["polling", "websocket"],
+                    reconnection: false,
+                    forceNew: true,
+                    withCredentials: true,
+                    extraHeaders: {
+                        Origin: origin,
+                        ...(cookieString && { Cookie: cookieString }),
+                    },
+                };
+                // Log connection attempt for debugging
+                socket = io(wsUrl, socketOptions);
+                socket.on("connect", () => {
+                    // Match frontend format exactly: pass instructions array directly
+                    socket.emit("executeTest", {
+                        testId: uniqueId,
+                        instructions: instructionsArray,
+                        model: modelId,
+                        environmentId: null,
+                        executionContext: {
+                            projectId,
+                            organizationId,
+                            userId,
+                        },
+                        projectId,
+                    });
+                });
+                socket.on("connect_error", (err) => {
+                    clearTimeout(timeout);
+                    const msg = err?.message || "Connection failed";
+                    const extra = [err?.description, err?.context].filter(Boolean).join("; ");
+                    finish(extra ? `${msg}. ${extra}` : msg);
+                });
+                socket.on("disconnect", (reason) => {
+                    // Disconnect handled silently
+                });
+                socket.on("log", (data) => {
+                    if (data && typeof data === "object") {
+                        const logMessage = data.message ?? data.text ?? JSON.stringify(data);
+                        executionLogs.push({
+                            ...data,
+                            timestamp: data.timestamp ?? Date.now(),
+                            message: logMessage,
+                            level: data.level ?? "info",
+                        });
+                    }
+                });
+                socket.on("testStep", (step) => {
+                    if (step && typeof step === "object") {
+                        testSteps.push({
+                            ...step,
+                            timestamp: step.timestamp ?? Date.now(),
+                            id: step.id ?? `step_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+                        });
+                    }
+                });
+                socket.on("tokenUsage", (usage) => {
+                    if (usage && typeof usage === "object")
+                        tokenUsage = usage;
+                });
+                socket.on("replayPlan", (data) => {
+                    if (data)
+                        replayPlan = data;
+                });
+                socket.on("testComplete", (result) => {
+                    testCompleteResult = result;
+                    clearTimeout(timeout);
+                    finish(result?.error);
+                });
+                socket.on("error", (err) => {
+                    clearTimeout(timeout);
+                    finish(err?.message || String(err));
+                });
+            }
+            catch (err) {
+                clearTimeout(timeout);
+                finish(err?.message || String(err));
+            }
+        });
+    }
+    async generateNlpScript(args) {
+        const { nlpInstructions, modelId, testCaseId } = args;
+        const projectId = this.projectContext.resolveProjectId(args, "generate_nlp_script");
+        if (!nlpInstructions || typeof nlpInstructions !== "string") {
+            return this.jsonResponse({
+                success: false,
+                message: "nlpInstructions (string) is required.",
+            });
+        }
+        if (!testCaseId) {
+            return this.jsonResponse({
+                success: false,
+                message: "testCaseId is required.",
+            });
+        }
+        if (!modelId) {
+            return this.jsonResponse({
+                success: false,
+                error_code: "MODEL_REQUIRED",
+                message: "modelId is required.",
+                ACTION_REQUIRED: [
+                    "Call list_llm_models to fetch the available LLM models.",
+                    "If the user provided a model by name, map it to the id from the list (e.g. match by name).",
+                    "Ask the user to choose one if needed, then retry generate_nlp_script with modelId set to the chosen id.",
+                ],
+            });
+        }
+        // Format instructions to match frontend format: array of {id, text} objects
+        const instructionsArray = this.formatInstructions(nlpInstructions);
+        const { userId, organizationId } = await this.getCurrentUserInfo();
+        // Get organization-specific WebSocket URL
+        const orgServiceUrl = await this.getOrganizationServiceUrl(projectId);
+        const { plan, error: executionError, executionLogs, testSteps, tokenUsage, } = await this.runExecutionOverWebSocket({
+            instructionsArray,
+            modelId,
+            projectId,
+            userId,
+            organizationId,
+            wsUrl: orgServiceUrl,
+        });
+        // Helper to sanitize arrays for JSON serialization
+        const sanitizeArray = (arr, fields) => {
+            return arr.map(item => {
+                const sanitized = {};
+                for (const field of fields) {
+                    if (item[field] !== undefined && item[field] !== null) {
+                        sanitized[field] = item[field];
+                    }
+                }
+                return sanitized;
+            });
+        };
+        if (executionError) {
+            const sanitizedLogs = sanitizeArray(executionLogs.slice(-100), ['message', 'level', 'timestamp']);
+            const sanitizedSteps = sanitizeArray(testSteps.slice(-50), ['stepDescription', 'passed', 'timestamp', 'id']);
+            return this.jsonResponse({
+                success: false,
+                message: "Automation execution failed.",
+                error: executionError,
+                executionLogs: sanitizedLogs,
+                testSteps: sanitizedSteps,
+            });
+        }
+        if (!plan || !plan.steps) {
+            const sanitizedLogs = sanitizeArray(executionLogs.slice(-100), ['message', 'level', 'timestamp']);
+            const sanitizedSteps = sanitizeArray(testSteps.slice(-50), ['stepDescription', 'passed', 'timestamp', 'id']);
+            return this.jsonResponse({
+                success: false,
+                message: "No automation plan was generated. The agent may not have produced steps.",
+                executionLogs: sanitizedLogs,
+                testSteps: sanitizedSteps,
+            });
+        }
+        try {
+            await this.apiClient.put(`${projectId}/auto-execution/updateExecutionRecord`, {
+                testCaseId,
+                plan,
+            });
+        }
+        catch (err) {
+            return this.jsonResponse({
+                success: false,
+                message: "Failed to save execution record to test case.",
+                error: err?.message || String(err),
+                executionLogs: executionLogs.slice(-100),
+                testSteps: testSteps.slice(-50),
+            });
+        }
+        // instructionsArray is already in the correct format: Array<{id: number, text: string}>
+        // Ensure all text fields are non-empty strings and ids are integers
+        const automationInstruction = instructionsArray
+            .filter(item => item.text && item.text.trim().length > 0)
+            .map(item => ({
+            id: Number(item.id),
+            text: String(item.text).trim(),
+        }));
+        if (automationInstruction.length === 0) {
+            // No valid automation instructions to save
+        }
+        else {
+            try {
+                await this.apiClient.put(`${projectId}/auto-execution/updateAutomationInstruction`, { testCaseId, automationInstruction });
+            }
+            catch (err) {
+                const sanitizedTestSteps = testSteps.slice(-50).map(step => ({
+                    stepDescription: step.stepDescription,
+                    expectedOutcome: step.expectedOutcome,
+                    actualOutcome: step.actualOutcome,
+                    confidence: step.confidence,
+                    passed: step.passed,
+                    reason: step.reason,
+                    isFinal: step.isFinal,
+                    timestamp: step.timestamp,
+                    screenshotPath: step.screenshotPath,
+                    executionId: step.executionId,
+                    id: step.id,
+                }));
+                const sanitizedExecutionLogs = executionLogs.slice(-100).map(log => ({
+                    message: log.message,
+                    level: log.level,
+                    timestamp: log.timestamp,
+                }));
+                return this.jsonResponse({
+                    success: true,
+                    message: "Execution record saved, but automation instruction text could not be updated.",
+                    testCaseId,
+                    executionRecordSaved: true,
+                    error: err?.message || String(err),
+                    executionLogs: sanitizedExecutionLogs,
+                    testSteps: sanitizedTestSteps,
+                    stepsCount: Array.isArray(plan.steps) ? plan.steps.length : 0,
+                });
+            }
+        }
+        const sanitizedTestSteps = testSteps.slice(-50).map(step => ({
+            stepDescription: step.stepDescription,
+            expectedOutcome: step.expectedOutcome,
+            actualOutcome: step.actualOutcome,
+            confidence: step.confidence,
+            passed: step.passed,
+            reason: step.reason,
+            isFinal: step.isFinal,
+            timestamp: step.timestamp,
+            screenshotPath: step.screenshotPath,
+            executionId: step.executionId,
+            locator: step.locator,
+            code: step.code,
+            duration: step.duration,
+            id: step.id,
+            playwrightAssertion: step.playwrightAssertion ? {
+                code: step.playwrightAssertion.code,
+                type: step.playwrightAssertion.type,
+                description: step.playwrightAssertion.description,
+                passed: step.playwrightAssertion.passed,
+                comment: step.playwrightAssertion.comment,
+            } : null,
+        }));
+        const sanitizedExecutionLogs = executionLogs.slice(-100).map(log => ({
+            message: log.message,
+            level: log.level,
+            timestamp: log.timestamp,
+        }));
+        return this.jsonResponse({
+            success: true,
+            message: "NLP script generated and saved to the test case successfully.",
+            testCaseId,
+            stepsCount: Array.isArray(plan.steps) ? plan.steps.length : 0,
+            executionLogs: sanitizedExecutionLogs,
+            testSteps: sanitizedTestSteps,
+            tokenUsage: tokenUsage ? {
+                input: tokenUsage.input,
+                output: tokenUsage.output,
+                total: tokenUsage.total,
+                iterations: tokenUsage.iterations?.length || 0,
+            } : undefined,
+        });
+    }
+    formatToolOutput(obj) {
+        const success = obj.success === true;
+        const message = obj.message || "";
+        if (success && obj.models?.length) {
+            const names = obj.models.map((m) => m.name ?? m.id).join(", ");
+            return `**${message}**\n\nAvailable models: ${names}`;
+        }
+        if (!success && !obj.executionLogs?.length) {
+            let out = `**${message}**`;
+            if (obj.error)
+                out += `\n\nError: ${obj.error}`;
+            if (obj.models?.length) {
+                out += `\n\nAvailable models: ${obj.models.map((m) => m.name ?? m.id).join(", ")}`;
+            }
+            return out;
+        }
+        if (!success) {
+            let out = `**${message}**`;
+            if (obj.error)
+                out += `\n\nError: ${obj.error}`;
+            const passed = obj.testSteps?.filter((s) => s?.passed).length ?? 0;
+            const total = obj.testSteps?.length ?? 0;
+            if (total > 0)
+                out += `\n\nSteps executed: ${passed}/${total}`;
+            return out;
+        }
+        const stepsCount = obj.stepsCount ?? 0;
+        const testSteps = Array.isArray(obj.testSteps) ? obj.testSteps : [];
+        const passed = testSteps.filter((s) => s?.passed).length;
+        const total = testSteps.length || stepsCount;
+        const executionTime = this.parseExecutionTime(obj.executionLogs);
+        const status = this.parseStatus(obj.executionLogs) ?? (passed === total && total > 0 ? "PASSED" : null);
+        let out = "**The NLP automation script ran successfully and was saved to the test case.**\n\n";
+        out += "| | |\n|---|---|\n";
+        out += `| **Test case** | ${obj.testCaseId ?? "—"} |\n`;
+        out += `| **Status** | ${status ?? "—"} |\n`;
+        out += `| **Steps in plan** | ${stepsCount} |\n`;
+        out += `| **Passed** | ${total > 0 ? `${passed}/${total}` : "—"} |\n`;
+        if (executionTime)
+            out += `| **Execution time** | ${executionTime} |\n`;
+        if (testSteps.length > 0) {
+            out += "\n**What was generated**\n\n";
+            testSteps.forEach((s, i) => {
+                const desc = s.stepDescription ?? s.code ?? `Step ${i + 1}`;
+                out += `- ${desc}\n`;
+            });
+        }
+        out += "\nThe plan includes Playwright steps and assertions. Both the execution record (plan) and the automation instruction text were saved to the test case. You can open the test case in QA Path to view or run the script.";
+        return out;
+    }
+    parseExecutionTime(logs) {
+        if (!Array.isArray(logs))
+            return null;
+        const line = logs.find((l) => {
+            const msg = l?.message ?? l?.text ?? "";
+            return typeof msg === "string" && msg.includes("Execution Time:");
+        });
+        const msg = line?.message ?? line?.text ?? "";
+        const match = typeof msg === "string" && msg.match(/Execution Time:\s*([\d.]+s?)/);
+        return match ? `~${match[1]}` : null;
+    }
+    parseStatus(logs) {
+        if (!Array.isArray(logs))
+            return null;
+        const line = logs.find((l) => {
+            const msg = l?.message ?? l?.text ?? "";
+            return typeof msg === "string" && (msg.includes("Status: PASSED") || msg.includes("Status: FAILED"));
+        });
+        const msg = line?.message ?? line?.text ?? "";
+        if (typeof msg !== "string")
+            return null;
+        if (msg.includes("Status: PASSED"))
+            return "PASSED";
+        if (msg.includes("Status: FAILED"))
+            return "FAILED";
+        return null;
+    }
+    sanitizeForJSON(obj) {
+        if (obj === null || obj === undefined)
+            return obj;
+        if (typeof obj !== 'object')
+            return obj;
+        if (Array.isArray(obj)) {
+            return obj.map(item => this.sanitizeForJSON(item));
+        }
+        const sanitized = {};
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                const value = obj[key];
+                // Skip functions, undefined, and circular references
+                if (typeof value === 'function' || value === undefined) {
+                    continue;
+                }
+                try {
+                    sanitized[key] = this.sanitizeForJSON(value);
+                }
+                catch (e) {
+                    // Skip circular references
+                    sanitized[key] = '[Circular]';
+                }
+            }
+        }
+        return sanitized;
+    }
+    formattedResponse(obj) {
+        const summary = this.formatToolOutput(obj);
+        // Sanitize the object to remove circular references and non-serializable values
+        const sanitized = this.sanitizeForJSON(obj);
+        let jsonString;
+        try {
+            jsonString = JSON.stringify(sanitized, null, 2);
+        }
+        catch (error) {
+            // Fallback: create a simplified version if JSON.stringify still fails
+            const simplified = {
+                success: sanitized.success,
+                message: sanitized.message,
+                testCaseId: sanitized.testCaseId,
+                stepsCount: sanitized.stepsCount,
+                error: sanitized.error,
+                executionRecordSaved: sanitized.executionRecordSaved,
+                executionLogs: sanitized.executionLogs?.length || 0,
+                testSteps: sanitized.testSteps?.length || 0,
+            };
+            jsonString = JSON.stringify(simplified, null, 2);
+        }
+        const text = summary + "\n\n<details>\n<summary>Full response (JSON)</summary>\n\n```json\n" + jsonString + "\n```\n</details>";
+        return textResponse(text);
+    }
+    jsonResponse(obj) {
+        return this.formattedResponse(obj);
+    }
+}
+//# sourceMappingURL=automation-tools.js.map