@cursor/bdk 0.2.2 → 0.2.4

package/src/internal/otel/runtime.ts

@@ -1,441 +0,0 @@
-/**
- * Process-level OTel SDK (OTLP HTTP exporters for traces / metrics / logs).
- *
- * Refuses to install a second global Tracer/Meter/Logger provider when one
- * already owns the process (CLI, extension host, etc.). Spans still use
- * `trace.getTracer()` so they nest under an existing parent when present.
- */
-
-import type { Histogram, Meter, Tracer } from "@opentelemetry/api";
-import { DiagLogLevel, diag, metrics, trace } from "@opentelemetry/api";
-import type { Logger as OtelLogger } from "@opentelemetry/api-logs";
-import { logs } from "@opentelemetry/api-logs";
-import { type ExportResult, ExportResultCode } from "@opentelemetry/core";
-import { OTLPLogExporter as OTLPLogExporterHttp } from "@opentelemetry/exporter-logs-otlp-http";
-import { OTLPLogExporter as OTLPLogExporterProto } from "@opentelemetry/exporter-logs-otlp-proto";
-import { OTLPMetricExporter as OTLPMetricExporterHttp } from "@opentelemetry/exporter-metrics-otlp-http";
-import { OTLPMetricExporter as OTLPMetricExporterProto } from "@opentelemetry/exporter-metrics-otlp-proto";
-import { OTLPTraceExporter as OTLPTraceExporterHttp } from "@opentelemetry/exporter-trace-otlp-http";
-import { OTLPTraceExporter as OTLPTraceExporterProto } from "@opentelemetry/exporter-trace-otlp-proto";
-import { type Resource, resourceFromAttributes } from "@opentelemetry/resources";
-import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
-import {
-  AggregationTemporality,
-  MeterProvider,
-  PeriodicExportingMetricReader,
-} from "@opentelemetry/sdk-metrics";
-import type { ReadableSpan, SpanExporter, SpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
-import {
-  BatchSpanProcessor,
-  NodeTracerProvider,
-  ParentBasedSampler,
-  TraceIdRatioBasedSampler,
-} from "@opentelemetry/sdk-trace-node";
-import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
-import {
-  installOutboundFetchInstrumentation,
-  type OtelExporterConfig,
-  type OtelSignal,
-} from "../../otel.js";
-import { exportersForSignal, type ResolvedOtelConfig } from "./config.js";
-import { ensureW3cPropagator } from "./propagation.js";
-
-const INSTRUMENTATION = "agent_sdk";
-
-/**
- * Hosted v2 pods may be frozen or destroyed as soon as the HTTP reply
- * lands. Bound the exporter wait so a slow collector cannot hold the
- * delivery (OTLP BatchSpanProcessor defaults to 30s).
- */
-export const OTEL_FORCE_FLUSH_TIMEOUT_MS = 1_000;
-
-/**
- * First hosted OTLP POST may include a cold TLS handshake to Datadog.
- * Bound separately from {@link OTEL_FORCE_FLUSH_TIMEOUT_MS} so the
- * queued turn/tool batch is not abandoned after 1s.
- */
-export const OTEL_DEFERRED_EXPORT_TIMEOUT_MS = 5_000;
-
-/** Drop oldest finished spans when no collector has drained the buffer. */
-export const OTEL_IN_MEMORY_SPAN_LIMIT = 2_048;
-
-export interface OtelRuntime {
-  config: ResolvedOtelConfig;
-  tracer: Tracer;
-  meter: Meter | undefined;
-  logger: OtelLogger | undefined;
-  httpDuration: Histogram | undefined;
-  forceFlush: () => Promise<void>;
-  shutdown: () => Promise<void>;
-}
-
-export interface CreateOtelRuntimeOptions {
-  /**
-   * Re-resolve exporters at flush (hosted v2 binds deployment secrets
-   * after bake). When bake had no OTLP exporters, finished spans sit
-   * in memory until this returns destinations.
-   */
-  resolveExport?: () => ResolvedOtelConfig;
-}
-
-export function createOtelRuntime(
-  config: ResolvedOtelConfig,
-  log: (line: string) => void,
-  options?: CreateOtelRuntimeOptions,
-): OtelRuntime | undefined {
-  if (!config.enabled) {
-    return undefined;
-  }
-  if (config.traces !== false) {
-    installOutboundFetchInstrumentation();
-  }
-  const proto = process.env.OTEL_EXPORTER_OTLP_PROTOCOL?.trim().toLowerCase();
-  if (proto === "grpc") {
-    log("[agent-sdk:otel] OTEL_EXPORTER_OTLP_PROTOCOL=grpc is unsupported; using http/protobuf");
-  }
-  ensureW3cPropagator();
-  const sdk = startOtelSdk(config, log, options?.resolveExport);
-  const meter =
-    config.metrics === false ? undefined : metrics.getMeterProvider().getMeter(INSTRUMENTATION);
-  return {
-    config,
-    tracer: trace.getTracer(INSTRUMENTATION),
-    meter,
-    logger: config.logs === false ? undefined : logs.getLogger(INSTRUMENTATION),
-    httpDuration:
-      meter === undefined
-        ? undefined
-        : meter.createHistogram("agent_sdk.http.duration", {
-            description: "HTTP request duration",
-            unit: "ms",
-          }),
-    forceFlush: sdk.forceFlush,
-    shutdown: sdk.shutdown,
-  };
-}
-
-export async function forceFlushOtelRuntime(runtime: OtelRuntime | undefined): Promise<void> {
-  await runtime?.forceFlush();
-}
-
-export async function shutdownOtelRuntime(runtime: OtelRuntime | undefined): Promise<void> {
-  await runtime?.shutdown();
-}
-
-export async function raceOtelForceFlush(
-  work: Promise<unknown>,
-  log: (line: string) => void,
-  timeoutMs: number = OTEL_FORCE_FLUSH_TIMEOUT_MS,
-): Promise<void> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<"timeout">(resolve => {
-    timer = setTimeout(() => resolve("timeout"), timeoutMs);
-  });
-  const result = await Promise.race([
-    work.then(() => "done" as const).catch(() => "done" as const),
-    timeout,
-  ]);
-  if (timer !== undefined) {
-    clearTimeout(timer);
-  }
-  if (result === "timeout") {
-    log(`[agent-sdk:otel] forceFlush exceeded ${timeoutMs}ms; continuing`);
-  }
-}
-
-function startOtelSdk(
-  config: ResolvedOtelConfig,
-  logger: (line: string) => void,
-  resolveExport?: () => ResolvedOtelConfig,
-): {
-  forceFlush: () => Promise<void>;
-  shutdown: () => Promise<void>;
-} {
-  diag.setLogger(
-    {
-      verbose: m => logger(`[agent-sdk:otel] ${m}`),
-      debug: m => logger(`[agent-sdk:otel] ${m}`),
-      info: m => logger(`[agent-sdk:otel] ${m}`),
-      warn: m => logger(`[agent-sdk:otel] warn: ${m}`),
-      error: m => logger(`[agent-sdk:otel] error: ${m}`),
-    },
-    DiagLogLevel.ERROR,
-  );
-
-  const resource = buildResource(config);
-  let tracerProvider: NodeTracerProvider | undefined;
-  let meterProvider: MeterProvider | undefined;
-  let loggerProvider: LoggerProvider | undefined;
-  let memoryExporter: BoundedMemorySpanExporter | undefined;
-
-  const traceOpts = config.traces;
-  if (traceOpts !== false) {
-    const exporters = exportersForSignal(config.exporters, "traces");
-    if (hasRealTracerProvider()) {
-      logger(
-        "[agent-sdk:otel] TracerProvider already registered; reusing global (Agent SDK OTLP exporters not attached)",
-      );
-    } else {
-      const spanProcessors: SpanProcessor[] = [];
-      if (exporters.length > 0) {
-        for (const exporter of exporters) {
-          spanProcessors.push(
-            new BatchSpanProcessor(
-              createTraceExporter(exporter, signalUrl(exporter.url, "traces")),
-            ),
-          );
-        }
-      } else {
-        memoryExporter = new BoundedMemorySpanExporter(OTEL_IN_MEMORY_SPAN_LIMIT);
-        spanProcessors.push(new SimpleSpanProcessor(memoryExporter));
-      }
-      tracerProvider = new NodeTracerProvider({
-        resource,
-        spanProcessors,
-        sampler: new ParentBasedSampler({
-          root: new TraceIdRatioBasedSampler(traceOpts.sampleRatio ?? 1),
-        }),
-      });
-      tracerProvider.register();
-    }
-  }
-
-  const metricOpts = config.metrics;
-  if (metricOpts !== false) {
-    const exporters = exportersForSignal(config.exporters, "metrics");
-    if (exporters.length > 0) {
-      const exportIntervalMillis = metricOpts.exportIntervalMillis ?? 10_000;
-      const provider = new MeterProvider({
-        resource,
-        readers: exporters.map(
-          exporter =>
-            new PeriodicExportingMetricReader({
-              exporter: createMetricExporter(exporter, signalUrl(exporter.url, "metrics")),
-              exportIntervalMillis,
-            }),
-        ),
-      });
-      if (metrics.setGlobalMeterProvider(provider)) {
-        meterProvider = provider;
-      } else {
-        logger(
-          "[agent-sdk:otel] MeterProvider already registered; reusing global (Agent SDK OTLP exporters not attached)",
-        );
-        void provider.shutdown();
-      }
-    }
-  }
-
-  if (config.logs !== false) {
-    const exporters = exportersForSignal(config.exporters, "logs");
-    if (exporters.length > 0) {
-      const provider = new LoggerProvider({
-        resource,
-        processors: exporters.map(
-          exporter =>
-            new BatchLogRecordProcessor(
-              createLogExporter(exporter, signalUrl(exporter.url, "logs")),
-            ),
-        ),
-      });
-      // api-logs returns the active provider (ours on success, existing otherwise).
-      if (logs.setGlobalLoggerProvider(provider) === provider) {
-        loggerProvider = provider;
-      } else {
-        logger(
-          "[agent-sdk:otel] LoggerProvider already registered; reusing global (Agent SDK OTLP exporters not attached)",
-        );
-        void provider.shutdown();
-      }
-    }
-  }
-
-  if (memoryExporter === undefined) {
-    logger(
-      `[agent-sdk] otel enabled service=${config.serviceName} exporters=${config.exporters.length} traces=${config.traces !== false} metrics=${config.metrics !== false} logs=${config.logs !== false}`,
-    );
-  } else {
-    logger(
-      `[agent-sdk] otel recording service=${config.serviceName} (export on flush when OTLP exporters resolve)`,
-    );
-  }
-
-  const flushDeferred = async (): Promise<void> => {
-    if (memoryExporter === undefined) {
-      return;
-    }
-    const spans = memoryExporter.getFinishedSpans();
-    if (spans.length === 0) {
-      return;
-    }
-    const exportConfig = resolveExport?.() ?? config;
-    const destinations = exportersForSignal(exportConfig.exporters, "traces");
-    if (destinations.length === 0) {
-      return;
-    }
-    // Spans already carry the bake-time Resource. Hosted v2 binds
-    // deployment secrets after bake, so env / service extras on
-    // exportConfig must replace that Resource on the wire.
-    const ok = await exportQueuedSpans(spans, destinations, logger, buildResource(exportConfig));
-    if (ok) {
-      memoryExporter.reset();
-    }
-  };
-
-  return {
-    forceFlush: async () => {
-      await Promise.allSettled([
-        raceOtelForceFlush(
-          Promise.allSettled([
-            tracerProvider?.forceFlush(),
-            meterProvider?.forceFlush(),
-            loggerProvider?.forceFlush(),
-          ]),
-          logger,
-        ),
-        raceOtelForceFlush(flushDeferred(), logger, OTEL_DEFERRED_EXPORT_TIMEOUT_MS),
-      ]);
-    },
-    shutdown: async () => {
-      await flushDeferred();
-      await Promise.allSettled([
-        tracerProvider?.shutdown(),
-        meterProvider?.shutdown(),
-        loggerProvider?.shutdown(),
-      ]);
-    },
-  };
-}
-
-function withExportResource(span: ReadableSpan, resource: Resource): ReadableSpan {
-  return new Proxy(span, {
-    get(target, prop, receiver) {
-      if (prop === "resource") {
-        return resource;
-      }
-      return Reflect.get(target, prop, receiver);
-    },
-  });
-}
-
-async function exportQueuedSpans(
-  spans: ReadableSpan[],
-  destinations: readonly OtelExporterConfig[],
-  logger: (line: string) => void,
-  resource: Resource,
-): Promise<boolean> {
-  const payload = spans.map(span => withExportResource(span, resource));
-  const exporters: SpanExporter[] = destinations.map(destination =>
-    createTraceExporter(destination, signalUrl(destination.url, "traces")),
-  );
-  try {
-    const results = await Promise.all(
-      exporters.map(
-        exporter =>
-          new Promise<boolean>(resolve => {
-            exporter.export(payload, (result: ExportResult) => {
-              resolve(result.code === ExportResultCode.SUCCESS);
-            });
-          }),
-      ),
-    );
-    return results.every(ok => ok);
-  } catch (error) {
-    logger(
-      `[agent-sdk:otel] deferred export failed: ${
-        error instanceof Error ? error.message : String(error)
-      }`,
-    );
-    return false;
-  } finally {
-    await Promise.allSettled(exporters.map(exporter => exporter.shutdown()));
-  }
-}
-
-function buildResource(config: ResolvedOtelConfig): Resource {
-  // Align with Cursor enterprise wire resource attrs where they overlap so
-  // Agent SDK traces join org metrics/logs in the same collector.
-  const resourceAttrs: Record<string, string> = {
-    [ATTR_SERVICE_NAME]: config.serviceName,
-    "telemetry.sdk.language": "nodejs",
-    "cursor.surface": "unspecified",
-    "cursor.entrypoint": "sdk_ts",
-    "agent_sdk.framework": "@cursor/bdk",
-    ...config.resourceAttributes,
-  };
-  if (config.serviceVersion !== undefined) {
-    resourceAttrs[ATTR_SERVICE_VERSION] = config.serviceVersion;
-  }
-  return resourceFromAttributes(resourceAttrs);
-}
-
-function signalUrl(base: string, signal: OtelSignal): string {
-  return `${base.replace(/\/$/, "")}/v1/${signal}`;
-}
-
-/** True when a non-noop TracerProvider already owns the process. */
-function hasRealTracerProvider(): boolean {
-  const provider = trace.getTracerProvider() as {
-    getDelegate?: () => { constructor: { name: string } };
-  };
-  const delegate = provider.getDelegate?.();
-  return delegate !== undefined && delegate.constructor.name !== "NoopTracerProvider";
-}
-
-function isProtobuf(exporter: OtelExporterConfig): boolean {
-  return exporter.protocol !== "http/json";
-}
-
-function createTraceExporter(exporter: OtelExporterConfig, url: string) {
-  const opts = { url, headers: exporter.headers };
-  return isProtobuf(exporter) ? new OTLPTraceExporterProto(opts) : new OTLPTraceExporterHttp(opts);
-}
-
-function createMetricExporter(exporter: OtelExporterConfig, url: string) {
-  const opts = {
-    url,
-    headers: exporter.headers,
-    temporalityPreference: AggregationTemporality.DELTA,
-  };
-  return isProtobuf(exporter)
-    ? new OTLPMetricExporterProto(opts)
-    : new OTLPMetricExporterHttp(opts);
-}
-
-function createLogExporter(exporter: OtelExporterConfig, url: string) {
-  const opts = { url, headers: exporter.headers };
-  return isProtobuf(exporter) ? new OTLPLogExporterProto(opts) : new OTLPLogExporterHttp(opts);
-}
-
-/** In-memory finished-span queue with a hard cap (oldest dropped). */
-class BoundedMemorySpanExporter implements SpanExporter {
-  private spans: ReadableSpan[] = [];
-
-  constructor(private readonly limit: number) {}
-
-  export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void {
-    this.spans.push(...spans);
-    if (this.spans.length > this.limit) {
-      this.spans.splice(0, this.spans.length - this.limit);
-    }
-    resultCallback({ code: ExportResultCode.SUCCESS });
-  }
-
-  getFinishedSpans(): ReadableSpan[] {
-    return this.spans.slice();
-  }
-
-  reset(): void {
-    this.spans = [];
-  }
-
-  shutdown(): Promise<void> {
-    this.reset();
-    return Promise.resolve();
-  }
-
-  forceFlush(): Promise<void> {
-    return Promise.resolve();
-  }
-}

package/src/internal/package-inline-stdio.ts

@@ -1,114 +0,0 @@
-/**
- * Package `defineConnection({ tools })` into a `node -e` stdio transport a
- * repo-less cloud VM can spawn.
- */
-
-import { existsSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import * as esbuild from "esbuild";
-import type {
-  ConnectionTransport,
-  InlineStdioConnectionConfig,
-  JsonSchemaObject,
-} from "../types.js";
-import type { InlineStdioCatalogEntry } from "./inline-stdio-mcp.js";
-import { toolInputJsonSchema, toolOutputJsonSchema } from "./json-schema.js";
-
-const require = createRequire(import.meta.url);
-
-function sibling(basename: string): string {
-  const dir = fileURLToPath(new URL(".", import.meta.url));
-  const ts = join(dir, `${basename}.ts`);
-  return existsSync(ts) ? ts : join(dir, `${basename}.js`);
-}
-
-function jsonSchemaCatalog(
-  tools: InlineStdioConnectionConfig["tools"],
-): Record<string, InlineStdioCatalogEntry> {
-  const catalog: Record<string, InlineStdioCatalogEntry> = {};
-  for (const [name, tool] of Object.entries(tools)) {
-    const outputSchema = toolOutputJsonSchema(tool.outputSchema);
-    catalog[name] = {
-      description: tool.description,
-      inputSchema: toolInputJsonSchema(tool.inputSchema) as JsonSchemaObject,
-      ...(outputSchema === undefined ? {} : { outputSchema: outputSchema as JsonSchemaObject }),
-    };
-  }
-  return catalog;
-}
-
-export async function packageInlineStdioConnection(options: {
-  name: string;
-  entryPath: string;
-  tools: InlineStdioConnectionConfig["tools"];
-  absWorkingDir: string;
-}): Promise<ConnectionTransport> {
-  const runtimePath = sibling("inline-stdio-mcp");
-  const stubPath = sibling("inline-stdio-define-stub");
-  const catalog = jsonSchemaCatalog(options.tools);
-  const result = await esbuild.build({
-    entryPoints: ["inline-stdio-entry"],
-    bundle: true,
-    write: false,
-    platform: "node",
-    format: "esm",
-    target: "node22",
-    minify: true,
-    legalComments: "none",
-    absWorkingDir: options.absWorkingDir,
-    alias: {
-      zod: require.resolve("zod"),
-    },
-    plugins: [
-      {
-        name: "inline-stdio-entry",
-        setup(build) {
-          build.onResolve({ filter: /^inline-stdio-entry$/ }, () => ({
-            path: "inline-stdio-entry",
-            namespace: "inline-stdio",
-          }));
-          build.onLoad({ filter: /.*/, namespace: "inline-stdio" }, () => ({
-            contents: `import definition from ${JSON.stringify(options.entryPath)};
-import { serveInlineStdioMcp } from ${JSON.stringify(runtimePath)};
-serveInlineStdioMcp(
-  ${JSON.stringify(options.name)},
-  definition,
-  ${JSON.stringify(catalog)}
-);
-`,
-            resolveDir: dirname(options.entryPath),
-            loader: "ts",
-          }));
-        },
-      },
-      {
-        name: "inline-stdio-connection-stub",
-        setup(build) {
-          build.onResolve({ filter: /^@cursor\/(?:bdk|july)\/connections$/ }, () => ({
-            path: stubPath,
-          }));
-        },
-      },
-    ],
-  });
-
-  const file = result.outputFiles?.[0];
-  if (file === undefined) {
-    throw new Error(
-      `Failed to package inline stdio MCP connection "${options.name}": esbuild produced no output.`,
-    );
-  }
-  const source = file.text.replace(/^#!.*\r?\n/, "");
-  if (source.trim() === "") {
-    throw new Error(
-      `Failed to package inline stdio MCP connection "${options.name}": empty bundle.`,
-    );
-  }
-  return {
-    type: "stdio",
-    command: "node",
-    args: ["--input-type=module", "-e", source],
-  };
-}

package/src/internal/peer-connections.ts

@@ -1,96 +0,0 @@
-/**
- * Peer MCP connections: `defineConnection({ agent: "<slug>" })` addresses
- * another agent mounted on the same serve host. Discovery keeps the
- * transport symbolic (the target slug); the server resolves it to that
- * agent's MCP endpoint (`/<slug>/v1/mcp`) once mounts and the listen
- * address are known.
- *
- * Local-runtime turns (and host-side `ctx.host.mcp` calls) use the loopback
- * server URL. Cloud-runtime turns run on a VM that cannot reach loopback,
- * so they use the serve `publicUrl` when configured — and omit the peer
- * (with a startup warning) when it is not.
- */
-
-import { type AgentProject, isPeerConnectionTransport } from "../types.js";
-import { MCP_ENDPOINT_PATH } from "./mcp-endpoint.js";
-import type { EngineResolvedConnection } from "./session-engine.js";
-
-/** A validated peer reference: MCP connection name → target mount slug. */
-export interface PeerConnectionRef {
-  /** Connection (MCP server) name — the filename under `agent/mcp-connections/`. */
-  name: string;
-  /** Slug of the peer agent mount this connection targets. */
-  targetSlug: string;
-}
-
-/**
- * Validate every peer MCP connection across `mounts` and return them grouped by
- * the referencing mount's slug. Throws on references to unknown slugs and on
- * self-references (an agent asking itself recurses forever).
- */
-export function collectPeerConnections(
-  mounts: Array<{ slug: string; project: AgentProject }>,
-): Map<string, PeerConnectionRef[]> {
-  const knownSlugs = new Set(mounts.map(({ slug }) => slug).filter(slug => slug !== ""));
-  const bySlug = new Map<string, PeerConnectionRef[]>();
-  for (const { slug, project } of mounts) {
-    const refs: PeerConnectionRef[] = [];
-    for (const connection of [
-      ...project.agent.connections,
-      ...(project.agent.hostConnections ?? []),
-    ]) {
-      if (!isPeerConnectionTransport(connection.transport)) {
-        continue;
-      }
-      const targetSlug = connection.transport.agent;
-      const label = slug === "" ? project.name : slug;
-      if (targetSlug === slug) {
-        throw new Error(
-          `Agent "${label}" connection "${connection.name}" references itself (agent: "${targetSlug}"); an agent cannot be its own peer.`,
-        );
-      }
-      if (!knownSlugs.has(targetSlug)) {
-        const available = [...knownSlugs].sort().join(", ") || "(none)";
-        throw new Error(
-          `Agent "${label}" connection "${connection.name}" references unknown peer agent "${targetSlug}". Mounted agents: ${available}. Peers require multi-agent serve (each agent mounted under its directory-name slug).`,
-        );
-      }
-      refs.push({ name: connection.name, targetSlug });
-    }
-    if (refs.length > 0) {
-      bySlug.set(slug, refs);
-    }
-  }
-  return bySlug;
-}
-
-/**
- * Resolve validated peer refs to concrete MCP URLs once the server is
- * listening. `serverUrl` is the loopback base (`http://127.0.0.1:<port>`);
- * `publicUrl` (when configured) is the externally reachable base used for
- * cloud-runtime turns. When the host requires a bearer token, it is attached
- * so peer calls pass the target agent's auth chain.
- */
-export function resolvePeerConnections(args: {
-  refs: PeerConnectionRef[];
-  serverUrl: string;
-  publicUrl?: string;
-  authToken?: string;
-}): EngineResolvedConnection[] {
-  const serverBase = trimTrailingSlash(args.serverUrl);
-  const publicBase = args.publicUrl === undefined ? undefined : trimTrailingSlash(args.publicUrl);
-  const headers =
-    args.authToken === undefined ? undefined : { authorization: `Bearer ${args.authToken}` };
-  return args.refs.map(ref => ({
-    name: ref.name,
-    localUrl: `${serverBase}/${ref.targetSlug}${MCP_ENDPOINT_PATH}`,
-    ...(publicBase === undefined
-      ? {}
-      : { cloudUrl: `${publicBase}/${ref.targetSlug}${MCP_ENDPOINT_PATH}` }),
-    ...(headers === undefined ? {} : { headers }),
-  }));
-}
-
-function trimTrailingSlash(url: string): string {
-  return url.endsWith("/") ? url.slice(0, -1) : url;
-}