@cursor/bdk 0.2.2 → 0.2.4

package/src/internal/mcp-endpoint.ts

@@ -1,747 +0,0 @@
-/**
- * Per-agent MCP surface: every mounted agent is also a Model Context
- * Protocol server over streamable HTTP at `<base>/v1/mcp`, so other agents
- * (peer MCP connections) and ordinary MCP clients can delegate work to it.
- *
- * The endpoint is stateless (a fresh `McpServer` + transport per POST, JSON
- * response mode): session identity travels in tool arguments, not in MCP
- * transport session headers, so any number of hosts can sit in front of it.
- *
- * Tools:
- * - `ask` — start (or continue, via `sessionId`) a conversation with this
- *   agent; runs a model turn in the agent's own context and returns the
- *   reply. Bounded wait: long turns return `status: "running"`.
- * - `check` — wait for / poll a running session started by `ask`.
- * - `call_tool` — call one of the agent's deterministic server tools
- *   directly (no model turn). Registered only when server tools exist.
- */
-
-import type { SDKCustomToolContent, SDKCustomToolResult, SDKJsonValue } from "@cursor/sdk";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
-import {
-  CallToolRequestSchema,
-  type CallToolResult,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-import { z } from "zod";
-import type { AgentProject, AuthContext, SessionRecord, TurnOutcome } from "../types.js";
-import { samePrincipal } from "./auth.js";
-import { describeError } from "./describe-error.js";
-import {
-  SessionBusyError,
-  type SessionEngine,
-  ToolInputError,
-  ToolNotDirectlyCallableError,
-  UnknownSessionError,
-  UnknownToolError,
-} from "./session-engine.js";
-
-/** Channel id recorded on sessions created through the MCP surface. */
-export const MCP_CHANNEL_ID = "mcp";
-
-/** Mount path of the MCP surface, relative to the agent base. */
-export const MCP_ENDPOINT_PATH = "/v1/mcp";
-/** Direct authored server tools used by this agent's cloud turns. */
-export const TOOL_MCP_ENDPOINT_PATH = "/v1/mcp/tools";
-
-/**
- * Bounded waits stay below the MCP client default request timeout (60s) so
- * a long model turn degrades to `status: "running"` instead of a client
- * timeout that loses the session id.
- */
-const MAX_WAIT_SECONDS = 55;
-const DEFAULT_WAIT_SECONDS = 50;
-
-export interface AgentMcpEndpoint {
-  /**
-   * Handle one HTTP request to the MCP mount. `auth` is the principal
-   * resolved by the route auth chain; sessions created through `ask` bind
-   * to it, and follow-ups enforce the same principal.
-   */
-  handle(request: Request, auth: AuthContext | null): Promise<Response>;
-}
-
-/** Minimal shape both `McpServer` and the low-level `Server` satisfy. */
-interface ConnectableMcpServer {
-  connect(transport: WebStandardStreamableHTTPServerTransport): Promise<void>;
-  close(): Promise<void>;
-}
-
-/**
- * Serve one stateless streamable-HTTP MCP request: a fresh server +
- * transport per POST, JSON response mode, spec-compliant 405 on other
- * methods. Shared by the per-agent MCP endpoint and the Cursor account
- * bridge so the subtle transport/error plumbing exists once.
- *
- * Origin MCP in `backend/server/src/origin/mcp/originMcpHttpHandler.ts`
- * is not a 1:1 copy: it races `request.signal` so a tool that ignores abort
- * cannot hang, while this helper has no such backstop and still leaks an
- * unsettled promise. backend/server cannot import `@cursor/bdk` internals,
- * so Origin diverges on purpose. Do not extract a shared package, and do
- * not port the abort race here, in that stack.
- */
-export async function handleStatelessMcpRequest(args: {
-  request: Request;
-  /** Builds the per-request MCP server (tools close over request state). */
-  buildServer: () => ConnectableMcpServer;
-  /** Label used in the failure log line, e.g. `"mcp endpoint"`. */
-  label: string;
-  logger?: (line: string) => void;
-}): Promise<Response> {
-  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" },
-      },
-    );
-  }
-  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(`[agent-sdk] ${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: AgentProject): string[] {
-  const names = ["ask", "check"];
-  if (project.agent.tools.some(tool => tool.execution === "server")) {
-    names.push("call_tool");
-  }
-  return names;
-}
-
-export function createAgentMcpEndpoint(args: {
-  engine: SessionEngine;
-  logger?: (line: string) => void;
-}): AgentMcpEndpoint {
-  const { engine, logger } = args;
-
-  return {
-    handle(request, auth): Promise<Response> {
-      return handleStatelessMcpRequest({
-        request,
-        buildServer: () => buildAgentMcpServer(engine, auth),
-        label: "mcp endpoint",
-        ...(logger === undefined ? {} : { logger }),
-      });
-    },
-  };
-}
-
-export function createToolMcpEndpoint(args: {
-  engine: SessionEngine;
-  logger?: (line: string) => void;
-}): AgentMcpEndpoint {
-  const { engine, logger } = args;
-  return {
-    handle(request): Promise<Response> {
-      const url = new URL(request.url);
-      const sessionId = url.searchParams.get("agentkitSessionId");
-      // `connection=<name>` serves a host connection bridge instead of the
-      // authored server tools: same endpoint, same auth, same session
-      // binding, but tools/list and tools/call forward to `host.mcp` for
-      // that connection (see buildConnectionBridgeMcpServer).
-      const connection = url.searchParams.get("connection");
-      return handleStatelessMcpRequest({
-        request,
-        buildServer: () =>
-          connection === null
-            ? buildToolMcpServer(engine, sessionId)
-            : buildConnectionBridgeMcpServer(engine, sessionId, connection),
-        label:
-          connection === null
-            ? "tool mcp endpoint"
-            : `connection bridge mcp endpoint (${connection})`,
-        ...(logger === undefined ? {} : { logger }),
-      });
-    },
-  };
-}
-
-function buildToolMcpServer(engine: SessionEngine, sessionId: string | null): Server {
-  const server = new Server(
-    { name: `${engine.project.name}:tools`, version: "0.1.0" },
-    {
-      capabilities: { tools: {} },
-      instructions:
-        "Direct tools implemented by the AgentSDK deployment for its active cloud turn.",
-    },
-  );
-  const tools = engine.project.agent.tools.filter(tool => tool.execution === "server");
-  server.setRequestHandler(ListToolsRequestSchema, () =>
-    Promise.resolve({
-      tools: tools.map(tool => ({
-        name: tool.name,
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-        ...(tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema }),
-      })),
-    }),
-  );
-  server.setRequestHandler(CallToolRequestSchema, async request => {
-    if (sessionId === null || sessionId === "") {
-      return errorResult("Missing AgentSDK session binding.");
-    }
-    const tool = tools.find(candidate => candidate.name === request.params.name);
-    if (tool === undefined) {
-      return errorResult(`Unknown server tool "${request.params.name}".`);
-    }
-    const result = await engine.callActiveServerTool(
-      sessionId,
-      tool.name,
-      request.params.arguments ?? {},
-    );
-    return sdkResultToMcpResult(result);
-  });
-  return server;
-}
-
-/**
- * Host connection bridge: one authored MCP connection served to a cloud turn
- * over the tool MCP endpoint. Listing and calling forward to the host-side
- * client (`host.mcp`), where the connection's credential — account bridge
- * secret or host OAuth token — actually lives, so nothing key-shaped ever
- * travels in the turn's MCP config or lands on the VM.
- *
- * The engine gates access twice, mirroring the authored server-tool path:
- * only bridgeable names (`isCloudBridgedConnection`) — unknown names
- * stay unreachable from a VM even with a valid endpoint credential —
- * and only while the bound session has a turn
- * in flight (`hasActiveTurn`), so a credential that persists on a VM after
- * its turn cannot keep calling host connectors. Listing forwards per
- * request, so a server that adds tools mid-session (`tools/list_changed`,
- * e.g. Datadog's skills-first mode) is picked up on the next list instead
- * of never.
- */
-function buildConnectionBridgeMcpServer(
-  engine: SessionEngine,
-  sessionId: string | null,
-  connectionName: string,
-): Server {
-  const server = new Server(
-    {
-      name: `${engine.project.name}:bridge:${connectionName}`,
-      version: "0.1.0",
-    },
-    {
-      capabilities: { tools: {} },
-      instructions: `Tools from the "${connectionName}" MCP connection, listed and called on the serve host where its credential lives.`,
-    },
-  );
-  const rejected = (): string | undefined => {
-    if (sessionId === null || sessionId === "") {
-      return "Missing AgentSDK session binding.";
-    }
-    if (!engine.isCloudBridgedConnection(connectionName)) {
-      return `MCP connection "${connectionName}" is not bridged to cloud turns.`;
-    }
-    if (!engine.hasActiveTurn(sessionId)) {
-      return `Session ${sessionId} has no active turn for connection "${connectionName}".`;
-    }
-    return undefined;
-  };
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
-    const reason = rejected();
-    if (reason !== undefined) {
-      throw new Error(reason);
-    }
-    const tools = await engine.runWithMcpPark(sessionId ?? "", "tools/list", () =>
-      engine.host.mcp.listTools(connectionName),
-    );
-    return {
-      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, 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 = await engine.bridgedCallAnswer({
-      sessionId: sessionId ?? "",
-      connectionName,
-      toolName: request.params.name,
-      input: request.params.arguments,
-    });
-    if (answer.answered) {
-      return sdkResultToMcpResult(answer.result);
-    }
-    try {
-      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 as CallToolResult["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;
-}
-
-// ============================================================================
-// Server construction (per request; tools close over the caller principal)
-// ============================================================================
-
-function buildAgentMcpServer(engine: SessionEngine, auth: AuthContext | null): McpServer {
-  const project = engine.project;
-  const agent = project.agent;
-  const server = new McpServer(
-    { name: project.name, version: "0.1.0" },
-    { instructions: buildInstructions(project) },
-  );
-
-  server.registerTool(
-    "ask",
-    {
-      description: buildAskDescription(project),
-      inputSchema: {
-        message: z.string().describe("The message or task for this agent."),
-        sessionId: z
-          .string()
-          .optional()
-          .describe(
-            "Existing session to follow up on (from a previous ask). Omit to start a fresh session with fresh context.",
-          ),
-        waitSeconds: z
-          .number()
-          .min(0)
-          .max(MAX_WAIT_SECONDS)
-          .optional()
-          .describe(
-            `How long to wait for the turn to finish before returning status "running" (default ${DEFAULT_WAIT_SECONDS}).`,
-          ),
-      },
-    },
-    async ({ message, sessionId, waitSeconds }) => {
-      try {
-        const targetSessionId = await (sessionId === undefined
-          ? startSession(engine, auth, message)
-          : followUpSession(engine, auth, sessionId, message));
-        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: {
-        sessionId: z.string().describe("Session id returned by ask."),
-        waitSeconds: z
-          .number()
-          .min(0)
-          .max(MAX_WAIT_SECONDS)
-          .optional()
-          .describe(
-            `How long to wait for the running turn before returning status "running" (default ${DEFAULT_WAIT_SECONDS}).`,
-          ),
-      },
-    },
-    async ({ sessionId, waitSeconds }) => {
-      try {
-        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",
-      {
-        description: `Call one of this agent's deterministic server tools directly (no model turn decides anything). Available tools: ${serverTools
-          .map(tool => tool.name)
-          .join(", ")}.`,
-        inputSchema: {
-          toolName: z.string().describe("Name of the server tool to call."),
-          input: z
-            .record(z.unknown())
-            .optional()
-            .describe("Tool input, validated against the tool's schema."),
-          sessionId: z
-            .string()
-            .optional()
-            .describe(
-              "Run the tool inside an existing session (recorded on its event stream). Omit for an ephemeral scratch workspace.",
-            ),
-        },
-      },
-      async ({ toolName, input, sessionId }) => {
-        try {
-          if (sessionId !== undefined) {
-            await requireOwnedSession(engine, auth, sessionId);
-          }
-          const outcome = await engine.callTool(toolName, input ?? {}, {
-            auth,
-            ...(sessionId === undefined ? {} : { sessionId }),
-          });
-          return {
-            content: [
-              {
-                type: "text" as const,
-                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 as const } : {}),
-          };
-        } catch (error) {
-          if (error instanceof UnknownToolError) {
-            return errorResult(
-              `${error.message}. Available tools: ${error.availableToolNames.join(", ") || "(none)"}.`,
-            );
-          }
-          if (
-            error instanceof ToolNotDirectlyCallableError ||
-            error instanceof ToolInputError ||
-            error instanceof SessionBusyError ||
-            error instanceof UnknownSessionError
-          ) {
-            return errorResult(error.message);
-          }
-          return errorResult(describeError(error));
-        }
-      },
-    );
-  }
-
-  return server;
-}
-
-function buildInstructions(project: AgentProject): string {
-  const agent = project.agent;
-  const parts = [
-    `This MCP server fronts the Cursor agent "${project.name}".`,
-    ...(agent.description === undefined ? [] : [agent.description]),
-    'Delegate a task with the ask tool: each call without a sessionId starts a fresh session (fresh context); pass the returned sessionId to continue the same conversation. When ask returns status "running", call check with that sessionId to keep waiting for the reply.',
-  ];
-  return parts.join(" ");
-}
-
-function buildAskDescription(project: AgentProject): string {
-  const description = project.agent.description;
-  const purpose =
-    description === undefined || description.trim() === ""
-      ? `the "${project.name}" agent`
-      : `the "${project.name}" agent — ${description.trim()}`;
-  return `Send a message to ${purpose}. Runs a full model turn in that agent's own context and returns its reply. Omit sessionId to start a fresh session; pass it to follow up. Long turns return status "running" — call check with the sessionId to keep waiting.`;
-}
-
-// ============================================================================
-// Session helpers
-// ============================================================================
-
-async function startSession(
-  engine: SessionEngine,
-  auth: AuthContext | null,
-  message: string,
-): Promise<string> {
-  const session = await engine.send(MCP_CHANNEL_ID, message, { auth });
-  return session.id;
-}
-
-async function followUpSession(
-  engine: SessionEngine,
-  auth: AuthContext | null,
-  sessionId: string,
-  message: string,
-): Promise<string> {
-  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;
-}
-
-async function requireOwnedSession(
-  engine: SessionEngine,
-  auth: AuthContext | null,
-  sessionId: string,
-): Promise<SessionRecord> {
-  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;
-}
-
-interface ReplyPayload {
-  status: "completed" | "running" | "error" | "cancelled";
-  sessionId: string;
-  reply?: string;
-  errorMessage?: string;
-  note?: string;
-}
-
-async function waitForReply(
-  engine: SessionEngine,
-  sessionId: string,
-  waitSeconds: number,
-): Promise<ReplyPayload> {
-  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);
-}
-
-async function toReplyPayload(
-  engine: SessionEngine,
-  sessionId: string,
-  outcome: TurnOutcome,
-): Promise<ReplyPayload> {
-  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: "completed",
-      sessionId,
-      ...(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.",
-  };
-}
-
-async function latestReplyFromEvents(
-  engine: SessionEngine,
-  sessionId: string,
-): Promise<string | undefined> {
-  let events: Awaited<ReturnType<SessionEngine["listEvents"]>>;
-  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;
-    }
-    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;
-    }
-  }
-  return undefined;
-}
-
-// ============================================================================
-// Result shaping
-// ============================================================================
-
-interface McpToolResult {
-  content: Array<{ type: "text"; text: string }>;
-  isError?: true;
-  [key: string]: unknown;
-}
-
-function toToolResult(payload: ReplyPayload): McpToolResult {
-  return {
-    content: [{ type: "text", text: JSON.stringify(payload) }],
-    ...(payload.status === "error" ? { isError: true as const } : {}),
-  };
-}
-
-function errorResult(message: string): McpToolResult {
-  return {
-    content: [{ type: "text", text: message }],
-    isError: true,
-  };
-}
-
-function sdkResultToMcpResult(result: SDKCustomToolResult) {
-  if (isSdkToolEnvelope(result)) {
-    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" as const, text: result }] };
-  }
-  return {
-    content: [{ type: "text" as const, text: JSON.stringify(result) }],
-    ...(isJsonObject(result) ? { structuredContent: result } : {}),
-  };
-}
-
-function toMcpContent(content: SDKCustomToolContent) {
-  if (content.type === "text") {
-    return content;
-  }
-  return {
-    type: "image" as const,
-    data: content.data,
-    mimeType: content.mimeType ?? "application/octet-stream",
-  };
-}
-
-function isSdkToolEnvelope(
-  result: SDKCustomToolResult,
-): result is Extract<SDKCustomToolResult, { content: unknown }> {
-  return (
-    typeof result === "object" &&
-    result !== null &&
-    !Array.isArray(result) &&
-    "content" in result &&
-    Array.isArray(result.content) &&
-    result.content.every(isSdkToolContent)
-  );
-}
-
-function isSdkToolContent(value: unknown): value is SDKCustomToolContent {
-  if (typeof value !== "object" || value === null || !("type" in value)) {
-    return false;
-  }
-  if (value.type === "text") {
-    return "text" in value && typeof value.text === "string";
-  }
-  return (
-    value.type === "image" &&
-    "data" in value &&
-    typeof value.data === "string" &&
-    (!("mimeType" in value) || value.mimeType === undefined || typeof value.mimeType === "string")
-  );
-}
-
-function isJsonObject(value: SDKJsonValue): value is Record<string, SDKJsonValue> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/** Resolve to the promise value, or undefined once `ms` elapses first. */
-function raceTimeout<T>(promise: Promise<T>, ms: number): Promise<T | undefined> {
-  return new Promise<T | undefined>((resolve, reject) => {
-    const timer = setTimeout(() => {
-      resolve(undefined);
-    }, ms);
-    promise.then(
-      value => {
-        clearTimeout(timer);
-        resolve(value);
-      },
-      (error: unknown) => {
-        clearTimeout(timer);
-        reject(error instanceof Error ? error : new Error(String(error)));
-      },
-    );
-  });
-}