mcp-web-inspector 0.8.0 → 0.9.2

package/README.md

@@ -1121,6 +1121,7 @@ Return full output for a previously previewed large result using a one-time toke
 
 - Parameters:
   - token (string, required): One-time token obtained from a tool's preview response
+  - reason (string, required): Explain why the full output is needed and how it will be used. This helps the user understand whether the action is reasonable and necessary.
 
 - Output Format:
   - Full original payload if token is valid (one-time)

package/dist/toolHandler.js

@@ -1,5 +1,5 @@
 import { chromium, firefox, webkit, devices } from 'playwright';
-import { checkBrowsersInstalled, getInstallationInstructions } from './utils/browserCheck.js';
+import { spawnSync } from 'node:child_process';
 import { getToolInstance, isBrowserTool, executeTool } from './tools/common/registry.js';
 // Global state
 let browser;
@@ -15,10 +15,6 @@ let sessionConfig = {
     exposeSensitiveNetworkData: false,
 };
 let colorSchemeOverride = null;
-// Resolve package root for child processes (like npx). Entry point sets
-// MCP_WEB_INSPECTOR_PACKAGE_ROOT using import.meta.url; tests and other
-// environments fall back to process.cwd().
-const PACKAGE_ROOT = process.env.MCP_WEB_INSPECTOR_PACKAGE_ROOT || process.cwd();
 /**
  * Sets the session configuration
  */
@@ -265,15 +261,13 @@ async function registerConsoleMessage(page) {
         });
     });
 }
-// Track if we've checked browser installation
-let browserInstallationChecked = false;
 /**
  * Gets the screen size using Playwright's API
  */
 async function getScreenSize() {
     try {
         // Launch a temporary browser to get screen size
-        const tempBrowser = await chromium.launch({ headless: true });
+        const tempBrowser = await chromium.launch({ headless: true, executablePath: process.env.CHROME_EXECUTABLE_PATH || undefined });
         const tempContext = await tempBrowser.newContext();
         const tempPage = await tempContext.newPage();
         const screenSize = await tempPage.evaluate(() => {
@@ -300,32 +294,6 @@ async function getScreenSize() {
  */
 export async function ensureBrowser(browserSettings) {
     try {
-        // Check if browsers are installed on first launch (only once)
-        if (!browser && !browserInstallationChecked) {
-            browserInstallationChecked = true;
-            const browserCheck = checkBrowsersInstalled();
-            if (!browserCheck.installed) {
-                // Try to install browsers automatically
-                console.warn('🎭 Playwright browsers not found. Installing automatically...');
-                console.warn('⏳ This will download ~1GB of browser binaries. Please wait...');
-                try {
-                    const { execSync } = await import('child_process');
-                    execSync('npx playwright install chromium firefox webkit', {
-                        stdio: 'inherit',
-                        encoding: 'utf8',
-                        cwd: PACKAGE_ROOT,
-                    });
-                    console.error('✅ Browsers installed successfully! Starting browser...');
-                    // Note: browser variable is still undefined here, which is correct.
-                    // The code below (line 342) will launch the browser after installation.
-                }
-                catch (installError) {
-                    // If auto-install fails, show instructions
-                    const instructions = getInstallationInstructions();
-                    throw new Error(`Playwright browsers not installed.\n\n${instructions}`);
-                }
-            }
-        }
         // Check if browser exists but is disconnected
         if (browser && !browser.isConnected()) {
             console.warn("Browser exists but is disconnected. Cleaning up...");
@@ -410,7 +378,7 @@ export async function ensureBrowser(browserSettings) {
                     browserInstance = chromium;
                     break;
             }
-            const executablePath = process.env.CHROME_EXECUTABLE_PATH;
+            const executablePath = process.env.CHROME_EXECUTABLE_PATH || undefined;
             // Determine viewport size
             let viewportWidth;
             let viewportHeight;
@@ -525,6 +493,60 @@ export async function ensureBrowser(browserSettings) {
             // Ignore errors during cleanup
         }
         resetBrowserState();
+        // If browser executable is missing, try installing it automatically
+        const errorMessage = error.message || '';
+        if (errorMessage.includes("Executable doesn't exist")) {
+            // Ensure we have a writable browsers path
+            const browsersPath = process.env.PLAYWRIGHT_BROWSERS_PATH;
+            let installPath = browsersPath;
+            if (installPath) {
+                try {
+                    const { accessSync, constants, mkdirSync } = await import('node:fs');
+                    mkdirSync(installPath, { recursive: true });
+                    accessSync(installPath, constants.W_OK);
+                }
+                catch {
+                    installPath = undefined; // not writable, fall back
+                }
+            }
+            if (!installPath) {
+                const { homedir } = await import('node:os');
+                installPath = `${homedir()}/.cache/ms-playwright`;
+                console.error(`Default browsers path not writable, using ${installPath}`);
+            }
+            console.error('Browser not found. Installing Chromium...');
+            const result = spawnSync('npx', ['playwright', 'install', 'chromium'], {
+                stdio: ['ignore', 'inherit', 'inherit'],
+                encoding: 'utf8',
+                env: { ...process.env, PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: '', PLAYWRIGHT_BROWSERS_PATH: installPath },
+            });
+            if (result.status === 0) {
+                // Playwright caches PLAYWRIGHT_BROWSERS_PATH at import time, so setting
+                // process.env mid-process won't help. Find the actual chrome binary and
+                // set CHROME_EXECUTABLE_PATH so the retry uses it via executablePath.
+                const { readdirSync, existsSync } = await import('node:fs');
+                const { join } = await import('node:path');
+                try {
+                    const dirs = readdirSync(installPath);
+                    const chromiumDir = dirs.find(d => d.startsWith('chromium-') && !d.includes('headless'));
+                    if (chromiumDir) {
+                        const chromePath = join(installPath, chromiumDir, 'chrome-linux', 'chrome');
+                        if (existsSync(chromePath)) {
+                            process.env.CHROME_EXECUTABLE_PATH = chromePath;
+                            console.error(`Chromium installed at ${chromePath}`);
+                        }
+                    }
+                }
+                catch {
+                    // Fall back — also try setting PLAYWRIGHT_BROWSERS_PATH in case it helps
+                    process.env.PLAYWRIGHT_BROWSERS_PATH = installPath;
+                    console.error('Chromium installed successfully.');
+                }
+            }
+            else {
+                console.error('Failed to install Chromium. Retrying launch anyway...');
+            }
+        }
         // Try one more time from scratch
         const { viewport, userAgent, headless = sessionConfig.headlessDefault, browserType = 'chromium', device } = browserSettings ?? {};
         // Get device configuration if device preset is specified
@@ -557,7 +579,7 @@ export async function ensureBrowser(browserSettings) {
                 browserInstance = chromium;
                 break;
         }
-        const executablePath = process.env.CHROME_EXECUTABLE_PATH;
+        const executablePath = process.env.CHROME_EXECUTABLE_PATH || undefined;
         // Determine viewport size for retry
         let retryViewportWidth;
         let retryViewportHeight;

package/dist/tools/browser/console/__tests__/console.test.js

@@ -209,7 +209,7 @@ describe('GetConsoleLogsTool', () => {
         // Confirm to retrieve full payload
         const { ConfirmOutputTool } = await import('../../../common/confirm_output.js');
         const confirmTool = new ConfirmOutputTool({});
-        const full = await confirmTool.execute({ token }, mockContext);
+        const full = await confirmTool.execute({ token, reason: 'test' }, mockContext);
         expect(full.isError).toBe(false);
         const fullText = full.content.map(c => c.text).join('\n');
         // By default limit=20 → header should reflect 20 lines
@@ -229,7 +229,7 @@ describe('GetConsoleLogsTool', () => {
         const token = (previewText.match(/confirm_output\(\{ token: \"([\w\d]+)\" \}\)/) || [])[1];
         const { ConfirmOutputTool } = await import('../../../common/confirm_output.js');
         const confirmTool = new ConfirmOutputTool({});
-        const full = await confirmTool.execute({ token }, mockContext);
+        const full = await confirmTool.execute({ token, reason: 'test' }, mockContext);
         expect(full.isError).toBe(false);
         const fullText = full.content.map(c => c.text).join('\n');
         // Header reflects number of groups shown (limit default 20)

package/dist/tools/browser/content/__tests__/screenshot.test.js

@@ -70,7 +70,7 @@ describe('ScreenshotTool', () => {
         const confirmTool = new ConfirmOutputTool({});
         const screenshotBuffer = Buffer.from('mock-screenshot');
         mockScreenshot.mockImplementationOnce(() => Promise.resolve(screenshotBuffer));
-        const finalResult = await confirmTool.execute({ token }, mockContext);
+        const finalResult = await confirmTool.execute({ token, reason: 'test' }, mockContext);
         expect(finalResult.isError).toBe(false);
         expect(finalResult.content[0].text).toContain('Screenshot saved to');
         expect(mockScreenshot).toHaveBeenCalledWith(expect.objectContaining({ fullPage: true, type: 'png' }));
@@ -90,7 +90,7 @@ describe('ScreenshotTool', () => {
         const confirmTool = new ConfirmOutputTool({});
         const screenshotBuffer = Buffer.from('mock-element-screenshot');
         mockLocatorScreenshot.mockImplementationOnce(() => Promise.resolve(screenshotBuffer));
-        const finalResult = await confirmTool.execute({ token }, mockContext);
+        const finalResult = await confirmTool.execute({ token, reason: 'test' }, mockContext);
         expect(finalResult.isError).toBe(false);
         expect(finalResult.content[0].text).toContain('Screenshot saved to');
     });
@@ -108,7 +108,7 @@ describe('ScreenshotTool', () => {
         const confirmTool = new ConfirmOutputTool({});
         // Mock a screenshot error on confirmation
         mockScreenshot.mockImplementationOnce(() => Promise.reject(new Error('Screenshot failed')));
-        const finalResult = await confirmTool.execute({ token }, mockContext);
+        const finalResult = await confirmTool.execute({ token, reason: 'test' }, mockContext);
         expect(finalResult.isError).toBe(true);
         expect(finalResult.content[0].text).toContain('Screenshot failed');
     });
@@ -136,7 +136,7 @@ describe('ScreenshotTool', () => {
         const { ConfirmOutputTool } = await import('../../../common/confirm_output.js');
         const confirmTool = new ConfirmOutputTool({});
         mockScreenshot.mockImplementationOnce(() => Promise.resolve(Buffer.from('mock-screenshot')));
-        await confirmTool.execute({ token }, mockContext);
+        await confirmTool.execute({ token, reason: 'test' }, mockContext);
         // Check that the screenshot was stored in the map
         const screenshots = screenshotTool.getScreenshots();
         expect(screenshots.has('test-screenshot')).toBe(true);
@@ -152,7 +152,7 @@ describe('ScreenshotTool', () => {
         const { ConfirmOutputTool } = await import('../../../common/confirm_output.js');
         const confirmTool = new ConfirmOutputTool({});
         mockScreenshot.mockImplementationOnce(() => Promise.resolve(Buffer.from('mock-screenshot')));
-        const result = await confirmTool.execute({ token }, mockContext);
+        const result = await confirmTool.execute({ token, reason: 'test' }, mockContext);
         expect(mockScreenshot).toHaveBeenCalled();
         expect(result.isError).toBe(false);
         expect(result.content[0].text).toContain('Screenshot saved to');

package/dist/tools/browser/content/__tests__/visiblePage.test.js

@@ -408,14 +408,14 @@ describe('GetHtmlTool', () => {
         const token = tokenMatch[1];
         const { ConfirmOutputTool } = await import('../../../common/confirm_output.js');
         const confirmTool = new ConfirmOutputTool({});
-        const fullResult = await confirmTool.execute({ token }, {});
+        const fullResult = await confirmTool.execute({ token, reason: 'test' }, {});
         expect(fullResult.isError).toBe(false);
         expect(fullResult.content[0].text).toContain(largeHtml);
     });
     test('confirm_output should error on invalid token', async () => {
         const { ConfirmOutputTool } = await import('../../../common/confirm_output.js');
         const confirmTool = new ConfirmOutputTool({});
-        const res = await confirmTool.execute({ token: 'invalid123' }, {});
+        const res = await confirmTool.execute({ token: 'invalid123', reason: 'test' }, {});
         expect(res.isError).toBe(true);
         expect(res.content[0].text).toContain('Invalid or expired token');
     });
@@ -443,11 +443,11 @@ describe('GetHtmlTool', () => {
         const { ConfirmOutputTool } = await import('../../../common/confirm_output.js');
         const confirmTool = new ConfirmOutputTool({});
         // Second call - use token (should work)
-        const fullResult = await confirmTool.execute({ token }, {});
+        const fullResult = await confirmTool.execute({ token, reason: 'test' }, {});
         expect(fullResult.isError).toBe(false);
         expect(fullResult.content[0].text).toContain(largeHtml);
         // Third call - try to reuse same token (should fail)
-        const retryResult = await confirmTool.execute({ token }, {});
+        const retryResult = await confirmTool.execute({ token, reason: 'test' }, {});
         expect(retryResult.isError).toBe(true);
         expect(retryResult.content[0].text).toContain('Invalid or expired token');
     });
@@ -470,7 +470,7 @@ describe('GetHtmlTool', () => {
         // Second call - with token via confirm tool
         const { ConfirmOutputTool } = await import('../../../common/confirm_output.js');
         const confirmTool = new ConfirmOutputTool({});
-        const fullResult = await confirmTool.execute({ token }, {});
+        const fullResult = await confirmTool.execute({ token, reason: 'test' }, {});
         expect(fullResult.isError).toBe(false);
         expect(fullResult.content[0].text).toContain(largeHtml);
         selectSpy.mockRestore();

package/dist/tools/common/confirm_output.js

@@ -87,8 +87,12 @@ export class ConfirmOutputTool {
                         type: 'string',
                         description: "One-time token obtained from a tool's preview response",
                     },
+                    reason: {
+                        type: 'string',
+                        description: "Explain why the full output is needed and how it will be used. This helps the user understand whether the action is reasonable and necessary.",
+                    },
                 },
-                required: ['token'],
+                required: ['token', 'reason'],
             },
             priority: 2,
             category: 'Other',
@@ -98,6 +102,9 @@ export class ConfirmOutputTool {
         const token = typeof args.token === 'string' ? args.token : '';
         if (!token)
             return createErrorResponse('Token is required');
+        const reason = typeof args.reason === 'string' ? args.reason : '';
+        if (!reason)
+            return createErrorResponse('Reason is required');
         const res = consumeThunk(token);
         if (!res.ok) {
             const err = res.error;

package/dist/utils/browserCheck.d.ts

@@ -1,11 +1,3 @@
-/**
- * Check if Playwright browsers are installed
- * Returns true if browsers are available, false otherwise
- */
-export declare function checkBrowsersInstalled(): {
-    installed: boolean;
-    message?: string;
-};
 /**
  * Get installation instructions for the current context
  */

package/dist/utils/browserCheck.js

@@ -1,72 +1,14 @@
-import { execSync } from 'child_process';
-import { existsSync } from 'fs';
-import { join } from 'path';
-// Resolve package root so npx uses this package's Playwright.
-// Entry point sets MCP_WEB_INSPECTOR_PACKAGE_ROOT using import.meta.url;
-// tests and other environments fall back to process.cwd().
-const PACKAGE_ROOT = process.env.MCP_WEB_INSPECTOR_PACKAGE_ROOT || process.cwd();
-/**
- * Check if Playwright browsers are installed
- * Returns true if browsers are available, false otherwise
- */
-export function checkBrowsersInstalled() {
-    try {
-        // Check if playwright is available
-        const result = execSync('npx playwright --version', {
-            encoding: 'utf8',
-            stdio: 'pipe',
-            cwd: PACKAGE_ROOT,
-        });
-        // If we got here, playwright CLI is available
-        // Now check if browsers are actually installed
-        // Playwright stores browsers in a cache directory
-        const homeDir = process.env.HOME || process.env.USERPROFILE;
-        if (!homeDir) {
-            return {
-                installed: false,
-                message: 'Could not determine home directory to check for browsers'
-            };
-        }
-        // Common browser cache locations
-        const possibleCacheDirs = [
-            join(homeDir, '.cache', 'ms-playwright'), // Linux
-            join(homeDir, 'Library', 'Caches', 'ms-playwright'), // macOS
-            join(homeDir, 'AppData', 'Local', 'ms-playwright'), // Windows
-        ];
-        const cacheExists = possibleCacheDirs.some(dir => existsSync(dir));
-        if (!cacheExists) {
-            return {
-                installed: false,
-                message: 'Playwright browsers not found in cache directories'
-            };
-        }
-        return { installed: true };
-    }
-    catch (error) {
-        return {
-            installed: false,
-            message: `Playwright check failed: ${error.message}`
-        };
-    }
-}
 /**
  * Get installation instructions for the current context
  */
 export function getInstallationInstructions() {
     return `
-Playwright browsers are not installed. To fix this, run one of the following commands:
-
-1. In your project directory:
-   npx playwright install chromium firefox webkit
+Chromium is not available. To fix this:
 
-2. If you installed mcp-web-inspector globally:
-   cd $(npm root -g)/mcp-web-inspector && npx playwright install chromium firefox webkit
+1. Run: npm install (installs bundled Chromium via @playwright/browser-chromium)
 
-3. Or install system-wide with dependencies (requires admin/sudo):
-   npx playwright install --with-deps chromium firefox webkit
+2. Or set CHROME_EXECUTABLE_PATH to your Chrome/Chromium binary
 
-For GitHub Copilot or VS Code users, you may need to:
-- Close and reopen your IDE after installation
-- Or run: npx playwright install chromium
+3. For Firefox/WebKit (optional): npx playwright install firefox webkit
 `.trim();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-web-inspector",
-  "version": "0.8.0",
+  "version": "0.9.2",
   "description": "Web Inspector MCP: Give LLMs visual superpowers to see, debug, and test any web page.",
   "license": "MIT",
   "author": "Anton",
@@ -30,9 +30,6 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.21.0",
     "@playwright/browser-chromium": "1.56.1",
-    "@playwright/browser-firefox": "1.56.1",
-    "@playwright/browser-webkit": "1.56.1",
-    "@playwright/test": "^1.56.1",
     "playwright": "1.56.1",
     "uuid": "13.0.0"
   },

package/dist/evals/evals.d.ts

@@ -1,5 +0,0 @@
-import { EvalConfig } from 'mcp-evals';
-import { EvalFunction } from "mcp-evals";
-declare const config: EvalConfig;
-export default config;
-export declare const evals: EvalFunction[];

package/dist/evals/evals.js

@@ -1,41 +0,0 @@
-//evals.ts
-import { openai } from "@ai-sdk/openai";
-import { grade } from "mcp-evals";
-const startCodegenSessionEval = {
-    name: 'startCodegenSession Evaluation',
-    description: 'Evaluates the start codegen session tool',
-    run: async () => {
-        const result = await grade(openai("gpt-4"), "Please start a new code generation session with an output path of /my/test/path, a testNamePrefix of MyPrefix, and comments enabled. Confirm the session was created successfully.");
-        return JSON.parse(result);
-    }
-};
-const end_codegen_sessionEval = {
-    name: 'end_codegen_session Evaluation',
-    description: 'Evaluates the end_codegen_session tool functionality',
-    run: async () => {
-        const result = await grade(openai("gpt-4"), "Please end the code generation session with ID session123 and generate the Playwright test code");
-        return JSON.parse(result);
-    }
-};
-const get_codegen_sessionEval = {
-    name: 'get_codegen_session Tool Evaluation',
-    description: 'Evaluates the retrieval of code generation session details',
-    run: async () => {
-        const result = await grade(openai("gpt-4"), "Please retrieve the code generation session details using session ID abc123.");
-        return JSON.parse(result);
-    }
-};
-const clearCodegenSessionEval = {
-    name: 'clear_codegen_session Evaluation',
-    description: 'Evaluates the functionality of clearing a code generation session',
-    run: async () => {
-        const result = await grade(openai("gpt-4"), "Please clear the code generation session with the ID testSession_123 to verify removal.");
-        return JSON.parse(result);
-    }
-};
-const config = {
-    model: openai("gpt-4"),
-    evals: [startCodegenSessionEval, end_codegen_sessionEval, get_codegen_sessionEval, clearCodegenSessionEval]
-};
-export default config;
-export const evals = [startCodegenSessionEval, end_codegen_sessionEval, get_codegen_sessionEval, clearCodegenSessionEval];

package/dist/toolConstants.d.ts

@@ -1,7 +0,0 @@
-/**
- * Tool constants - separate file to avoid circular dependencies
- */
-/**
- * Get list of all browser tool names
- */
-export declare const BROWSER_TOOLS: string[];

package/dist/toolConstants.js

@@ -1,46 +0,0 @@
-/**
- * Tool constants - separate file to avoid circular dependencies
- */
-/**
- * Get list of all browser tool names
- */
-export const BROWSER_TOOLS = [
-    // Navigation & Control
-    "navigate",
-    "go_back",
-    "go_forward",
-    "screenshot",
-    // DOM Inspection (PRIMARY)
-    "inspect_dom",
-    "get_test_ids",
-    "query_selector",
-    "find_by_text",
-    // Visibility & Position
-    "check_visibility",
-    "compare_element_alignment",
-    "inspect_ancestors",
-    "element_exists",
-    "wait_for_element",
-    "wait_for_network_idle",
-    // Style & Content
-    "get_computed_styles",
-    "measure_element",
-    "get_text",
-    "get_html",
-    "get_console_logs",
-    // Network Monitoring
-    "list_network_requests",
-    "get_request_details",
-    // Interactions (for debugging/testing workflows)
-    "click",
-    "fill",
-    "hover",
-    "select",
-    "upload_file",
-    "drag",
-    "press_key",
-    // JavaScript Execution
-    "evaluate",
-    // Cleanup
-    "close"
-];

package/dist/tools/api/base.d.ts

@@ -1,33 +0,0 @@
-import type { APIRequestContext } from 'playwright';
-import { ToolHandler, ToolContext, ToolResponse } from '../common/types.js';
-/**
- * Base class for all API-based tools
- * Provides common functionality and error handling
- */
-export declare abstract class ApiToolBase implements ToolHandler {
-    protected server: any;
-    constructor(server: any);
-    /**
-     * Main execution method that all tools must implement
-     */
-    abstract execute(args: any, context: ToolContext): Promise<ToolResponse>;
-    /**
-     * Ensures an API context is available and returns it
-     * @param context The tool context containing apiContext
-     * @returns The apiContext or null if not available
-     */
-    protected ensureApiContext(context: ToolContext): APIRequestContext | null;
-    /**
-     * Validates that an API context is available and returns an error response if not
-     * @param context The tool context
-     * @returns Either null if apiContext is available, or an error response
-     */
-    protected validateApiContextAvailable(context: ToolContext): ToolResponse | null;
-    /**
-     * Safely executes an API operation with proper error handling
-     * @param context The tool context
-     * @param operation The async operation to perform
-     * @returns The tool response
-     */
-    protected safeExecute(context: ToolContext, operation: (apiContext: APIRequestContext) => Promise<ToolResponse>): Promise<ToolResponse>;
-}

package/dist/tools/api/base.js

@@ -1,49 +0,0 @@
-import { createErrorResponse } from '../common/types.js';
-/**
- * Base class for all API-based tools
- * Provides common functionality and error handling
- */
-export class ApiToolBase {
-    constructor(server) {
-        this.server = server;
-    }
-    /**
-     * Ensures an API context is available and returns it
-     * @param context The tool context containing apiContext
-     * @returns The apiContext or null if not available
-     */
-    ensureApiContext(context) {
-        if (!context.apiContext) {
-            return null;
-        }
-        return context.apiContext;
-    }
-    /**
-     * Validates that an API context is available and returns an error response if not
-     * @param context The tool context
-     * @returns Either null if apiContext is available, or an error response
-     */
-    validateApiContextAvailable(context) {
-        if (!this.ensureApiContext(context)) {
-            return createErrorResponse("API context not initialized");
-        }
-        return null;
-    }
-    /**
-     * Safely executes an API operation with proper error handling
-     * @param context The tool context
-     * @param operation The async operation to perform
-     * @returns The tool response
-     */
-    async safeExecute(context, operation) {
-        const apiError = this.validateApiContextAvailable(context);
-        if (apiError)
-            return apiError;
-        try {
-            return await operation(context.apiContext);
-        }
-        catch (error) {
-            return createErrorResponse(`API operation failed: ${error.message}`);
-        }
-    }
-}

package/dist/tools/api/index.d.ts

@@ -1,2 +0,0 @@
-export * from './base.js';
-export * from './requests.js';

package/dist/tools/api/index.js

@@ -1,3 +0,0 @@
-export * from './base.js';
-export * from './requests.js';
-// TODO: Add exports for other API tools as they are implemented 

package/dist/tools/api/requests.d.ts

@@ -1,47 +0,0 @@
-import { ApiToolBase } from './base.js';
-import { ToolContext, ToolResponse } from '../common/types.js';
-/**
- * Tool for making GET requests
- */
-export declare class GetRequestTool extends ApiToolBase {
-    /**
-     * Execute the GET request tool
-     */
-    execute(args: any, context: ToolContext): Promise<ToolResponse>;
-}
-/**
- * Tool for making POST requests
- */
-export declare class PostRequestTool extends ApiToolBase {
-    /**
-     * Execute the POST request tool
-     */
-    execute(args: any, context: ToolContext): Promise<ToolResponse>;
-}
-/**
- * Tool for making PUT requests
- */
-export declare class PutRequestTool extends ApiToolBase {
-    /**
-     * Execute the PUT request tool
-     */
-    execute(args: any, context: ToolContext): Promise<ToolResponse>;
-}
-/**
- * Tool for making PATCH requests
- */
-export declare class PatchRequestTool extends ApiToolBase {
-    /**
-     * Execute the PATCH request tool
-     */
-    execute(args: any, context: ToolContext): Promise<ToolResponse>;
-}
-/**
- * Tool for making DELETE requests
- */
-export declare class DeleteRequestTool extends ApiToolBase {
-    /**
-     * Execute the DELETE request tool
-     */
-    execute(args: any, context: ToolContext): Promise<ToolResponse>;
-}