@toolsdk.ai/registry 1.0.114 → 1.0.116

package/README.md

@@ -6,35 +6,70 @@
 
 [![Product Hunt](https://api.producthunt.com/widgets/embed-image/v1/top-post-badge.svg?post_id=997428&theme=light&period=daily)](https://www.producthunt.com/products/toolsdk-ai)
 
-![How many MCP Servers in Awesome MCP Registry](https://img.shields.io/badge/MCP_Servers-4107-blue)
+![How many MCP Servers in Awesome MCP Registry](https://img.shields.io/badge/MCP_Servers-4108-blue)
 ![awesome-mcp-registry License](https://img.shields.io/badge/LICENSE-MIT-ff69b4)
 
-An open, high-quality, well-structured and developer-friendly list of 4107+ MCP servers.
+🚀 **Open-source**, **production-ready**, and **developer-friendly** registry for 4108+ Model Context Protocol (MCP) servers, plugins, and AI agent tools.
+
+Perfect for **AI automation**, **chatbot development**, **LLM integrations**, and **enterprise AI deployments**.
 
 ---
 
 </div>
 
-The **Awesome MCP Registry** acts as a central database for MCP servers and packages.  
+## 🌟 Why Awesome MCP Registry?
+
+**Awesome MCP Registry** is the most comprehensive, self-hosted registry for Model Context Protocol (MCP) servers and AI agent tools. Built for developers, teams, and enterprises who need full control over their AI infrastructure.
 
-You can use it to:
+### 🎯 Key Features
 
-- ⚡ Build and host your own MCP projects with ease  
-- 🔒 Deploy a fully **private registry** for your team or organization  
-- 🛠️ Maintain complete control of your MCP tools in a secure environment  
+- 🔐 **Private & Self-Hosted** - Deploy your own secure MCP registry with Docker in minutes
+- 🤖 **4108+ AI Tools** - Largest curated collection of MCP servers for Claude, LLMs, and AI agents
+- ⚡ **Remote Execution** - Run MCP tools in isolated sandbox environments via REST API
+- 🔍 **Powerful Search** - Fast, full-text search powered by Meilisearch
+- 📦 **NPM Integration** - Use as a TypeScript/Node.js SDK in your projects
+- 🛠️ **Developer-Friendly** - OpenAPI/Swagger documentation, structured JSON configs
+- 🐳 **Docker Ready** - Production-grade deployment with Docker Compose
+- 🔌 **Plugin System** - Extensible architecture for custom integrations
 
-This registry leverages structured JSON configs to generate:  
+### 💡 Use Cases
 
-- `README.md`  
-- [npm package](https://www.npmjs.com/package/@toolsdk.ai/registry)  
-- [packages-list.json](https://toolsdk-ai.github.io/awesome-mcp-registry/indexes/packages-list.json)  
+- 🏢 **Enterprise AI Teams** - Deploy private MCP registry for your organization
+- 🤖 **AI Agent Development** - Build and test AI agents with verified MCP tools
+- 💬 **Chatbot Builders** - Integrate LLM-powered chatbots with MCP servers
+- 🔧 **Developer Tools** - Access automation tools, APIs, and integrations
+- 🚀 **CI/CD Automation** - Execute MCP tools in your deployment pipelines
 
 ---
 
-- [Video: How to submit a MCP server in JSON file?](https://www.youtube.com/watch?v=J_oaDtCoVVo)
-- [Quick Start](#quick-start)
-- [Contributing Guide](./docs/guide.md)
-- [Awesome MCP Servers](#mcp-servers)
+## 📦 What You Get
+
+This open-source registry provides:
+
+- 📚 **Structured Database** - 4108+ validated MCP servers with metadata
+- 🔗 **Multiple Formats** - JSON, npm package, and generated documentation
+- 🌐 **REST API** - Query and execute tools remotely
+- 📖 **Auto-Generated Docs** - Always up-to-date README and API documentation
+
+**Available as:**
+
+- 📄 `README.md` - Human-readable documentation
+- 📦 [npm package](https://www.npmjs.com/package/@toolsdk.ai/registry) - TypeScript/JavaScript SDK
+- 🔗 [packages-list.json](https://toolsdk-ai.github.io/awesome-mcp-registry/indexes/packages-list.json) - Raw data API  
+
+---
+
+## 📚 Table of Contents
+
+- [🎥 Video: How to submit a MCP server in JSON file?](https://www.youtube.com/watch?v=J_oaDtCoVVo)
+- [🚀 Quick Start](#quick-start)
+  - [🐳 Docker Self-Hosting](#-docker-self-hosting)
+  - [📦 Install via Package Manager](#install-via-package-manager)
+  - [📄 Submit New MCP Servers](#submit-new-mcp-servers)
+- [📖 Development Guide](./docs/DEVELOPMENT.md)
+- [🤝 Contributing Guide](./docs/guide.md)
+- [⭐ Awesome MCP Servers](#mcp-servers)
+
   - [Uncategorized](#uncategorized)
   - [Aggregators](#aggregators)
   - [Art & Culture](#art-and-culture)
@@ -71,30 +106,118 @@ This registry leverages structured JSON configs to generate:
 
 ## 🚀 Quick Start
 
-#### Install via package manager:
+### 🐳 Self-Hosted MCP Registry with Docker
+
+Deploy your own **private MCP registry** in 5 minutes! Get a production-ready AI agent tool registry with full-text search, REST API, and secure sandbox execution.
+
+Perfect for **AI developers**, **LLM teams**, and **enterprises** building with Claude, Anthropic, and other AI platforms.
+
+#### ⚡ Quick Deploy (2 Steps)
+
+**Step 1: Configure Sandbox Environment**
+
+- Get your Sandock API Key from https://sandock.ai (for secure remote code execution)
+- Edit `.env` and set: `SANDOCK_API_KEY=your-api-key-here`
+
+**Step 2: Launch with Docker Compose**
+
+```bash
+docker compose up -d
+```
+
+That's it! Your self-hosted MCP registry is now running with:
+- 🔍 **Full-text search** (Meilisearch)
+- 🌐 **REST API** with OpenAPI documentation
+- 🛡️ **Sandbox execution** for AI agent tools
+
+#### 🎉 Access Your Private AI Tool Registry
+
+- 🌐 **Web Interface**: http://localhost:3003
+- 📚 **Swagger API Docs**: http://localhost:3003/swagger  
+- 🔍 **Search & Execute** 4108+ MCP tools remotely
+- 🤖 **Integrate** with your AI agents, chatbots, and LLM applications
+
+#### 💻 Remote Tool Execution Example
+
+Execute any MCP tool via REST API - perfect for AI automation, chatbot integrations, and serverless deployments:
+
+```bash
+curl -X POST http://localhost:3003/api/v1/packages/run \
+  -H "Content-Type: application/json" \
+  -d '{
+    "packageName": "@modelcontextprotocol/server-everything",
+    "toolKey": "echo",
+    "inputData": {
+      "message": "Hello from Awesome MCP Registry!"
+    },
+    "envs": {}
+  }'
+```
+
+**Use Cases:**
+- 🤖 Build AI agents with remote tool execution
+- 💬 Power chatbots with MCP server integrations
+- 🚀 Create serverless AI workflows
+- 🔧 Automate tasks with LLM-powered tools
+
+> 📖 For advanced deployment options and configuration, see the [DEVELOPMENT documentation](./docs/DEVELOPMENT.md#4--quick-start-with-docker).
+
+<a id="install-via-package-manager"></a>
+
+### 📦 Install as NPM Package (TypeScript/Node.js SDK)
+
+Use the MCP Registry as a TypeScript/JavaScript SDK in your AI agent, chatbot, or LLM integration projects:
 
 ```bash
 npm install @toolsdk.ai/registry
 ```
 
-#### Use it on your JavaScript / Typescript project:
+#### Use in TypeScript/JavaScript Projects
+
+Perfect for AI agent development, chatbot builders, and LLM tool integrations:
 
 ```ts
 import mcpServerLists from '@toolsdk.ai/registry/indexes/packages-lists.json';
 ```
 
-#### Fetch all MCP Servers lists via cURL:
+#### 🌐 Access via Public API (No Installation Required)
+
+Fetch the complete MCP server registry programmatically - ideal for AI applications, integrations, and automation:
 
 ```bash
 curl https://toolsdk-ai.github.io/awesome-mcp-registry/indexes/packages-list.json
 ```
 
 ```ts
-// JavaScript TypeScript
-console.log(await(await fetch('https://toolsdk-ai.github.io/awesome-mcp-registry/indexes/packages-list.json')).json());
+// JavaScript/TypeScript - Fetch API
+const mcpServers = await (
+  await fetch('https://toolsdk-ai.github.io/awesome-mcp-registry/indexes/packages-list.json')
+).json();
+
+// Use for AI agent tool discovery, LLM integrations, etc.
+console.log(mcpServers);
 ```
 
-## 📦 Submit new MCP servers:
+```python
+# Python - For AI/ML projects
+import requests
+
+mcp_servers = requests.get(
+    'https://toolsdk-ai.github.io/awesome-mcp-registry/indexes/packages-list.json'
+).json()
+
+# Perfect for LangChain, CrewAI, AutoGen integrations
+```
+
+<a id="submit-new-mcp-servers"></a>
+
+## 🤝 Contribute Your MCP Server
+
+Help grow the world's largest open-source MCP registry! Share your AI tools, plugins, and integrations with the community.
+
+### How to Submit
+
+**1. Create JSON Config** - Simple, structured format:
 
 ```json
 {
@@ -114,15 +237,34 @@ console.log(await(await fetch('https://toolsdk-ai.github.io/awesome-mcp-registry
 }
 ```
 
-[Fork this repo](https://github.com/toolsdk-ai/awesome-mcp-registry/fork), and create a new file called `your-new-mcp-server.json` under [packages/uncategorized](./packages/uncategorized) folder.
+**2. Submit via Pull Request**
+
+- [Fork this repository](https://github.com/toolsdk-ai/awesome-mcp-registry/fork)
+- Create `your-mcp-server.json` in [packages/uncategorized](./packages/uncategorized)
+- Submit a PR and join 4108+ MCP servers!
+
+**3. Get Discovered**
+
+Your MCP server will be:
+- ✅ Listed in the registry
+- 🔍 Searchable via REST API
+- 📦 Available in npm package
+- 🌐 Featured on our website
+
+📖 **Detailed Guide**: [Contributing Documentation](./docs/guide.md)
+
+---
+
+<a id="mcp-servers"></a>
 
-For more detail please see [the guide](./docs/guide.md).
+## 📋 MCP Servers Directory
 
-## MCP Servers
+**4108+ AI Agent Tools, LLM Integrations & Automation Servers**
 
-✅: Validated and runnable tools (709)
+- ✅ **Validated & Tested** (709) - Production-ready MCP servers
+- ⚙️ **Community Contributed** (3399) - Requires configuration
 
-❌: Cannot be run by the MCP client (with mock environments variables (3398))
+Browse by category: Developer Tools, AI Agents, Databases, Cloud Platforms, APIs, and more!
 
 
 
@@ -1786,6 +1928,7 @@ Enhance your development workflow with tools for coding and environment manageme
 - [❌ @fiveohhwon/workflows-mcp](https://github.com/fiveohhwon/workflows-mcp): Provides workflow management and automation through step-by-step execution with branching logic, conditional operations, template variables, and state persistence for complex multi-step processes like code reviews and data pipelines.  (node) 
 - [❌ autodocument](https://github.com/pars-doe/autodocument): Automatically generates documentation, test plans, and code reviews for software repositories through a bottom-up analysis approach that respects .gitignore rules and handles existing file updates.  (node) 
 - [❌ gdb-debugger](https://github.com/yywz1999/gdb-mcp-server): Integrates GDB with AI capabilities to provide interactive debugging assistance for C/C++ applications, enabling breakpoint management, memory examination, and execution flow analysis during debugging sessions.  (python) 
+- [❌ @juspay/neurolink](https://github.com/juspay/neurolink): Universal AI development platform unifying 12+ providers (OpenAI, Anthropic, Google, Bedrock, Azure) with built-in MCP support, multi-provider failover, and production-ready enterprise features  (node) 
 - [❌ clojars-dependency-versions](https://github.com/bigsy/clojars-mcp-server): Retrieves information related to Clojure dependency management.  (node) 
 - [❌ react-analyzer](https://github.com/azer/react-analyzer-mcp): Enables parsing and analysis of React component structures, props, and state management patterns for code review, debugging, and understanding complex React codebases  (node) 
 - [❌ ansible](https://github.com/tarnover/mcp-sysoperator): Integrates with Ansible to enable infrastructure automation through direct execution of playbooks, ad-hoc commands, inventory management, and AWS resource operations for DevOps workflows  (node) 

package/dist/api/index.d.ts

@@ -1,3 +1,3 @@
 import { OpenAPIHono } from "@hono/zod-openapi";
-declare const app: OpenAPIHono;
+declare const app: OpenAPIHono<import("hono").Env, {}, "/">;
 export default app;

package/dist/api/index.js

@@ -1,19 +1,17 @@
-import fs from "node:fs/promises";
-import path from "node:path";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { serve } from "@hono/node-server";
 import { swaggerUI } from "@hono/swagger-ui";
 import { OpenAPIHono } from "@hono/zod-openapi";
-import dotenv from "dotenv";
-import { searchRoutes } from "../search/search-route";
-import searchService from "../search/search-service";
-import { getDirname } from "../utils";
-import { packageRoutes } from "./package-route";
-const __dirname = getDirname(import.meta.url);
-dotenv.config({ path: path.resolve(process.cwd(), ".env.local") });
-dotenv.config({ path: path.resolve(process.cwd(), ".env") });
+import { configRoutes } from "../domains/config/config-route";
+import { packageRoutes } from "../domains/package/package-route";
+import { searchRoutes } from "../domains/search/search-route";
+import { SearchSO } from "../domains/search/search-so";
+import { getServerPort, isSearchEnabled } from "../shared/config/environment";
+import { getDirname } from "../shared/utils";
 const initializeSearchService = async () => {
     try {
-        await searchService.initialize();
+        await SearchSO.getInstance();
         console.log("🔍 Search service initialized");
     }
     catch (error) {
@@ -21,22 +19,20 @@ const initializeSearchService = async () => {
         console.log("💡 Install and start MeiliSearch to enable enhanced search features");
     }
 };
+// Load search.html content
+const __dirname = getDirname(import.meta.url);
+const searchHtmlPath = join(__dirname, "../domains/search/search.html");
+const searchHtmlContent = readFileSync(searchHtmlPath, "utf-8");
 const app = new OpenAPIHono();
+// Domain routes
 app.route("/api/v1", packageRoutes);
-if (process.env.ENABLE_SEARCH === "true") {
+app.route("/api/v1/config", configRoutes);
+if (isSearchEnabled()) {
     initializeSearchService().catch(console.error);
-    app.route("/api/v1", searchRoutes);
+    app.route("/api/v1/search", searchRoutes);
 }
-app.get("/", async (c) => {
-    try {
-        const htmlPath = path.join(__dirname, "..", "search", "search.html");
-        const html = await fs.readFile(htmlPath, "utf8");
-        return c.html(html);
-    }
-    catch (error) {
-        console.error("Failed to load home page:", error);
-        return c.text("MCP Registry API Server is running!");
-    }
+app.get("/", (c) => {
+    return c.html(searchHtmlContent);
 });
 app.get("/api/meta", async (c) => {
     try {
@@ -50,6 +46,7 @@ app.get("/api/meta", async (c) => {
         return c.json({ version: "unknown" });
     }
 });
+// OpenAPI documentation
 app.doc("/api/v1/doc", {
     openapi: "3.0.0",
     info: {
@@ -57,6 +54,7 @@ app.doc("/api/v1/doc", {
         title: "MCP Registry API",
     },
 });
+// Swagger UI
 app.get("/swagger", swaggerUI({ url: "/api/v1/doc" }));
 app.notFound((c) => {
     return c.json({ success: false, code: 404, message: "[Registry API] Route not found" }, 404);
@@ -69,10 +67,10 @@ app.onError((err, c) => {
         message: `[Registry API] Internal server error, errMsg: ${err.message}`,
     }, 500);
 });
-const port = process.env.MCP_SERVER_PORT ? parseInt(process.env.MCP_SERVER_PORT, 10) : 3003;
-console.log(`Server is running on: http://localhost:${port}`);
+const port = getServerPort();
 serve({
     fetch: app.fetch,
     port,
 });
+console.log(`🚀 Server is running on http://localhost:${port}`);
 export default app;

package/dist/domains/config/config-route.d.ts

@@ -0,0 +1,2 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+export declare const configRoutes: OpenAPIHono<import("hono").Env, {}, "/">;

package/dist/domains/config/config-route.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+import { createRoute, OpenAPIHono } from "@hono/zod-openapi";
+import { getDirname } from "../../shared/utils/file-util";
+import { createResponse, createRouteResponses } from "../../shared/utils/response-util";
+import { configSchemas } from "./config-schema";
+const __dirname = getDirname(import.meta.url);
+export const configRoutes = new OpenAPIHono();
+const featuredRoute = createRoute({
+    method: "get",
+    path: "/featured",
+    responses: createRouteResponses(configSchemas.FeaturedResponseSchema),
+});
+configRoutes.openapi(featuredRoute, async (c) => {
+    const featuredPath = path.join(__dirname, "../../../config/featured.mjs");
+    const featuredModule = await import(`file://${featuredPath}`);
+    const featured = featuredModule.default;
+    const response = createResponse(featured);
+    return c.json(response, 200);
+});
+const categoriesRoute = createRoute({
+    method: "get",
+    path: "/categories",
+    responses: createRouteResponses(configSchemas.CategoriesResponseSchema),
+});
+configRoutes.openapi(categoriesRoute, async (c) => {
+    const categoriesPath = path.join(__dirname, "../../../config/categories.mjs");
+    const categoriesModule = await import(`file://${categoriesPath}`);
+    const categories = categoriesModule.default;
+    const response = createResponse(categories);
+    return c.json(response, 200);
+});

package/dist/domains/config/config-schema.d.ts

@@ -0,0 +1,57 @@
+import { z } from "@hono/zod-openapi";
+export declare const configSchemas: {
+    FeaturedResponseSchema: z.ZodObject<{
+        success: z.ZodBoolean;
+        code: z.ZodNumber;
+        message: z.ZodString;
+    } & {
+        data: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        success: boolean;
+        code: number;
+        message: string;
+        data?: string[] | undefined;
+    }, {
+        success: boolean;
+        code: number;
+        message: string;
+        data?: string[] | undefined;
+    }>;
+    CategoriesResponseSchema: z.ZodObject<{
+        success: z.ZodBoolean;
+        code: z.ZodNumber;
+        message: z.ZodString;
+    } & {
+        data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            key: string;
+            description?: string | undefined;
+        }, {
+            name: string;
+            key: string;
+            description?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        success: boolean;
+        code: number;
+        message: string;
+        data?: {
+            name: string;
+            key: string;
+            description?: string | undefined;
+        }[] | undefined;
+    }, {
+        success: boolean;
+        code: number;
+        message: string;
+        data?: {
+            name: string;
+            key: string;
+            description?: string | undefined;
+        }[] | undefined;
+    }>;
+};

package/dist/domains/config/config-schema.js

@@ -0,0 +1,10 @@
+import { z } from "@hono/zod-openapi";
+import { BaseResponseSchema, CategoryConfigSchema } from "../../shared/schemas/common-schema";
+export const configSchemas = {
+    FeaturedResponseSchema: BaseResponseSchema.extend({
+        data: z.array(z.string()).optional(),
+    }).openapi("FeaturedResponse"),
+    CategoriesResponseSchema: BaseResponseSchema.extend({
+        data: z.array(CategoryConfigSchema).optional(),
+    }).openapi("CategoriesResponse"),
+};

package/dist/domains/config/config-types.d.ts

@@ -0,0 +1,3 @@
+import type { z } from "zod";
+import type { CategoryConfigSchema } from "../../shared/schemas";
+export type CategoryConfig = z.infer<typeof CategoryConfigSchema>;

package/dist/domains/executor/executor-factory.d.ts

@@ -0,0 +1,9 @@
+import type { MCPSandboxProvider } from "../sandbox/sandbox-types";
+import type { ToolExecutor } from "./executor-types";
+/**
+ * Executor Factory
+ * Creates appropriate executor based on sandbox provider configuration
+ */
+export declare class ExecutorFactory {
+    static create(provider: MCPSandboxProvider): ToolExecutor;
+}

package/dist/domains/executor/executor-factory.js

@@ -0,0 +1,17 @@
+import { LocalExecutor } from "./local-executor";
+import { SandboxExecutor } from "./sandbox-executor";
+/**
+ * Executor Factory
+ * Creates appropriate executor based on sandbox provider configuration
+ */
+// biome-ignore lint/complexity/noStaticOnlyClass: Factory pattern
+export class ExecutorFactory {
+    static create(provider) {
+        if (provider === "LOCAL") {
+            console.log("[ExecutorFactory] Creating LocalExecutor");
+            return new LocalExecutor();
+        }
+        console.log(`[ExecutorFactory] Creating SandboxExecutor with provider: ${provider}`);
+        return new SandboxExecutor(provider);
+    }
+}

package/dist/domains/executor/executor-types.d.ts

@@ -0,0 +1,15 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+export interface ToolExecuteRequest {
+    packageName: string;
+    toolKey: string;
+    inputData: Record<string, unknown>;
+    envs?: Record<string, string>;
+}
+/**
+ * Tool Executor Interface
+ * Unified abstraction for local and sandbox execution
+ */
+export interface ToolExecutor {
+    executeTool(request: ToolExecuteRequest): Promise<unknown>;
+    listTools(packageName: string): Promise<Tool[]>;
+}

package/dist/domains/executor/local-executor.d.ts

@@ -0,0 +1,12 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { ToolExecuteRequest, ToolExecutor } from "./executor-types";
+/**
+ * Local Executor
+ * Executes MCP tools in local environment
+ */
+export declare class LocalExecutor implements ToolExecutor {
+    private readonly packageRepository;
+    constructor();
+    executeTool(request: ToolExecuteRequest): Promise<unknown>;
+    listTools(packageName: string): Promise<Tool[]>;
+}

package/dist/domains/executor/local-executor.js

@@ -0,0 +1,48 @@
+import path from "node:path";
+import { getDirname } from "../../shared/utils/file-util";
+import { getMcpClient } from "../../shared/utils/mcp-client-util";
+import { PackageRepository } from "../package/package-repository";
+/**
+ * Local Executor
+ * Executes MCP tools in local environment
+ */
+export class LocalExecutor {
+    constructor() {
+        const __dirname = getDirname(import.meta.url);
+        const packagesDir = path.join(__dirname, "../../../packages");
+        this.packageRepository = new PackageRepository(packagesDir);
+    }
+    async executeTool(request) {
+        const mcpServerConfig = this.packageRepository.getPackageConfig(request.packageName);
+        const { client, closeConnection } = await getMcpClient(mcpServerConfig, request.envs || {});
+        try {
+            const result = await client.callTool({
+                name: request.toolKey,
+                arguments: request.inputData,
+            });
+            console.log(`[LocalExecutor] Tool ${request.toolKey} executed successfully`);
+            return result;
+        }
+        finally {
+            await closeConnection();
+        }
+    }
+    async listTools(packageName) {
+        const mcpServerConfig = this.packageRepository.getPackageConfig(packageName);
+        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(`[LocalExecutor] Tools list retrieved successfully for package ${packageName}`);
+            return tools;
+        }
+        finally {
+            await closeConnection();
+        }
+    }
+}

package/dist/domains/executor/sandbox-executor.d.ts

@@ -0,0 +1,16 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { MCPSandboxProvider } from "../sandbox/sandbox-types";
+import type { ToolExecuteRequest, ToolExecutor } from "./executor-types";
+/**
+ * Sandbox Executor
+ * Executes MCP tools in sandbox environment
+ */
+export declare class SandboxExecutor implements ToolExecutor {
+    private readonly provider;
+    private readonly sandboxPool;
+    private readonly packageRepository;
+    private readonly localExecutor;
+    constructor(provider: MCPSandboxProvider);
+    executeTool(request: ToolExecuteRequest): Promise<unknown>;
+    listTools(packageName: string): Promise<Tool[]>;
+}