auto-feedback 0.1.0

package/build/tools/screenshot-electron.d.ts

@@ -0,0 +1,13 @@
+/**
+ * screenshot_electron MCP tool
+ * Captures a screenshot of a running Electron app via stored Page reference
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SessionManager } from "../session-manager.js";
+/**
+ * Register the screenshot_electron tool with the MCP server
+ *
+ * @param server - MCP server instance
+ * @param sessionManager - Session manager for resource tracking
+ */
+export declare function registerScreenshotElectronTool(server: McpServer, sessionManager: SessionManager): void;

package/build/tools/screenshot-electron.js

@@ -0,0 +1,72 @@
+/**
+ * screenshot_electron MCP tool
+ * Captures a screenshot of a running Electron app via stored Page reference
+ */
+import { z } from "zod";
+import { createToolError, createScreenshotResult } from "../utils/errors.js";
+import { capturePlaywrightPage } from "../screenshot/capture.js";
+import { optimizeScreenshot } from "../screenshot/optimize.js";
+/**
+ * Register the screenshot_electron tool with the MCP server
+ *
+ * @param server - MCP server instance
+ * @param sessionManager - Session manager for resource tracking
+ */
+export function registerScreenshotElectronTool(server, sessionManager) {
+    server.tool("screenshot_electron", "Capture a screenshot of a running Electron app. Use after launch_electron to see the current visual state.", {
+        sessionId: z.string().describe("Session ID of the Electron app"),
+        fullPage: z
+            .boolean()
+            .optional()
+            .describe("Capture full page (true) or viewport only (false, default)"),
+        maxWidth: z
+            .number()
+            .int()
+            .min(100)
+            .max(3840)
+            .optional()
+            .describe("Max image width in pixels (default: 1280)"),
+        quality: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe("WebP quality 1-100 (default: 80)"),
+    }, async ({ sessionId, fullPage, maxWidth, quality }) => {
+        try {
+            const session = sessionManager.get(sessionId);
+            if (!session) {
+                return createToolError(`Session not found: ${sessionId}`, "The session may have already been ended", "Create a session and launch an Electron app first.");
+            }
+            const pageRef = sessionManager.getPageRef(sessionId, "electron");
+            if (!pageRef) {
+                return createToolError("No Electron app found for this session", `Session ${sessionId} has no Electron page reference`, "Launch an Electron app first with launch_electron.");
+            }
+            console.error(`[screenshot_electron] Capturing for session ${sessionId}`);
+            // Capture raw PNG from Playwright Page
+            const rawBuffer = await capturePlaywrightPage(pageRef.page, {
+                fullPage: fullPage ?? false,
+            });
+            // Optimize: resize + WebP conversion
+            const optimized = await optimizeScreenshot(rawBuffer, {
+                maxWidth: maxWidth ?? 1280,
+                quality: quality ?? 80,
+            });
+            const imageBase64 = optimized.data.toString("base64");
+            return createScreenshotResult({
+                sessionId,
+                type: "electron",
+                mode: fullPage ? "full-page" : "viewport",
+                width: optimized.width,
+                height: optimized.height,
+                originalSize: rawBuffer.length,
+                optimizedSize: optimized.data.length,
+            }, imageBase64, optimized.mimeType);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return createToolError("Failed to capture Electron screenshot", message, "Ensure the Electron app is still running and the window is visible.");
+        }
+    });
+}

package/build/tools/screenshot-web.d.ts

@@ -0,0 +1,13 @@
+/**
+ * screenshot_web MCP tool
+ * Captures a screenshot of a web page by URL with lazy browser creation
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SessionManager } from "../session-manager.js";
+/**
+ * Register the screenshot_web tool with the MCP server
+ *
+ * @param server - MCP server instance
+ * @param sessionManager - Session manager for resource tracking
+ */
+export declare function registerScreenshotWebTool(server: McpServer, sessionManager: SessionManager): void;

package/build/tools/screenshot-web.js

@@ -0,0 +1,129 @@
+/**
+ * screenshot_web MCP tool
+ * Captures a screenshot of a web page by URL with lazy browser creation
+ */
+import { z } from "zod";
+import { chromium } from "playwright";
+import { createToolError, createScreenshotResult } from "../utils/errors.js";
+import { capturePlaywrightPage } from "../screenshot/capture.js";
+import { optimizeScreenshot } from "../screenshot/optimize.js";
+import { setupAutoCapture } from "../screenshot/auto-capture.js";
+import { attachConsoleCollector } from "../capture/console-collector.js";
+import { attachErrorCollector } from "../capture/error-collector.js";
+import { attachNetworkCollector } from "../capture/network-collector.js";
+/**
+ * Register the screenshot_web tool with the MCP server
+ *
+ * @param server - MCP server instance
+ * @param sessionManager - Session manager for resource tracking
+ */
+export function registerScreenshotWebTool(server, sessionManager) {
+    server.tool("screenshot_web", "Capture a screenshot of a web page by URL. Creates a browser automatically on first use. Use to see visual state of web apps.", {
+        sessionId: z
+            .string()
+            .describe("Session ID to associate the browser with"),
+        url: z
+            .string()
+            .url()
+            .describe("URL to screenshot (e.g., http://localhost:3000)"),
+        fullPage: z
+            .boolean()
+            .optional()
+            .describe("Capture full page (true) or viewport only (false, default)"),
+        maxWidth: z
+            .number()
+            .int()
+            .min(100)
+            .max(3840)
+            .optional()
+            .describe("Max image width in pixels (default: 1280)"),
+        quality: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe("WebP quality 1-100 (default: 80)"),
+    }, async ({ sessionId, url, fullPage, maxWidth, quality }) => {
+        try {
+            const session = sessionManager.get(sessionId);
+            if (!session) {
+                return createToolError(`Session not found: ${sessionId}`, "The session may have already been ended", "Create a session first with create_session.");
+            }
+            // Check for existing page reference for this URL
+            let pageRef = sessionManager.getPageRef(sessionId, url);
+            if (!pageRef) {
+                // Lazy browser creation: first screenshot of this URL
+                console.error(`[screenshot_web] Creating browser for ${url} in session ${sessionId}`);
+                const browser = await chromium.launch({ headless: true });
+                const context = await browser.newContext({
+                    viewport: { width: 1280, height: 720 },
+                });
+                const page = await context.newPage();
+                await page.goto(url, { waitUntil: "load", timeout: 30000 });
+                // Store page reference for reuse
+                pageRef = {
+                    type: "web",
+                    page,
+                    browser,
+                    browserContext: context,
+                    url,
+                };
+                sessionManager.setPageRef(sessionId, url, pageRef);
+                // Attach auto-capture on navigation
+                setupAutoCapture(page, sessionId, sessionManager);
+                // Attach diagnostic collectors
+                const consoleCollector = attachConsoleCollector(page);
+                const errorCollector = attachErrorCollector(page);
+                const networkCollector = attachNetworkCollector(page);
+                sessionManager.setConsoleCollector(sessionId, url, consoleCollector);
+                sessionManager.setErrorCollector(sessionId, url, errorCollector);
+                sessionManager.setNetworkCollector(sessionId, url, networkCollector);
+                // Register browser cleanup as a session resource
+                sessionManager.addResource(sessionId, {
+                    cleanup: async () => {
+                        console.error(`[screenshot_web] Closing browser for ${url}`);
+                        await context.close().catch(() => { });
+                        await browser.close().catch(() => { });
+                    },
+                });
+                console.error(`[screenshot_web] Browser ready for ${url}`);
+            }
+            else {
+                // Reuse existing page — navigate if URL changed
+                const currentUrl = pageRef.page.url();
+                if (currentUrl !== url) {
+                    await pageRef.page.goto(url, {
+                        waitUntil: "load",
+                        timeout: 30000,
+                    });
+                }
+            }
+            console.error(`[screenshot_web] Capturing ${url} for session ${sessionId}`);
+            // Capture raw PNG
+            const rawBuffer = await capturePlaywrightPage(pageRef.page, {
+                fullPage: fullPage ?? false,
+            });
+            // Optimize: resize + WebP
+            const optimized = await optimizeScreenshot(rawBuffer, {
+                maxWidth: maxWidth ?? 1280,
+                quality: quality ?? 80,
+            });
+            const imageBase64 = optimized.data.toString("base64");
+            return createScreenshotResult({
+                sessionId,
+                type: "web",
+                url,
+                mode: fullPage ? "full-page" : "viewport",
+                width: optimized.width,
+                height: optimized.height,
+                originalSize: rawBuffer.length,
+                optimizedSize: optimized.data.length,
+            }, imageBase64, optimized.mimeType);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return createToolError("Failed to capture web screenshot", message, "Check the URL is accessible. For dev servers, ensure the server is running first (use launch_web_server).");
+        }
+    });
+}

package/build/tools/stop-process.d.ts

@@ -0,0 +1,14 @@
+/**
+ * stop_process MCP tool (PROC-05)
+ * Stops all processes in a session by destroying the session and its resources
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SessionManager } from "../session-manager.js";
+/**
+ * Register the stop_process tool with the MCP server
+ *
+ * Destroys a session, which triggers cleanup of all registered resources
+ * (process trees, Electron apps, etc.). This is intentionally session-wide
+ * because each session typically manages one application under test.
+ */
+export declare function registerStopProcessTool(server: McpServer, sessionManager: SessionManager): void;

package/build/tools/stop-process.js

@@ -0,0 +1,41 @@
+/**
+ * stop_process MCP tool (PROC-05)
+ * Stops all processes in a session by destroying the session and its resources
+ */
+import { z } from "zod";
+import { createToolError, createToolResult } from "../utils/errors.js";
+/**
+ * Register the stop_process tool with the MCP server
+ *
+ * Destroys a session, which triggers cleanup of all registered resources
+ * (process trees, Electron apps, etc.). This is intentionally session-wide
+ * because each session typically manages one application under test.
+ */
+export function registerStopProcessTool(server, sessionManager) {
+    server.tool("stop_process", "Stop all processes in a session and clean up resources. Use to terminate running apps when done or to free ports.", {
+        sessionId: z.string().describe("Session ID whose processes to stop"),
+    }, async ({ sessionId }) => {
+        try {
+            // Validate session exists
+            const session = sessionManager.get(sessionId);
+            if (!session) {
+                const availableSessions = sessionManager.list();
+                return createToolError(`Session not found: ${sessionId}`, "The session may have already been ended or never existed", availableSessions.length > 0
+                    ? `Available sessions: ${availableSessions.join(", ")}`
+                    : "No active sessions. Use list_sessions to check.");
+            }
+            console.error(`[stop_process] Stopping all processes in session ${sessionId}`);
+            // Destroy session -- triggers cleanup of all registered resources
+            await sessionManager.destroy(sessionId);
+            return createToolResult({
+                sessionId,
+                stopped: true,
+                message: "All processes in session stopped and resources cleaned up",
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return createToolError("Failed to stop processes", message, "The session may be in an inconsistent state. Try end_session or create a new session.");
+        }
+    });
+}

package/build/tools/type-text.d.ts

@@ -0,0 +1,13 @@
+/**
+ * type_text MCP tool
+ * Types text into input fields on web or Electron pages using Playwright Locator API
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SessionManager } from "../session-manager.js";
+/**
+ * Register the type_text tool with the MCP server
+ *
+ * @param server - MCP server instance
+ * @param sessionManager - Session manager for resource tracking
+ */
+export declare function registerTypeTextTool(server: McpServer, sessionManager: SessionManager): void;

package/build/tools/type-text.js

@@ -0,0 +1,137 @@
+/**
+ * type_text MCP tool
+ * Types text into input fields on web or Electron pages using Playwright Locator API
+ */
+import { z } from "zod";
+import { createToolError, createScreenshotResult } from "../utils/errors.js";
+import { capturePlaywrightPage } from "../screenshot/capture.js";
+import { optimizeScreenshot } from "../screenshot/optimize.js";
+import { resolveSelector, getActivePage } from "../interaction/selectors.js";
+/**
+ * Register the type_text tool with the MCP server
+ *
+ * @param server - MCP server instance
+ * @param sessionManager - Session manager for resource tracking
+ */
+export function registerTypeTextTool(server, sessionManager) {
+    server.tool("type_text", "Type text into an input field or textarea on a web or Electron page. Returns a screenshot after typing. Uses fill (paste) by default; set pressSequentially for apps with keystroke handlers.", {
+        sessionId: z
+            .string()
+            .describe("Session ID from create_session"),
+        selector: z
+            .string()
+            .describe("Element selector for the input field. CSS: #email, .search-box, input[name='query']. Role: role=textbox[name='Email']. Test ID: testid=search-input"),
+        text: z
+            .string()
+            .describe("Text to type into the field"),
+        pageIdentifier: z
+            .string()
+            .optional()
+            .describe("URL or 'electron' to target a specific page. Omit if session has only one page."),
+        pressSequentially: z
+            .boolean()
+            .optional()
+            .describe("Type one character at a time instead of fill/paste (default: false). Use for inputs with autocomplete or per-keystroke handlers."),
+        delay: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("Delay between keystrokes in ms (only used with pressSequentially, default: 50)"),
+        clear: z
+            .boolean()
+            .optional()
+            .describe("Clear the field before typing (default: true). Set false to append text."),
+        timeout: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("Max wait time in ms for element readiness (default: 30000)"),
+    }, async ({ sessionId, selector, text, pageIdentifier, pressSequentially, delay, clear, timeout, }) => {
+        try {
+            // Validate session exists
+            const session = sessionManager.get(sessionId);
+            if (!session) {
+                const availableSessions = sessionManager.list();
+                return createToolError(`Session not found: ${sessionId}`, "The session may have already been ended", availableSessions.length > 0
+                    ? `Available sessions: ${availableSessions.join(", ")}`
+                    : "Create a session first with create_session.");
+            }
+            // Find the active page
+            const pageResult = getActivePage(sessionManager, sessionId, pageIdentifier);
+            if (!pageResult.success) {
+                return createToolError(pageResult.error, `Session: ${sessionId}`, pageResult.availablePages
+                    ? `Available pages: ${pageResult.availablePages.join(", ")}`
+                    : undefined);
+            }
+            const { page } = pageResult;
+            // Resolve selector to Playwright Locator
+            const locator = resolveSelector(page, selector);
+            const effectiveTimeout = timeout ?? 30000;
+            // Perform the type action based on mode
+            if (clear === false && pressSequentially) {
+                // Append mode + pressSequentially: click to focus, then type char-by-char
+                await locator.click({ timeout: effectiveTimeout });
+                await locator.pressSequentially(text, {
+                    delay: delay ?? 50,
+                    timeout: effectiveTimeout,
+                });
+            }
+            else if (pressSequentially) {
+                // Clear first, then type char-by-char
+                await locator.fill("", { timeout: effectiveTimeout });
+                await locator.pressSequentially(text, {
+                    delay: delay ?? 50,
+                    timeout: effectiveTimeout,
+                });
+            }
+            else if (clear === false) {
+                // Append mode + fill: click to focus, then insertText to append
+                await locator.click({ timeout: effectiveTimeout });
+                await page.keyboard.insertText(text);
+            }
+            else {
+                // Default: fill() clears and types in one step
+                await locator.fill(text, { timeout: effectiveTimeout });
+            }
+            // Capture post-type screenshot
+            const rawBuffer = await capturePlaywrightPage(page, {
+                fullPage: false,
+            });
+            const optimized = await optimizeScreenshot(rawBuffer, {
+                maxWidth: 1280,
+                quality: 80,
+            });
+            const imageBase64 = optimized.data.toString("base64");
+            return createScreenshotResult({
+                sessionId,
+                action: "type",
+                selector,
+                textLength: text.length,
+                mode: pressSequentially ? "pressSequentially" : "fill",
+                success: true,
+            }, imageBase64, optimized.mimeType);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            // Strict mode violation: selector matched multiple elements
+            if (message.includes("strict mode violation")) {
+                return createToolError("Selector matched multiple elements", `Selector "${selector}" matched more than one element (strict mode violation)`, "Use a more specific selector or add :nth-child(), :first-of-type, or similar to target a single element.");
+            }
+            // Timeout: element not found or not actionable within timeout
+            if (message.includes("Timeout") ||
+                message.includes("timeout")) {
+                return createToolError("Element not found or not editable within timeout", `Selector "${selector}" did not match any visible, editable element within ${timeout ?? 30000}ms`, "Check the selector is correct, the element is visible and editable, or increase the timeout. Take a screenshot first to verify the page state.");
+            }
+            // Element is not editable (not an input/textarea/contenteditable)
+            if (message.includes("not an <input>") ||
+                message.includes("not editable") ||
+                message.includes("Element is not")) {
+                return createToolError("Element is not a text input", `Selector "${selector}" matched an element that cannot accept text input`, "Ensure the selector targets an <input>, <textarea>, or contenteditable element. Take a screenshot to verify.");
+            }
+            // Default error
+            return createToolError("Failed to type text", `Selector: "${selector}" — ${message}`, "Take a screenshot to verify the element exists and is an editable text field.");
+        }
+    });
+}

package/build/tools/wait-for-element.d.ts

@@ -0,0 +1,14 @@
+/**
+ * wait_for_element MCP tool
+ * Waits for an element to reach a specific state (visible, hidden, attached, detached)
+ * and returns a screenshot after the wait since the page likely changed.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SessionManager } from "../session-manager.js";
+/**
+ * Register the wait_for_element tool with the MCP server
+ *
+ * @param server - MCP server instance
+ * @param sessionManager - Session manager for resource tracking
+ */
+export declare function registerWaitForElementTool(server: McpServer, sessionManager: SessionManager): void;

package/build/tools/wait-for-element.js

@@ -0,0 +1,93 @@
+/**
+ * wait_for_element MCP tool
+ * Waits for an element to reach a specific state (visible, hidden, attached, detached)
+ * and returns a screenshot after the wait since the page likely changed.
+ */
+import { z } from "zod";
+import { createToolError, createScreenshotResult } from "../utils/errors.js";
+import { resolveSelector, getActivePage } from "../interaction/selectors.js";
+import { capturePlaywrightPage } from "../screenshot/capture.js";
+import { optimizeScreenshot } from "../screenshot/optimize.js";
+/**
+ * Register the wait_for_element tool with the MCP server
+ *
+ * @param server - MCP server instance
+ * @param sessionManager - Session manager for resource tracking
+ */
+export function registerWaitForElementTool(server, sessionManager) {
+    server.tool("wait_for_element", "Wait for an element to reach a specific state. Use before interacting with elements that may not be ready yet (loading spinners, disabled buttons, lazy content).", {
+        sessionId: z
+            .string()
+            .describe("Session ID from create_session"),
+        selector: z
+            .string()
+            .describe("Element selector. CSS: #id, .class, div > span. Text: text=Click me. Role: role=button[name='Submit']. Test ID: testid=my-btn"),
+        state: z
+            .enum(["visible", "hidden", "attached", "detached"])
+            .describe("Target state to wait for. 'visible': element visible on page. 'hidden': element hidden or removed. 'attached': element in DOM (may be hidden). 'detached': element removed from DOM."),
+        pageIdentifier: z
+            .string()
+            .optional()
+            .describe("URL or 'electron' to target a specific page. Omit if session has only one page."),
+        timeout: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("Max wait time in ms (default: 30000)"),
+    }, async ({ sessionId, selector, state, pageIdentifier, timeout }) => {
+        try {
+            // Validate session exists
+            const session = sessionManager.get(sessionId);
+            if (!session) {
+                const availableSessions = sessionManager.list();
+                return createToolError(`Session not found: ${sessionId}`, "The session may have already been ended", availableSessions.length > 0
+                    ? `Available sessions: ${availableSessions.join(", ")}`
+                    : "Create a session first with create_session.");
+            }
+            // Find the active page
+            const pageResult = getActivePage(sessionManager, sessionId, pageIdentifier);
+            if (!pageResult.success) {
+                return createToolError(pageResult.error, `Session: ${sessionId}`, pageResult.availablePages
+                    ? `Available pages: ${pageResult.availablePages.join(", ")}`
+                    : undefined);
+            }
+            const { page } = pageResult;
+            const effectiveTimeout = timeout ?? 30000;
+            // Resolve selector to Playwright Locator
+            const locator = resolveSelector(page, selector);
+            // Wait for the specified state
+            await locator.waitFor({ state, timeout: effectiveTimeout });
+            // Capture post-wait screenshot (page likely changed during wait)
+            const rawBuffer = await capturePlaywrightPage(page, {
+                fullPage: false,
+            });
+            const optimized = await optimizeScreenshot(rawBuffer, {
+                maxWidth: 1280,
+                quality: 80,
+            });
+            const imageBase64 = optimized.data.toString("base64");
+            return createScreenshotResult({
+                sessionId,
+                action: "wait_for_element",
+                selector,
+                state,
+                success: true,
+            }, imageBase64, optimized.mimeType);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            // Strict mode violation: selector matched multiple elements
+            if (message.includes("strict mode violation")) {
+                return createToolError("Selector matched multiple elements", `Selector "${selector}" matched more than one element (strict mode violation)`, "Use a more specific selector or add :nth-child(), :first-of-type, or similar to target a single element.");
+            }
+            // Timeout: element did not reach expected state
+            if (message.includes("Timeout") ||
+                message.includes("timeout")) {
+                return createToolError(`Element did not reach state '${state}' within ${timeout ?? 30000}ms`, `Selector: "${selector}", target state: "${state}"`, `The element exists but did not become ${state}. Take a screenshot to see the current page state.`);
+            }
+            // Default error
+            return createToolError("Failed to wait for element", `Selector: "${selector}", state: "${state}" — ${message}`, "Take a screenshot to verify the element exists and is visible on the page.");
+        }
+    });
+}

package/build/types/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared type definitions for the Feedback MCP server
+ */
+/**
+ * Resource with cleanup capability
+ */
+export interface Resource {
+    cleanup: () => Promise<void>;
+}
+/**
+ * Session tracking active resources
+ */
+export interface Session {
+    id: string;
+    createdAt: Date;
+    resources: Resource[];
+}
+/**
+ * MCP tool result format (supports text and image content)
+ */
+export type ToolResult = {
+    content: Array<{
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+    }>;
+    isError?: boolean;
+};

package/build/types/index.js

@@ -0,0 +1,4 @@
+/**
+ * Shared type definitions for the Feedback MCP server
+ */
+export {};

package/build/utils/errors.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Structured error formatting for tool results
+ */
+import { ToolResult } from "../types/index.js";
+/**
+ * Create a tool error response with structured information
+ * @param message Error message
+ * @param context Optional context about what was being attempted
+ * @param suggestedFix Optional suggestion for how to fix the issue
+ * @returns ToolResult with isError: true
+ */
+export declare function createToolError(message: string, context?: string, suggestedFix?: string): ToolResult;
+/**
+ * Create a successful tool result
+ * @param data Data to serialize as JSON
+ * @returns ToolResult with isError: false
+ */
+export declare function createToolResult(data: unknown): ToolResult;
+/**
+ * Create a screenshot tool result with text metadata and image content
+ * @param metadata Metadata to include as JSON text
+ * @param imageBase64 Base64-encoded image data
+ * @param mimeType Image MIME type (default: 'image/webp')
+ * @returns ToolResult with text + image content
+ */
+export declare function createScreenshotResult(metadata: Record<string, unknown>, imageBase64: string, mimeType?: string): ToolResult;