@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/mcp-host.js

@@ -9,15 +9,6 @@
  * {@link ChannelHandlerArgs.host}.mcp. Host connections skip the model
  * and stay on `host.mcp` plus `mcp oauth`.
  */
-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 { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
@@ -76,16 +67,14 @@ export class McpHost {
     names() {
         return [...this.byName.keys()].sort();
     }
-    listTools(connectionName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connection = this.requireConnection(connectionName);
-            return runMcpClientSpan({ method: "tools/list", connection: connectionName }, () => this.withClient(connectionName, (client) => __awaiter(this, void 0, void 0, function* () {
-                const listed = yield client.listTools(mcpListParams());
-                return listed.tools
-                    .map(toToolInfo)
-                    .filter(tool => connectionAllowsTool(connection, tool.name));
-            })));
-        });
+    async listTools(connectionName) {
+        const connection = this.requireConnection(connectionName);
+        return runMcpClientSpan({ method: "tools/list", connection: connectionName }, () => this.withClient(connectionName, async (client) => {
+            const listed = await client.listTools(mcpListParams());
+            return listed.tools
+                .map(toToolInfo)
+                .filter(tool => connectionAllowsTool(connection, tool.name));
+        }));
     }
     /**
      * A one-off view of a connection that is not (or not exactly) in the
@@ -98,70 +87,72 @@ export class McpHost {
      */
     oneOff(connection) {
         const redirectUrl = this.oauthRedirectUrl;
-        const withFreshClient = (run) => __awaiter(this, void 0, void 0, function* () {
-            const opened = yield openConnection(connection, redirectUrl);
+        const withFreshClient = async (run) => {
+            const opened = await openConnection(connection, redirectUrl);
             try {
-                return yield run(opened.client);
+                return await run(opened.client);
             }
             finally {
-                yield opened.close();
+                await opened.close();
             }
-        });
+        };
         return {
-            listTools: () => runMcpClientSpan({ method: "tools/list", connection: connection.name }, () => withFreshClient((client) => __awaiter(this, void 0, void 0, function* () {
-                const listed = yield client.listTools(mcpListParams());
+            listTools: () => runMcpClientSpan({ method: "tools/list", connection: connection.name }, () => withFreshClient(async (client) => {
+                const listed = await client.listTools(mcpListParams());
                 return listed.tools
                     .map(toToolInfo)
                     .filter(tool => connectionAllowsTool(connection, tool.name));
-            }))),
+            })),
             callTool: (toolName, args = {}) => {
                 assertConnectionAllowsTool(connection, toolName);
                 return runMcpClientSpan({
                     method: "tools/call",
                     connection: connection.name,
                     toolName,
-                }, () => withFreshClient((client) => __awaiter(this, void 0, void 0, function* () {
-                    const result = yield client.callTool(Object.assign({ name: toolName, arguments: args }, mcpCallMeta()));
+                }, () => withFreshClient(async (client) => {
+                    const result = await client.callTool({
+                        name: toolName,
+                        arguments: args,
+                        ...mcpCallMeta(),
+                    });
                     return throwIfCallNeedsAuth(connection.name, normalizeCallResult(result));
-                })));
+                }));
             },
         };
     }
-    callTool(connectionName_1, toolName_1) {
-        return __awaiter(this, arguments, void 0, function* (connectionName, toolName, args = {}) {
-            const connection = this.requireConnection(connectionName);
-            assertConnectionAllowsTool(connection, toolName);
-            return runMcpClientSpan({ method: "tools/call", connection: connectionName, toolName }, () => this.withClient(connectionName, (client) => __awaiter(this, void 0, void 0, function* () {
-                const result = yield client.callTool(Object.assign({ name: toolName, arguments: args }, mcpCallMeta()));
-                return throwIfCallNeedsAuth(connectionName, normalizeCallResult(result));
-            })));
-        });
+    async callTool(connectionName, toolName, args = {}) {
+        const connection = this.requireConnection(connectionName);
+        assertConnectionAllowsTool(connection, toolName);
+        return runMcpClientSpan({ method: "tools/call", connection: connectionName, toolName }, () => this.withClient(connectionName, async (client) => {
+            const result = await client.callTool({
+                name: toolName,
+                arguments: args,
+                ...mcpCallMeta(),
+            });
+            return throwIfCallNeedsAuth(connectionName, normalizeCallResult(result));
+        }));
     }
-    dropClient(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const cached = this.clients.get(name);
-            this.clients.delete(name);
-            if (cached === undefined) {
-                return;
-            }
-            try {
-                yield (yield cached.opened).close();
-            }
-            catch (_a) {
-                // Best-effort teardown.
-            }
-        });
+    async dropClient(name) {
+        const cached = this.clients.get(name);
+        this.clients.delete(name);
+        if (cached === undefined) {
+            return;
+        }
+        try {
+            await (await cached.opened).close();
+        }
+        catch {
+            // Best-effort teardown.
+        }
     }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opened = yield Promise.allSettled([...this.clients.values()].map(entry => entry.opened));
-            this.clients.clear();
-            yield Promise.allSettled(opened.map((settled) => __awaiter(this, void 0, void 0, function* () {
-                if (settled.status === "fulfilled") {
-                    yield settled.value.close();
-                }
-            })));
-        });
+    async close() {
+        const opened = await Promise.allSettled([...this.clients.values()].map(entry => entry.opened));
+        this.clients.clear();
+        await Promise.allSettled(opened.map(async (settled) => {
+            if (settled.status === "fulfilled") {
+                await settled.value.close();
+            }
+        }));
     }
     /**
      * Run against a cached host MCP client, reconnecting once when the remote
@@ -172,21 +163,19 @@ export class McpHost {
      * the dead session id, so without this invalidation every later host.mcp
      * call fails until the serve process restarts.
      */
-    withClient(name, run) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opened = yield this.getClient(name);
-            try {
-                return yield run(opened.client);
-            }
-            catch (error) {
-                if (!isStaleMcpSessionError(error)) {
-                    throw error;
-                }
-                yield this.invalidateClient(name, opened);
-                const reopened = yield this.getClient(name);
-                return yield run(reopened.client);
+    async withClient(name, run) {
+        const opened = await this.getClient(name);
+        try {
+            return await run(opened.client);
+        }
+        catch (error) {
+            if (!isStaleMcpSessionError(error)) {
+                throw error;
             }
-        });
+            await this.invalidateClient(name, opened);
+            const reopened = await this.getClient(name);
+            return await run(reopened.client);
+        }
     }
     /**
      * Cached per connection, but only for as long as the credentials it opened
@@ -217,21 +206,19 @@ export class McpHost {
         this.clients.set(name, entry);
         return entry.opened;
     }
-    invalidateClient(name, opened) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const cached = this.clients.get(name);
-            if (cached !== undefined) {
-                try {
-                    if ((yield cached.opened) === opened) {
-                        this.clients.delete(name);
-                    }
-                }
-                catch (_a) {
+    async invalidateClient(name, opened) {
+        const cached = this.clients.get(name);
+        if (cached !== undefined) {
+            try {
+                if ((await cached.opened) === opened) {
                     this.clients.delete(name);
                 }
             }
-            yield opened.close();
-        });
+            catch {
+                this.clients.delete(name);
+            }
+        }
+        await opened.close();
     }
     requireConnection(name) {
         const connection = this.byName.get(name);
@@ -241,10 +228,8 @@ export class McpHost {
         }
         return connection;
     }
-    connect(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return openConnection(this.requireConnection(name), this.oauthRedirectUrl);
-        });
+    async connect(name) {
+        return openConnection(this.requireConnection(name), this.oauthRedirectUrl);
     }
 }
 function assertConnectionAllowsTool(connection, toolName) {
@@ -303,85 +288,93 @@ export function boundedToolAnnotations(annotations) {
 }
 function toToolInfo(tool) {
     const annotations = boundedToolAnnotations(tool.annotations);
-    return Object.assign(Object.assign(Object.assign(Object.assign({ name: tool.name }, (tool.description === undefined ? {} : { description: tool.description })), (tool.inputSchema === undefined ? {} : { inputSchema: tool.inputSchema })), (tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema })), (annotations === undefined ? {} : { annotations }));
+    return {
+        name: tool.name,
+        ...(tool.description === undefined ? {} : { description: tool.description }),
+        ...(tool.inputSchema === undefined ? {} : { inputSchema: tool.inputSchema }),
+        ...(tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema }),
+        ...(annotations === undefined ? {} : { annotations }),
+    };
 }
-function openConnection(connection, oauthRedirectUrl) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const client = new Client({
-            name: "agent-serve",
-            version: "0.1.0",
-        });
-        const transport = yield createTransport(connection, oauthRedirectUrl);
-        try {
-            yield client.connect(transport);
+async function openConnection(connection, oauthRedirectUrl) {
+    const client = new Client({
+        name: "agent-serve",
+        version: "0.1.0",
+    });
+    const transport = await createTransport(connection, oauthRedirectUrl);
+    try {
+        await client.connect(transport);
+    }
+    catch (error) {
+        if (error instanceof UnauthorizedError && isOauthHttpTransport(connection.transport)) {
+            throw new McpNeedsAuthError(connection.name, error);
         }
-        catch (error) {
-            if (error instanceof UnauthorizedError && isOauthHttpTransport(connection.transport)) {
-                throw new McpNeedsAuthError(connection.name, error);
+        throw error;
+    }
+    return {
+        client,
+        close: async () => {
+            try {
+                await client.close();
             }
-            throw error;
-        }
-        return {
-            client,
-            close: () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                try {
-                    yield client.close();
-                }
-                catch (_b) {
-                    // Best-effort teardown.
-                }
-                try {
-                    yield (_a = transport.close) === null || _a === void 0 ? void 0 : _a.call(transport);
-                }
-                catch (_c) {
-                    // Best-effort teardown.
-                }
-            }),
-        };
-    });
+            catch {
+                // Best-effort teardown.
+            }
+            try {
+                await transport.close?.();
+            }
+            catch {
+                // Best-effort teardown.
+            }
+        },
+    };
 }
-function createTransport(connection, oauthRedirectUrl) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const transport = resolveConnectionEnvTemplates(connection.transport);
-        if ("agent" in transport) {
-            // Peers are resolved to concrete URLs by the serve host before any call
-            // (SessionEngine.setResolvedConnections); reaching here means the
-            // connection is being used outside a running server.
-            throw new Error(`MCP connection "${connection.name}" targets peer agent "${transport.agent}" and has not been resolved; peer MCP connections are only callable on a running serve host.`);
-        }
-        if ("cursorAccount" in transport) {
-            // Same contract as peers: the serve host resolves the account bridge URL
-            // before any call (SessionEngine.setResolvedConnections).
-            throw new Error(`MCP connection "${connection.name}" exposes the Cursor account's connectors and has not been resolved; Cursor account MCP connections are only callable on a running serve host.`);
-        }
-        if ("command" in transport) {
-            return new StdioClientTransport(Object.assign(Object.assign(Object.assign({ command: transport.command }, (transport.args === undefined ? {} : { args: transport.args })), { env: Object.assign(Object.assign({}, Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== undefined))), ((_a = transport.env) !== null && _a !== void 0 ? _a : {})) }), (transport.cwd === undefined ? {} : { cwd: transport.cwd })));
-        }
-        const url = new URL(transport.url);
-        const requestInit = transport.headers === undefined ? undefined : { headers: transport.headers };
-        const authProvider = transport.oauth === true
-            ? yield createHostMcpOAuthProvider({
-                identifier: connection.name,
-                resourceUrl: transport.url,
-                redirectUrl: oauthRedirectUrl,
-            })
-            : undefined;
-        const fetchImpl = instrumentedMcpFetch();
-        const fetchLike = (url, init) => fetchImpl(url, init);
-        if (transport.type === "sse") {
-            return new SSEClientTransport(url, {
-                requestInit,
-                authProvider,
-                fetch: fetchLike,
-            });
-        }
-        return new StreamableHTTPClientTransport(url, {
+async function createTransport(connection, oauthRedirectUrl) {
+    const transport = resolveConnectionEnvTemplates(connection.transport);
+    if ("agent" in transport) {
+        // Peers are resolved to concrete URLs by the serve host before any call
+        // (SessionEngine.setResolvedConnections); reaching here means the
+        // connection is being used outside a running server.
+        throw new Error(`MCP connection "${connection.name}" targets peer agent "${transport.agent}" and has not been resolved; peer MCP connections are only callable on a running serve host.`);
+    }
+    if ("cursorAccount" in transport) {
+        // Same contract as peers: the serve host resolves the account bridge URL
+        // before any call (SessionEngine.setResolvedConnections).
+        throw new Error(`MCP connection "${connection.name}" exposes the Cursor account's connectors and has not been resolved; Cursor account MCP connections are only callable on a running serve host.`);
+    }
+    if ("command" in transport) {
+        return new StdioClientTransport({
+            command: transport.command,
+            ...(transport.args === undefined ? {} : { args: transport.args }),
+            env: {
+                ...Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== undefined)),
+                ...(transport.env ?? {}),
+            },
+            ...(transport.cwd === undefined ? {} : { cwd: transport.cwd }),
+        });
+    }
+    const url = new URL(transport.url);
+    const requestInit = transport.headers === undefined ? undefined : { headers: transport.headers };
+    const authProvider = transport.oauth === true
+        ? await createHostMcpOAuthProvider({
+            identifier: connection.name,
+            resourceUrl: transport.url,
+            redirectUrl: oauthRedirectUrl,
+        })
+        : undefined;
+    const fetchImpl = instrumentedMcpFetch();
+    const fetchLike = (url, init) => fetchImpl(url, init);
+    if (transport.type === "sse") {
+        return new SSEClientTransport(url, {
             requestInit,
             authProvider,
             fetch: fetchLike,
         });
+    }
+    return new StreamableHTTPClientTransport(url, {
+        requestInit,
+        authProvider,
+        fetch: fetchLike,
     });
 }
 function mcpListParams() {
@@ -402,9 +395,13 @@ function normalizeCallResult(result) {
         };
     }
     const record = result;
-    return Object.assign(Object.assign({ content: Array.isArray(record.content)
+    return {
+        content: Array.isArray(record.content)
             ? record.content
-            : [{ type: "text", text: JSON.stringify(result) }] }, (record.isError === undefined ? {} : { isError: record.isError })), (record.structuredContent === undefined
-        ? {}
-        : { structuredContent: record.structuredContent }));
+            : [{ type: "text", text: JSON.stringify(result) }],
+        ...(record.isError === undefined ? {} : { isError: record.isError }),
+        ...(record.structuredContent === undefined
+            ? {}
+            : { structuredContent: record.structuredContent }),
+    };
 }