@cursor/bdk 0.2.9 → 0.2.11

package/dist/internal/discovery/connections.js

@@ -1,15 +1,6 @@
 /**
  * `agent/mcp-connections/*.ts` and `agent/host-connections/*.ts`: MCP servers for the model and the host.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { join } from "node:path";
 import { cursorAccountServersHasMixedWildcard, isInlineStdioConnection, isToolEffect, normalizeConnectionEffects, normalizeConnectionTools, normalizeCursorAccountServers, } from "../../types.js";
 import { unresolvedConnectionEnvNames } from "../connection-env.js";
@@ -86,7 +77,10 @@ function connectionHasSpawnOrRemote(connection) {
 function connectionTransport(connection) {
     if ("cursorAccount" in connection && connection.cursorAccount === true) {
         const servers = normalizeCursorAccountServers(connection.servers);
-        return Object.assign({ cursorAccount: true }, (servers === undefined ? {} : { servers }));
+        return {
+            cursorAccount: true,
+            ...(servers === undefined ? {} : { servers }),
+        };
     }
     if ("agent" in connection && !isBlank(connection.agent)) {
         return { agent: connection.agent };
@@ -100,41 +94,43 @@ function connectionTransport(connection) {
         };
     }
     if ("command" in connection && !isBlank(connection.command)) {
-        return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (connection.type === undefined ? {} : { type: connection.type })), { command: connection.command }), (connection.args === undefined ? {} : { args: connection.args })), (connection.env === undefined ? {} : { env: connection.env })), (connection.cwd === undefined ? {} : { cwd: connection.cwd }));
+        return {
+            ...(connection.type === undefined ? {} : { type: connection.type }),
+            command: connection.command,
+            ...(connection.args === undefined ? {} : { args: connection.args }),
+            ...(connection.env === undefined ? {} : { env: connection.env }),
+            ...(connection.cwd === undefined ? {} : { cwd: connection.cwd }),
+        };
     }
     return undefined;
 }
-export function loadHostConnections(ctx, agentDir, modelConnections) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const hostDir = join(agentDir, "host-connections");
-        const loaded = yield loadConnections(ctx, hostDir, "host");
-        const modelNames = new Set(modelConnections.map(connection => connection.name));
-        const hostConnections = [];
-        for (const connection of loaded) {
-            if (modelNames.has(connection.name)) {
-                ctx.diagnostics.push({
-                    severity: "error",
-                    path: displayPath(ctx, join(hostDir, `${connection.name}.ts`)),
-                    message: `Host connection "${connection.name}" collides with the model connection of the same name. Rename one of them.`,
-                });
-                continue;
-            }
-            if (rejectHostConnectionFeatures(ctx, join(hostDir, `${connection.name}.ts`), connection)) {
-                continue;
-            }
-            hostConnections.push(connection);
+export async function loadHostConnections(ctx, agentDir, modelConnections) {
+    const hostDir = join(agentDir, "host-connections");
+    const loaded = await loadConnections(ctx, hostDir, "host");
+    const modelNames = new Set(modelConnections.map(connection => connection.name));
+    const hostConnections = [];
+    for (const connection of loaded) {
+        if (modelNames.has(connection.name)) {
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, join(hostDir, `${connection.name}.ts`)),
+                message: `Host connection "${connection.name}" collides with the model connection of the same name. Rename one of them.`,
+            });
+            continue;
         }
-        return hostConnections;
-    });
-}
-export function compileHostConnection(ctx, path, name, definition) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const connection = yield compileConnection(ctx, path, name, definition, "host");
-        if (connection === undefined || rejectHostConnectionFeatures(ctx, path, connection)) {
-            return undefined;
+        if (rejectHostConnectionFeatures(ctx, join(hostDir, `${connection.name}.ts`), connection)) {
+            continue;
         }
-        return connection;
-    });
+        hostConnections.push(connection);
+    }
+    return hostConnections;
+}
+export async function compileHostConnection(ctx, path, name, definition) {
+    const connection = await compileConnection(ctx, path, name, definition, "host");
+    if (connection === undefined || rejectHostConnectionFeatures(ctx, path, connection)) {
+        return undefined;
+    }
+    return connection;
 }
 function rejectHostConnectionFeatures(ctx, path, connection) {
     if (connection.advertiseTools === true) {
@@ -155,286 +151,280 @@ function rejectHostConnectionFeatures(ctx, path, connection) {
     }
     return false;
 }
-export function loadConnections(ctx_1, connectionsDir_1) {
-    return __awaiter(this, arguments, void 0, function* (ctx, connectionsDir, role = "model") {
-        const connections = [];
-        for (const { name, path } of yield moduleEntries(ctx, connectionsDir, "connection")) {
-            const definition = yield importDefault(ctx, path, "connection");
-            if (definition === undefined) {
-                continue;
-            }
-            const connection = yield compileConnection(ctx, path, name, definition, role);
-            if (connection !== undefined) {
-                connections.push(connection);
-            }
+export async function loadConnections(ctx, connectionsDir, role = "model") {
+    const connections = [];
+    for (const { name, path } of await moduleEntries(ctx, connectionsDir, "connection")) {
+        const definition = await importDefault(ctx, path, "connection");
+        if (definition === undefined) {
+            continue;
         }
-        return connections;
-    });
+        const connection = await compileConnection(ctx, path, name, definition, role);
+        if (connection !== undefined) {
+            connections.push(connection);
+        }
+    }
+    return connections;
 }
 /** Validate one `defineConnection` and resolve its transport. */
-export function compileConnection(ctx, entryPath, name, connection, role) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (Object.hasOwn(connection, "hostOnly")) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: "MCP connection `hostOnly` was removed. Model connections are always visible to the model. Put privileged servers in host-connections/ so only host tools can call them.",
-            });
-            return undefined;
-        }
-        if (isInlineStdioConnection(connection) && connectionHasSpawnOrRemote(connection)) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: "MCP connection `tools` cannot be combined with `command`, `url`, `agent`, or `cursorAccount`. Author TypeScript tools, or point at an existing server, not both.",
-            });
-            return undefined;
-        }
-        if (connection.auth !== undefined && typeof connection.auth !== "function") {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: "MCP connection `auth` must be a function: (session) => { headers }.",
-            });
-            return undefined;
-        }
-        if (connection.auth !== undefined && !("url" in connection)) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: "MCP connection `auth` (per-session headers) is only supported on http/sse connections (`url`).",
-            });
-            return undefined;
-        }
-        if (connection.advertiseTools !== undefined && typeof connection.advertiseTools !== "boolean") {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: "MCP connection `advertiseTools` must be a boolean.",
-            });
-            return undefined;
-        }
-        if (connection.optional !== undefined && typeof connection.optional !== "boolean") {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: "MCP connection `optional` must be a boolean.",
-            });
-            return undefined;
-        }
-        if (connection.optional === true && connection.advertiseTools !== true) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: "MCP connection `optional` skips advertised listing failures; set `advertiseTools: true` or drop `optional`.",
-            });
-            return undefined;
-        }
-        const parsedEffects = parseConnectionEffects(connection.effects);
-        if (!parsedEffects.ok) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: 'MCP connection `effects` must be "read", "write", or a non-empty array of those.',
-            });
-            return undefined;
-        }
-        if (parsedEffects.value !== undefined && connection.advertiseTools !== true) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: "MCP connection `effects` filters advertised tools; set `advertiseTools: true` or drop `effects`.",
-            });
-            return undefined;
-        }
-        const parsedTools = isInlineStdioConnection(connection)
-            ? { ok: true, value: undefined }
-            : parseConnectionTools(connection.tools);
-        if (!parsedTools.ok) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: "MCP connection `tools` allowlist must be a non-empty array of tool names.",
-            });
-            return undefined;
-        }
-        if (isInlineStdioConnection(connection) && connection.disallowedTools !== undefined) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: "MCP connection `disallowedTools` is not supported on inline `tools` connections — author only the tools you want.",
-            });
-            return undefined;
-        }
-        const parsedDisallowed = isInlineStdioConnection(connection)
-            ? { ok: true, value: undefined }
-            : parseConnectionTools(connection.disallowedTools);
-        if (!parsedDisallowed.ok) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: "MCP connection `disallowedTools` must be a non-empty array of tool names.",
-            });
-            return undefined;
-        }
-        if ((parsedTools.value !== undefined || parsedDisallowed.value !== undefined) &&
-            role === "model" &&
-            connection.advertiseTools !== true) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: "MCP connection `tools` / `disallowedTools` filter advertised tools; set `advertiseTools: true` or drop the name list. Put the connection in host-connections/ to restrict `host.mcp` only.",
-            });
-            return undefined;
-        }
-        if (connection.advertiseTools === true && isInlineStdioConnection(connection)) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: "MCP connection `advertiseTools` is not supported on inline `tools` connections — author those under tools/ as server tools instead.",
-            });
-            return undefined;
-        }
-        if (connection.auth !== undefined && "url" in connection && connection.oauth === true) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: "MCP connection `oauth: true` cannot be combined with `auth` (per-session headers): the host OAuth provider owns the Authorization header. Drop one of them.",
-            });
-            return undefined;
-        }
-        if (isInlineStdioConnection(connection)) {
-            return loadInlineStdioConnection(ctx, name, entryPath, connection);
-        }
-        if ("url" in connection &&
-            connection.oauth === true &&
-            hasAuthorizationHeader(connection.headers)) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: "MCP connection `oauth: true` cannot set an Authorization header. Drop the header or remove `oauth`.",
-            });
-            return undefined;
-        }
-        if ("cursorAccount" in connection &&
-            connection.cursorAccount === true &&
-            cursorAccountServersHasMixedWildcard(connection.servers)) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: 'Cursor account MCP connection `servers` cannot mix `"*"` with connector names. Use `"*"` / `["*"]` (or omit `servers`) for every connected server, or list only concrete connector names.',
-            });
-            return undefined;
-        }
-        const transport = connectionTransport(connection);
-        if (transport === undefined) {
+export async function compileConnection(ctx, entryPath, name, connection, role) {
+    if (Object.hasOwn(connection, "hostOnly")) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connection `hostOnly` was removed. Model connections are always visible to the model. Put privileged servers in host-connections/ so only host tools can call them.",
+        });
+        return undefined;
+    }
+    if (isInlineStdioConnection(connection) && connectionHasSpawnOrRemote(connection)) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connection `tools` cannot be combined with `command`, `url`, `agent`, or `cursorAccount`. Author TypeScript tools, or point at an existing server, not both.",
+        });
+        return undefined;
+    }
+    if (connection.auth !== undefined && typeof connection.auth !== "function") {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connection `auth` must be a function: (session) => { headers }.",
+        });
+        return undefined;
+    }
+    if (connection.auth !== undefined && !("url" in connection)) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connection `auth` (per-session headers) is only supported on http/sse connections (`url`).",
+        });
+        return undefined;
+    }
+    if (connection.advertiseTools !== undefined && typeof connection.advertiseTools !== "boolean") {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connection `advertiseTools` must be a boolean.",
+        });
+        return undefined;
+    }
+    if (connection.optional !== undefined && typeof connection.optional !== "boolean") {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connection `optional` must be a boolean.",
+        });
+        return undefined;
+    }
+    if (connection.optional === true && connection.advertiseTools !== true) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connection `optional` skips advertised listing failures; set `advertiseTools: true` or drop `optional`.",
+        });
+        return undefined;
+    }
+    const parsedEffects = parseConnectionEffects(connection.effects);
+    if (!parsedEffects.ok) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: 'MCP connection `effects` must be "read", "write", or a non-empty array of those.',
+        });
+        return undefined;
+    }
+    if (parsedEffects.value !== undefined && connection.advertiseTools !== true) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connection `effects` filters advertised tools; set `advertiseTools: true` or drop `effects`.",
+        });
+        return undefined;
+    }
+    const parsedTools = isInlineStdioConnection(connection)
+        ? { ok: true, value: undefined }
+        : parseConnectionTools(connection.tools);
+    if (!parsedTools.ok) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connection `tools` allowlist must be a non-empty array of tool names.",
+        });
+        return undefined;
+    }
+    if (isInlineStdioConnection(connection) && connection.disallowedTools !== undefined) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connection `disallowedTools` is not supported on inline `tools` connections — author only the tools you want.",
+        });
+        return undefined;
+    }
+    const parsedDisallowed = isInlineStdioConnection(connection)
+        ? { ok: true, value: undefined }
+        : parseConnectionTools(connection.disallowedTools);
+    if (!parsedDisallowed.ok) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connection `disallowedTools` must be a non-empty array of tool names.",
+        });
+        return undefined;
+    }
+    if ((parsedTools.value !== undefined || parsedDisallowed.value !== undefined) &&
+        role === "model" &&
+        connection.advertiseTools !== true) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connection `tools` / `disallowedTools` filter advertised tools; set `advertiseTools: true` or drop the name list. Put the connection in host-connections/ to restrict `host.mcp` only.",
+        });
+        return undefined;
+    }
+    if (connection.advertiseTools === true && isInlineStdioConnection(connection)) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connection `advertiseTools` is not supported on inline `tools` connections — author those under tools/ as server tools instead.",
+        });
+        return undefined;
+    }
+    if (connection.auth !== undefined && "url" in connection && connection.oauth === true) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connection `oauth: true` cannot be combined with `auth` (per-session headers): the host OAuth provider owns the Authorization header. Drop one of them.",
+        });
+        return undefined;
+    }
+    if (isInlineStdioConnection(connection)) {
+        return loadInlineStdioConnection(ctx, name, entryPath, connection);
+    }
+    if ("url" in connection &&
+        connection.oauth === true &&
+        hasAuthorizationHeader(connection.headers)) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connection `oauth: true` cannot set an Authorization header. Drop the header or remove `oauth`.",
+        });
+        return undefined;
+    }
+    if ("cursorAccount" in connection &&
+        connection.cursorAccount === true &&
+        cursorAccountServersHasMixedWildcard(connection.servers)) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: 'Cursor account MCP connection `servers` cannot mix `"*"` with connector names. Use `"*"` / `["*"]` (or omit `servers`) for every connected server, or list only concrete connector names.',
+        });
+        return undefined;
+    }
+    const transport = connectionTransport(connection);
+    if (transport === undefined) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connections require a `url` (http/sse), a `command` (stdio), `tools` (TypeScript packaged as stdio), an `agent` (peer agent slug on the same serve host), or `cursorAccount: true` (the Cursor account's MCP connectors).",
+        });
+        return undefined;
+    }
+    if ("cursorAccount" in transport &&
+        transport.servers !== undefined &&
+        (transport.servers.length === 0 || transport.servers.some(server => isBlank(server)))) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: 'Cursor account MCP connection `servers` must be a non-empty list of connector names, `"*"` / `["*"]` for every connected server, or omitted for the same all-connectors behavior.',
+        });
+        return undefined;
+    }
+    if ("agent" in transport && !NAME_PATTERN.test(transport.agent)) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: `Peer MCP connection agent "${transport.agent}" must be a mount slug matching ${NAME_PATTERN}.`,
+        });
+        return undefined;
+    }
+    // A warning, never an error: templates resolve when the connection opens,
+    // and a hosted deployment binds its secrets after discovery has run.
+    const unresolved = unresolvedConnectionEnvNames(transport);
+    if (unresolved.length > 0) {
+        ctx.diagnostics.push({
+            severity: "warning",
+            path: displayPath(ctx, entryPath),
+            message: `MCP connection "${name}" templates ${unresolved.map(variable => `\${${variable}}`).join(", ")}, which the environment does not set. The value resolves when the connection opens, so hosted deployments are fine; locally, set it before the turn or the credential is empty.`,
+        });
+    }
+    return {
+        name,
+        transport,
+        description: connection.description,
+        auth: connection.auth,
+        advertiseTools: connection.advertiseTools,
+        optional: connection.optional,
+        effects: parsedEffects.value,
+        tools: parsedTools.value,
+        disallowedTools: parsedDisallowed.value,
+    };
+}
+async function loadInlineStdioConnection(ctx, name, entryPath, connection) {
+    const tools = connection.tools;
+    const names = Object.keys(tools);
+    if (names.length === 0) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "MCP connection `tools` must declare at least one tool.",
+        });
+        return undefined;
+    }
+    for (const toolName of names) {
+        if (!NAME_PATTERN.test(toolName)) {
             ctx.diagnostics.push({
                 severity: "error",
                 path: displayPath(ctx, entryPath),
-                message: "MCP connections require a `url` (http/sse), a `command` (stdio), `tools` (TypeScript packaged as stdio), an `agent` (peer agent slug on the same serve host), or `cursorAccount: true` (the Cursor account's MCP connectors).",
+                message: `MCP tool name "${toolName}" must match ${NAME_PATTERN}.`,
             });
             return undefined;
         }
-        if ("cursorAccount" in transport &&
-            transport.servers !== undefined &&
-            (transport.servers.length === 0 || transport.servers.some(server => isBlank(server)))) {
+        const tool = tools[toolName];
+        if (tool === undefined || isBlank(tool.description)) {
             ctx.diagnostics.push({
                 severity: "error",
                 path: displayPath(ctx, entryPath),
-                message: 'Cursor account MCP connection `servers` must be a non-empty list of connector names, `"*"` / `["*"]` for every connected server, or omitted for the same all-connectors behavior.',
+                message: `MCP tool "${toolName}" requires a non-empty description.`,
             });
             return undefined;
         }
-        if ("agent" in transport && !NAME_PATTERN.test(transport.agent)) {
+        if (typeof tool.execute !== "function") {
             ctx.diagnostics.push({
                 severity: "error",
                 path: displayPath(ctx, entryPath),
-                message: `Peer MCP connection agent "${transport.agent}" must be a mount slug matching ${NAME_PATTERN}.`,
+                message: `MCP tool "${toolName}" requires an execute(input) function.`,
             });
             return undefined;
         }
-        // A warning, never an error: templates resolve when the connection opens,
-        // and a hosted deployment binds its secrets after discovery has run.
-        const unresolved = unresolvedConnectionEnvNames(transport);
-        if (unresolved.length > 0) {
-            ctx.diagnostics.push({
-                severity: "warning",
-                path: displayPath(ctx, entryPath),
-                message: `MCP connection "${name}" templates ${unresolved.map(variable => `\${${variable}}`).join(", ")}, which the environment does not set. The value resolves when the connection opens, so hosted deployments are fine; locally, set it before the turn or the credential is empty.`,
-            });
-        }
+    }
+    try {
+        const transport = await packageInlineStdioConnection({
+            name,
+            entryPath,
+            tools,
+            absWorkingDir: ctx.rootDir,
+        });
         return {
             name,
             transport,
             description: connection.description,
-            auth: connection.auth,
-            advertiseTools: connection.advertiseTools,
-            optional: connection.optional,
-            effects: parsedEffects.value,
-            tools: parsedTools.value,
-            disallowedTools: parsedDisallowed.value,
         };
-    });
-}
-function loadInlineStdioConnection(ctx, name, entryPath, connection) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const tools = connection.tools;
-        const names = Object.keys(tools);
-        if (names.length === 0) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: "MCP connection `tools` must declare at least one tool.",
-            });
-            return undefined;
-        }
-        for (const toolName of names) {
-            if (!NAME_PATTERN.test(toolName)) {
-                ctx.diagnostics.push({
-                    severity: "error",
-                    path: displayPath(ctx, entryPath),
-                    message: `MCP tool name "${toolName}" must match ${NAME_PATTERN}.`,
-                });
-                return undefined;
-            }
-            const tool = tools[toolName];
-            if (tool === undefined || isBlank(tool.description)) {
-                ctx.diagnostics.push({
-                    severity: "error",
-                    path: displayPath(ctx, entryPath),
-                    message: `MCP tool "${toolName}" requires a non-empty description.`,
-                });
-                return undefined;
-            }
-            if (typeof tool.execute !== "function") {
-                ctx.diagnostics.push({
-                    severity: "error",
-                    path: displayPath(ctx, entryPath),
-                    message: `MCP tool "${toolName}" requires an execute(input) function.`,
-                });
-                return undefined;
-            }
-        }
-        try {
-            const transport = yield packageInlineStdioConnection({
-                name,
-                entryPath,
-                tools,
-                absWorkingDir: ctx.rootDir,
-            });
-            return {
-                name,
-                transport,
-                description: connection.description,
-            };
-        }
-        catch (error) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, entryPath),
-                message: `Failed to package inline stdio MCP connection: ${errorMessage(error)}`,
-            });
-            return undefined;
-        }
-    });
+    }
+    catch (error) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: `Failed to package inline stdio MCP connection: ${errorMessage(error)}`,
+        });
+        return undefined;
+    }
 }