@toolsdk.ai/registry 1.0.113 → 1.0.114

package/dist/api/package-handler.js

@@ -1,13 +1,12 @@
+import { getSandboxProvider } from "../helper";
 import { createErrorResponse, createResponse } from "../utils";
 import { PackageSO } from "./package-so";
-const shouldUseSandbox = () => {
-    return process.env.USE_MCP_SANDBOX === "true";
-};
 export const packageHandler = {
     executeTool: async (c) => {
         const requestBody = await c.req.json();
+        const provider = getSandboxProvider();
         try {
-            const toolSO = new PackageSO(shouldUseSandbox());
+            const toolSO = new PackageSO(provider);
             const result = await toolSO.executeTool(requestBody);
             const response = createResponse(result);
             return c.json(response, 200);
@@ -35,8 +34,9 @@ export const packageHandler = {
             const errorResponse = createErrorResponse("Missing packageName query parameter", 400);
             return c.json(errorResponse, 200);
         }
+        const provider = getSandboxProvider();
         try {
-            const toolSO = new PackageSO(shouldUseSandbox());
+            const toolSO = new PackageSO(provider);
             const result = await toolSO.getPackageDetail(packageName);
             const response = createResponse(result);
             return c.json(response, 200);
@@ -55,8 +55,9 @@ export const packageHandler = {
             const errorResponse = createErrorResponse("Missing packageName query parameter", 400);
             return c.json(errorResponse, 200);
         }
+        const provider = getSandboxProvider();
         try {
-            const toolSO = new PackageSO(shouldUseSandbox());
+            const toolSO = new PackageSO(provider);
             const result = await toolSO.listTools(packageName);
             const response = createResponse(result);
             return c.json(response, 200);

package/dist/api/package-so.d.ts

@@ -1,16 +1,16 @@
 import type { Tool } from "@modelcontextprotocol/sdk/types.js";
 import { MCPSandboxClient } from "../sandbox/mcp-sandbox-client.js";
-import type { MCPServerPackageConfig, ToolExecute } from "../types";
+import type { MCPSandboxProvider, MCPServerPackageConfig, ToolExecute } from "../types";
 export declare class PackageSO {
-    private useSandbox;
-    private sandboxClient;
+    private sandboxProvider;
     private static sandboxInstances;
     private static MAX_SANDBOXES;
-    private static IDLE_CLOSE_MS;
-    constructor(useSandbox?: boolean);
-    static acquireSandbox(key?: string): Promise<MCPSandboxClient>;
-    static releaseSandbox(key?: string): Promise<void>;
+    constructor(provider?: MCPSandboxProvider);
+    static acquireSandbox(runtime?: "node" | "python" | "java" | "go", provider?: MCPSandboxProvider): Promise<MCPSandboxClient>;
+    static releaseSandbox(runtime?: "node" | "python" | "java" | "go", provider?: MCPSandboxProvider): Promise<void>;
     static cleanupSandboxInstances(): Promise<void>;
+    private static getSandboxKey;
+    private isSandboxEnabled;
     executeTool(request: ToolExecute): Promise<unknown>;
     private executeToolInSandbox;
     listTools(packageName: string): Promise<Tool[]>;

package/dist/api/package-so.js

@@ -5,66 +5,17 @@ import { MCPSandboxClient } from "../sandbox/mcp-sandbox-client.js";
 import { getDirname } from "../utils";
 const __dirname = getDirname(import.meta.url);
 export class PackageSO {
-    constructor(useSandbox = false) {
-        this.useSandbox = false;
-        this.sandboxClient = null;
-        this.useSandbox = useSandbox;
-        if (useSandbox) {
-            const sandboxKey = "default";
-            const record = PackageSO.sandboxInstances.get(sandboxKey);
-            if (record) {
-                record.refCount++;
-                record.lastUsedAt = Date.now();
-                this.sandboxClient = record.client;
-                // Cancel all idle close timer
-                record.client.touch();
-            }
-            else {
-                // Create a new instance if none exists (subject to max limit)
-                this.sandboxClient = new MCPSandboxClient();
-                const newRecord = {
-                    client: this.sandboxClient,
-                    refCount: 1,
-                    lastUsedAt: Date.now(),
-                    idleCloseMs: PackageSO.IDLE_CLOSE_MS,
-                };
-                // Try to insert, evict LRU idle instance if MAX is reached
-                if (PackageSO.sandboxInstances.size >= PackageSO.MAX_SANDBOXES) {
-                    // Find the oldest idle instance (refCount === 0)
-                    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);
-                        // Immediately close and delete
-                        if (evict) {
-                            evict.client.kill().catch((e) => {
-                                console.error("[PackageSO] Error killing evicted sandbox:", e);
-                            });
-                            PackageSO.sandboxInstances.delete(lruKey);
-                        }
-                    }
-                    else {
-                        // No recyclable instances -> throw error to prevent exceeding system limit
-                        throw new Error("Cannot create new sandbox: max sandboxes reached and none are idle");
-                    }
-                }
-                PackageSO.sandboxInstances.set(sandboxKey, newRecord);
-            }
-        }
+    constructor(provider = "LOCAL") {
+        this.sandboxProvider = "LOCAL";
+        this.sandboxProvider = provider;
     }
     // Acquire / Release explicit APIs (for external or future use)
-    static async acquireSandbox(key = "default") {
-        const record = PackageSO.sandboxInstances.get(key);
+    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();
-            record.client.touch();
             return record.client;
         }
         // Create new instance (note MAX_SANDBOXES check, consistent with constructor logic)
@@ -91,25 +42,32 @@ export class PackageSO {
                 throw new Error("Cannot create new sandbox: max sandboxes reached and none are idle");
             }
         }
-        const client = new MCPSandboxClient();
+        const client = new MCPSandboxClient(runtime, provider);
         const newRecord = {
             client,
             refCount: 1,
             lastUsedAt: Date.now(),
-            idleCloseMs: PackageSO.IDLE_CLOSE_MS,
+            provider,
         };
-        PackageSO.sandboxInstances.set(key, newRecord);
+        PackageSO.sandboxInstances.set(sandboxKey, newRecord);
         return client;
     }
-    static async releaseSandbox(key = "default") {
-        const record = PackageSO.sandboxInstances.get(key);
+    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) {
-            // schedule idle close after IDLE_CLOSE_MS
-            record.client.scheduleIdleClose(record.idleCloseMs || PackageSO.IDLE_CLOSE_MS);
+            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
@@ -128,9 +86,15 @@ export class PackageSO {
         }
         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.useSandbox && mcpServerConfig.runtime === "node") {
+        if (this.isSandboxEnabled()) {
             try {
                 const result = await this.executeToolInSandbox(request);
                 return result;
@@ -153,15 +117,13 @@ export class PackageSO {
         }
     }
     async executeToolInSandbox(request) {
-        if (!this.sandboxClient) {
-            throw new Error("Sandbox client not initialized");
-        }
+        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 this.sandboxClient.initialize();
-        // Mark usage
-        this.sandboxClient.touch();
+        await sandboxClient.initialize();
         try {
-            const result = await this.sandboxClient.executeTool(request.packageName, request.toolKey, request.inputData || {}, request.envs);
+            const result = await sandboxClient.executeTool(request.packageName, request.toolKey, request.inputData || {}, request.envs);
             console.log(`Tool ${request.toolKey} executed successfully in sandbox`);
             return result;
         }
@@ -169,9 +131,9 @@ export class PackageSO {
             // 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 this.sandboxClient.initialize();
+                await sandboxClient.initialize();
                 // Retry tool execution
-                const result = await this.sandboxClient.executeTool(request.packageName, request.toolKey, request.inputData || {}, request.envs);
+                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;
             }
@@ -179,12 +141,12 @@ export class PackageSO {
         }
         finally {
             // Release reference count
-            await PackageSO.releaseSandbox("default");
+            await PackageSO.releaseSandbox(runtime, this.sandboxProvider);
         }
     }
     async listTools(packageName) {
         const mcpServerConfig = getPackageConfigByKey(packageName);
-        if (this.useSandbox && mcpServerConfig.runtime === "node") {
+        if (this.isSandboxEnabled()) {
             try {
                 const tools = await this.listToolsInSandbox(packageName);
                 return tools;
@@ -210,14 +172,13 @@ export class PackageSO {
         }
     }
     async listToolsInSandbox(packageName) {
-        if (!this.sandboxClient) {
-            throw new Error("Sandbox client not initialized");
-        }
-        // Initialize only if sandbox is not initialized
-        await this.sandboxClient.initialize();
-        this.sandboxClient.touch();
+        const mcpServerConfig = getPackageConfigByKey(packageName);
+        const runtime = mcpServerConfig.runtime || "python";
+        const sandboxClient = await PackageSO.acquireSandbox(runtime, this.sandboxProvider);
         try {
-            const tools = await this.sandboxClient.listTools(packageName);
+            // 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;
         }
@@ -225,16 +186,16 @@ export class PackageSO {
             // 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 this.sandboxClient.initialize();
+                await sandboxClient.initialize();
                 // Retry listing tools
-                const tools = await this.sandboxClient.listTools(packageName);
+                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("default");
+            await PackageSO.releaseSandbox(runtime, this.sandboxProvider);
         }
     }
     async getPackageDetail(packageName) {
@@ -260,4 +221,3 @@ export class PackageSO {
 }
 PackageSO.sandboxInstances = new Map();
 PackageSO.MAX_SANDBOXES = 10;
-PackageSO.IDLE_CLOSE_MS = 5 * 60 * 1000;

package/dist/helper.d.ts

@@ -1,6 +1,6 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import type { MCPServerPackageConfig } from "./types";
+import type { MCPSandboxProvider, MCPServerPackageConfig } from "./types";
 export declare const typedAllPackagesList: Record<string, {
     path: string;
     category?: string | undefined;
@@ -10,6 +10,7 @@ export declare const typedAllPackagesList: Record<string, {
         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<{
@@ -69,4 +70,5 @@ export declare function extractPackageName(dep: string): string;
  * @returns Array of Python dependency names
  */
 export declare function getPythonDependencies(): string[];
+export declare function extractLastOuterJSON(str: string): string;
 export {};

package/dist/helper.js

@@ -11,6 +11,14 @@ 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) {
@@ -101,6 +109,7 @@ export function updatePackageJsonDependencies({ packageDeps, enableValidation =
     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",
@@ -276,3 +285,28 @@ export function getPythonDependencies() {
     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,37 +1,16 @@
 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 toolCache;
-    private readonly E2B_SANDBOX_TIMEOUT_MS;
-    private readonly TOOL_CACHE_TTL;
-    TOOL_EXECUTION_TIMEOUT: number;
-    private lastTouchTime;
-    private readonly THROTTLE_DELAY_MS;
-    createdAt: number | null;
-    lastUsedAt: number | null;
-    private ttlTimer;
-    private autoCloseOnIdleTimer;
-    private idleCloseMs;
-    constructor(apiKey?: string);
+    private readonly provider;
+    private runtime;
+    constructor(runtime?: "node" | "python" | "java" | "go", provider?: MCPSandboxProvider);
     initialize(): Promise<void>;
-    private setupTTLTimer;
-    /**
-     * Update sandbox last used time
-     */
-    touch(): void;
-    /**
-     * Actually perform the touch operation
-     */
-    private performTouch;
-    scheduleIdleClose(idleMs: number): void;
     kill(): Promise<void>;
-    clearPackageCache(packageKey: string): void;
-    clearAllCache(): void;
     listTools(packageKey: string): Promise<Tool[]>;
     executeTool(packageKey: string, toolName: string, argumentsObj: Record<string, unknown>, envs?: Record<string, string>): Promise<unknown>;
-    private runCodeWithTimeout;
     private generateMCPTestCode;
     private generateEnvVariables;
 }