@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/mcp-endpoint.js

@@ -15,15 +15,6 @@
  * - `call_tool` — call one of the agent's deterministic server tools
  *   directly (no model turn). Registered only when server tools exist.
  */
-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 { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
@@ -58,46 +49,43 @@ const DEFAULT_WAIT_SECONDS = 50;
  * so Origin diverges on purpose. Do not extract a shared package, and do
  * not port the abort race here, in that stack.
  */
-export function handleStatelessMcpRequest(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const logger = (_a = args.logger) !== null && _a !== void 0 ? _a : (() => { });
-        if (args.request.method !== "POST") {
-            // Stateless server: no server-initiated SSE stream (GET) and no
-            // transport sessions to delete (DELETE). 405 per the MCP spec;
-            // clients treat it as "streaming unsupported" and carry on.
-            return new Response(JSON.stringify({
-                jsonrpc: "2.0",
-                error: { code: -32000, message: "Method not allowed." },
-                id: null,
-            }), {
-                status: 405,
-                headers: { "content-type": "application/json", allow: "POST" },
-            });
-        }
-        const server = args.buildServer();
-        const transport = new WebStandardStreamableHTTPServerTransport({
-            sessionIdGenerator: undefined,
-            enableJsonResponse: true,
+export async function handleStatelessMcpRequest(args) {
+    const logger = args.logger ?? (() => { });
+    if (args.request.method !== "POST") {
+        // Stateless server: no server-initiated SSE stream (GET) and no
+        // transport sessions to delete (DELETE). 405 per the MCP spec;
+        // clients treat it as "streaming unsupported" and carry on.
+        return new Response(JSON.stringify({
+            jsonrpc: "2.0",
+            error: { code: -32000, message: "Method not allowed." },
+            id: null,
+        }), {
+            status: 405,
+            headers: { "content-type": "application/json", allow: "POST" },
         });
-        try {
-            yield server.connect(transport);
-            // JSON-response mode materializes the full body before resolving,
-            // so closing in `finally` never truncates a streamed response.
-            return yield transport.handleRequest(args.request);
-        }
-        catch (error) {
-            logger(`[bdk] ${args.label} request failed: ${describeError(error)}`);
-            return new Response(JSON.stringify({
-                jsonrpc: "2.0",
-                error: { code: -32603, message: "Internal server error." },
-                id: null,
-            }), { status: 500, headers: { "content-type": "application/json" } });
-        }
-        finally {
-            void server.close().catch(() => { });
-        }
+    }
+    const server = args.buildServer();
+    const transport = new WebStandardStreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+        enableJsonResponse: true,
     });
+    try {
+        await server.connect(transport);
+        // JSON-response mode materializes the full body before resolving,
+        // so closing in `finally` never truncates a streamed response.
+        return await transport.handleRequest(args.request);
+    }
+    catch (error) {
+        logger(`[bdk] ${args.label} request failed: ${describeError(error)}`);
+        return new Response(JSON.stringify({
+            jsonrpc: "2.0",
+            error: { code: -32603, message: "Internal server error." },
+            id: null,
+        }), { status: 500, headers: { "content-type": "application/json" } });
+    }
+    finally {
+        void server.close().catch(() => { });
+    }
 }
 /** Tool names the MCP surface exposes for `project` (info projection). */
 export function mcpEndpointToolNames(project) {
@@ -111,7 +99,12 @@ export function createAgentMcpEndpoint(args) {
     const { engine, logger } = args;
     return {
         handle(request, auth) {
-            return handleStatelessMcpRequest(Object.assign({ request, buildServer: () => buildAgentMcpServer(engine, auth), label: "mcp endpoint" }, (logger === undefined ? {} : { logger })));
+            return handleStatelessMcpRequest({
+                request,
+                buildServer: () => buildAgentMcpServer(engine, auth),
+                label: "mcp endpoint",
+                ...(logger === undefined ? {} : { logger }),
+            });
         },
     };
 }
@@ -126,11 +119,16 @@ export function createToolMcpEndpoint(args) {
             // binding, but tools/list and tools/call forward to `host.mcp` for
             // that connection (see buildConnectionBridgeMcpServer).
             const connection = url.searchParams.get("connection");
-            return handleStatelessMcpRequest(Object.assign({ request, buildServer: () => connection === null
+            return handleStatelessMcpRequest({
+                request,
+                buildServer: () => connection === null
                     ? buildToolMcpServer(engine, sessionId)
-                    : buildConnectionBridgeMcpServer(engine, sessionId, connection), label: connection === null
+                    : buildConnectionBridgeMcpServer(engine, sessionId, connection),
+                label: connection === null
                     ? "tool mcp endpoint"
-                    : `connection bridge mcp endpoint (${connection})` }, (logger === undefined ? {} : { logger })));
+                    : `connection bridge mcp endpoint (${connection})`,
+                ...(logger === undefined ? {} : { logger }),
+            });
         },
     };
 }
@@ -141,10 +139,14 @@ function buildToolMcpServer(engine, sessionId) {
     });
     const tools = engine.project.agent.tools.filter(tool => tool.execution === "server");
     server.setRequestHandler(ListToolsRequestSchema, () => Promise.resolve({
-        tools: tools.map(tool => (Object.assign({ name: tool.name, description: tool.description, inputSchema: tool.inputSchema }, (tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema })))),
+        tools: tools.map(tool => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+            ...(tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema }),
+        })),
     }));
-    server.setRequestHandler(CallToolRequestSchema, (request) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
         if (sessionId === null || sessionId === "") {
             return errorResult("Missing AgentSDK session binding.");
         }
@@ -152,9 +154,9 @@ function buildToolMcpServer(engine, sessionId) {
         if (tool === undefined) {
             return errorResult(`Unknown server tool "${request.params.name}".`);
         }
-        const result = yield engine.callActiveServerTool(sessionId, tool.name, (_a = request.params.arguments) !== null && _a !== void 0 ? _a : {});
+        const result = await engine.callActiveServerTool(sessionId, tool.name, request.params.arguments ?? {});
         return sdkResultToMcpResult(result);
-    }));
+    });
     return server;
 }
 /**
@@ -194,25 +196,32 @@ function buildConnectionBridgeMcpServer(engine, sessionId, connectionName) {
         }
         return undefined;
     };
-    server.setRequestHandler(ListToolsRequestSchema, () => __awaiter(this, void 0, void 0, function* () {
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
         const reason = rejected();
         if (reason !== undefined) {
             throw new Error(reason);
         }
-        const tools = yield engine.runWithMcpPark(sessionId !== null && sessionId !== void 0 ? sessionId : "", "tools/list", () => engine.host.mcp.listTools(connectionName));
+        const tools = await engine.runWithMcpPark(sessionId ?? "", "tools/list", () => engine.host.mcp.listTools(connectionName));
         return {
-            tools: tools.map(tool => { var _a; return (Object.assign(Object.assign(Object.assign(Object.assign({ name: tool.name }, (tool.description === undefined ? {} : { description: tool.description })), { inputSchema: (_a = tool.inputSchema) !== null && _a !== void 0 ? _a : { type: "object" } }), (tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema })), (tool.annotations === undefined ? {} : { annotations: tool.annotations }))); }),
+            tools: tools.map(tool => ({
+                name: tool.name,
+                ...(tool.description === undefined ? {} : { description: tool.description }),
+                inputSchema: tool.inputSchema ?? { type: "object" },
+                ...(tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema }),
+                // Already bounded to the MCP-spec fields at listing time (mcp-host).
+                ...(tool.annotations === undefined ? {} : { annotations: tool.annotations }),
+            })),
         };
-    }));
-    server.setRequestHandler(CallToolRequestSchema, (request) => __awaiter(this, void 0, void 0, function* () {
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const reason = rejected();
         if (reason !== undefined) {
             return errorResult(reason);
         }
         // The one tool path that never reaches `executeServerTool`, so it asks
         // the policy itself.
-        const answer = yield engine.bridgedCallAnswer({
-            sessionId: sessionId !== null && sessionId !== void 0 ? sessionId : "",
+        const answer = await engine.bridgedCallAnswer({
+            sessionId: sessionId ?? "",
             connectionName,
             toolName: request.params.name,
             input: request.params.arguments,
@@ -221,19 +230,22 @@ function buildConnectionBridgeMcpServer(engine, sessionId, connectionName) {
             return sdkResultToMcpResult(answer.result);
         }
         try {
-            const result = yield engine.runWithMcpPark(sessionId !== null && sessionId !== void 0 ? sessionId : "", request.params.name, () => { var _a; return engine.host.mcp.callTool(connectionName, request.params.name, (_a = request.params.arguments) !== null && _a !== void 0 ? _a : {}); });
-            return Object.assign(Object.assign({ 
+            const result = await engine.runWithMcpPark(sessionId ?? "", request.params.name, () => engine.host.mcp.callTool(connectionName, request.params.name, request.params.arguments ?? {}));
+            return {
                 // The host client already speaks MCP, so the content array is valid
                 // CallToolResult content; HostMcpCallResult just types the tail of
                 // the union open-endedly.
-                content: result.content }, (result.isError === undefined ? {} : { isError: result.isError })), (result.structuredContent === undefined
-                ? {}
-                : { structuredContent: result.structuredContent }));
+                content: result.content,
+                ...(result.isError === undefined ? {} : { isError: result.isError }),
+                ...(result.structuredContent === undefined
+                    ? {}
+                    : { structuredContent: result.structuredContent }),
+            };
         }
         catch (error) {
             return errorResult(`MCP connection "${connectionName}" is not reachable from the serve host: ${describeError(error)}`);
         }
-    }));
+    });
     return server;
 }
 // ============================================================================
@@ -258,18 +270,18 @@ function buildAgentMcpServer(engine, auth) {
                 .optional()
                 .describe(`How long to wait for the turn to finish before returning status "running" (default ${DEFAULT_WAIT_SECONDS}).`),
         },
-    }, (_a) => __awaiter(this, [_a], void 0, function* ({ message, sessionId, waitSeconds }) {
+    }, async ({ message, sessionId, waitSeconds }) => {
         try {
-            const targetSessionId = yield (sessionId === undefined
+            const targetSessionId = await (sessionId === undefined
                 ? startSession(engine, auth, message)
                 : followUpSession(engine, auth, sessionId, message));
-            const payload = yield waitForReply(engine, targetSessionId, waitSeconds !== null && waitSeconds !== void 0 ? waitSeconds : DEFAULT_WAIT_SECONDS);
+            const payload = await waitForReply(engine, targetSessionId, waitSeconds ?? DEFAULT_WAIT_SECONDS);
             return toToolResult(payload);
         }
         catch (error) {
             return errorResult(describeError(error));
         }
-    }));
+    });
     server.registerTool("check", {
         description: 'Wait for (or poll) a session started with ask. Returns the final reply once the turn completes, or status "running" to keep waiting. Use waitSeconds: 0 for a non-blocking poll.',
         inputSchema: {
@@ -281,16 +293,16 @@ function buildAgentMcpServer(engine, auth) {
                 .optional()
                 .describe(`How long to wait for the running turn before returning status "running" (default ${DEFAULT_WAIT_SECONDS}).`),
         },
-    }, (_a) => __awaiter(this, [_a], void 0, function* ({ sessionId, waitSeconds }) {
+    }, async ({ sessionId, waitSeconds }) => {
         try {
-            yield requireOwnedSession(engine, auth, sessionId);
-            const payload = yield waitForReply(engine, sessionId, waitSeconds !== null && waitSeconds !== void 0 ? waitSeconds : DEFAULT_WAIT_SECONDS);
+            await requireOwnedSession(engine, auth, sessionId);
+            const payload = await waitForReply(engine, sessionId, waitSeconds ?? DEFAULT_WAIT_SECONDS);
             return toToolResult(payload);
         }
         catch (error) {
             return errorResult(describeError(error));
         }
-    }));
+    });
     const serverTools = agent.tools.filter(tool => tool.execution === "server");
     if (serverTools.length > 0) {
         server.registerTool("call_tool", {
@@ -308,20 +320,32 @@ function buildAgentMcpServer(engine, auth) {
                     .optional()
                     .describe("Run the tool inside an existing session (recorded on its event stream). Omit for an ephemeral scratch workspace."),
             },
-        }, (_a) => __awaiter(this, [_a], void 0, function* ({ toolName, input, sessionId }) {
+        }, async ({ toolName, input, sessionId }) => {
             try {
                 if (sessionId !== undefined) {
-                    yield requireOwnedSession(engine, auth, sessionId);
+                    await requireOwnedSession(engine, auth, sessionId);
                 }
-                const outcome = yield engine.callTool(toolName, input !== null && input !== void 0 ? input : {}, Object.assign({ auth }, (sessionId === undefined ? {} : { sessionId })));
-                return Object.assign({ content: [
+                const outcome = await engine.callTool(toolName, input ?? {}, {
+                    auth,
+                    ...(sessionId === undefined ? {} : { sessionId }),
+                });
+                return {
+                    content: [
                         {
                             type: "text",
-                            text: JSON.stringify(Object.assign({ toolName: outcome.toolName, isError: outcome.isError, result: outcome.result, durationMs: outcome.durationMs }, (outcome.errorMessage === undefined
-                                ? {}
-                                : { errorMessage: outcome.errorMessage }))),
+                            text: JSON.stringify({
+                                toolName: outcome.toolName,
+                                isError: outcome.isError,
+                                result: outcome.result,
+                                durationMs: outcome.durationMs,
+                                ...(outcome.errorMessage === undefined
+                                    ? {}
+                                    : { errorMessage: outcome.errorMessage }),
+                            }),
                         },
-                    ] }, (outcome.isError ? { isError: true } : {}));
+                    ],
+                    ...(outcome.isError ? { isError: true } : {}),
+                };
             }
             catch (error) {
                 if (error instanceof UnknownToolError) {
@@ -335,7 +359,7 @@ function buildAgentMcpServer(engine, auth) {
                 }
                 return errorResult(describeError(error));
             }
-        }));
+        });
     }
     return server;
 }
@@ -358,109 +382,103 @@ function buildAskDescription(project) {
 // ============================================================================
 // Session helpers
 // ============================================================================
-function startSession(engine, auth, message) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const session = yield engine.send(MCP_CHANNEL_ID, message, { auth });
-        return session.id;
-    });
+async function startSession(engine, auth, message) {
+    const session = await engine.send(MCP_CHANNEL_ID, message, { auth });
+    return session.id;
 }
-function followUpSession(engine, auth, sessionId, message) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const record = yield requireOwnedSession(engine, auth, sessionId);
-        if (record.mode === "task") {
-            throw new Error(`Session ${sessionId} is a fire-and-forget task session; it does not accept follow-ups.`);
-        }
-        if (record.continuationKey === null) {
-            throw new Error(`Session ${sessionId} is not addressable for follow-ups (no active continuation).`);
-        }
-        // Send as the session owner after the ownership gate above, mirroring the
-        // HTTP follow-up route (machine callers address sessions by id; the HTTP
-        // continuation token is not rotated).
-        yield engine.send(record.channelId, message, {
-            auth: record.auth,
-            continuationToken: record.continuationKey,
-        });
-        return sessionId;
+async function followUpSession(engine, auth, sessionId, message) {
+    const record = await requireOwnedSession(engine, auth, sessionId);
+    if (record.mode === "task") {
+        throw new Error(`Session ${sessionId} is a fire-and-forget task session; it does not accept follow-ups.`);
+    }
+    if (record.continuationKey === null) {
+        throw new Error(`Session ${sessionId} is not addressable for follow-ups (no active continuation).`);
+    }
+    // Send as the session owner after the ownership gate above, mirroring the
+    // HTTP follow-up route (machine callers address sessions by id; the HTTP
+    // continuation token is not rotated).
+    await engine.send(record.channelId, message, {
+        auth: record.auth,
+        continuationToken: record.continuationKey,
     });
+    return sessionId;
 }
-function requireOwnedSession(engine, auth, sessionId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const record = yield engine.sessions.get(sessionId);
-        if (record === undefined) {
-            throw new UnknownSessionError(sessionId);
-        }
-        if (!samePrincipal(record.auth, auth)) {
-            throw new Error(`Session ${sessionId} belongs to a different principal; use the credentials that created it.`);
-        }
-        return record;
-    });
+async function requireOwnedSession(engine, auth, sessionId) {
+    const record = await engine.sessions.get(sessionId);
+    if (record === undefined) {
+        throw new UnknownSessionError(sessionId);
+    }
+    if (!samePrincipal(record.auth, auth)) {
+        throw new Error(`Session ${sessionId} belongs to a different principal; use the credentials that created it.`);
+    }
+    return record;
 }
-function waitForReply(engine, sessionId, waitSeconds) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const waitMs = Math.max(0, Math.min(waitSeconds, MAX_WAIT_SECONDS)) * 1000;
-        const outcome = yield raceTimeout(engine.waitForCompletion(sessionId), waitMs);
-        if (outcome === undefined) {
-            return {
-                status: "running",
-                sessionId,
-                note: `The turn is still running. Call check with { "sessionId": "${sessionId}" } to keep waiting.`,
-            };
-        }
-        return toReplyPayload(engine, sessionId, outcome);
-    });
+async function waitForReply(engine, sessionId, waitSeconds) {
+    const waitMs = Math.max(0, Math.min(waitSeconds, MAX_WAIT_SECONDS)) * 1000;
+    const outcome = await raceTimeout(engine.waitForCompletion(sessionId), waitMs);
+    if (outcome === undefined) {
+        return {
+            status: "running",
+            sessionId,
+            note: `The turn is still running. Call check with { "sessionId": "${sessionId}" } to keep waiting.`,
+        };
+    }
+    return toReplyPayload(engine, sessionId, outcome);
 }
-function toReplyPayload(engine, sessionId, outcome) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        if (outcome.status === "finished") {
-            let reply = outcome.result;
-            if (reply === undefined || reply === "") {
-                // The engine's in-memory outcome is gone after a host restart; fall
-                // back to the durable event log for the last completed turn.
-                reply = yield latestReplyFromEvents(engine, sessionId);
-            }
-            return Object.assign({ status: "completed", sessionId }, (reply === undefined ? {} : { reply }));
-        }
-        if (outcome.status === "cancelled") {
-            return {
-                status: "cancelled",
-                sessionId,
-                errorMessage: (_a = outcome.errorMessage) !== null && _a !== void 0 ? _a : "The turn was cancelled.",
-            };
+async function toReplyPayload(engine, sessionId, outcome) {
+    if (outcome.status === "finished") {
+        let reply = outcome.result;
+        if (reply === undefined || reply === "") {
+            // The engine's in-memory outcome is gone after a host restart; fall
+            // back to the durable event log for the last completed turn.
+            reply = await latestReplyFromEvents(engine, sessionId);
         }
         return {
-            status: "error",
+            status: "completed",
             sessionId,
-            errorMessage: (_b = outcome.errorMessage) !== null && _b !== void 0 ? _b : "The turn failed.",
+            ...(reply === undefined ? {} : { reply }),
         };
-    });
+    }
+    if (outcome.status === "cancelled") {
+        return {
+            status: "cancelled",
+            sessionId,
+            errorMessage: outcome.errorMessage ?? "The turn was cancelled.",
+        };
+    }
+    return {
+        status: "error",
+        sessionId,
+        errorMessage: outcome.errorMessage ?? "The turn failed.",
+    };
 }
-function latestReplyFromEvents(engine, sessionId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let events;
-        try {
-            events = yield engine.listEvents(sessionId);
+async function latestReplyFromEvents(engine, sessionId) {
+    let events;
+    try {
+        events = await engine.listEvents(sessionId);
+    }
+    catch {
+        return undefined;
+    }
+    for (let i = events.length - 1; i >= 0; i--) {
+        const event = events[i];
+        if (event === undefined) {
+            continue;
         }
-        catch (_a) {
-            return undefined;
+        if (event.type === "turn.completed" && event.data.result !== undefined) {
+            return event.data.result;
         }
-        for (let i = events.length - 1; i >= 0; i--) {
-            const event = events[i];
-            if (event === undefined) {
-                continue;
-            }
-            if (event.type === "turn.completed" && event.data.result !== undefined) {
-                return event.data.result;
-            }
-            if (event.type === "message.completed" && event.data.text !== "") {
-                return event.data.text;
-            }
+        if (event.type === "message.completed" && event.data.text !== "") {
+            return event.data.text;
         }
-        return undefined;
-    });
+    }
+    return undefined;
 }
 function toToolResult(payload) {
-    return Object.assign({ content: [{ type: "text", text: JSON.stringify(payload) }] }, (payload.status === "error" ? { isError: true } : {}));
+    return {
+        content: [{ type: "text", text: JSON.stringify(payload) }],
+        ...(payload.status === "error" ? { isError: true } : {}),
+    };
 }
 function errorResult(message) {
     return {
@@ -470,24 +488,30 @@ function errorResult(message) {
 }
 function sdkResultToMcpResult(result) {
     if (isSdkToolEnvelope(result)) {
-        return Object.assign(Object.assign({ content: result.content.map(toMcpContent) }, (result.isError === true ? { isError: true } : {})), (result.structuredContent === undefined
-            ? {}
-            : { structuredContent: result.structuredContent }));
+        return {
+            content: result.content.map(toMcpContent),
+            ...(result.isError === true ? { isError: true } : {}),
+            ...(result.structuredContent === undefined
+                ? {}
+                : { structuredContent: result.structuredContent }),
+        };
     }
     if (typeof result === "string") {
         return { content: [{ type: "text", text: result }] };
     }
-    return Object.assign({ content: [{ type: "text", text: JSON.stringify(result) }] }, (isJsonObject(result) ? { structuredContent: result } : {}));
+    return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        ...(isJsonObject(result) ? { structuredContent: result } : {}),
+    };
 }
 function toMcpContent(content) {
-    var _a;
     if (content.type === "text") {
         return content;
     }
     return {
         type: "image",
         data: content.data,
-        mimeType: (_a = content.mimeType) !== null && _a !== void 0 ? _a : "application/octet-stream",
+        mimeType: content.mimeType ?? "application/octet-stream",
     };
 }
 function isSdkToolEnvelope(result) {