@execbox/core 0.1.0

package/dist/index.js

@@ -0,0 +1,221 @@
+import { c as isJsonSerializable, d as isReservedWord, f as isValidIdentifier, l as sanitizeToolName, m as serializePropertyName, n as generateTypesFromJsonSchema, o as ExecuteFailure, p as sanitizeIdentifier, s as isExecuteFailure, t as resolveProvider, u as assertValidIdentifier } from "./resolveProvider-CUxAvFCK.js";
+import { parse } from "acorn";
+
+//#region src/executor/shared.ts
+const EXECUTION_TIMEOUT_MESSAGE = "Execution timed out";
+/**
+* Canonical error codes that may safely cross trusted executor boundaries.
+*/
+const KNOWN_EXECUTE_ERROR_CODES = new Set([
+	"timeout",
+	"memory_limit",
+	"validation_error",
+	"tool_error",
+	"runtime_error",
+	"serialization_error",
+	"internal_error"
+]);
+/**
+* Returns whether the value is one of execbox's stable execution error codes.
+*/
+function isKnownExecuteErrorCode(value) {
+	return KNOWN_EXECUTE_ERROR_CODES.has(value);
+}
+/**
+* Returns the stable timeout message used across executor implementations.
+*/
+function getExecutionTimeoutMessage() {
+	return EXECUTION_TIMEOUT_MESSAGE;
+}
+/**
+* Creates the canonical timeout failure result used for preflight cancellation.
+*/
+function createTimeoutExecuteResult(durationMs = 0) {
+	return {
+		durationMs,
+		error: {
+			code: "timeout",
+			message: getExecutionTimeoutMessage()
+		},
+		logs: [],
+		ok: false
+	};
+}
+/**
+* Normalizes an unknown thrown value into a human-readable message.
+*/
+function normalizeThrownMessage(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "object" && error !== null && "message" in error) {
+		const message = error.message;
+		if (typeof message === "string") return message;
+	}
+	return String(error);
+}
+/**
+* Returns the thrown error name when one is available.
+*/
+function normalizeThrownName(error) {
+	if (error instanceof Error) return error.name;
+	if (typeof error === "object" && error !== null && "name" in error) {
+		const name = error.name;
+		if (typeof name === "string") return name;
+	}
+}
+/**
+* Builds the standard tool execution context passed to resolved tool wrappers.
+*/
+function createExecutionContext(signal, providerName, safeToolName, originalToolName) {
+	return {
+		originalToolName,
+		providerName,
+		safeToolName,
+		signal
+	};
+}
+/**
+* Truncates captured logs to the configured line and character limits.
+*/
+function truncateLogs(logs, maxLogLines, maxLogChars) {
+	const limitedLines = logs.slice(0, maxLogLines);
+	let remainingChars = maxLogChars;
+	const truncated = [];
+	for (const line of limitedLines) {
+		if (remainingChars <= 0) break;
+		if (line.length <= remainingChars) {
+			truncated.push(line);
+			remainingChars -= line.length;
+			continue;
+		}
+		truncated.push(line.slice(0, remainingChars));
+		break;
+	}
+	return truncated;
+}
+function formatLogValue(value) {
+	if (typeof value === "string") return value;
+	if (value === void 0) return "undefined";
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+/**
+* Formats guest console arguments into a single host-side log line.
+*/
+function formatConsoleLine(values) {
+	return values.map((value) => formatLogValue(value)).join(" ");
+}
+
+//#endregion
+//#region src/normalize.ts
+function stripCodeFences(source) {
+	const match = source.match(/^\s*```[^\n]*\n([\s\S]*?)\n?```\s*$/);
+	return match ? match[1] : source;
+}
+function wrapAsync(body) {
+	if (body.trim().length === 0) return "async () => {}";
+	return `async () => {\n${body}\n}`;
+}
+/**
+* Normalizes model-produced JavaScript into an executable async function body.
+*/
+function normalizeCode(source) {
+	const normalizedSource = stripCodeFences(source).trim();
+	if (normalizedSource.length === 0) return "async () => {}";
+	try {
+		const program = parse(normalizedSource, {
+			ecmaVersion: "latest",
+			sourceType: "module"
+		});
+		if (program.body?.length === 1) {
+			const [statement] = program.body;
+			if (statement.type === "FunctionDeclaration" && statement.id?.name) return wrapAsync(`${normalizedSource}\nreturn ${statement.id.name}();`);
+			if (statement.type === "ExpressionStatement" && statement.expression) {
+				if (statement.expression.type === "ArrowFunctionExpression" && statement.expression.async) return normalizedSource;
+				return wrapAsync(`return (${normalizedSource});`);
+			}
+		}
+		const lastStatement = (program.body ?? []).at(-1);
+		if (lastStatement?.type === "ExpressionStatement" && lastStatement.expression) {
+			const bodyPrefix = normalizedSource.slice(0, lastStatement.start).trimEnd();
+			const expressionSource = normalizedSource.slice(lastStatement.expression.start, lastStatement.expression.end);
+			const lines = [];
+			if (bodyPrefix.length > 0) lines.push(bodyPrefix);
+			lines.push(`return (${expressionSource});`);
+			return wrapAsync(lines.join("\n"));
+		}
+		return wrapAsync(normalizedSource);
+	} catch {
+		return wrapAsync(normalizedSource);
+	}
+}
+
+//#endregion
+//#region src/runner.ts
+function toTrustedExecuteError(error) {
+	if (isExecuteFailure(error)) return {
+		code: error.code,
+		message: error.message
+	};
+	return {
+		code: "tool_error",
+		message: normalizeThrownMessage(error)
+	};
+}
+/**
+* Converts resolved providers into manifest metadata that reveals only namespace details.
+*/
+function extractProviderManifests(providers) {
+	return providers.map((provider) => ({
+		name: provider.name,
+		tools: Object.fromEntries(Object.entries(provider.tools).map(([safeToolName, descriptor]) => [safeToolName, {
+			description: descriptor.description,
+			originalName: descriptor.originalName,
+			safeName: descriptor.safeName
+		}])),
+		types: provider.types
+	}));
+}
+/**
+* Creates a host-side dispatcher for runner-emitted tool calls.
+*/
+function createToolCallDispatcher(providers, signal) {
+	const providerMap = new Map(providers.map((provider) => [provider.name, provider]));
+	return async (call) => {
+		const provider = providerMap.get(call.providerName);
+		const descriptor = provider?.tools[call.safeToolName];
+		if (!provider || !descriptor) return {
+			error: {
+				code: "internal_error",
+				message: `Unknown tool ${call.providerName}.${call.safeToolName}`
+			},
+			ok: false
+		};
+		try {
+			if (signal.aborted) return {
+				error: {
+					code: "timeout",
+					message: getExecutionTimeoutMessage()
+				},
+				ok: false
+			};
+			const result = await descriptor.execute(call.input, createExecutionContext(signal, provider.name, descriptor.safeName, descriptor.originalName));
+			if (result !== void 0 && !isJsonSerializable(result)) throw new ExecuteFailure("serialization_error", "Host value is not JSON-serializable");
+			return {
+				ok: true,
+				result
+			};
+		} catch (error) {
+			return {
+				error: toTrustedExecuteError(error),
+				ok: false
+			};
+		}
+	};
+}
+
+//#endregion
+export { ExecuteFailure, assertValidIdentifier, createExecutionContext, createTimeoutExecuteResult, createToolCallDispatcher, extractProviderManifests, formatConsoleLine, generateTypesFromJsonSchema, getExecutionTimeoutMessage, isExecuteFailure, isJsonSerializable, isKnownExecuteErrorCode, isReservedWord, isValidIdentifier, normalizeCode, normalizeThrownMessage, normalizeThrownName, resolveProvider, sanitizeIdentifier, sanitizeToolName, serializePropertyName, truncateLogs };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["truncated: string[]"],"sources":["../src/executor/shared.ts","../src/normalize.ts","../src/runner.ts"],"sourcesContent":["import type {\n  ExecuteError,\n  ExecuteErrorCode,\n  ExecuteResult,\n  ToolExecutionContext,\n} from \"../types\";\n\nconst EXECUTION_TIMEOUT_MESSAGE = \"Execution timed out\";\n\n/**\n * Canonical error codes that may safely cross trusted executor boundaries.\n */\nconst KNOWN_EXECUTE_ERROR_CODES = new Set<ExecuteErrorCode>([\n  \"timeout\",\n  \"memory_limit\",\n  \"validation_error\",\n  \"tool_error\",\n  \"runtime_error\",\n  \"serialization_error\",\n  \"internal_error\",\n]);\n\n/**\n * Returns whether the value is one of execbox's stable execution error codes.\n */\nexport function isKnownExecuteErrorCode(\n  value: unknown,\n): value is ExecuteErrorCode {\n  return KNOWN_EXECUTE_ERROR_CODES.has(value as ExecuteErrorCode);\n}\n\n/**\n * Returns the stable timeout message used across executor implementations.\n */\nexport function getExecutionTimeoutMessage(): string {\n  return EXECUTION_TIMEOUT_MESSAGE;\n}\n\n/**\n * Creates the canonical timeout failure result used for preflight cancellation.\n */\nexport function createTimeoutExecuteResult(durationMs = 0): ExecuteResult {\n  return {\n    durationMs,\n    error: {\n      code: \"timeout\",\n      message: getExecutionTimeoutMessage(),\n    } satisfies ExecuteError,\n    logs: [],\n    ok: false,\n  };\n}\n\n/**\n * Normalizes an unknown thrown value into a human-readable message.\n */\nexport function normalizeThrownMessage(error: unknown): string {\n  if (error instanceof Error) {\n    return error.message;\n  }\n\n  if (typeof error === \"object\" && error !== null && \"message\" in error) {\n    const message = (error as { message?: unknown }).message;\n    if (typeof message === \"string\") {\n      return message;\n    }\n  }\n\n  return String(error);\n}\n\n/**\n * Returns the thrown error name when one is available.\n */\nexport function normalizeThrownName(error: unknown): string | undefined {\n  if (error instanceof Error) {\n    return error.name;\n  }\n\n  if (typeof error === \"object\" && error !== null && \"name\" in error) {\n    const name = (error as { name?: unknown }).name;\n    if (typeof name === \"string\") {\n      return name;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Builds the standard tool execution context passed to resolved tool wrappers.\n */\nexport function createExecutionContext(\n  signal: AbortSignal,\n  providerName: string,\n  safeToolName: string,\n  originalToolName: string,\n): ToolExecutionContext {\n  return {\n    originalToolName,\n    providerName,\n    safeToolName,\n    signal,\n  };\n}\n\n/**\n * Truncates captured logs to the configured line and character limits.\n */\nexport function truncateLogs(\n  logs: string[],\n  maxLogLines: number,\n  maxLogChars: number,\n): string[] {\n  const limitedLines = logs.slice(0, maxLogLines);\n  let remainingChars = maxLogChars;\n  const truncated: string[] = [];\n\n  for (const line of limitedLines) {\n    if (remainingChars <= 0) {\n      break;\n    }\n\n    if (line.length <= remainingChars) {\n      truncated.push(line);\n      remainingChars -= line.length;\n      continue;\n    }\n\n    truncated.push(line.slice(0, remainingChars));\n    break;\n  }\n\n  return truncated;\n}\n\nfunction formatLogValue(value: unknown): string {\n  if (typeof value === \"string\") {\n    return value;\n  }\n\n  if (value === undefined) {\n    return \"undefined\";\n  }\n\n  try {\n    return JSON.stringify(value);\n  } catch {\n    return String(value);\n  }\n}\n\n/**\n * Formats guest console arguments into a single host-side log line.\n */\nexport function formatConsoleLine(values: unknown[]): string {\n  return values.map((value) => formatLogValue(value)).join(\" \");\n}\n","import { parse } from \"acorn\";\nimport type { Node } from \"acorn\";\n\ntype PositionedNode = Node & {\n  end: number;\n  start: number;\n  body?: PositionedNode[];\n  expression?: PositionedNode;\n  async?: boolean;\n  id?: {\n    name: string;\n  };\n};\n\nfunction stripCodeFences(source: string): string {\n  const match = source.match(/^\\s*```[^\\n]*\\n([\\s\\S]*?)\\n?```\\s*$/);\n  return match ? match[1] : source;\n}\n\nfunction wrapAsync(body: string): string {\n  if (body.trim().length === 0) {\n    return \"async () => {}\";\n  }\n\n  return `async () => {\\n${body}\\n}`;\n}\n\n/**\n * Normalizes model-produced JavaScript into an executable async function body.\n */\nexport function normalizeCode(source: string): string {\n  const normalizedSource = stripCodeFences(source).trim();\n\n  if (normalizedSource.length === 0) {\n    return \"async () => {}\";\n  }\n\n  try {\n    const program = parse(normalizedSource, {\n      ecmaVersion: \"latest\",\n      sourceType: \"module\",\n    }) as PositionedNode;\n\n    if (program.body?.length === 1) {\n      const [statement] = program.body;\n\n      if (statement.type === \"FunctionDeclaration\" && statement.id?.name) {\n        return wrapAsync(`${normalizedSource}\\nreturn ${statement.id.name}();`);\n      }\n\n      if (statement.type === \"ExpressionStatement\" && statement.expression) {\n        if (\n          statement.expression.type === \"ArrowFunctionExpression\" &&\n          statement.expression.async\n        ) {\n          return normalizedSource;\n        }\n\n        return wrapAsync(`return (${normalizedSource});`);\n      }\n    }\n\n    const body = program.body ?? [];\n    const lastStatement = body.at(-1);\n\n    if (\n      lastStatement?.type === \"ExpressionStatement\" &&\n      lastStatement.expression\n    ) {\n      const bodyPrefix = normalizedSource\n        .slice(0, lastStatement.start)\n        .trimEnd();\n      const expressionSource = normalizedSource.slice(\n        lastStatement.expression.start,\n        lastStatement.expression.end,\n      );\n\n      const lines = [];\n\n      if (bodyPrefix.length > 0) {\n        lines.push(bodyPrefix);\n      }\n\n      lines.push(`return (${expressionSource});`);\n\n      return wrapAsync(lines.join(\"\\n\"));\n    }\n\n    return wrapAsync(normalizedSource);\n  } catch {\n    return wrapAsync(normalizedSource);\n  }\n}\n","import {\n  createExecutionContext,\n  getExecutionTimeoutMessage,\n  normalizeThrownMessage,\n} from \"./executor/shared.ts\";\nimport {\n  ExecuteFailure,\n  isExecuteFailure,\n  isJsonSerializable,\n} from \"./errors.ts\";\nimport type { ExecuteError, ResolvedToolProvider } from \"./types.ts\";\n\n/**\n * Transport-safe metadata for one exposed tool.\n */\nexport interface ProviderToolManifest {\n  description?: string;\n  originalName: string;\n  safeName: string;\n}\n\n/**\n * Namespace manifest shared with runner implementations.\n */\nexport interface ProviderManifest {\n  name: string;\n  tools: Record<string, ProviderToolManifest>;\n  types: string;\n}\n\n/**\n * Execution limits forwarded to runner implementations.\n */\nexport interface ExecutorRuntimeOptions {\n  maxLogChars?: number;\n  maxLogLines?: number;\n  memoryLimitBytes?: number;\n  timeoutMs?: number;\n}\n\n/**\n * Public execution options accepted by executors per call.\n */\nexport interface ExecutionOptions extends ExecutorRuntimeOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Tool invocation request emitted from a runner.\n */\nexport interface ToolCall {\n  input: unknown;\n  providerName: string;\n  safeToolName: string;\n}\n\n/**\n * Trusted host response to a tool invocation request.\n */\nexport type ToolCallResult =\n  | {\n      ok: true;\n      result: unknown;\n    }\n  | {\n      error: ExecuteError;\n      ok: false;\n    };\n\nfunction toTrustedExecuteError(error: unknown): ExecuteError {\n  if (isExecuteFailure(error)) {\n    return {\n      code: error.code,\n      message: error.message,\n    };\n  }\n\n  return {\n    code: \"tool_error\",\n    message: normalizeThrownMessage(error),\n  };\n}\n\n/**\n * Converts resolved providers into manifest metadata that reveals only namespace details.\n */\nexport function extractProviderManifests(\n  providers: ResolvedToolProvider[],\n): ProviderManifest[] {\n  return providers.map((provider) => ({\n    name: provider.name,\n    tools: Object.fromEntries(\n      Object.entries(provider.tools).map(([safeToolName, descriptor]) => [\n        safeToolName,\n        {\n          description: descriptor.description,\n          originalName: descriptor.originalName,\n          safeName: descriptor.safeName,\n        },\n      ]),\n    ),\n    types: provider.types,\n  }));\n}\n\n/**\n * Creates a host-side dispatcher for runner-emitted tool calls.\n */\nexport function createToolCallDispatcher(\n  providers: ResolvedToolProvider[],\n  signal: AbortSignal,\n): (call: ToolCall) => Promise<ToolCallResult> {\n  const providerMap = new Map(\n    providers.map((provider) => [provider.name, provider] as const),\n  );\n\n  return async (call) => {\n    const provider = providerMap.get(call.providerName);\n    const descriptor = provider?.tools[call.safeToolName];\n\n    if (!provider || !descriptor) {\n      return {\n        error: {\n          code: \"internal_error\",\n          message: `Unknown tool ${call.providerName}.${call.safeToolName}`,\n        },\n        ok: false,\n      };\n    }\n\n    try {\n      if (signal.aborted) {\n        return {\n          error: {\n            code: \"timeout\",\n            message: getExecutionTimeoutMessage(),\n          },\n          ok: false,\n        };\n      }\n\n      const result = await descriptor.execute(\n        call.input,\n        createExecutionContext(\n          signal,\n          provider.name,\n          descriptor.safeName,\n          descriptor.originalName,\n        ),\n      );\n\n      if (result !== undefined && !isJsonSerializable(result)) {\n        throw new ExecuteFailure(\n          \"serialization_error\",\n          \"Host value is not JSON-serializable\",\n        );\n      }\n\n      return {\n        ok: true,\n        result,\n      };\n    } catch (error) {\n      return {\n        error: toTrustedExecuteError(error),\n        ok: false,\n      };\n    }\n  };\n}\n"],"mappings":"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"}

package/dist/mcp/index.cjs

@@ -0,0 +1,234 @@
+const require_resolveProvider = require('../resolveProvider-CixOjPKp.cjs');
+let zod = require("zod");
+zod = require_resolveProvider.__toESM(zod);
+let __modelcontextprotocol_sdk_server_mcp_js = require("@modelcontextprotocol/sdk/server/mcp.js");
+let __modelcontextprotocol_sdk_client_index_js = require("@modelcontextprotocol/sdk/client/index.js");
+let __modelcontextprotocol_sdk_inMemory_js = require("@modelcontextprotocol/sdk/inMemory.js");
+
+//#region src/mcp/mcpWrappedToolTypes.ts
+const MCP_CALL_TOOL_RESULT_TYPE = [
+	"type McpCallToolResult = {",
+	"  content: Array<{",
+	"    type: string;",
+	"    text?: string;",
+	"    data?: string;",
+	"    mimeType?: string;",
+	"    resource?: unknown;",
+	"    uri?: string;",
+	"    name?: string;",
+	"    description?: string;",
+	"  }>;",
+	"  structuredContent?: unknown;",
+	"  isError?: boolean;",
+	"  _meta?: Record<string, unknown>;",
+	"};"
+].join("\n");
+/**
+* Generates the wrapped MCP tool namespace declarations exposed to guest code.
+*/
+function generateMcpWrappedToolTypes(provider) {
+	const declarations = [MCP_CALL_TOOL_RESULT_TYPE];
+	for (const [safeName, tool] of Object.entries(provider.tools)) {
+		const comment = require_resolveProvider.renderDocComment([...tool.description ? [tool.description, ""] : [], "Wrapped MCP tool. Inspect structuredContent first, then fall back to content text items."]);
+		declarations.push([comment, `function ${safeName}(input: ${require_resolveProvider.schemaToType(tool.inputSchema)}): Promise<McpCallToolResult>;`].filter(Boolean).join("\n"));
+	}
+	return require_resolveProvider.renderNamespaceDeclaration(provider.name, declarations);
+}
+
+//#endregion
+//#region src/mcp/createMcpToolProvider.ts
+const DEFAULT_MCP_TOOL_CLIENT_INFO = {
+	name: "mcp-tool-client",
+	version: "0.0.0"
+};
+/**
+* Returns the upstream server identity when the source can provide one.
+*/
+function getMcpToolSourceServerInfo(source) {
+	if (source.serverInfo) return source.serverInfo;
+	if ("client" in source) return source.client.getServerVersion();
+}
+async function closeAll(closers) {
+	const rejected = (await Promise.allSettled(closers.map((close) => close()))).find((result) => result.status === "rejected");
+	if (rejected) throw rejected.reason;
+}
+async function openMcpToolClient(source, clientInfo) {
+	if ("client" in source) return {
+		client: source.client,
+		close: async () => {}
+	};
+	if (source.server.isConnected()) throw new Error("{ server } sources must be unconnected local MCP servers");
+	const [clientTransport, serverTransport] = __modelcontextprotocol_sdk_inMemory_js.InMemoryTransport.createLinkedPair();
+	const client = new __modelcontextprotocol_sdk_client_index_js.Client(clientInfo);
+	let closePromise;
+	await Promise.all([source.server.connect(serverTransport), client.connect(clientTransport)]);
+	return {
+		client,
+		close: async () => {
+			closePromise ??= closeAll([() => client.close(), () => source.server.close()]);
+			return closePromise;
+		}
+	};
+}
+/**
+* Opens an MCP tool source as a resolved execution provider with explicit cleanup.
+*/
+async function openMcpToolProvider(source, options = {}) {
+	const connection = await openMcpToolClient(source, options.clientInfo ?? DEFAULT_MCP_TOOL_CLIENT_INFO);
+	try {
+		const toolsResponse = await connection.client.listTools();
+		const provider = {
+			name: options.namespace ?? "mcp",
+			tools: {}
+		};
+		for (const tool of toolsResponse.tools) provider.tools[tool.name] = {
+			description: tool.description,
+			execute: async (input, context) => {
+				const argumentsObject = typeof input === "object" && input !== null ? input : void 0;
+				return connection.client.callTool({
+					arguments: argumentsObject,
+					name: tool.name
+				}, void 0, { signal: context.signal });
+			},
+			inputSchema: tool.inputSchema
+		};
+		const resolvedProvider = require_resolveProvider.resolveProvider(provider);
+		return {
+			close: connection.close,
+			provider: {
+				...resolvedProvider,
+				types: generateMcpWrappedToolTypes(resolvedProvider)
+			},
+			serverInfo: getMcpToolSourceServerInfo(source)
+		};
+	} catch (error) {
+		await connection.close().catch(() => {});
+		throw error;
+	}
+}
+/**
+* Wraps MCP tools from a client or server as a resolved execution provider.
+*/
+async function createMcpToolProvider(source, options = {}) {
+	return (await openMcpToolProvider(source, options)).provider;
+}
+
+//#endregion
+//#region src/mcp/codeMcpServer.ts
+const DEFAULT_MAX_TEXT_CHARS = 24e3;
+const DEFAULT_MCP_CODE_WRAPPER_SERVER_INFO = {
+	name: "mcp-code-wrapper",
+	version: "0.0.0"
+};
+function truncateText(text, maxTextChars) {
+	return text.length <= maxTextChars ? text : text.slice(0, maxTextChars);
+}
+function renderText(value, maxTextChars) {
+	return truncateText(JSON.stringify(value, null, 2), maxTextChars);
+}
+function searchTools(provider, query, limit) {
+	const normalizedQuery = query?.toLowerCase().trim();
+	const matches = Object.entries(provider.tools).map(([safeName, descriptor]) => ({
+		description: descriptor.description,
+		inputSchema: descriptor.inputSchema,
+		originalName: descriptor.originalName,
+		outputSchema: descriptor.outputSchema,
+		safeName
+	})).filter((tool) => {
+		if (!normalizedQuery) return true;
+		return [
+			tool.originalName,
+			tool.safeName,
+			tool.description ?? ""
+		].some((field) => field.toLowerCase().includes(normalizedQuery));
+	}).slice(0, limit);
+	return {
+		namespace: provider.name,
+		originalToSafeName: provider.originalToSafeName,
+		safeToOriginalName: provider.safeToOriginalName,
+		tools: matches,
+		types: provider.types
+	};
+}
+function registerExecuteTool(server, name, provider, executor, maxTextChars, description) {
+	server.registerTool.bind(server)(name, {
+		description,
+		inputSchema: { code: zod.string() }
+	}, async (args) => {
+		const execution = await executor.execute(args.code, [provider]);
+		return {
+			content: [{
+				text: renderText(execution, maxTextChars),
+				type: "text"
+			}],
+			isError: !execution.ok,
+			structuredContent: execution
+		};
+	});
+}
+function registerSearchTool(server, name, provider, maxTextChars) {
+	server.registerTool.bind(server)(name, {
+		description: `Search wrapped MCP tools exposed under the ${provider.name} namespace.`,
+		inputSchema: {
+			limit: zod.number().int().optional(),
+			query: zod.string().optional()
+		}
+	}, async (args) => {
+		const structuredContent = searchTools(provider, args.query, args.limit ?? 20);
+		return {
+			content: [{
+				text: renderText(structuredContent, maxTextChars),
+				type: "text"
+			}],
+			structuredContent
+		};
+	});
+}
+function attachOwnedClose(server, closeOwnedResources) {
+	const originalClose = server.close.bind(server);
+	let closePromise;
+	server.close = async () => {
+		closePromise ??= (async () => {
+			const rejected = (await Promise.allSettled([originalClose(), closeOwnedResources()])).find((result) => result.status === "rejected");
+			if (rejected) throw rejected.reason;
+		})();
+		return closePromise;
+	};
+	return server;
+}
+/**
+* Creates an MCP server that exposes code-execution tools for a wrapped MCP source.
+*/
+async function codeMcpServer(source, options) {
+	const maxTextChars = options.maxTextChars ?? DEFAULT_MAX_TEXT_CHARS;
+	const mode = options.mode ?? "both";
+	const names = {
+		execute: options.names?.execute ?? "mcp_execute_code",
+		search: options.names?.search ?? "mcp_search_tools",
+		single: options.names?.single ?? "mcp_code"
+	};
+	const handle = await openMcpToolProvider(source, {
+		clientInfo: options.clientInfo,
+		namespace: options.namespace ?? "mcp"
+	});
+	const provider = handle.provider;
+	const server = new __modelcontextprotocol_sdk_server_mcp_js.McpServer(options.serverInfo ?? handle.serverInfo ?? DEFAULT_MCP_CODE_WRAPPER_SERVER_INFO);
+	try {
+		if (mode === "both" || mode === "split") {
+			registerSearchTool(server, names.search, provider, maxTextChars);
+			registerExecuteTool(server, names.execute, provider, options.executor, maxTextChars, `Execute JavaScript against the wrapped ${provider.name} MCP tool namespace.`);
+		}
+		if (mode === "both" || mode === "single") registerExecuteTool(server, names.single, provider, options.executor, maxTextChars, `Execute JavaScript against the wrapped ${provider.name} MCP tool namespace.\n\n${provider.types}`);
+		return attachOwnedClose(server, handle.close);
+	} catch (error) {
+		await handle.close().catch(() => {});
+		throw error;
+	}
+}
+
+//#endregion
+exports.codeMcpServer = codeMcpServer;
+exports.createMcpToolProvider = createMcpToolProvider;
+exports.getMcpToolSourceServerInfo = getMcpToolSourceServerInfo;
+exports.openMcpToolProvider = openMcpToolProvider;
+//# sourceMappingURL=index.cjs.map

package/dist/mcp/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["renderDocComment","schemaToType","renderNamespaceDeclaration","InMemoryTransport","Client","closePromise: Promise<void> | undefined","provider: ToolProvider","resolveProvider","z","closePromise: Promise<void> | undefined","McpServer"],"sources":["../../src/mcp/mcpWrappedToolTypes.ts","../../src/mcp/createMcpToolProvider.ts","../../src/mcp/codeMcpServer.ts"],"sourcesContent":["import type { ResolvedToolProvider } from \"../types\";\nimport { schemaToType } from \"../typegen/jsonSchema\";\nimport {\n  renderDocComment,\n  renderNamespaceDeclaration,\n} from \"../typegen/render\";\n\nconst MCP_CALL_TOOL_RESULT_TYPE = [\n  \"type McpCallToolResult = {\",\n  \"  content: Array<{\",\n  \"    type: string;\",\n  \"    text?: string;\",\n  \"    data?: string;\",\n  \"    mimeType?: string;\",\n  \"    resource?: unknown;\",\n  \"    uri?: string;\",\n  \"    name?: string;\",\n  \"    description?: string;\",\n  \"  }>;\",\n  \"  structuredContent?: unknown;\",\n  \"  isError?: boolean;\",\n  \"  _meta?: Record<string, unknown>;\",\n  \"};\",\n].join(\"\\n\");\n\n/**\n * Generates the wrapped MCP tool namespace declarations exposed to guest code.\n */\nexport function generateMcpWrappedToolTypes(\n  provider: ResolvedToolProvider,\n): string {\n  const declarations = [MCP_CALL_TOOL_RESULT_TYPE];\n\n  for (const [safeName, tool] of Object.entries(provider.tools)) {\n    const comment = renderDocComment([\n      ...(tool.description ? [tool.description, \"\"] : []),\n      \"Wrapped MCP tool. Inspect structuredContent first, then fall back to content text items.\",\n    ]);\n\n    declarations.push(\n      [\n        comment,\n        `function ${safeName}(input: ${schemaToType(tool.inputSchema)}): Promise<McpCallToolResult>;`,\n      ]\n        .filter(Boolean)\n        .join(\"\\n\"),\n    );\n  }\n\n  return renderNamespaceDeclaration(provider.name, declarations);\n}\n","import { Client } from \"@modelcontextprotocol/sdk/client/index.js\";\nimport { InMemoryTransport } from \"@modelcontextprotocol/sdk/inMemory.js\";\nimport type { McpServer } from \"@modelcontextprotocol/sdk/server/mcp.js\";\nimport type { Implementation } from \"@modelcontextprotocol/sdk/types.js\";\n\nimport { resolveProvider } from \"../provider/resolveProvider\";\nimport type { ResolvedToolProvider, ToolProvider } from \"../types\";\nimport { generateMcpWrappedToolTypes } from \"./mcpWrappedToolTypes\";\n\n/**\n * Source used to discover MCP tools for wrapping.\n */\nexport type McpToolSource =\n  | { client: Client; serverInfo?: Implementation }\n  | { server: McpServer; serverInfo?: Implementation };\n\nconst DEFAULT_MCP_TOOL_CLIENT_INFO = {\n  name: \"mcp-tool-client\",\n  version: \"0.0.0\",\n} satisfies Implementation;\n\n/**\n * Returns the upstream server identity when the source can provide one.\n */\nexport function getMcpToolSourceServerInfo(\n  source: McpToolSource,\n): Implementation | undefined {\n  if (source.serverInfo) {\n    return source.serverInfo;\n  }\n\n  if (\"client\" in source) {\n    return source.client.getServerVersion();\n  }\n\n  return undefined;\n}\n\n/**\n * Options for wrapping MCP tools into a code-execution provider.\n */\nexport interface CreateMcpToolProviderOptions {\n  /** Namespace exposed to guest code for the wrapped tools. */\n  namespace?: string;\n  /** Implementation metadata exposed to local `{ server }` sources as the client identity. */\n  clientInfo?: Implementation;\n}\n\n/**\n * Explicit handle for a wrapped MCP provider and any owned source connections.\n */\nexport interface McpToolProviderHandle {\n  /** Resolved provider exposed to the executor or wrapper server. */\n  provider: ResolvedToolProvider;\n  /** Best-effort upstream server identity when available. */\n  serverInfo?: Implementation;\n  /** Releases any internal MCP client/server connection opened for the provider. */\n  close: () => Promise<void>;\n}\n\ninterface OpenMcpToolClientResult {\n  client: Client;\n  close: () => Promise<void>;\n}\n\nasync function closeAll(closers: Array<() => Promise<void>>): Promise<void> {\n  const results = await Promise.allSettled(closers.map((close) => close()));\n  const rejected = results.find(\n    (result): result is PromiseRejectedResult => result.status === \"rejected\",\n  );\n\n  if (rejected) {\n    throw rejected.reason;\n  }\n}\n\nasync function openMcpToolClient(\n  source: McpToolSource,\n  clientInfo: Implementation,\n): Promise<OpenMcpToolClientResult> {\n  if (\"client\" in source) {\n    return {\n      client: source.client,\n      close: async () => {},\n    };\n  }\n\n  if (source.server.isConnected()) {\n    throw new Error(\"{ server } sources must be unconnected local MCP servers\");\n  }\n\n  const [clientTransport, serverTransport] =\n    InMemoryTransport.createLinkedPair();\n  const client = new Client(clientInfo);\n  let closePromise: Promise<void> | undefined;\n\n  await Promise.all([\n    source.server.connect(serverTransport),\n    client.connect(clientTransport),\n  ]);\n\n  return {\n    client,\n    close: async () => {\n      closePromise ??= closeAll([\n        () => client.close(),\n        () => source.server.close(),\n      ]);\n      return closePromise;\n    },\n  };\n}\n\n/**\n * Opens an MCP tool source as a resolved execution provider with explicit cleanup.\n */\nexport async function openMcpToolProvider(\n  source: McpToolSource,\n  options: CreateMcpToolProviderOptions = {},\n): Promise<McpToolProviderHandle> {\n  const connection = await openMcpToolClient(\n    source,\n    options.clientInfo ?? DEFAULT_MCP_TOOL_CLIENT_INFO,\n  );\n\n  try {\n    const toolsResponse = await connection.client.listTools();\n    const provider: ToolProvider = {\n      name: options.namespace ?? \"mcp\",\n      tools: {},\n    };\n\n    for (const tool of toolsResponse.tools) {\n      provider.tools[tool.name] = {\n        description: tool.description,\n        execute: async (input, context) => {\n          const argumentsObject =\n            typeof input === \"object\" && input !== null\n              ? (input as Record<string, unknown>)\n              : undefined;\n\n          return connection.client.callTool(\n            {\n              arguments: argumentsObject,\n              name: tool.name,\n            },\n            undefined,\n            { signal: context.signal },\n          );\n        },\n        inputSchema: tool.inputSchema,\n      };\n    }\n\n    const resolvedProvider = resolveProvider(provider);\n\n    return {\n      close: connection.close,\n      provider: {\n        ...resolvedProvider,\n        types: generateMcpWrappedToolTypes(resolvedProvider),\n      },\n      serverInfo: getMcpToolSourceServerInfo(source),\n    };\n  } catch (error) {\n    await connection.close().catch(() => {});\n    throw error;\n  }\n}\n\n/**\n * Wraps MCP tools from a client or server as a resolved execution provider.\n */\nexport async function createMcpToolProvider(\n  source: McpToolSource,\n  options: CreateMcpToolProviderOptions = {},\n): Promise<ResolvedToolProvider> {\n  const handle = await openMcpToolProvider(source, options);\n  return handle.provider;\n}\n","import { McpServer } from \"@modelcontextprotocol/sdk/server/mcp.js\";\nimport type { Implementation } from \"@modelcontextprotocol/sdk/types.js\";\nimport * as z from \"zod\";\n\nimport type { Executor } from \"../executor/executor\";\nimport type { ResolvedToolProvider } from \"../types\";\nimport {\n  openMcpToolProvider,\n  type CreateMcpToolProviderOptions,\n  type McpToolSource,\n} from \"./createMcpToolProvider\";\n\n/**\n * Options for exposing wrapped MCP tool execution through an MCP server.\n */\nexport interface CodeMcpServerOptions extends CreateMcpToolProviderOptions {\n  /** Executor used to run guest JavaScript against the wrapped provider. */\n  executor: Executor;\n  /** Implementation metadata exposed to downstream clients as the wrapper server identity. */\n  serverInfo?: Implementation;\n  /** Maximum number of text characters returned in text content blocks. */\n  maxTextChars?: number;\n  /** Wrapper tool layout to expose on the returned server. */\n  mode?: \"both\" | \"single\" | \"split\";\n  /** Optional custom names for the wrapper tools. */\n  names?: {\n    execute?: string;\n    search?: string;\n    single?: string;\n  };\n}\n\nconst DEFAULT_MAX_TEXT_CHARS = 24_000;\nconst DEFAULT_MCP_CODE_WRAPPER_SERVER_INFO = {\n  name: \"mcp-code-wrapper\",\n  version: \"0.0.0\",\n} satisfies Implementation;\n\nfunction truncateText(text: string, maxTextChars: number): string {\n  return text.length <= maxTextChars ? text : text.slice(0, maxTextChars);\n}\n\nfunction renderText(value: unknown, maxTextChars: number): string {\n  return truncateText(JSON.stringify(value, null, 2), maxTextChars);\n}\n\nfunction searchTools(\n  provider: ResolvedToolProvider,\n  query: string | undefined,\n  limit: number,\n): Record<string, unknown> {\n  const normalizedQuery = query?.toLowerCase().trim();\n  const matches = Object.entries(provider.tools)\n    .map(([safeName, descriptor]) => ({\n      description: descriptor.description,\n      inputSchema: descriptor.inputSchema,\n      originalName: descriptor.originalName,\n      outputSchema: descriptor.outputSchema,\n      safeName,\n    }))\n    .filter((tool) => {\n      if (!normalizedQuery) {\n        return true;\n      }\n\n      return [tool.originalName, tool.safeName, tool.description ?? \"\"].some(\n        (field) => field.toLowerCase().includes(normalizedQuery),\n      );\n    })\n    .slice(0, limit);\n\n  return {\n    namespace: provider.name,\n    originalToSafeName: provider.originalToSafeName,\n    safeToOriginalName: provider.safeToOriginalName,\n    tools: matches,\n    types: provider.types,\n  };\n}\n\nfunction registerExecuteTool(\n  server: McpServer,\n  name: string,\n  provider: ResolvedToolProvider,\n  executor: Executor,\n  maxTextChars: number,\n  description: string,\n): void {\n  const registerTool = server.registerTool.bind(server) as (\n    toolName: string,\n    config: {\n      description: string;\n      inputSchema: Record<string, z.ZodTypeAny>;\n    },\n    handler: (args: { code: string }) => Promise<{\n      content: Array<{ text: string; type: \"text\" }>;\n      isError: boolean;\n      structuredContent: Record<string, unknown>;\n    }>,\n  ) => void;\n\n  registerTool(\n    name,\n    {\n      description,\n      inputSchema: {\n        code: z.string(),\n      },\n    },\n    async (args: { code: string }) => {\n      const execution = await executor.execute(args.code, [provider]);\n\n      return {\n        content: [{ text: renderText(execution, maxTextChars), type: \"text\" }],\n        isError: !execution.ok,\n        structuredContent: execution as Record<string, unknown>,\n      };\n    },\n  );\n}\n\nfunction registerSearchTool(\n  server: McpServer,\n  name: string,\n  provider: ResolvedToolProvider,\n  maxTextChars: number,\n): void {\n  const registerTool = server.registerTool.bind(server) as (\n    toolName: string,\n    config: {\n      description: string;\n      inputSchema: Record<string, z.ZodTypeAny>;\n    },\n    handler: (args: { limit?: number; query?: string }) => Promise<{\n      content: Array<{ text: string; type: \"text\" }>;\n      structuredContent: Record<string, unknown>;\n    }>,\n  ) => void;\n\n  registerTool(\n    name,\n    {\n      description: `Search wrapped MCP tools exposed under the ${provider.name} namespace.`,\n      inputSchema: {\n        limit: z.number().int().optional(),\n        query: z.string().optional(),\n      },\n    },\n    async (args: { limit?: number; query?: string }) => {\n      const structuredContent = searchTools(\n        provider,\n        args.query,\n        args.limit ?? 20,\n      );\n      return {\n        content: [\n          { text: renderText(structuredContent, maxTextChars), type: \"text\" },\n        ],\n        structuredContent,\n      };\n    },\n  );\n}\n\nfunction attachOwnedClose(\n  server: McpServer,\n  closeOwnedResources: () => Promise<void>,\n): McpServer {\n  const originalClose = server.close.bind(server);\n  let closePromise: Promise<void> | undefined;\n\n  server.close = async () => {\n    closePromise ??= (async () => {\n      const results = await Promise.allSettled([\n        originalClose(),\n        closeOwnedResources(),\n      ]);\n      const rejected = results.find(\n        (result): result is PromiseRejectedResult =>\n          result.status === \"rejected\",\n      );\n\n      if (rejected) {\n        throw rejected.reason;\n      }\n    })();\n\n    return closePromise;\n  };\n\n  return server;\n}\n\n/**\n * Creates an MCP server that exposes code-execution tools for a wrapped MCP source.\n */\nexport async function codeMcpServer(\n  source: McpToolSource,\n  options: CodeMcpServerOptions,\n): Promise<McpServer> {\n  const maxTextChars = options.maxTextChars ?? DEFAULT_MAX_TEXT_CHARS;\n  const mode = options.mode ?? \"both\";\n  const names = {\n    execute: options.names?.execute ?? \"mcp_execute_code\",\n    search: options.names?.search ?? \"mcp_search_tools\",\n    single: options.names?.single ?? \"mcp_code\",\n  };\n  const handle = await openMcpToolProvider(source, {\n    clientInfo: options.clientInfo,\n    namespace: options.namespace ?? \"mcp\",\n  });\n  const provider = handle.provider;\n  const server = new McpServer(\n    options.serverInfo ??\n      handle.serverInfo ??\n      DEFAULT_MCP_CODE_WRAPPER_SERVER_INFO,\n  );\n\n  try {\n    if (mode === \"both\" || mode === \"split\") {\n      registerSearchTool(server, names.search, provider, maxTextChars);\n      registerExecuteTool(\n        server,\n        names.execute,\n        provider,\n        options.executor,\n        maxTextChars,\n        `Execute JavaScript against the wrapped ${provider.name} MCP tool namespace.`,\n      );\n    }\n\n    if (mode === \"both\" || mode === \"single\") {\n      registerExecuteTool(\n        server,\n        names.single,\n        provider,\n        options.executor,\n        maxTextChars,\n        `Execute JavaScript against the wrapped ${provider.name} MCP tool namespace.\\n\\n${provider.types}`,\n      );\n    }\n\n    return attachOwnedClose(server, handle.close);\n  } catch (error) {\n    await handle.close().catch(() => {});\n    throw error;\n  }\n}\n"],"mappings":"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"}

package/dist/mcp/index.d.cts

@@ -0,0 +1,77 @@
+import { h as ResolvedToolProvider, t as Executor } from "../executor-DcnjQGwA.cjs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Implementation } from "@modelcontextprotocol/sdk/types.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+
+//#region src/mcp/createMcpToolProvider.d.ts
+
+/**
+ * Source used to discover MCP tools for wrapping.
+ */
+type McpToolSource = {
+  client: Client;
+  serverInfo?: Implementation;
+} | {
+  server: McpServer;
+  serverInfo?: Implementation;
+};
+/**
+ * Returns the upstream server identity when the source can provide one.
+ */
+declare function getMcpToolSourceServerInfo(source: McpToolSource): Implementation | undefined;
+/**
+ * Options for wrapping MCP tools into a code-execution provider.
+ */
+interface CreateMcpToolProviderOptions {
+  /** Namespace exposed to guest code for the wrapped tools. */
+  namespace?: string;
+  /** Implementation metadata exposed to local `{ server }` sources as the client identity. */
+  clientInfo?: Implementation;
+}
+/**
+ * Explicit handle for a wrapped MCP provider and any owned source connections.
+ */
+interface McpToolProviderHandle {
+  /** Resolved provider exposed to the executor or wrapper server. */
+  provider: ResolvedToolProvider;
+  /** Best-effort upstream server identity when available. */
+  serverInfo?: Implementation;
+  /** Releases any internal MCP client/server connection opened for the provider. */
+  close: () => Promise<void>;
+}
+/**
+ * Opens an MCP tool source as a resolved execution provider with explicit cleanup.
+ */
+declare function openMcpToolProvider(source: McpToolSource, options?: CreateMcpToolProviderOptions): Promise<McpToolProviderHandle>;
+/**
+ * Wraps MCP tools from a client or server as a resolved execution provider.
+ */
+declare function createMcpToolProvider(source: McpToolSource, options?: CreateMcpToolProviderOptions): Promise<ResolvedToolProvider>;
+//#endregion
+//#region src/mcp/codeMcpServer.d.ts
+/**
+ * Options for exposing wrapped MCP tool execution through an MCP server.
+ */
+interface CodeMcpServerOptions extends CreateMcpToolProviderOptions {
+  /** Executor used to run guest JavaScript against the wrapped provider. */
+  executor: Executor;
+  /** Implementation metadata exposed to downstream clients as the wrapper server identity. */
+  serverInfo?: Implementation;
+  /** Maximum number of text characters returned in text content blocks. */
+  maxTextChars?: number;
+  /** Wrapper tool layout to expose on the returned server. */
+  mode?: "both" | "single" | "split";
+  /** Optional custom names for the wrapper tools. */
+  names?: {
+    execute?: string;
+    search?: string;
+    single?: string;
+  };
+}
+/**
+ * Creates an MCP server that exposes code-execution tools for a wrapped MCP source.
+ */
+declare function codeMcpServer(source: McpToolSource, options: CodeMcpServerOptions): Promise<McpServer>;
+//#endregion
+export { type CodeMcpServerOptions, type CreateMcpToolProviderOptions, type McpToolProviderHandle, type McpToolSource, codeMcpServer, createMcpToolProvider, getMcpToolSourceServerInfo, openMcpToolProvider };
+//# sourceMappingURL=index.d.cts.map

package/dist/mcp/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/mcp/createMcpToolProvider.ts","../../src/mcp/codeMcpServer.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAYA;AACc,KADF,aAAA,GACE;EAAqB,MAAA,EAArB,MAAqB;EACrB,UAAA,CAAA,EADqB,cACrB;CAAwB,GAAA;EAAc,MAAA,EAAtC,SAAsC;EAUpC,UAAA,CAAA,EAVsB,cAUtB;AAiBhB,CAAA;AAUA;;;AAMe,iBAjCC,0BAAA,CAiCD,MAAA,EAhCL,aAgCK,CAAA,EA/BZ,cA+BY,GAAA,SAAA;;AA2Df;;AAEW,UA7EM,4BAAA,CA6EN;EACA;EAAR,SAAA,CAAA,EAAA,MAAA;EAAO;EAsDY,UAAA,CAAA,EAhIP,cAgI4B;;;;;AAGjC,UA7HO,qBAAA,CA6HP;;YA3HE;;ECtCK,UAAA,CAAA,EDwCF,cCxCuB;EAE1B;EAEG,KAAA,EAAA,GAAA,GDsCA,OCtCA,CAAA,IAAA,CAAA;;;AAiLf;;AAEW,iBDlFW,mBAAA,CCkFX,MAAA,EDjFD,aCiFC,EAAA,OAAA,CAAA,EDhFA,4BCgFA,CAAA,ED/ER,OC+EQ,CD/EA,qBC+EA,CAAA;;;;iBDzBW,qBAAA,SACZ,yBACC,+BACR,QAAQ;;;;;AApKX;AACc,UCEG,oBAAA,SAA6B,4BDFhC,CAAA;EAAqB;EACrB,QAAA,ECGF,QDHE;EAAwB;EAAc,UAAA,CAAA,ECKrC,cDLqC;EAUpC;EAiBC,YAAA,CAAA,EAAA,MAAA;EAUA;EAEL,IAAA,CAAA,EAAA,MAAA,GAAA,QAAA,GAAA,OAAA;EAEG;EAEA,KAAA,CAAA,EAAA;IAAO,OAAA,CAAA,EAAA,MAAA;IA2DA,MAAA,CAAA,EAAA,MAAA;IACZ,MAAA,CAAA,EAAA,MAAA;EACC,CAAA;;;;AAuDX;AACU,iBCsBY,aAAA,CDtBZ,MAAA,ECuBA,aDvBA,EAAA,OAAA,ECwBC,oBDxBD,CAAA,ECyBP,ODzBO,CCyBC,SDzBD,CAAA"}