@cursor/july 0.1.41 → 0.1.43

package/dist/internal/otel/config.js

@@ -0,0 +1,236 @@
+/**
+ * Merge authored `defineOtel`, `serve({ otel })`, and standard OTel env.
+ */
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+/** True when any standard OTLP endpoint env var is set. */
+export function hasOtelEnv(env = process.env) {
+    return (nonEmpty(env.OTEL_EXPORTER_OTLP_ENDPOINT) ||
+        nonEmpty(env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT) ||
+        nonEmpty(env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT) ||
+        nonEmpty(env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT));
+}
+/**
+ * Process-global authored config. OTel SDK is one per serve process — if
+ * several mounts ship `agent/otel.ts`, they must be identical.
+ */
+export function pickAuthoredOtel(mounts) {
+    const found = mounts.filter((m) => m.otel !== undefined);
+    if (found.length === 0) {
+        return undefined;
+    }
+    const first = found[0];
+    const key = stableConfigKey(first.otel);
+    for (const other of found.slice(1)) {
+        if (stableConfigKey(other.otel) !== key) {
+            const a = first.slug === "" ? first.name : first.slug;
+            const b = other.slug === "" ? other.name : other.slug;
+            throw new Error(`Conflicting agent/otel.ts on mounts "${a}" and "${b}": OTel is process-global. Use identical defineOtel configs, or configure once via serve({ otel }) / OTEL_EXPORTER_OTLP_*.`);
+        }
+    }
+    return first.otel;
+}
+/**
+ * Resolve effective config.
+ *
+ * Precedence: `serve({ otel: false })` disables; otherwise merge
+ * `serve({ otel })` over `defineOtel` over env defaults.
+ */
+export function resolveOtelConfig(input) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    const env = (_a = input.env) !== null && _a !== void 0 ? _a : process.env;
+    if (input.serve === false) {
+        return disabled();
+    }
+    const authored = (_b = input.authored) !== null && _b !== void 0 ? _b : {};
+    const serve = input.serve === undefined ? {} : input.serve;
+    const merged = {
+        serviceName: (_c = serve.serviceName) !== null && _c !== void 0 ? _c : authored.serviceName,
+        serviceVersion: (_d = serve.serviceVersion) !== null && _d !== void 0 ? _d : authored.serviceVersion,
+        resourceAttributes: Object.assign(Object.assign({}, authored.resourceAttributes), serve.resourceAttributes),
+        exporters: (_e = serve.exporters) !== null && _e !== void 0 ? _e : authored.exporters,
+        traces: (_f = serve.traces) !== null && _f !== void 0 ? _f : authored.traces,
+        metrics: (_g = serve.metrics) !== null && _g !== void 0 ? _g : authored.metrics,
+        logs: (_h = serve.logs) !== null && _h !== void 0 ? _h : authored.logs,
+    };
+    const envExporters = exportersFromEnv(env);
+    const exporters = merged.exporters !== undefined && merged.exporters.length > 0
+        ? merged.exporters.map((e) => withEnvHeaders(e, env))
+        : envExporters;
+    const optedIn = input.authored !== undefined ||
+        input.serve !== undefined ||
+        envExporters.length > 0;
+    if (!optedIn || exporters.length === 0) {
+        return disabled();
+    }
+    const traces = resolveSignal(merged.traces);
+    const metrics = resolveSignal(merged.metrics);
+    const logs = resolveLogs(merged.logs, env);
+    return {
+        enabled: traces !== false || metrics !== false || logs !== false,
+        serviceName: (_k = (_j = merged.serviceName) !== null && _j !== void 0 ? _j : env.OTEL_SERVICE_NAME) !== null && _k !== void 0 ? _k : "cursor",
+        serviceVersion: merged.serviceVersion,
+        resourceAttributes: (_l = merged.resourceAttributes) !== null && _l !== void 0 ? _l : {},
+        exporters,
+        traces,
+        metrics,
+        logs,
+    };
+}
+export function parseOtelHeaders(raw) {
+    if (raw === undefined || raw.length === 0) {
+        return {};
+    }
+    const out = {};
+    for (const part of raw.split(",")) {
+        const idx = part.indexOf("=");
+        if (idx <= 0) {
+            continue;
+        }
+        const key = part.slice(0, idx).trim();
+        const value = part.slice(idx + 1).trim();
+        if (key.length > 0) {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+/** Collapse `…/v1/{traces,metrics,logs}` to the collector base. */
+export function stripSignalPath(url) {
+    return url.replace(/\/v1\/(traces|metrics|logs)\/?$/i, "");
+}
+/** Exporters that apply to one signal (honors per-exporter `signals`). */
+export function exportersForSignal(exporters, signal) {
+    return exporters.filter((exporter) => exporter.signals === undefined || exporter.signals.includes(signal));
+}
+function disabled() {
+    return {
+        enabled: false,
+        serviceName: "cursor",
+        serviceVersion: undefined,
+        resourceAttributes: {},
+        exporters: [],
+        traces: false,
+        metrics: false,
+        logs: false,
+    };
+}
+/**
+ * Build exporters from env. A shared `OTEL_EXPORTER_OTLP_ENDPOINT` fans out
+ * to every signal. Distinct `*_TRACES_ENDPOINT` / `*_METRICS_ENDPOINT` /
+ * `*_LOGS_ENDPOINT` values each become their own exporter scoped to that
+ * signal (OTel env spec).
+ */
+function exportersFromEnv(env) {
+    var _a, _b, _c, _d;
+    const base = (_a = env.OTEL_EXPORTER_OTLP_ENDPOINT) === null || _a === void 0 ? void 0 : _a.trim();
+    const traces = (_b = env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT) === null || _b === void 0 ? void 0 : _b.trim();
+    const metrics = (_c = env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT) === null || _c === void 0 ? void 0 : _c.trim();
+    const logs = (_d = env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT) === null || _d === void 0 ? void 0 : _d.trim();
+    const protocol = protocolFromEnv(env.OTEL_EXPORTER_OTLP_PROTOCOL);
+    const headers = parseOtelHeaders(env.OTEL_EXPORTER_OTLP_HEADERS);
+    if (nonEmpty(base)) {
+        return [{ url: stripSignalPath(base), headers, protocol }];
+    }
+    const out = [];
+    pushSignalExporter(out, traces, "traces", headers, protocol);
+    pushSignalExporter(out, metrics, "metrics", headers, protocol);
+    pushSignalExporter(out, logs, "logs", headers, protocol);
+    return out;
+}
+function pushSignalExporter(out, raw, signal, headers, protocol) {
+    if (!nonEmpty(raw)) {
+        return;
+    }
+    out.push({
+        url: stripSignalPath(raw),
+        headers,
+        protocol,
+        signals: [signal],
+    });
+}
+function withEnvHeaders(exporter, env) {
+    var _a;
+    const envHeaders = parseOtelHeaders(env.OTEL_EXPORTER_OTLP_HEADERS);
+    return {
+        url: stripSignalPath(exporter.url),
+        headers: Object.assign(Object.assign({}, envHeaders), exporter.headers),
+        protocol: (_a = exporter.protocol) !== null && _a !== void 0 ? _a : protocolFromEnv(env.OTEL_EXPORTER_OTLP_PROTOCOL),
+        signals: exporter.signals,
+    };
+}
+function protocolFromEnv(raw) {
+    const v = raw === null || raw === void 0 ? void 0 : raw.trim().toLowerCase();
+    if (v === "http/json" || v === "json") {
+        return "http/json";
+    }
+    // Default protobuf — matches Cursor enterprise OTLP/HTTP. grpc unsupported.
+    return "http/protobuf";
+}
+function resolveSignal(value) {
+    if (value === false) {
+        return false;
+    }
+    if (value === true || value === undefined) {
+        return {};
+    }
+    return value;
+}
+function resolveLogs(value, env) {
+    var _a, _b;
+    if (value === false) {
+        return false;
+    }
+    const envPrompts = env.OTEL_LOG_USER_PROMPTS === "1";
+    const envTools = env.OTEL_LOG_TOOL_CONTENT === "1";
+    if (value === true) {
+        return { userPrompts: envPrompts, toolContent: envTools };
+    }
+    if (value === undefined) {
+        // Match OTel: unset / empty / `none` means logs off. Any other
+        // `OTEL_LOGS_EXPORTER` value (e.g. `otlp`) opts logs on.
+        if (!envPrompts && !envTools && !logsExporterOptIn(env)) {
+            return false;
+        }
+        return { userPrompts: envPrompts, toolContent: envTools };
+    }
+    return {
+        userPrompts: (_a = value.userPrompts) !== null && _a !== void 0 ? _a : envPrompts,
+        toolContent: (_b = value.toolContent) !== null && _b !== void 0 ? _b : envTools,
+    };
+}
+/** `OTEL_LOGS_EXPORTER=none` (or unset) must not enable log export. */
+function logsExporterOptIn(env) {
+    var _a;
+    const raw = (_a = env.OTEL_LOGS_EXPORTER) === null || _a === void 0 ? void 0 : _a.trim().toLowerCase();
+    return raw !== undefined && raw.length > 0 && raw !== "none";
+}
+function stableConfigKey(def) {
+    const { __agentServe: _brand } = def, rest = __rest(def, ["__agentServe"]);
+    return stable(rest);
+}
+function stable(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(stable).join(",")}]`;
+    }
+    const obj = value;
+    return `{${Object.keys(obj)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${stable(obj[key])}`)
+        .join(",")}}`;
+}
+function nonEmpty(value) {
+    return value !== undefined && value.trim().length > 0;
+}

package/dist/internal/otel/http.d.ts

@@ -0,0 +1,11 @@
+/**
+ * HTTP SERVER spans + W3C `traceparent` extraction for inbound requests.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { OtelRuntime } from "./runtime.js";
+/**
+ * Instrument one inbound Node request: SERVER span, W3C extract, auto-end
+ * on response finish/close, run `fn` under the span context.
+ */
+export declare function instrumentHttp<T>(runtime: OtelRuntime | undefined, req: IncomingMessage, res: ServerResponse, fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=http.d.ts.map

package/dist/internal/otel/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../../src/internal/otel/http.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAUjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAiBhD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,OAAO,EAAE,WAAW,GAAG,SAAS,EAChC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAcZ"}

package/dist/internal/otel/http.js

@@ -0,0 +1,97 @@
+/**
+ * HTTP SERVER spans + W3C `traceparent` extraction for inbound requests.
+ */
+import { context, propagation, SpanKind, SpanStatusCode, trace, } from "@opentelemetry/api";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+let propagatorInstalled = false;
+function ensurePropagator() {
+    if (propagatorInstalled) {
+        return;
+    }
+    propagation.setGlobalPropagator(new W3CTraceContextPropagator());
+    propagatorInstalled = true;
+}
+/**
+ * Instrument one inbound Node request: SERVER span, W3C extract, auto-end
+ * on response finish/close, run `fn` under the span context.
+ */
+export function instrumentHttp(runtime, req, res, fn) {
+    const handle = startHttpSpan(runtime, req);
+    if (handle === undefined) {
+        return fn();
+    }
+    res.once("finish", () => {
+        handle.end(res.statusCode);
+    });
+    res.once("close", () => {
+        if (!res.writableFinished) {
+            handle.end(res.statusCode || 499);
+        }
+    });
+    return context.with(handle.context, fn);
+}
+function startHttpSpan(runtime, req) {
+    var _a, _b, _c, _d;
+    if (runtime === undefined || runtime.config.traces === false) {
+        return undefined;
+    }
+    ensurePropagator();
+    const headers = {};
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (typeof value === "string") {
+            headers[key] = value;
+        }
+        else if (Array.isArray(value) && value[0] !== undefined) {
+            headers[key] = value[0];
+        }
+    }
+    const parent = propagation.extract(context.active(), headers);
+    const method = (_a = req.method) !== null && _a !== void 0 ? _a : "GET";
+    const path = (_c = ((_b = req.url) !== null && _b !== void 0 ? _b : "/").split("?")[0]) !== null && _c !== void 0 ? _c : "/";
+    const started = Date.now();
+    const span = runtime.tracer.startSpan("agent_sdk.http", {
+        kind: SpanKind.SERVER,
+        attributes: {
+            "http.request.method": method,
+            "url.path": path,
+            "network.peer.address": (_d = req.socket.remoteAddress) !== null && _d !== void 0 ? _d : "",
+        },
+    }, parent);
+    const ctx = trace.setSpan(parent, span);
+    let ended = false;
+    return {
+        context: ctx,
+        end(statusCode, error) {
+            var _a;
+            if (ended) {
+                return;
+            }
+            ended = true;
+            span.setAttribute("http.response.status_code", statusCode);
+            if (error !== undefined) {
+                span.recordException(error instanceof Error ? error : new Error(String(error)));
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+            else if (statusCode >= 500) {
+                span.setStatus({ code: SpanStatusCode.ERROR });
+            }
+            else {
+                span.setStatus({ code: SpanStatusCode.OK });
+            }
+            span.end();
+            (_a = runtime.httpDuration) === null || _a === void 0 ? void 0 : _a.record(Date.now() - started, {
+                "http.request.method": method,
+                "http.response.status_code": statusCode,
+                "url.path": routeClass(path),
+            });
+        },
+    };
+}
+function routeClass(path) {
+    return path
+        .replace(/\/sessions\/[0-9a-f-]{8,}/gi, "/sessions/:id")
+        .replace(/\/[0-9a-f]{8,}(?:-[0-9a-f]{4,})+/gi, "/:id");
+}

package/dist/internal/otel/runtime.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 type { Logger as OtelLogger } from "@opentelemetry/api-logs";
+import { type ResolvedOtelConfig } from "./config.js";
+export interface OtelRuntime {
+    config: ResolvedOtelConfig;
+    tracer: Tracer;
+    meter: Meter | undefined;
+    logger: OtelLogger | undefined;
+    httpDuration: Histogram | undefined;
+    shutdown: () => Promise<void>;
+}
+export declare function createOtelRuntime(config: ResolvedOtelConfig, log: (line: string) => void): OtelRuntime | undefined;
+export declare function shutdownOtelRuntime(runtime: OtelRuntime | undefined): Promise<void>;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/internal/otel/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/internal/otel/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEnE,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAgCpE,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAI1E,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,kBAAkB,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC;IACzB,MAAM,EAAE,UAAU,GAAG,SAAS,CAAC;IAC/B,YAAY,EAAE,SAAS,GAAG,SAAS,CAAC;IACpC,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,kBAAkB,EAC1B,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAC1B,WAAW,GAAG,SAAS,CA6BzB;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,WAAW,GAAG,SAAS,GAC/B,OAAO,CAAC,IAAI,CAAC,CAEf"}

package/dist/internal/otel/runtime.js

@@ -0,0 +1,188 @@
+/**
+ * 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.
+ */
+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 { DiagLogLevel, diag, metrics, trace } from "@opentelemetry/api";
+import { logs } from "@opentelemetry/api-logs";
+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 { resourceFromAttributes, } from "@opentelemetry/resources";
+import { BatchLogRecordProcessor, LoggerProvider, } from "@opentelemetry/sdk-logs";
+import { AggregationTemporality, MeterProvider, PeriodicExportingMetricReader, } from "@opentelemetry/sdk-metrics";
+import { BatchSpanProcessor, NodeTracerProvider, ParentBasedSampler, TraceIdRatioBasedSampler, } from "@opentelemetry/sdk-trace-node";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
+import { exportersForSignal } from "./config.js";
+const INSTRUMENTATION = "agent_sdk";
+export function createOtelRuntime(config, log) {
+    var _a;
+    if (!config.enabled) {
+        return undefined;
+    }
+    const proto = (_a = process.env.OTEL_EXPORTER_OTLP_PROTOCOL) === null || _a === void 0 ? void 0 : _a.trim().toLowerCase();
+    if (proto === "grpc") {
+        log("[agent-sdk:otel] OTEL_EXPORTER_OTLP_PROTOCOL=grpc is unsupported; using http/protobuf");
+    }
+    const sdk = startOtelSdk(config, log);
+    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",
+            }),
+        shutdown: sdk.shutdown,
+    };
+}
+export function shutdownOtelRuntime(runtime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield runtime === null || runtime === void 0 ? void 0 : runtime.shutdown();
+    });
+}
+function startOtelSdk(config, logger) {
+    var _a, _b;
+    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;
+    let meterProvider;
+    let loggerProvider;
+    const traceOpts = config.traces;
+    if (traceOpts !== false) {
+        const exporters = exportersForSignal(config.exporters, "traces");
+        if (exporters.length > 0) {
+            if (hasRealTracerProvider()) {
+                logger("[agent-sdk:otel] TracerProvider already registered; reusing global (Agent SDK OTLP exporters not attached)");
+            }
+            else {
+                tracerProvider = new NodeTracerProvider({
+                    resource,
+                    spanProcessors: exporters.map((exporter) => new BatchSpanProcessor(createTraceExporter(exporter, signalUrl(exporter.url, "traces")))),
+                    sampler: new ParentBasedSampler({
+                        root: new TraceIdRatioBasedSampler((_a = traceOpts.sampleRatio) !== null && _a !== void 0 ? _a : 1),
+                    }),
+                });
+                tracerProvider.register();
+            }
+        }
+    }
+    const metricOpts = config.metrics;
+    if (metricOpts !== false) {
+        const exporters = exportersForSignal(config.exporters, "metrics");
+        if (exporters.length > 0) {
+            const exportIntervalMillis = (_b = metricOpts.exportIntervalMillis) !== null && _b !== void 0 ? _b : 10000;
+            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();
+            }
+        }
+    }
+    logger(`[agent-sdk] otel enabled service=${config.serviceName} exporters=${config.exporters.length} traces=${config.traces !== false} metrics=${config.metrics !== false} logs=${config.logs !== false}`);
+    return {
+        shutdown: () => __awaiter(this, void 0, void 0, function* () {
+            yield Promise.allSettled([
+                tracerProvider === null || tracerProvider === void 0 ? void 0 : tracerProvider.shutdown(),
+                meterProvider === null || meterProvider === void 0 ? void 0 : meterProvider.shutdown(),
+                loggerProvider === null || loggerProvider === void 0 ? void 0 : loggerProvider.shutdown(),
+            ]);
+        }),
+    };
+}
+function buildResource(config) {
+    // Align with Cursor enterprise wire resource attrs where they overlap so
+    // Agent SDK traces join org metrics/logs in the same collector.
+    const resourceAttrs = Object.assign({ [ATTR_SERVICE_NAME]: config.serviceName, "telemetry.sdk.language": "nodejs", "cursor.surface": "unspecified", "cursor.entrypoint": "sdk_ts", "agent_sdk.framework": "@cursor/july" }, config.resourceAttributes);
+    if (config.serviceVersion !== undefined) {
+        resourceAttrs[ATTR_SERVICE_VERSION] = config.serviceVersion;
+    }
+    return resourceFromAttributes(resourceAttrs);
+}
+function signalUrl(base, signal) {
+    return `${base.replace(/\/$/, "")}/v1/${signal}`;
+}
+/** True when a non-noop TracerProvider already owns the process. */
+function hasRealTracerProvider() {
+    var _a;
+    const provider = trace.getTracerProvider();
+    const delegate = (_a = provider.getDelegate) === null || _a === void 0 ? void 0 : _a.call(provider);
+    return (delegate !== undefined && delegate.constructor.name !== "NoopTracerProvider");
+}
+function isProtobuf(exporter) {
+    return exporter.protocol !== "http/json";
+}
+function createTraceExporter(exporter, url) {
+    const opts = { url, headers: exporter.headers };
+    return isProtobuf(exporter)
+        ? new OTLPTraceExporterProto(opts)
+        : new OTLPTraceExporterHttp(opts);
+}
+function createMetricExporter(exporter, url) {
+    const opts = {
+        url,
+        headers: exporter.headers,
+        temporalityPreference: AggregationTemporality.DELTA,
+    };
+    return isProtobuf(exporter)
+        ? new OTLPMetricExporterProto(opts)
+        : new OTLPMetricExporterHttp(opts);
+}
+function createLogExporter(exporter, url) {
+    const opts = { url, headers: exporter.headers };
+    return isProtobuf(exporter)
+        ? new OTLPLogExporterProto(opts)
+        : new OTLPLogExporterHttp(opts);
+}

package/dist/internal/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/internal/server.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA4BH,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAOhB,YAAY,EACb,MAAM,aAAa,CAAC;AAqGrB,OAAO,EAAE,KAAK,WAAW,EAAmB,MAAM,iBAAiB,CAAC;AAiBpE,8EAA8E;AAC9E,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,YAAY,CAAC;CACvB;AAaD,6EAA6E;AAC7E,MAAM,WAAW,0BAA0B;IACzC,oEAAoE;IACpE,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,UAAU,EAAE,EACpB,OAAO,GAAE,YAAY,GAAG,0BAA+B,GACtD,OAAO,CAAC,gBAAgB,CAAC,CAgtB3B"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/internal/server.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA4BH,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAOhB,YAAY,EACb,MAAM,aAAa,CAAC;AAyGrB,OAAO,EAAE,KAAK,WAAW,EAAmB,MAAM,iBAAiB,CAAC;AAiBpE,8EAA8E;AAC9E,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,YAAY,CAAC;CACvB;AAaD,6EAA6E;AAC7E,MAAM,WAAW,0BAA0B;IACzC,oEAAoE;IACpE,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,UAAU,EAAE,EACpB,OAAO,GAAE,YAAY,GAAG,0BAA+B,GACtD,OAAO,CAAC,gBAAgB,CAAC,CAivB3B"}

package/dist/internal/server.js

@@ -59,6 +59,10 @@ import { createLocalControlPlane, } from "./local-control-plane.js";
 import { createLogRing } from "./log-ring.js";
 import { createAgentMcpEndpoint, createToolMcpEndpoint, MCP_ENDPOINT_PATH, TOOL_MCP_ENDPOINT_PATH, } from "./mcp-endpoint.js";
 import { isLoopbackAddress } from "./net.js";
+import { createOtelCollector } from "./otel/collector.js";
+import { pickAuthoredOtel, resolveOtelConfig } from "./otel/config.js";
+import { instrumentHttp } from "./otel/http.js";
+import { createOtelRuntime, shutdownOtelRuntime } from "./otel/runtime.js";
 import { collectPeerConnections } from "./peer-connections.js";
 import { PLATFORM_SCHEDULE_CATALOG_FILENAME, syncHostedPlatformSchedules, } from "./platform-schedule-sync.js";
 import { createCursorHostedPlatformTimers } from "./platform-timers.js";
@@ -106,6 +110,20 @@ export function startServer(mounts_1) {
         // this when building its client-version header) so the internal-only
         // agentkit_enabled gate applies to every turn.
         (_j = (_s = process.env).CURSOR_AGENTKIT_VERSION) !== null && _j !== void 0 ? _j : (_s.CURSOR_AGENTKIT_VERSION = packageVersion());
+        const authoredOtel = pickAuthoredOtel(mounts.map((m) => ({
+            slug: m.slug,
+            name: m.project.name,
+            otel: m.project.otel,
+        })));
+        const otelRuntime = createOtelRuntime(resolveOtelConfig({
+            authored: authoredOtel,
+            serve: options.otel,
+        }), logger);
+        if (otelRuntime === undefined &&
+            options.otel !== false &&
+            authoredOtel !== undefined) {
+            logger("[agent-sdk] otel: agent/otel.ts present but no OTLP exporters configured (set exporters or OTEL_EXPORTER_OTLP_ENDPOINT)");
+        }
         const cursorGithubTargets = collectCursorGithubTargets(mounts);
         const cursorGithubConfig = resolveCursorGithubEventConfig({
             configured: options.cursorEvents,
@@ -239,12 +257,16 @@ export function startServer(mounts_1) {
             // Each agent gets an isolated state root so their sessions never mix.
             const baseStateRoot = (_m = options.stateRoot) !== null && _m !== void 0 ? _m : join(project.rootDir, ".agent-serve");
             const stateRoot = slug === "" ? baseStateRoot : join(baseStateRoot, slug);
+            const otelCollector = otelRuntime === undefined
+                ? undefined
+                : createOtelCollector(otelRuntime, project.name, logger);
             const engine = new SessionEngine({
                 project,
                 stateRoot,
                 runner,
                 logger,
                 platforms: hostPlatforms,
+                otel: otelCollector,
             });
             // Rehydrate sessions from the authored storage sink before any
             // channel or route can address them (continuation tokens must resolve).
@@ -489,7 +511,7 @@ export function startServer(mounts_1) {
             cursorAccountOnly: options.cursorEvents === undefined && cursorGithubTargets.length > 0,
         });
         const server = createServer((req, res) => {
-            void handleRequest(router, req, res, logger);
+            void instrumentHttp(otelRuntime, req, res, () => handleRequest(router, req, res, logger));
         });
         const host = (_p = options.host) !== null && _p !== void 0 ? _p : "127.0.0.1";
         const portWasExplicit = options.port !== undefined;
@@ -508,6 +530,7 @@ export function startServer(mounts_1) {
             yield cursorEventRelay === null || cursorEventRelay === void 0 ? void 0 : cursorEventRelay.stop();
             yield cursorSlackRelay === null || cursorSlackRelay === void 0 ? void 0 : cursorSlackRelay.stop();
             cursorGithubCredentials === null || cursorGithubCredentials === void 0 ? void 0 : cursorGithubCredentials.stop();
+            yield shutdownOtelRuntime(otelRuntime);
             throw error;
         }
         const address = server.address();
@@ -681,6 +704,7 @@ export function startServer(mounts_1) {
                 }
                 finally {
                     cursorGithubCredentials === null || cursorGithubCredentials === void 0 ? void 0 : cursorGithubCredentials.stop();
+                    yield shutdownOtelRuntime(otelRuntime);
                 }
             }),
         };