@cursor/bdk 0.2.8 → 0.2.10

package/dist/internal/cursor/backend-client.js

@@ -13,15 +13,6 @@
  * a short-lived access token (`POST /auth/exchange_user_api_key`, ~1h),
  * cached until shortly before expiry and re-exchanged once on a 401.
  */
-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 { randomUUID } from "node:crypto";
 import { z } from "zod";
 import { describeError } from "../describe-error.js";
@@ -30,9 +21,9 @@ import { boundedToolAnnotations } from "../mcp-host.js";
 import { CURSOR_SESSION_EXCHANGE_PATH, CursorSessionExchangeError, exchangeCursorApiKeyForSession, SESSION_TOKEN_EXPIRY_LEEWAY_MS, } from "./session-token.js";
 const CLIENT_VERSION = "agent-serve-0.1.0";
 const DASHBOARD_SERVICE = "DashboardService";
-const LIST_TIMEOUT_MS = 60000;
+const LIST_TIMEOUT_MS = 60_000;
 /** Backend-executed tools call out to third-party servers; be generous. */
-const EXECUTE_TIMEOUT_MS = 120000;
+const EXECUTE_TIMEOUT_MS = 120_000;
 export class CursorBackendError extends Error {
     constructor(message, status, retryAfterMs) {
         super(message);
@@ -160,117 +151,113 @@ const executeResponseSchema = z.object({
 // Shared request machinery (used by the client and the login-time mint)
 // ============================================================================
 /** One DashboardService Connect-JSON POST; auth is the caller's bearer. */
-function connectRpc(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        try {
-            return yield args.fetchImpl(`${args.backendUrl}/aiserver.v1.${args.service}/${args.method}`, {
-                method: "POST",
-                headers: Object.assign({ "content-type": "application/json", authorization: `Bearer ${args.bearer}`, "x-ghost-mode": "true", "x-cursor-client-version": CLIENT_VERSION, "x-cursor-client-type": "agent-serve", "x-request-id": randomUUID() }, args.extraHeaders),
-                body: JSON.stringify((_a = args.body) !== null && _a !== void 0 ? _a : {}),
-                signal: AbortSignal.timeout(args.timeoutMs),
-            });
-        }
-        catch (error) {
-            throw new CursorBackendError(`Cursor backend request ${args.method} failed: ${describeError(error)}`);
-        }
-    });
+async function connectRpc(args) {
+    try {
+        return await args.fetchImpl(`${args.backendUrl}/aiserver.v1.${args.service}/${args.method}`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${args.bearer}`,
+                "x-ghost-mode": "true",
+                "x-cursor-client-version": CLIENT_VERSION,
+                "x-cursor-client-type": "agent-serve",
+                "x-request-id": randomUUID(),
+                ...args.extraHeaders,
+            },
+            body: JSON.stringify(args.body ?? {}),
+            signal: AbortSignal.timeout(args.timeoutMs),
+        });
+    }
+    catch (error) {
+        throw new CursorBackendError(`Cursor backend request ${args.method} failed: ${describeError(error)}`);
+    }
 }
 /** Drain and parse an RPC response; maps non-2xx to a CursorBackendError. */
-function parseRpcResponse(method, response) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const text = yield response.text();
-        if (!response.ok) {
-            throw new CursorBackendError(`Cursor backend ${method} failed (${response.status}): ${connectErrorMessage(text)}`, response.status);
-        }
-        try {
-            return JSON.parse(text);
-        }
-        catch (_a) {
-            throw new CursorBackendError(`Cursor backend ${method} returned a non-JSON response.`);
-        }
-    });
+async function parseRpcResponse(method, response) {
+    const text = await response.text();
+    if (!response.ok) {
+        throw new CursorBackendError(`Cursor backend ${method} failed (${response.status}): ${connectErrorMessage(text)}`, response.status);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new CursorBackendError(`Cursor backend ${method} returned a non-JSON response.`);
+    }
 }
 export class CursorBackendClient {
     constructor(options) {
-        var _a, _b, _c;
         this.backendUrl = options.backendUrl.endsWith("/")
             ? options.backendUrl.slice(0, -1)
             : options.backendUrl;
-        this.resolveApiKey = (_a = options.getApiKey) !== null && _a !== void 0 ? _a : (() => options.apiKey);
-        this.logger = (_b = options.logger) !== null && _b !== void 0 ? _b : (() => { });
-        this.fetchImpl = (_c = options.fetchImpl) !== null && _c !== void 0 ? _c : fetch;
+        this.resolveApiKey = options.getApiKey ?? (() => options.apiKey);
+        this.logger = options.logger ?? (() => { });
+        this.fetchImpl = options.fetchImpl ?? fetch;
     }
     currentApiKey() {
         return this.resolveApiKey().trim();
     }
     /** Who this API key acts as. */
-    getMe() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return getMeResponseSchema.parse(yield this.rpc("GetMe", {}));
-        });
+    async getMe() {
+        return getMeResponseSchema.parse(await this.rpc("GetMe", {}));
     }
     /**
      * The account's MCP connectors with live status and backend-prefixed tool
      * definitions. `serverIdentifiers` restricts discovery (empty = all
      * HTTP/SSE servers on the account).
      */
-    listAccountMcpTools(serverIdentifiers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const raw = yield this.rpc("ListSandMcpTools", { serverIdentifiers: [...serverIdentifiers] }, LIST_TIMEOUT_MS);
-            const parsed = listSandMcpToolsResponseSchema.parse(raw);
-            return ((_a = parsed.servers) !== null && _a !== void 0 ? _a : []).map(server => { var _a; return ({
-                serverIdentifier: server.serverIdentifier,
-                status: server.status,
-                tools: ((_a = server.tools) !== null && _a !== void 0 ? _a : []).map(tool => {
-                    var _a;
-                    const outputSchema = parseOutputSchemaJson(tool.outputSchemaJson);
-                    const annotations = parseAnnotationsJson(tool.annotationsJson);
-                    return Object.assign(Object.assign({ name: tool.name, description: (_a = tool.description) !== null && _a !== void 0 ? _a : "", inputSchema: normalizeInputSchema(tool.inputSchema) }, (outputSchema === undefined ? {} : { outputSchema })), (annotations === undefined ? {} : { annotations }));
-                }),
-            }); });
-        });
+    async listAccountMcpTools(serverIdentifiers) {
+        const raw = await this.rpc("ListSandMcpTools", { serverIdentifiers: [...serverIdentifiers] }, LIST_TIMEOUT_MS);
+        const parsed = listSandMcpToolsResponseSchema.parse(raw);
+        return (parsed.servers ?? []).map(server => ({
+            serverIdentifier: server.serverIdentifier,
+            status: server.status,
+            tools: (server.tools ?? []).map(tool => {
+                const outputSchema = parseOutputSchemaJson(tool.outputSchemaJson);
+                const annotations = parseAnnotationsJson(tool.annotationsJson);
+                return {
+                    name: tool.name,
+                    description: tool.description ?? "",
+                    inputSchema: normalizeInputSchema(tool.inputSchema),
+                    ...(outputSchema === undefined ? {} : { outputSchema }),
+                    ...(annotations === undefined ? {} : { annotations }),
+                };
+            }),
+        }));
     }
     /**
      * Execute one connector tool **on the Cursor backend** with the account's
      * stored OAuth credentials. `toolName` is the fully-qualified name from
      * {@link listAccountMcpTools}.
      */
-    executeAccountMcpTool(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const raw = yield this.rpc("ExecuteSandMcpTool", {
-                serverIdentifier: args.serverIdentifier,
-                toolName: args.toolName,
-                args: args.args,
-                toolCallId: randomUUID(),
-            }, EXECUTE_TIMEOUT_MS);
-            const parsed = executeResponseSchema.parse(raw);
-            return toCallResult((_a = parsed.result) !== null && _a !== void 0 ? _a : {});
-        });
+    async executeAccountMcpTool(args) {
+        const raw = await this.rpc("ExecuteSandMcpTool", {
+            serverIdentifier: args.serverIdentifier,
+            toolName: args.toolName,
+            args: args.args,
+            toolCallId: randomUUID(),
+        }, EXECUTE_TIMEOUT_MS);
+        const parsed = executeResponseSchema.parse(raw);
+        return toCallResult(parsed.result ?? {});
     }
     /**
      * The account's dashboard MCP connector listing (id + name per server).
      * `teamId` pins the ambient team so team-scoped connectors resolve for
      * multi-team accounts.
      */
-    getAvailableMcpServers(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const raw = yield this.rpc("GetAvailableMcpServers", {}, LIST_TIMEOUT_MS, {
-                teamId: options === null || options === void 0 ? void 0 : options.teamId,
-            });
-            const parsed = getAvailableMcpServersResponseSchema.parse(raw);
-            return ((_a = parsed.servers) !== null && _a !== void 0 ? _a : [])
-                .filter(server => server.id !== undefined && server.id > 0)
-                .map(server => { var _a; return ({
-                id: server.id,
-                name: (_a = server.name) !== null && _a !== void 0 ? _a : "",
-                isTeamServer: server.isTeamServer === true,
-                serverIdentifier: server.serverIdentifier,
-            }); });
+    async getAvailableMcpServers(options) {
+        const raw = await this.rpc("GetAvailableMcpServers", {}, LIST_TIMEOUT_MS, {
+            teamId: options?.teamId,
         });
+        const parsed = getAvailableMcpServersResponseSchema.parse(raw);
+        return (parsed.servers ?? [])
+            .filter(server => server.id !== undefined && server.id > 0)
+            .map(server => ({
+            id: server.id,
+            name: server.name ?? "",
+            isTeamServer: server.isTeamServer === true,
+            serverIdentifier: server.serverIdentifier,
+        }));
     }
     /**
      * Probe connectors and mint OAuth `authUrl`s where authorization is
@@ -278,56 +265,50 @@ export class CursorBackendClient {
      * flow for a hosted deployment's service account. Omit it to probe the
      * signed-in user (local `serve` preflight).
      */
-    checkHttpMcpStatus(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const raw = yield this.rpc("CheckHttpMcpStatus", {
-                serverIds: args.serverIds,
-                oauthRedirectUri: args.oauthRedirectUri,
-                serviceAccountId: args.serviceAccountId,
-            }, LIST_TIMEOUT_MS);
-            const parsed = checkHttpMcpStatusResponseSchema.parse(raw);
-            return ((_a = parsed.statuses) !== null && _a !== void 0 ? _a : []).map(status => { var _a; return ({
-                id: (_a = status.id) !== null && _a !== void 0 ? _a : 0,
-                requiresAuth: status.requiresAuth === true,
-                authUrl: status.authUrl,
-                error: status.error,
-            }); });
-        });
+    async checkHttpMcpStatus(args) {
+        const raw = await this.rpc("CheckHttpMcpStatus", {
+            serverIds: args.serverIds,
+            oauthRedirectUri: args.oauthRedirectUri,
+            serviceAccountId: args.serviceAccountId,
+        }, LIST_TIMEOUT_MS);
+        const parsed = checkHttpMcpStatusResponseSchema.parse(raw);
+        return (parsed.statuses ?? []).map(status => ({
+            id: status.id ?? 0,
+            requiresAuth: status.requiresAuth === true,
+            authUrl: status.authUrl,
+            error: status.error,
+        }));
     }
     /** Mint a short-lived GitHub token scoped to the requested repositories. */
-    getGithubToken(repos, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const permissions = (_a = options === null || options === void 0 ? void 0 : options.permissions) !== null && _a !== void 0 ? _a : "pr-write";
-            let response;
-            try {
-                response = yield this.fetchImpl(`${this.backendUrl}/v0/scm-events/github-token`, {
-                    method: "POST",
-                    headers: {
-                        "content-type": "application/json",
-                        authorization: `Bearer ${this.currentApiKey()}`,
-                    },
-                    body: JSON.stringify({ repos: [...repos], permissions }),
-                    signal: AbortSignal.timeout(30000),
-                });
-            }
-            catch (error) {
-                throw new CursorBackendError(`Cursor GitHub credential request failed: ${describeError(error)}`);
-            }
-            const text = yield response.text();
-            if (!response.ok) {
-                throw new CursorBackendError(describeGithubTokenHttpFailure(response.status, text), response.status, retryAfterMsFromResponse(response));
-            }
-            let parsed;
-            try {
-                parsed = JSON.parse(text);
-            }
-            catch (_b) {
-                throw new CursorBackendError("Cursor backend returned a non-JSON GitHub credential response.");
-            }
-            return githubTokenResponseSchema.parse(parsed);
-        });
+    async getGithubToken(repos, options) {
+        const permissions = options?.permissions ?? "pr-write";
+        let response;
+        try {
+            response = await this.fetchImpl(`${this.backendUrl}/v0/scm-events/github-token`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${this.currentApiKey()}`,
+                },
+                body: JSON.stringify({ repos: [...repos], permissions }),
+                signal: AbortSignal.timeout(30_000),
+            });
+        }
+        catch (error) {
+            throw new CursorBackendError(`Cursor GitHub credential request failed: ${describeError(error)}`);
+        }
+        const text = await response.text();
+        if (!response.ok) {
+            throw new CursorBackendError(describeGithubTokenHttpFailure(response.status, text), response.status, retryAfterMsFromResponse(response));
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            throw new CursorBackendError("Cursor backend returned a non-JSON GitHub credential response.");
+        }
+        return githubTokenResponseSchema.parse(parsed);
     }
     /**
      * Resolve the proxied clone target for a GitHub (GHES) / GitLab /
@@ -336,44 +317,42 @@ export class CursorBackendClient {
      * returned remote lives on the backend and takes this client's API key,
      * never a provider token.
      */
-    getScmCloneTarget(provider, repo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const label = SCM_CLONE_PROVIDER_LABELS[provider];
-            let response;
-            try {
-                response = yield this.fetchImpl(`${this.backendUrl}/v0/scm-events/${provider}-clone-target`, {
-                    method: "POST",
-                    headers: {
-                        "content-type": "application/json",
-                        authorization: `Bearer ${this.currentApiKey()}`,
-                    },
-                    body: JSON.stringify({ repo }),
-                    signal: AbortSignal.timeout(30000),
-                });
-            }
-            catch (error) {
-                throw new CursorBackendError(`Cursor ${label} clone target request failed: ${describeError(error)}`);
-            }
-            const text = yield response.text();
-            if (!response.ok) {
-                throw new CursorBackendError(describeGithubTokenHttpFailure(response.status, text, label), response.status, retryAfterMsFromResponse(response));
-            }
-            let parsed;
-            try {
-                parsed = JSON.parse(text);
-            }
-            catch (_a) {
-                throw new CursorBackendError(`Cursor backend returned a non-JSON ${label} clone target response.`);
-            }
-            const body = scmCloneTargetResponseSchema.parse(parsed);
-            return {
-                remoteUrl: `${this.backendUrl}${body.clone.remotePath}`,
-                token: this.currentApiKey(),
-                expiresAt: body.expiresAt,
-                username: body.clone.username,
-                authMode: body.clone.authMode,
-            };
-        });
+    async getScmCloneTarget(provider, repo) {
+        const label = SCM_CLONE_PROVIDER_LABELS[provider];
+        let response;
+        try {
+            response = await this.fetchImpl(`${this.backendUrl}/v0/scm-events/${provider}-clone-target`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${this.currentApiKey()}`,
+                },
+                body: JSON.stringify({ repo }),
+                signal: AbortSignal.timeout(30_000),
+            });
+        }
+        catch (error) {
+            throw new CursorBackendError(`Cursor ${label} clone target request failed: ${describeError(error)}`);
+        }
+        const text = await response.text();
+        if (!response.ok) {
+            throw new CursorBackendError(describeGithubTokenHttpFailure(response.status, text, label), response.status, retryAfterMsFromResponse(response));
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            throw new CursorBackendError(`Cursor backend returned a non-JSON ${label} clone target response.`);
+        }
+        const body = scmCloneTargetResponseSchema.parse(parsed);
+        return {
+            remoteUrl: `${this.backendUrl}${body.clone.remotePath}`,
+            token: this.currentApiKey(),
+            expiresAt: body.expiresAt,
+            username: body.clone.username,
+            authMode: body.clone.authMode,
+        };
     }
     /**
      * One unary Connect-JSON call on `aiserver.v1.<service>` with the same
@@ -383,50 +362,46 @@ export class CursorBackendClient {
     serviceRpc(service, method, body, timeoutMs = LIST_TIMEOUT_MS) {
         return this.rpc(method, body, timeoutMs, { service });
     }
-    rpc(method_1, body_1) {
-        return __awaiter(this, arguments, void 0, function* (method, body, timeoutMs = LIST_TIMEOUT_MS, options) {
-            var _a, _b;
-            var _c;
-            const service = (_c = options === null || options === void 0 ? void 0 : options.service) !== null && _c !== void 0 ? _c : DASHBOARD_SERVICE;
-            const extraHeaders = (options === null || options === void 0 ? void 0 : options.teamId) === undefined ? undefined : { "x-cursor-team-id": String(options.teamId) };
-            const bearer = yield this.getAccessToken();
-            const first = yield connectRpc({
-                fetchImpl: this.fetchImpl,
-                backendUrl: this.backendUrl,
-                service,
-                method,
-                bearer,
-                body,
-                timeoutMs,
-                extraHeaders,
-            });
-            if (first.status !== 401) {
-                return parseRpcResponse(method, first);
-            }
-            // The token aged out server-side. Drain the rejected body (keeps the
-            // connection reusable), drop the token — unless a concurrent retry
-            // already minted a newer one — and retry once.
-            yield drainResponseBody(first);
-            if (((_a = this.token) === null || _a === void 0 ? void 0 : _a.value) === bearer) {
-                this.token = undefined;
-            }
-            const retryBearer = yield this.getAccessToken();
-            const second = yield connectRpc({
-                fetchImpl: this.fetchImpl,
-                backendUrl: this.backendUrl,
-                service,
-                method,
-                bearer: retryBearer,
-                body,
-                timeoutMs,
-                extraHeaders,
-            });
-            if (second.status === 401 && ((_b = this.token) === null || _b === void 0 ? void 0 : _b.value) === retryBearer) {
-                // The freshly minted token was rejected too; do not keep serving it.
-                this.token = undefined;
-            }
-            return parseRpcResponse(method, second);
+    async rpc(method, body, timeoutMs = LIST_TIMEOUT_MS, options) {
+        const service = options?.service ?? DASHBOARD_SERVICE;
+        const extraHeaders = options?.teamId === undefined ? undefined : { "x-cursor-team-id": String(options.teamId) };
+        const bearer = await this.getAccessToken();
+        const first = await connectRpc({
+            fetchImpl: this.fetchImpl,
+            backendUrl: this.backendUrl,
+            service,
+            method,
+            bearer,
+            body,
+            timeoutMs,
+            extraHeaders,
+        });
+        if (first.status !== 401) {
+            return parseRpcResponse(method, first);
+        }
+        // The token aged out server-side. Drain the rejected body (keeps the
+        // connection reusable), drop the token — unless a concurrent retry
+        // already minted a newer one — and retry once.
+        await drainResponseBody(first);
+        if (this.token?.value === bearer) {
+            this.token = undefined;
+        }
+        const retryBearer = await this.getAccessToken();
+        const second = await connectRpc({
+            fetchImpl: this.fetchImpl,
+            backendUrl: this.backendUrl,
+            service,
+            method,
+            bearer: retryBearer,
+            body,
+            timeoutMs,
+            extraHeaders,
         });
+        if (second.status === 401 && this.token?.value === retryBearer) {
+            // The freshly minted token was rejected too; do not keep serving it.
+            this.token = undefined;
+        }
+        return parseRpcResponse(method, second);
     }
     /**
      * Serve a cached access token for the account, exchanging the API key
@@ -453,58 +428,53 @@ export class CursorBackendClient {
         }
         return this.tokenExchange;
     }
-    exchangeApiKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const apiKey = this.currentApiKey();
-            let session;
-            try {
-                session = yield exchangeCursorApiKeyForSession({
-                    exchangeUrl: `${this.backendUrl}${CURSOR_SESSION_EXCHANGE_PATH}`,
-                    apiKey,
-                    fetchImpl: this.fetchImpl,
-                });
-            }
-            catch (error) {
-                if (error instanceof CursorSessionExchangeError) {
-                    if (error.status === undefined) {
-                        throw new CursorBackendError(`Could not reach the Cursor backend at ${this.backendUrl}: ${error.message}`);
-                    }
-                    if (error.status >= 200 && error.status < 300) {
-                        // 2xx without a token in the body.
-                        throw new CursorBackendError("Cursor API key exchange returned no access token.");
-                    }
-                    throw new CursorBackendError(error.status === 401
-                        ? `The Cursor API key was rejected. Run \`${CLI} login\` again or update CURSOR_API_KEY.`
-                        : `Cursor API key exchange failed (${error.status}).`, error.status);
+    async exchangeApiKey() {
+        const apiKey = this.currentApiKey();
+        let session;
+        try {
+            session = await exchangeCursorApiKeyForSession({
+                exchangeUrl: `${this.backendUrl}${CURSOR_SESSION_EXCHANGE_PATH}`,
+                apiKey,
+                fetchImpl: this.fetchImpl,
+            });
+        }
+        catch (error) {
+            if (error instanceof CursorSessionExchangeError) {
+                if (error.status === undefined) {
+                    throw new CursorBackendError(`Could not reach the Cursor backend at ${this.backendUrl}: ${error.message}`);
+                }
+                if (error.status >= 200 && error.status < 300) {
+                    // 2xx without a token in the body.
+                    throw new CursorBackendError("Cursor API key exchange returned no access token.");
                 }
-                throw error;
+                throw new CursorBackendError(error.status === 401
+                    ? `The Cursor API key was rejected. Run \`${CLI} login\` again or update CURSOR_API_KEY.`
+                    : `Cursor API key exchange failed (${error.status}).`, error.status);
             }
-            this.token = { value: session.token, expiresAtMs: session.expiresAtMs };
-            this.lastExchangedApiKey = apiKey;
-            this.logger("[bdk] cursor account: minted a fresh access token");
-            return session.token;
-        });
+            throw error;
+        }
+        this.token = { value: session.token, expiresAtMs: session.expiresAtMs };
+        this.lastExchangedApiKey = apiKey;
+        this.logger("[bdk] cursor account: minted a fresh access token");
+        return session.token;
     }
 }
 /**
  * Mint a named user API key from a short-lived login session token. Used
  * exactly once per `agent-sdk login`; the session token is then discarded.
  */
-export function createUserApiKeyWithSessionToken(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const response = yield connectRpc({
-            fetchImpl: (_a = args.fetchImpl) !== null && _a !== void 0 ? _a : fetch,
-            backendUrl: args.backendUrl.endsWith("/") ? args.backendUrl.slice(0, -1) : args.backendUrl,
-            service: DASHBOARD_SERVICE,
-            method: "CreateUserApiKey",
-            bearer: args.sessionToken,
-            body: { name: args.keyName },
-            timeoutMs: 30000,
-        });
-        const raw = yield parseRpcResponse("CreateUserApiKey", response);
-        return createUserApiKeyResponseSchema.parse(raw).apiKey;
+export async function createUserApiKeyWithSessionToken(args) {
+    const response = await connectRpc({
+        fetchImpl: args.fetchImpl ?? fetch,
+        backendUrl: args.backendUrl.endsWith("/") ? args.backendUrl.slice(0, -1) : args.backendUrl,
+        service: DASHBOARD_SERVICE,
+        method: "CreateUserApiKey",
+        bearer: args.sessionToken,
+        body: { name: args.keyName },
+        timeoutMs: 30_000,
     });
+    const raw = await parseRpcResponse("CreateUserApiKey", response);
+    return createUserApiKeyResponseSchema.parse(raw).apiKey;
 }
 const API_KEY_PREFIX = "crsr_";
 /** Matches dashboard `maskApiKey` (`crsr_...abcd`). */
@@ -527,39 +497,36 @@ const listUserApiKeysResponseSchema = z.object({
  * so replica lag after `CreateUserApiKey` can only skip the cleanup, not
  * revoke an older same-named key.
  */
-export function revokeMintedUserApiKey(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const fetchImpl = (_a = args.fetchImpl) !== null && _a !== void 0 ? _a : fetch;
-        const backendUrl = args.backendUrl.endsWith("/") ? args.backendUrl.slice(0, -1) : args.backendUrl;
-        const listResponse = yield connectRpc({
-            fetchImpl,
-            backendUrl,
-            service: DASHBOARD_SERVICE,
-            method: "ListUserApiKeys",
-            bearer: args.sessionToken,
-            body: {},
-            timeoutMs: 30000,
-        });
-        const listed = listUserApiKeysResponseSchema.parse(yield parseRpcResponse("ListUserApiKeys", listResponse));
-        const masked = maskApiKey(args.apiKey);
-        const match = ((_b = listed.apiKeys) !== null && _b !== void 0 ? _b : []).find(key => key.name === args.keyName && key.maskedKey === masked);
-        if (match === undefined) {
-            // CreateUserApiKey writes the primary while ListUserApiKeys may read a
-            // lagging replica — skip rather than touch any other key.
-            return;
-        }
-        const revokeResponse = yield connectRpc({
-            fetchImpl,
-            backendUrl,
-            service: DASHBOARD_SERVICE,
-            method: "RevokeUserApiKey",
-            bearer: args.sessionToken,
-            body: { id: match.id },
-            timeoutMs: 30000,
-        });
-        yield drainResponseBody(revokeResponse);
+export async function revokeMintedUserApiKey(args) {
+    const fetchImpl = args.fetchImpl ?? fetch;
+    const backendUrl = args.backendUrl.endsWith("/") ? args.backendUrl.slice(0, -1) : args.backendUrl;
+    const listResponse = await connectRpc({
+        fetchImpl,
+        backendUrl,
+        service: DASHBOARD_SERVICE,
+        method: "ListUserApiKeys",
+        bearer: args.sessionToken,
+        body: {},
+        timeoutMs: 30_000,
     });
+    const listed = listUserApiKeysResponseSchema.parse(await parseRpcResponse("ListUserApiKeys", listResponse));
+    const masked = maskApiKey(args.apiKey);
+    const match = (listed.apiKeys ?? []).find(key => key.name === args.keyName && key.maskedKey === masked);
+    if (match === undefined) {
+        // CreateUserApiKey writes the primary while ListUserApiKeys may read a
+        // lagging replica — skip rather than touch any other key.
+        return;
+    }
+    const revokeResponse = await connectRpc({
+        fetchImpl,
+        backendUrl,
+        service: DASHBOARD_SERVICE,
+        method: "RevokeUserApiKey",
+        bearer: args.sessionToken,
+        body: { id: match.id },
+        timeoutMs: 30_000,
+    });
+    await drainResponseBody(revokeResponse);
 }
 // ============================================================================
 // Helpers
@@ -568,7 +535,7 @@ function safeJsonParse(text) {
     try {
         return JSON.parse(text);
     }
-    catch (_a) {
+    catch {
         return undefined;
     }
 }
@@ -592,7 +559,7 @@ function parseOutputSchemaJson(outputSchemaJson) {
     try {
         parsed = JSON.parse(outputSchemaJson);
     }
-    catch (_a) {
+    catch {
         return undefined;
     }
     return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
@@ -612,26 +579,33 @@ function parseAnnotationsJson(annotationsJson) {
     try {
         parsed = JSON.parse(annotationsJson);
     }
-    catch (_a) {
+    catch {
         return undefined;
     }
     return boundedToolAnnotations(parsed);
 }
 function toCallResult(result) {
-    var _a;
     if (result.success !== undefined) {
         const content = [];
-        for (const item of (_a = result.success.content) !== null && _a !== void 0 ? _a : []) {
+        for (const item of result.success.content ?? []) {
             if (item.text !== undefined) {
                 content.push({ type: "text", text: item.text.text });
             }
             else if (item.image !== undefined) {
-                content.push(Object.assign({ type: "image", data: item.image.data }, (item.image.mimeType === undefined ? {} : { mimeType: item.image.mimeType })));
+                content.push({
+                    type: "image",
+                    data: item.image.data,
+                    ...(item.image.mimeType === undefined ? {} : { mimeType: item.image.mimeType }),
+                });
             }
         }
-        return Object.assign({ content, isError: result.success.isError === true }, (result.success.structuredContent === undefined
-            ? {}
-            : { structuredContent: result.success.structuredContent }));
+        return {
+            content,
+            isError: result.success.isError === true,
+            ...(result.success.structuredContent === undefined
+                ? {}
+                : { structuredContent: result.success.structuredContent }),
+        };
     }
     return {
         content: [{ type: "text", text: describeFailure(result) }],
@@ -639,21 +613,20 @@ function toCallResult(result) {
     };
 }
 function describeFailure(result) {
-    var _a, _b, _c, _d, _e, _f;
     if (result.error !== undefined) {
-        return (_a = result.error.error) !== null && _a !== void 0 ? _a : "The tool call failed.";
+        return result.error.error ?? "The tool call failed.";
     }
     if (result.permissionDenied !== undefined) {
-        return (_b = result.permissionDenied.error) !== null && _b !== void 0 ? _b : "Permission denied.";
+        return result.permissionDenied.error ?? "Permission denied.";
     }
     if (result.rejected !== undefined) {
         return `The tool call was rejected${result.rejected.reason === undefined ? "" : `: ${result.rejected.reason}`}.`;
     }
     if (result.toolNotFound !== undefined) {
-        return `Unknown tool "${(_c = result.toolNotFound.name) !== null && _c !== void 0 ? _c : ""}". Available: ${((_d = result.toolNotFound.availableTools) !== null && _d !== void 0 ? _d : []).join(", ") || "(none)"}.`;
+        return `Unknown tool "${result.toolNotFound.name ?? ""}". Available: ${(result.toolNotFound.availableTools ?? []).join(", ") || "(none)"}.`;
     }
     if (result.serverNotFound !== undefined) {
-        return `Unknown MCP server "${(_e = result.serverNotFound.name) !== null && _e !== void 0 ? _e : ""}". Available: ${((_f = result.serverNotFound.availableServers) !== null && _f !== void 0 ? _f : []).join(", ") || "(none)"}.`;
+        return `Unknown MCP server "${result.serverNotFound.name ?? ""}". Available: ${(result.serverNotFound.availableServers ?? []).join(", ") || "(none)"}.`;
     }
     return "The tool call returned no result.";
 }
@@ -668,7 +641,7 @@ function connectErrorMessage(bodyText) {
     }
     return bodyText.slice(0, 300) || "(empty response body)";
 }
-const MAX_GITHUB_TOKEN_RETRY_AFTER_MS = 60 * 60000;
+const MAX_GITHUB_TOKEN_RETRY_AFTER_MS = 60 * 60_000;
 /**
  * Prefer the backend's actionable denial message. Only a true 401 on this
  * route means the Cursor API key itself was rejected — GitHub-connection
@@ -705,21 +678,18 @@ function githubTokenErrorFromBody(bodyText) {
     return undefined;
 }
 function retryAfterMsFromResponse(response) {
-    var _a;
-    const retryAfter = Number((_a = response.headers.get("retry-after")) !== null && _a !== void 0 ? _a : "");
+    const retryAfter = Number(response.headers.get("retry-after") ?? "");
     if (!Number.isFinite(retryAfter) || retryAfter <= 0) {
         return undefined;
     }
     return Math.min(retryAfter * 1000, MAX_GITHUB_TOKEN_RETRY_AFTER_MS);
 }
 /** Release undici/fetch connection slots on responses we will not parse. */
-function drainResponseBody(response) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            yield response.arrayBuffer();
-        }
-        catch (_a) {
-            // Best-effort; the socket may already be closed.
-        }
-    });
+async function drainResponseBody(response) {
+    try {
+        await response.arrayBuffer();
+    }
+    catch {
+        // Best-effort; the socket may already be closed.
+    }
 }