@toolsdk.ai/registry 1.0.114 → 1.0.116

package/dist/api/package-so.js

@@ -1,223 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { getMcpClient, getPackageConfigByKey, typedAllPackagesList } from "../helper.js";
-import { MCPSandboxClient } from "../sandbox/mcp-sandbox-client.js";
-import { getDirname } from "../utils";
-const __dirname = getDirname(import.meta.url);
-export class PackageSO {
-    constructor(provider = "LOCAL") {
-        this.sandboxProvider = "LOCAL";
-        this.sandboxProvider = provider;
-    }
-    // Acquire / Release explicit APIs (for external or future use)
-    static async acquireSandbox(runtime = "python", provider = "DAYTONA") {
-        const sandboxKey = PackageSO.getSandboxKey(runtime, provider);
-        const record = PackageSO.sandboxInstances.get(sandboxKey);
-        if (record) {
-            record.refCount++;
-            record.lastUsedAt = Date.now();
-            return record.client;
-        }
-        // Create new instance (note MAX_SANDBOXES check, consistent with constructor logic)
-        if (PackageSO.sandboxInstances.size >= PackageSO.MAX_SANDBOXES) {
-            // Try to evict LRU idle instance
-            let lruKey = null;
-            let lruTime = Infinity;
-            for (const [k, r] of PackageSO.sandboxInstances) {
-                if (r.refCount === 0 && r.lastUsedAt < lruTime) {
-                    lruKey = k;
-                    lruTime = r.lastUsedAt;
-                }
-            }
-            if (lruKey) {
-                const evict = PackageSO.sandboxInstances.get(lruKey);
-                if (evict) {
-                    await evict.client
-                        .kill()
-                        .catch((e) => console.error("[PackageSO] Error killing evicted sandbox:", e));
-                    PackageSO.sandboxInstances.delete(lruKey);
-                }
-            }
-            else {
-                throw new Error("Cannot create new sandbox: max sandboxes reached and none are idle");
-            }
-        }
-        const client = new MCPSandboxClient(runtime, provider);
-        const newRecord = {
-            client,
-            refCount: 1,
-            lastUsedAt: Date.now(),
-            provider,
-        };
-        PackageSO.sandboxInstances.set(sandboxKey, newRecord);
-        return client;
-    }
-    static async releaseSandbox(runtime = "python", provider = "DAYTONA") {
-        const sandboxKey = PackageSO.getSandboxKey(runtime, provider);
-        const record = PackageSO.sandboxInstances.get(sandboxKey);
-        if (!record)
-            return;
-        record.refCount = Math.max(0, record.refCount - 1);
-        record.lastUsedAt = Date.now();
-        if (record.refCount === 0) {
-            try {
-                await record.client.kill();
-                PackageSO.sandboxInstances.delete(sandboxKey);
-                console.log(`[PackageSO] Sandbox ${sandboxKey} closed immediately after use`);
-            }
-            catch (error) {
-                console.error(`[PackageSO] Error closing sandbox ${sandboxKey}:`, error);
-            }
-        }
-    }
-    // Cleanup all static sandbox instances safely
-    static async cleanupSandboxInstances() {
-        const killers = [];
-        for (const [key, record] of PackageSO.sandboxInstances) {
-            killers.push((async () => {
-                try {
-                    await record.client.kill();
-                }
-                catch (err) {
-                    console.error("[PackageSO] cleanup error for sandbox", key, err);
-                }
-            })());
-            PackageSO.sandboxInstances.delete(key);
-        }
-        await Promise.all(killers);
-    }
-    static getSandboxKey(runtime, provider) {
-        return `sandbox-${provider}-${runtime}`;
-    }
-    isSandboxEnabled() {
-        return this.sandboxProvider === "DAYTONA" || this.sandboxProvider === "SANDOCK";
-    }
-    async executeTool(request) {
-        const mcpServerConfig = getPackageConfigByKey(request.packageName);
-        if (this.isSandboxEnabled()) {
-            try {
-                const result = await this.executeToolInSandbox(request);
-                return result;
-            }
-            catch (error) {
-                console.warn(`[executeTool] Sandbox mode failed for tool ${request.toolKey} in package ${request.packageName}, falling back to local mode:`, error);
-            }
-        }
-        const { client, closeConnection } = await getMcpClient(mcpServerConfig, request.envs || {});
-        try {
-            const result = await client.callTool({
-                name: request.toolKey,
-                arguments: request.inputData,
-            });
-            console.log(`Tool ${request.toolKey} executed successfully`);
-            return result;
-        }
-        finally {
-            await closeConnection();
-        }
-    }
-    async executeToolInSandbox(request) {
-        const mcpServerConfig = getPackageConfigByKey(request.packageName);
-        const runtime = mcpServerConfig.runtime || "python"; // Default to python if not specified
-        const sandboxClient = await PackageSO.acquireSandbox(runtime, this.sandboxProvider);
-        // Initialize if not already initialized (concurrency protection via MCPSandboxClient.initialize)
-        await sandboxClient.initialize();
-        try {
-            const result = await sandboxClient.executeTool(request.packageName, request.toolKey, request.inputData || {}, request.envs);
-            console.log(`Tool ${request.toolKey} executed successfully in sandbox`);
-            return result;
-        }
-        catch (error) {
-            // If it's a sandbox not found error, try reinitializing and retrying once
-            if (error instanceof Error && error.message.includes("sandbox was not found")) {
-                console.log("[PackageSO] Retrying tool execution after sandbox failure");
-                await sandboxClient.initialize();
-                // Retry tool execution
-                const result = await sandboxClient.executeTool(request.packageName, request.toolKey, request.inputData || {}, request.envs);
-                console.log(`Tool ${request.toolKey} executed successfully in sandbox (retry)`);
-                return result;
-            }
-            throw error;
-        }
-        finally {
-            // Release reference count
-            await PackageSO.releaseSandbox(runtime, this.sandboxProvider);
-        }
-    }
-    async listTools(packageName) {
-        const mcpServerConfig = getPackageConfigByKey(packageName);
-        if (this.isSandboxEnabled()) {
-            try {
-                const tools = await this.listToolsInSandbox(packageName);
-                return tools;
-            }
-            catch (error) {
-                console.warn(`[listTools] Sandbox mode failed for package ${packageName}, falling back to local mode:`, error);
-            }
-        }
-        const mockEnvs = {};
-        if (mcpServerConfig.env) {
-            Object.keys(mcpServerConfig.env).forEach((key) => {
-                mockEnvs[key] = "mock_value";
-            });
-        }
-        const { client, closeConnection } = await getMcpClient(mcpServerConfig, mockEnvs);
-        try {
-            const { tools } = await client.listTools();
-            console.log(`Tools list retrieved successfully for package ${packageName}`);
-            return tools;
-        }
-        finally {
-            await closeConnection();
-        }
-    }
-    async listToolsInSandbox(packageName) {
-        const mcpServerConfig = getPackageConfigByKey(packageName);
-        const runtime = mcpServerConfig.runtime || "python";
-        const sandboxClient = await PackageSO.acquireSandbox(runtime, this.sandboxProvider);
-        try {
-            // Initialize only if sandbox is not initialized
-            await sandboxClient.initialize();
-            const tools = await sandboxClient.listTools(packageName);
-            console.log(`Tools list retrieved successfully for package ${packageName} in sandbox`);
-            return tools;
-        }
-        catch (error) {
-            // If it's a sandbox not found error, try reinitializing and retrying once
-            if (error instanceof Error && error.message.includes("sandbox was not found")) {
-                console.log("[PackageSO] Retrying tools listing after sandbox failure");
-                await sandboxClient.initialize();
-                // Retry listing tools
-                const tools = await sandboxClient.listTools(packageName);
-                console.log(`Tools list retrieved successfully for package ${packageName} in sandbox (retry)`);
-                return tools;
-            }
-            throw error;
-        }
-        finally {
-            await PackageSO.releaseSandbox(runtime, this.sandboxProvider);
-        }
-    }
-    async getPackageDetail(packageName) {
-        const packageInfo = typedAllPackagesList[packageName];
-        if (!packageInfo) {
-            throw new Error(`Package ${packageName} not found`);
-        }
-        const jsonFilePath = path.join(__dirname, "../../packages/", packageInfo.path);
-        const jsonStr = fs.readFileSync(jsonFilePath, "utf-8");
-        const packageConfig = JSON.parse(jsonStr);
-        let tools;
-        try {
-            tools = await this.listTools(packageName);
-        }
-        catch (error) {
-            console.warn(`Warn retrieving tools for package ${packageName}:`, error.message);
-            // if tools cannot be retrieved, set tools to undefined
-            tools = undefined;
-        }
-        const packageConfigWithTools = Object.assign(Object.assign({}, packageConfig), { tools });
-        return packageConfigWithTools;
-    }
-}
-PackageSO.sandboxInstances = new Map();
-PackageSO.MAX_SANDBOXES = 10;

package/dist/api/package.test.js

@@ -1,19 +0,0 @@
-// npx vitest run src/api/package.test.ts
-import { describe, expect, it } from "vitest";
-import { PackageSO } from "./package-so";
-describe("PackageSO - MCP Tool Execution Service Test", () => {
-    it("should execute tool successfully", async () => {
-        const toolSO = new PackageSO();
-        const request = {
-            packageName: "mcp-starter",
-            toolKey: "hello_tool",
-            inputData: { name: "Mike" },
-            envs: {},
-        };
-        const result = await toolSO.executeTool(request);
-        expect(result).toEqual({
-            content: [],
-            message: "Hello, Mike!",
-        });
-    });
-});

package/dist/helper.d.ts

@@ -1,74 +0,0 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import type { MCPSandboxProvider, MCPServerPackageConfig } from "./types";
-export declare const typedAllPackagesList: Record<string, {
-    path: string;
-    category?: string | undefined;
-    validated?: boolean | undefined;
-    tools?: Record<string, {
-        description?: string | undefined;
-        name?: string | undefined;
-    }> | undefined;
-}>;
-export declare function getSandboxProvider(): MCPSandboxProvider;
-export declare function getPackageConfigByKey(packageKey: string): MCPServerPackageConfig;
-export declare function getPackageJSON(packageName: string): any;
-export declare function getMcpClient(mcpServerConfig: MCPServerPackageConfig, env?: Record<string, string>): Promise<{
-    client: Client<{
-        method: string;
-        params?: {
-            [x: string]: unknown;
-            _meta?: {
-                [x: string]: unknown;
-                progressToken?: string | number | undefined;
-            } | undefined;
-        } | undefined;
-    }, {
-        method: string;
-        params?: {
-            [x: string]: unknown;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-        } | undefined;
-    }, {
-        [x: string]: unknown;
-        _meta?: {
-            [x: string]: unknown;
-        } | undefined;
-    }>;
-    transport: StdioClientTransport;
-    closeConnection: () => Promise<void>;
-}>;
-export declare function updatePackageJsonDependencies({ packageDeps, enableValidation, }: {
-    packageDeps: Record<string, string>;
-    enableValidation?: boolean;
-}): void;
-export declare function getActualVersion(packageName: string, configuredVersion?: string): string;
-export declare function withTimeout<T>(ms: number, promise: Promise<T>): Promise<T>;
-export declare function isValidNpmPackage(packageName: string): Promise<boolean>;
-interface PyProjectToml {
-    project?: {
-        dependencies?: string[];
-        [key: string]: unknown;
-    };
-    [key: string]: unknown;
-}
-/**
- * Parses the pyproject.toml file and returns its content
- * @returns Parsed pyproject.toml content
- */
-export declare function parsePyprojectToml(): PyProjectToml;
-/**
- * Extracts package name from a dependency string
- * @param dep - Dependency string (e.g., "package>=1.0.0")
- * @returns Package name without version constraints
- */
-export declare function extractPackageName(dep: string): string;
-/**
- * Gets Python dependencies from pyproject.toml
- * @returns Array of Python dependency names
- */
-export declare function getPythonDependencies(): string[];
-export declare function extractLastOuterJSON(str: string): string;
-export {};

package/dist/helper.js

@@ -1,312 +0,0 @@
-import assert from "node:assert";
-import fs from "node:fs";
-import * as path from "node:path";
-import toml from "@iarna/toml";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import axios from "axios";
-import semver from "semver";
-import allPackagesList from "../indexes/packages-list.json";
-import { getDirname } from "../src/utils";
-import { MCPServerPackageConfigSchema, PackagesListSchema } from "./schema";
-const __dirname = getDirname(import.meta.url);
-export const typedAllPackagesList = PackagesListSchema.parse(allPackagesList);
-export function getSandboxProvider() {
-    const provider = (process.env.MCP_SANDBOX_PROVIDER || "LOCAL").toUpperCase();
-    if (provider === "LOCAL" || provider === "DAYTONA" || provider === "SANDOCK") {
-        return provider;
-    }
-    console.warn(`[helper] Unsupported MCP_SANDBOX_PROVIDER value '${provider}', falling back to LOCAL mode`);
-    return "LOCAL";
-}
-export function getPackageConfigByKey(packageKey) {
-    const value = typedAllPackagesList[packageKey];
-    if (!value) {
-        throw new Error(`Package '${packageKey}' not found in packages list.`);
-    }
-    const jsonFile = value.path;
-    // read the JSON file and convert it to MCPServerPackageConfig
-    const jsonStr = fs.readFileSync(`${__dirname}/../packages/${jsonFile}`, "utf-8");
-    const mcpServerConfig = MCPServerPackageConfigSchema.parse(JSON.parse(jsonStr));
-    return mcpServerConfig;
-}
-export function getPackageJSON(packageName) {
-    const packageJSONFilePath = `${__dirname}/../node_modules/${packageName}/package.json`;
-    // Check if the package exists in node_modules
-    if (!fs.existsSync(packageJSONFilePath)) {
-        throw new Error(`Package '${packageName}' not found in node_modules. Install it first with: pnpm add ${packageName}`);
-    }
-    const packageJSONStr = fs.readFileSync(packageJSONFilePath, "utf8");
-    const packageJSON = JSON.parse(packageJSONStr);
-    return packageJSON;
-}
-async function createMcpClient(mcpServerConfig, transport) {
-    const { packageName, name } = mcpServerConfig;
-    const client = new Client({
-        name: `mcp-server-${name}-client`,
-        version: "1.0.0",
-    }, {
-        capabilities: {
-            tools: {},
-        },
-    });
-    await client.connect(transport);
-    const closeConnection = async () => {
-        try {
-            await client.close();
-        }
-        catch (e) {
-            console.warn(`${packageName} mcp client close failure.`, e);
-        }
-    };
-    return { client, transport, closeConnection };
-}
-async function getNodeMcpClient(mcpServerConfig, env) {
-    const { packageName } = mcpServerConfig;
-    const packageJSON = getPackageJSON(packageName);
-    let binFilePath = "";
-    let binPath;
-    if (typeof packageJSON.bin === "string") {
-        binPath = packageJSON.bin;
-    }
-    else if (typeof packageJSON.bin === "object") {
-        binPath = Object.values(packageJSON.bin)[0];
-    }
-    else {
-        binPath = packageJSON.main;
-    }
-    assert(binPath, `Package ${packageName} does not have a valid bin path in package.json.`);
-    binFilePath = `${__dirname}/../node_modules/${packageName}/${binPath}`;
-    const mcpServerBinPath = mcpServerConfig.bin || binFilePath;
-    const binArgs = mcpServerConfig.binArgs || [];
-    const transport = new StdioClientTransport({
-        args: [mcpServerBinPath, ...binArgs],
-        command: process.execPath,
-        env: env || {},
-    });
-    return createMcpClient(mcpServerConfig, transport);
-}
-async function getPyMcpClient(mcpServerConfig, env) {
-    const { packageName } = mcpServerConfig;
-    const pythonModuleName = packageName;
-    const transport = new StdioClientTransport({
-        command: "uv",
-        args: ["run", "--directory", "./python-mcp", pythonModuleName],
-        env: Object.assign(Object.assign({}, Object.fromEntries(Object.entries(process.env).filter(([_, v]) => v !== undefined))), env),
-    });
-    return createMcpClient(mcpServerConfig, transport);
-}
-export async function getMcpClient(mcpServerConfig, env) {
-    const { runtime } = mcpServerConfig;
-    if (runtime === "python") {
-        return getPyMcpClient(mcpServerConfig, env);
-    }
-    return getNodeMcpClient(mcpServerConfig, env);
-}
-export function updatePackageJsonDependencies({ packageDeps, enableValidation = false, }) {
-    var _a;
-    // Write package.json dependencies
-    const packageJsonFile = "./package.json";
-    const packageJSONStr = fs.readFileSync(packageJsonFile, "utf-8");
-    const newDeps = {
-        "@daytonaio/sdk": "0.109.0",
-        "@e2b/code-interpreter": "^2.0.0",
-        "@modelcontextprotocol/sdk": "^1.12.0",
-        "@hono/node-server": "1.15.0",
-        "@hono/swagger-ui": "^0.5.2",
-        "@hono/zod-openapi": "^0.16.4",
-        "@iarna/toml": "^2.2.5",
-        meilisearch: "^0.33.0",
-        lodash: "^4.17.21",
-        zod: "^3.23.30",
-        axios: "^1.9.0",
-        hono: "4.8.3",
-        semver: "^7.5.4",
-    };
-    for (const [depName, depVer] of Object.entries(packageDeps)) {
-        if (!enableValidation || ((_a = typedAllPackagesList[depName]) === null || _a === void 0 ? void 0 : _a.validated)) {
-            newDeps[depName] = depVer || "latest";
-        }
-    }
-    // const blacklistDeps = new Set([
-    //   "@mcp-server/google-search-mcp",
-    //   "@executeautomation/playwright-mcp-server",
-    // ]);
-    // for (const dep of blacklistDeps) {
-    //   if (newDeps[dep]) {
-    //     delete newDeps[dep];
-    //   }
-    // }
-    const packageJSON = JSON.parse(packageJSONStr);
-    packageJSON.dependencies = newDeps;
-    fs.writeFileSync(packageJsonFile, JSON.stringify(packageJSON, null, 2), "utf-8");
-    console.log(`Generated new package.json file at ${packageJsonFile}`);
-    return;
-}
-export function getActualVersion(packageName, configuredVersion) {
-    if (configuredVersion && configuredVersion !== "latest") {
-        return configuredVersion;
-    }
-    try {
-        const packageJsonPath = path.join(__dirname, "../node_modules", packageName, "package.json");
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-        return packageJson.version;
-    }
-    catch (e) {
-        console.warn(`Failed to read version for ${packageName}, using 'latest' by default`, e.message);
-        return "latest";
-    }
-}
-export function withTimeout(ms, promise) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            reject(new Error(`Operation timed out after ${ms}ms`));
-        }, ms);
-        promise.then((res) => {
-            clearTimeout(timer);
-            resolve(res);
-        }, (err) => {
-            clearTimeout(timer);
-            reject(err);
-        });
-    });
-}
-function checkDependencyValidity(dependencyData, versionRange) {
-    // 兼容 "latest" 的情况
-    if (versionRange === "latest") {
-        return Object.keys(dependencyData.versions).length > 0;
-    }
-    // 使用 semver 检查是否有满足版本范围的有效版本
-    const versions = Object.keys(dependencyData.versions);
-    for (const version of versions) {
-        if (semver.satisfies(version, versionRange)) {
-            return true;
-        }
-    }
-    return false;
-}
-async function checkDependencies(dependencies) {
-    const dependencyCache = {};
-    const checkSingleDependency = async (depName, depVersionRange) => {
-        const cacheKey = `${depName}@${depVersionRange}`;
-        if (dependencyCache[cacheKey] !== undefined) {
-            return dependencyCache[cacheKey];
-        }
-        try {
-            const depResponse = await axios.get(`https://registry.npmjs.org/${depName}`, {
-                timeout: 5000,
-                headers: {
-                    "User-Agent": "MyToolManager/1.0",
-                },
-            });
-            if (depResponse.status !== 200 || !depResponse.data.versions) {
-                console.error(`Failed to fetch ${depName}`);
-                dependencyCache[cacheKey] = false;
-                return false;
-            }
-            const isValid = checkDependencyValidity(depResponse.data, depVersionRange);
-            dependencyCache[cacheKey] = isValid;
-            if (!isValid) {
-                console.error(`Invalid or missing: ${depName}`);
-            }
-            return isValid;
-        }
-        catch (error) {
-            console.error(`Error fetching ${depName}: ${error.message}`);
-            dependencyCache[cacheKey] = false;
-            return false;
-        }
-    };
-    const promises = Object.entries(dependencies).map(([depName, depVersionRange]) => checkSingleDependency(depName, depVersionRange));
-    const results = await Promise.all(promises);
-    return results.every((result) => result);
-}
-export async function isValidNpmPackage(packageName) {
-    var _a, _b, _c, _d;
-    try {
-        // 检查主包是否存在
-        console.log("checking package:", packageName);
-        const response = await axios.get(`https://registry.npmjs.org/${packageName}`, {
-            timeout: 5000,
-            headers: {
-                "User-Agent": "MyToolManager/1.0",
-            },
-        });
-        // 检查主包是否被标记为 unpublished
-        if (response.status !== 200 || !((_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a["dist-tags"]) === null || _b === void 0 ? void 0 : _b.latest)) {
-            console.error(`Package marked as unpublished: ${packageName}`);
-            return false;
-        }
-        // 获取主包的最新版本信息
-        const latestVersion = response.data["dist-tags"].latest;
-        const versionData = (_d = (_c = response.data) === null || _c === void 0 ? void 0 : _c.versions) === null || _d === void 0 ? void 0 : _d[latestVersion];
-        if (!versionData) {
-            console.error(`Invalid package: ${packageName} - No version data found`);
-            return false;
-        }
-        // 检查 dependencies 和 devDependencies
-        console.log(`Checking dependencies for ${packageName}`);
-        const dependencies = Object.assign(Object.assign({}, versionData.dependencies), versionData.devDependencies);
-        if (!(await checkDependencies(dependencies))) {
-            return false;
-        }
-        console.log(`Valid package: ${packageName}`);
-        return true;
-    }
-    catch (error) {
-        console.error(`Error validating package ${packageName}:`, error.message);
-        return false;
-    }
-}
-/**
- * Parses the pyproject.toml file and returns its content
- * @returns Parsed pyproject.toml content
- */
-export function parsePyprojectToml() {
-    const pyprojectPath = "./python-mcp/pyproject.toml";
-    const content = fs.readFileSync(pyprojectPath, "utf-8");
-    return toml.parse(content);
-}
-/**
- * Extracts package name from a dependency string
- * @param dep - Dependency string (e.g., "package>=1.0.0")
- * @returns Package name without version constraints
- */
-export function extractPackageName(dep) {
-    return dep.split(/[=<>!]/)[0].trim();
-}
-/**
- * Gets Python dependencies from pyproject.toml
- * @returns Array of Python dependency names
- */
-export function getPythonDependencies() {
-    var _a;
-    const data = parsePyprojectToml();
-    const deps = ((_a = data.project) === null || _a === void 0 ? void 0 : _a.dependencies) || [];
-    return deps.map(extractPackageName);
-}
-export function extractLastOuterJSON(str) {
-    let braceCount = 0;
-    let end = -1;
-    let start = -1;
-    for (let i = str.length - 1; i >= 0; i--) {
-        const ch = str[i];
-        if (ch === "}") {
-            if (end === -1)
-                end = i;
-            braceCount++;
-        }
-        else if (ch === "{") {
-            braceCount--;
-            if (braceCount === 0 && end !== -1) {
-                start = i;
-                break;
-            }
-        }
-    }
-    if (start === -1 || end === -1) {
-        throw new Error("No valid JSON found in string");
-    }
-    const jsonStr = str.slice(start, end + 1);
-    return jsonStr;
-}

package/dist/sandbox/mcp-sandbox-client.d.ts

@@ -1,16 +0,0 @@
-import type { Tool } from "@modelcontextprotocol/sdk/types.js";
-import type { MCPSandboxProvider } from "../types";
-export declare class MCPSandboxClient {
-    private sandbox;
-    private initializing;
-    private readonly apiKey;
-    private readonly provider;
-    private runtime;
-    constructor(runtime?: "node" | "python" | "java" | "go", provider?: MCPSandboxProvider);
-    initialize(): Promise<void>;
-    kill(): Promise<void>;
-    listTools(packageKey: string): Promise<Tool[]>;
-    executeTool(packageKey: string, toolName: string, argumentsObj: Record<string, unknown>, envs?: Record<string, string>): Promise<unknown>;
-    private generateMCPTestCode;
-    private generateEnvVariables;
-}