@toolsdk.ai/registry 1.0.121 → 1.0.122

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

@@ -5,5 +5,13 @@ import type { ToolExecutor } from "./executor-types";
  * Creates appropriate executor based on sandbox provider configuration
  */
 export declare class ExecutorFactory {
-    static create(provider: MCPSandboxProvider): ToolExecutor;
+    /**
+     * Validate if the provided sandbox provider is valid
+     */
+    private static isValidProvider;
+    /**
+     * Create executor with optional provider override
+     * If sandboxProvider is provided, it takes priority over environment config
+     */
+    static create(overrideProvider?: MCPSandboxProvider): ToolExecutor;
 }

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

@@ -1,3 +1,5 @@
+import { getSandboxProvider } from "../../shared/config/environment";
+import { VALID_SANDBOX_PROVIDERS } from "../sandbox/sandbox-types";
 import { LocalExecutor } from "./local-executor";
 import { SandboxExecutor } from "./sandbox-executor";
 /**
@@ -6,7 +8,20 @@ import { SandboxExecutor } from "./sandbox-executor";
  */
 // biome-ignore lint/complexity/noStaticOnlyClass: Factory pattern
 export class ExecutorFactory {
-    static create(provider) {
+    /**
+     * Validate if the provided sandbox provider is valid
+     */
+    static isValidProvider(provider) {
+        return VALID_SANDBOX_PROVIDERS.includes(provider);
+    }
+    /**
+     * Create executor with optional provider override
+     * If sandboxProvider is provided, it takes priority over environment config
+     */
+    static create(overrideProvider) {
+        const provider = ExecutorFactory.isValidProvider(overrideProvider)
+            ? overrideProvider
+            : getSandboxProvider();
         if (provider === "LOCAL") {
             console.log("[ExecutorFactory] Creating LocalExecutor");
             return new LocalExecutor();

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

@@ -1,9 +1,11 @@
 import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { MCPSandboxProvider } from "../sandbox/sandbox-types";
 export interface ToolExecuteRequest {
     packageName: string;
     toolKey: string;
     inputData: Record<string, unknown>;
     envs?: Record<string, string>;
+    sandboxProvider?: MCPSandboxProvider;
 }
 /**
  * Tool Executor Interface
@@ -11,5 +13,5 @@ export interface ToolExecuteRequest {
  */
 export interface ToolExecutor {
     executeTool(request: ToolExecuteRequest): Promise<unknown>;
-    listTools(packageName: string): Promise<Tool[]>;
+    listTools(packageName: string, sandboxProvider?: MCPSandboxProvider): Promise<Tool[]>;
 }

package/dist/domains/package/package-handler.d.ts

@@ -1,15 +1,16 @@
+import type { MCPSandboxProvider } from "../sandbox/sandbox-types";
 export declare const packageHandler: {
-    getPackageDetail: (packageName: string) => Promise<{
+    getPackageDetail: (packageName: string, sandboxProvider?: MCPSandboxProvider) => Promise<{
         success: boolean;
         code: number;
         message: string;
     }>;
-    executeTool: (packageName: string, toolKey: string, inputData: Record<string, unknown>, envs?: Record<string, string>) => Promise<{
+    executeTool: (packageName: string, toolKey: string, inputData: Record<string, unknown>, envs?: Record<string, string>, sandboxProvider?: MCPSandboxProvider) => Promise<{
         success: boolean;
         code: number;
         message: string;
     }>;
-    listTools: (packageName: string) => Promise<{
+    listTools: (packageName: string, sandboxProvider?: MCPSandboxProvider) => Promise<{
         success: boolean;
         code: number;
         message: string;

package/dist/domains/package/package-handler.js

@@ -1,5 +1,4 @@
 import path from "node:path";
-import { getSandboxProvider } from "../../shared/config/environment";
 import { getDirname } from "../../shared/utils/file-util";
 import { createErrorResponse, createResponse } from "../../shared/utils/response-util";
 import { ExecutorFactory } from "../executor/executor-factory";
@@ -8,10 +7,10 @@ import { PackageSO } from "./package-so";
 const __dirname = getDirname(import.meta.url);
 const packagesDir = path.join(__dirname, "../../../packages");
 const repository = new PackageRepository(packagesDir);
-const executor = ExecutorFactory.create(getSandboxProvider());
 export const packageHandler = {
-    getPackageDetail: async (packageName) => {
+    getPackageDetail: async (packageName, sandboxProvider) => {
         try {
+            const executor = ExecutorFactory.create(sandboxProvider);
             const packageSO = await PackageSO.init(packageName, repository, executor);
             const result = await packageSO.getDetailWithTools();
             return createResponse(result);
@@ -23,8 +22,9 @@ export const packageHandler = {
             throw error;
         }
     },
-    executeTool: async (packageName, toolKey, inputData, envs) => {
+    executeTool: async (packageName, toolKey, inputData, envs, sandboxProvider) => {
         try {
+            const executor = ExecutorFactory.create(sandboxProvider);
             const packageSO = await PackageSO.init(packageName, repository, executor);
             const result = await packageSO.executeTool(toolKey, inputData, envs);
             return createResponse(result);
@@ -42,8 +42,9 @@ export const packageHandler = {
             throw error;
         }
     },
-    listTools: async (packageName) => {
+    listTools: async (packageName, sandboxProvider) => {
         try {
+            const executor = ExecutorFactory.create(sandboxProvider);
             const packageSO = await PackageSO.init(packageName, repository, executor);
             const tools = await packageSO.getTools();
             return createResponse(tools);

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

@@ -13,8 +13,8 @@ const packageDetailRoute = createRoute({
     }),
 });
 packageRoutes.openapi(packageDetailRoute, async (c) => {
-    const { packageName } = c.req.valid("query");
-    const result = await packageHandler.getPackageDetail(packageName);
+    const { packageName, sandboxProvider } = c.req.valid("query");
+    const result = await packageHandler.getPackageDetail(packageName, sandboxProvider);
     return c.json(result, 200);
 });
 const toolsRoute = createRoute({
@@ -26,8 +26,8 @@ const toolsRoute = createRoute({
     }),
 });
 packageRoutes.openapi(toolsRoute, async (c) => {
-    const { packageName } = c.req.valid("query");
-    const result = await packageHandler.listTools(packageName);
+    const { packageName, sandboxProvider } = c.req.valid("query");
+    const result = await packageHandler.listTools(packageName, sandboxProvider);
     return c.json(result, 200);
 });
 const executeToolRoute = createRoute({
@@ -49,7 +49,7 @@ const executeToolRoute = createRoute({
 });
 packageRoutes.openapi(executeToolRoute, async (c) => {
     const body = c.req.valid("json");
-    const result = await packageHandler.executeTool(body.packageName, body.toolKey, body.inputData, body.envs);
+    const result = await packageHandler.executeTool(body.packageName, body.toolKey, body.inputData, body.envs, body.sandboxProvider);
     return c.json(result, 200);
 });
 const packagesListRoute = createRoute({

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

@@ -1,26 +1,32 @@
 import { z } from "@hono/zod-openapi";
 export declare const packageNameQuerySchema: z.ZodObject<{
     packageName: z.ZodString;
+    sandboxProvider: z.ZodOptional<z.ZodEnum<["LOCAL", "DAYTONA", "SANDOCK", "E2B"]>>;
 }, "strip", z.ZodTypeAny, {
     packageName: string;
+    sandboxProvider?: "SANDOCK" | "DAYTONA" | "E2B" | "LOCAL" | undefined;
 }, {
     packageName: string;
+    sandboxProvider?: "SANDOCK" | "DAYTONA" | "E2B" | "LOCAL" | undefined;
 }>;
 export declare const ToolExecuteSchema: z.ZodObject<{
     packageName: z.ZodString;
     toolKey: z.ZodString;
     inputData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     envs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    sandboxProvider: z.ZodOptional<z.ZodEnum<["LOCAL", "DAYTONA", "SANDOCK", "E2B"]>>;
 }, "strip", z.ZodTypeAny, {
     packageName: string;
     toolKey: string;
     inputData: Record<string, unknown>;
     envs?: Record<string, string> | undefined;
+    sandboxProvider?: "SANDOCK" | "DAYTONA" | "E2B" | "LOCAL" | undefined;
 }, {
     packageName: string;
     toolKey: string;
     inputData: Record<string, unknown>;
     envs?: Record<string, string> | undefined;
+    sandboxProvider?: "SANDOCK" | "DAYTONA" | "E2B" | "LOCAL" | undefined;
 }>;
 export declare const PackageDetailResponseSchema: z.ZodObject<{
     success: z.ZodBoolean;
@@ -28,12 +34,31 @@ export declare const PackageDetailResponseSchema: z.ZodObject<{
     message: z.ZodString;
 } & {
     data: z.ZodOptional<z.ZodObject<{
-        name: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"mcp-server">;
+        runtime: z.ZodEnum<["node", "python", "java", "go"]>;
         packageName: z.ZodString;
+        packageVersion: z.ZodOptional<z.ZodString>;
+        bin: z.ZodOptional<z.ZodString>;
+        binArgs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        key: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
-        category: z.ZodOptional<z.ZodString>;
-        validated: z.ZodOptional<z.ZodBoolean>;
-        runtime: z.ZodOptional<z.ZodEnum<["node", "python", "java", "go"]>>;
+        readme: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        license: z.ZodOptional<z.ZodString>;
+        logo: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodString;
+            required: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            required: boolean;
+        }, {
+            description: string;
+            required: boolean;
+        }>>>;
+    } & {
         tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
@@ -68,12 +93,24 @@ export declare const PackageDetailResponseSchema: z.ZodObject<{
             } | undefined;
         }>, "many">>;
     }, "strip", z.ZodTypeAny, {
+        type: "mcp-server";
+        runtime: "node" | "python" | "java" | "go";
         packageName: string;
         description?: string | undefined;
         name?: string | undefined;
-        runtime?: "node" | "python" | "java" | "go" | undefined;
-        category?: string | undefined;
-        validated?: boolean | undefined;
+        key?: string | undefined;
+        packageVersion?: string | undefined;
+        bin?: string | undefined;
+        binArgs?: string[] | undefined;
+        readme?: string | undefined;
+        url?: string | undefined;
+        license?: string | undefined;
+        logo?: string | undefined;
+        author?: string | undefined;
+        env?: Record<string, {
+            description: string;
+            required: boolean;
+        }> | undefined;
         tools?: {
             name: string;
             description?: string | undefined;
@@ -84,12 +121,24 @@ export declare const PackageDetailResponseSchema: z.ZodObject<{
             } | undefined;
         }[] | undefined;
     }, {
+        type: "mcp-server";
+        runtime: "node" | "python" | "java" | "go";
         packageName: string;
         description?: string | undefined;
         name?: string | undefined;
-        runtime?: "node" | "python" | "java" | "go" | undefined;
-        category?: string | undefined;
-        validated?: boolean | undefined;
+        key?: string | undefined;
+        packageVersion?: string | undefined;
+        bin?: string | undefined;
+        binArgs?: string[] | undefined;
+        readme?: string | undefined;
+        url?: string | undefined;
+        license?: string | undefined;
+        logo?: string | undefined;
+        author?: string | undefined;
+        env?: Record<string, {
+            description: string;
+            required: boolean;
+        }> | undefined;
         tools?: {
             name: string;
             description?: string | undefined;
@@ -105,12 +154,24 @@ export declare const PackageDetailResponseSchema: z.ZodObject<{
     code: number;
     message: string;
     data?: {
+        type: "mcp-server";
+        runtime: "node" | "python" | "java" | "go";
         packageName: string;
         description?: string | undefined;
         name?: string | undefined;
-        runtime?: "node" | "python" | "java" | "go" | undefined;
-        category?: string | undefined;
-        validated?: boolean | undefined;
+        key?: string | undefined;
+        packageVersion?: string | undefined;
+        bin?: string | undefined;
+        binArgs?: string[] | undefined;
+        readme?: string | undefined;
+        url?: string | undefined;
+        license?: string | undefined;
+        logo?: string | undefined;
+        author?: string | undefined;
+        env?: Record<string, {
+            description: string;
+            required: boolean;
+        }> | undefined;
         tools?: {
             name: string;
             description?: string | undefined;
@@ -126,12 +187,24 @@ export declare const PackageDetailResponseSchema: z.ZodObject<{
     code: number;
     message: string;
     data?: {
+        type: "mcp-server";
+        runtime: "node" | "python" | "java" | "go";
         packageName: string;
         description?: string | undefined;
         name?: string | undefined;
-        runtime?: "node" | "python" | "java" | "go" | undefined;
-        category?: string | undefined;
-        validated?: boolean | undefined;
+        key?: string | undefined;
+        packageVersion?: string | undefined;
+        bin?: string | undefined;
+        binArgs?: string[] | undefined;
+        readme?: string | undefined;
+        url?: string | undefined;
+        license?: string | undefined;
+        logo?: string | undefined;
+        author?: string | undefined;
+        env?: Record<string, {
+            description: string;
+            required: boolean;
+        }> | undefined;
         tools?: {
             name: string;
             description?: string | undefined;

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

@@ -1,5 +1,5 @@
 import { z } from "@hono/zod-openapi";
-import { BaseResponseSchema } from "../../shared/schemas/common-schema";
+import { BaseResponseSchema, MCPServerPackageConfigSchema, } from "../../shared/schemas/common-schema";
 export const packageNameQuerySchema = z.object({
     packageName: z
         .string()
@@ -9,6 +9,14 @@ export const packageNameQuerySchema = z.object({
         example: "@modelcontextprotocol/server-filesystem",
         description: "Package name",
     }),
+    sandboxProvider: z
+        .enum(["LOCAL", "DAYTONA", "SANDOCK", "E2B"])
+        .optional()
+        .openapi({
+        param: { name: "sandboxProvider", in: "query" },
+        example: "LOCAL",
+        description: "Optional sandbox provider to override default (LOCAL, DAYTONA, SANDOCK, E2B)",
+    }),
 });
 export const ToolExecuteSchema = z
     .object({
@@ -16,6 +24,10 @@ export const ToolExecuteSchema = z
     toolKey: z.string().openapi({ example: "read_file" }),
     inputData: z.record(z.unknown()).openapi({ example: { path: "/tmp/test.txt" } }),
     envs: z.record(z.string()).optional(),
+    sandboxProvider: z.enum(["LOCAL", "DAYTONA", "SANDOCK", "E2B"]).optional().openapi({
+        example: "LOCAL",
+        description: "Optional sandbox provider to override default (LOCAL, DAYTONA, SANDOCK, E2B)",
+    }),
 })
     .openapi("ToolExecute");
 const ToolDataSchema = z.object({
@@ -29,13 +41,7 @@ const ToolDataSchema = z.object({
     })
         .optional(),
 });
-const PackageDetailDataSchema = z.object({
-    name: z.string().optional(),
-    packageName: z.string(),
-    description: z.string().optional(),
-    category: z.string().optional(),
-    validated: z.boolean().optional(),
-    runtime: z.enum(["node", "python", "java", "go"]).optional(),
+const PackageDetailDataSchema = MCPServerPackageConfigSchema.extend({
     tools: z.array(ToolDataSchema).optional(),
 });
 export const PackageDetailResponseSchema = BaseResponseSchema.extend({

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

@@ -1,6 +1,7 @@
 import type { Tool } from "@modelcontextprotocol/sdk/types.js";
 import type { ToolExecutor } from "../executor/executor-types";
 import type { PackageRepository } from "./package-repository";
+import type { MCPServerPackageConfigWithTools } from "./package-types";
 export declare class PackageSO {
     private readonly _packageName;
     private readonly _config;
@@ -35,44 +36,5 @@ export declare class PackageSO {
     static init(packageName: string, repository: PackageRepository, executor: ToolExecutor): Promise<PackageSO>;
     getTools(): Promise<Tool[]>;
     executeTool(toolKey: string, inputData: Record<string, unknown>, envs?: Record<string, string>): Promise<unknown>;
-    getDetailWithTools(): Promise<{
-        name: string | undefined;
-        packageName: string;
-        description: string | undefined;
-        category: string | undefined;
-        validated: boolean | undefined;
-        tools: {
-            [x: string]: unknown;
-            name: string;
-            inputSchema: {
-                [x: string]: unknown;
-                type: "object";
-                properties?: {
-                    [x: string]: unknown;
-                } | undefined;
-                required?: string[] | undefined;
-            };
-            description?: string | undefined;
-            title?: string | undefined;
-            outputSchema?: {
-                [x: string]: unknown;
-                type: "object";
-                properties?: {
-                    [x: string]: unknown;
-                } | undefined;
-                required?: string[] | undefined;
-            } | undefined;
-            annotations?: {
-                [x: string]: unknown;
-                title?: string | undefined;
-                readOnlyHint?: boolean | undefined;
-                destructiveHint?: boolean | undefined;
-                idempotentHint?: boolean | undefined;
-                openWorldHint?: boolean | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-        }[] | undefined;
-    }>;
+    getDetailWithTools(): Promise<MCPServerPackageConfigWithTools>;
 }

package/dist/domains/package/package-so.js

@@ -49,13 +49,6 @@ export class PackageSO {
             console.warn(`[PackageSO] Failed to get tools for ${this.packageName}:`, error);
             tools = undefined;
         }
-        return {
-            name: this.name,
-            packageName: this.packageName,
-            description: this.description,
-            category: this.category,
-            validated: this.validated,
-            tools,
-        };
+        return Object.assign(Object.assign({}, this._config), { tools });
     }
 }

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

@@ -14,6 +14,7 @@ export interface SandboxClient {
     destroy(): Promise<void>;
 }
 export type MCPSandboxProvider = "SANDOCK" | "DAYTONA" | "E2B" | "LOCAL";
+export declare const VALID_SANDBOX_PROVIDERS: readonly MCPSandboxProvider[];
 export interface MCPToolResult {
     toolCount: number;
     tools: Tool[];

package/dist/domains/sandbox/sandbox-types.js

@@ -1 +1,6 @@
-export {};
+export const VALID_SANDBOX_PROVIDERS = [
+    "LOCAL",
+    "DAYTONA",
+    "SANDOCK",
+    "E2B",
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolsdk.ai/registry",
-  "version": "1.0.121",
+  "version": "1.0.122",
   "description": "An Open, Structured, and Standard Registry for MCP Servers and Packages.",
   "keywords": [
     "mcp",