@yagni-app/code 1.0.5 → 1.0.7

package/dist/extension/telemetry/probe.js

@@ -0,0 +1,122 @@
+/**
+ * Doctor probe: send one real record per enabled signal and report the
+ * exporter's verdict. This is what `yagni doctor` runs, so its "otel export"
+ * line means "the collector ACCEPTED a span/metric/log with these headers",
+ * not "port 443 answered" — a wrong API key (403), a wrong path (404), or a
+ * protocol mismatch all show up as the real status.
+ *
+ * The probe records are tiny and clearly named (`yagni_code.doctor.probe`)
+ * so a customer can find them in their backend as proof the pipe works.
+ */
+import { metrics, trace } from "@opentelemetry/api";
+import { logs, SeverityNumber } from "@opentelemetry/api-logs";
+import { PREFIX } from "./attrs.js";
+import { enabledSignals, resolveTelemetryConfig } from "./config.js";
+import { createTelemetrySdk, makeLogExporter, makeMetricExporter, makeTraceExporter, unrefTimer } from "./sdk.js";
+const PROBE_TIMEOUT_MS = 8_000;
+/**
+ * Wrap an exporter so its export callback's result is observable. Every
+ * other member (the metric exporter's temporality selector, for one) is
+ * forwarded by prototype so the wrapper stays a drop-in.
+ */
+function observe(inner) {
+    let resolveResult = () => { };
+    const result = new Promise((resolve) => {
+        resolveResult = resolve;
+    });
+    const wrapped = Object.create(inner);
+    wrapped.export = (items, cb) => {
+        inner.export(items, (r) => {
+            resolveResult(r);
+            cb(r);
+        });
+    };
+    return { wrapped, result };
+}
+function describe(r) {
+    if (!r)
+        return "no export attempted (timed out)";
+    if (r.code === 0)
+        return undefined;
+    const e = r.error;
+    if (!e)
+        return "export failed";
+    // The OTLP http exporter's error carries the status code as `code` and the
+    // status text as the message ("Forbidden"); name the code so a reader can
+    // tell a bad key (401/403) from a bad path (404) at a glance.
+    const status = e.code;
+    const prefix = typeof status === "number" ? `HTTP ${status}: ` : "";
+    const msg = `${prefix}${e.message || String(e)}`;
+    return msg.length > 300 ? `${msg.slice(0, 300)}…` : msg;
+}
+function withTimeout(p, ms) {
+    return Promise.race([p, new Promise((resolve) => unrefTimer(setTimeout(resolve, ms)))]);
+}
+/**
+ * Run the probe against a config resolved from `env` (the launcher passes the
+ * exact child env a session would get). Never throws.
+ */
+export async function probeTelemetryExport(env) {
+    const config = resolveTelemetryConfig({ ...env, YAGNI_OTEL_EXPORT: "1" });
+    const results = [];
+    const signals = enabledSignals(config);
+    if (signals.length === 0)
+        return { config, results };
+    const traceProbe = config.traces.enabled
+        ? observe(makeTraceExporter(config.traces))
+        : undefined;
+    const metricProbe = config.metrics.enabled
+        ? observe(makeMetricExporter(config.metrics, config.metricsTemporality))
+        : undefined;
+    const logProbe = config.logs.enabled
+        ? observe(makeLogExporter(config.logs))
+        : undefined;
+    const sdk = createTelemetrySdk(config, {
+        simpleProcessors: true,
+        exporters: {
+            ...(traceProbe ? { traces: traceProbe.wrapped } : {}),
+            ...(metricProbe ? { metrics: metricProbe.wrapped } : {}),
+            ...(logProbe ? { logs: logProbe.wrapped } : {}),
+        },
+    });
+    try {
+        if (traceProbe) {
+            const span = trace.getTracer(PREFIX).startSpan(`${PREFIX}.doctor.probe`, {
+                attributes: { [`${PREFIX}.probe`]: true },
+            });
+            span.end();
+        }
+        if (metricProbe) {
+            metrics.getMeter(PREFIX).createCounter(`${PREFIX}.doctor.probe`, { unit: "1" }).add(1);
+        }
+        if (logProbe) {
+            logs.getLogger(PREFIX).emit({
+                eventName: `${PREFIX}.doctor.probe`,
+                severityNumber: SeverityNumber.INFO,
+                body: `${PREFIX}.doctor.probe`,
+                attributes: { "event.name": "doctor.probe" },
+            });
+        }
+        await sdk.forceFlush();
+        const settle = async (signal, probe) => {
+            if (!probe)
+                return;
+            const r = await withTimeout(probe.result, PROBE_TIMEOUT_MS);
+            const error = describe(r);
+            results.push({
+                signal,
+                url: config[signal].url,
+                protocol: config[signal].protocol,
+                ok: error === undefined,
+                ...(error ? { error } : {}),
+            });
+        };
+        await Promise.all([settle("traces", traceProbe), settle("metrics", metricProbe), settle("logs", logProbe)]);
+    }
+    finally {
+        await sdk.shutdown();
+    }
+    results.sort((a, b) => signals.indexOf(a.signal) - signals.indexOf(b.signal));
+    return { config, results };
+}
+//# sourceMappingURL=probe.js.map

package/dist/extension/telemetry/register.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Wire pi's lifecycle events into the session telemetry tracker.
+ *
+ * Registered from the extension entry on every launch; it is a no-op unless
+ * the launcher set `YAGNI_OTEL_EXPORT=1` (an OTLP destination is configured)
+ * and no kill switch is set. /go stage children and subagents load this same
+ * extension with the inherited env, so their spend is traced without any
+ * extra plumbing.
+ *
+ * The OTel SDK and exporter graph (a couple of hundred modules) is loaded
+ * LAZILY, at the first session_start of an exporting session, so the common
+ * case — no collector configured — never pays for it.
+ *
+ * Every handler is wrapped so a telemetry bug can never break a session:
+ * exceptions are swallowed, and the SDK degrades to "not exporting" with one
+ * notice.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type TelemetryConfig } from "./config.js";
+import type { TelemetrySdk, TelemetrySdkOptions } from "./sdk.js";
+import { SessionTelemetry, type ToolDecisionInput } from "./tracker.js";
+export interface TelemetryHandle {
+    /** Whether this process is configured to export. */
+    readonly enabled: boolean;
+    readonly config: TelemetryConfig;
+    /** The gate calls this at every terminal tool_call outcome. */
+    toolDecision(input: ToolDecisionInput): void;
+    /** The mode holder calls this on every /mode (or shift-tab) change. */
+    permissionModeChanged(fromMode: string, toMode: string): void;
+    /** Test/introspection seam: the live tracker once the SDK is up. */
+    readonly tracker: SessionTelemetry | null;
+}
+export interface RegisterTelemetryDeps {
+    env?: NodeJS.ProcessEnv;
+    /** Override SDK construction (tests inject in-memory exporters). */
+    createSdk?: (config: TelemetryConfig, opts: TelemetrySdkOptions) => TelemetrySdk;
+    now?: () => number;
+}
+export declare function registerTelemetry(pi: ExtensionAPI, deps?: RegisterTelemetryDeps): TelemetryHandle;
+//# sourceMappingURL=register.d.ts.map

package/dist/extension/telemetry/register.js

@@ -0,0 +1,192 @@
+/**
+ * Wire pi's lifecycle events into the session telemetry tracker.
+ *
+ * Registered from the extension entry on every launch; it is a no-op unless
+ * the launcher set `YAGNI_OTEL_EXPORT=1` (an OTLP destination is configured)
+ * and no kill switch is set. /go stage children and subagents load this same
+ * extension with the inherited env, so their spend is traced without any
+ * extra plumbing.
+ *
+ * The OTel SDK and exporter graph (a couple of hundred modules) is loaded
+ * LAZILY, at the first session_start of an exporting session, so the common
+ * case — no collector configured — never pays for it.
+ *
+ * Every handler is wrapped so a telemetry bug can never break a session:
+ * exceptions are swallowed, and the SDK degrades to "not exporting" with one
+ * notice.
+ */
+import { basename } from "node:path";
+import { metrics, trace } from "@opentelemetry/api";
+import { logs } from "@opentelemetry/api-logs";
+import { logEvent } from "../errorSink.js";
+import { PREFIX } from "./attrs.js";
+import { resolveTelemetryConfig } from "./config.js";
+import { countContentLines, countPatchLines, byteLength, SessionTelemetry } from "./tracker.js";
+const NOOP_HANDLE = (config) => ({
+    enabled: false,
+    config,
+    toolDecision: () => { },
+    permissionModeChanged: () => { },
+    tracker: null,
+});
+export function registerTelemetry(pi, deps = {}) {
+    const env = deps.env ?? process.env;
+    const config = resolveTelemetryConfig(env);
+    if (!config.enabled)
+        return NOOP_HANDLE(config);
+    if (!config.traces.enabled && !config.metrics.enabled && !config.logs.enabled)
+        return NOOP_HANDLE(config);
+    let ctx0;
+    let sdk = null;
+    let tracker = null;
+    /** Set once construction failed: never retry, never notify twice. */
+    let failed = false;
+    const notify = (message, severity) => {
+        try {
+            ctx0?.ui?.notify?.(message, severity);
+        }
+        catch {
+            // best-effort
+        }
+    };
+    // Telemetry must never break the session — but a swallowed error must
+    // leave a trail in the local error sink (~/.yagni-code error log), so a
+    // "why is nothing in Datadog" investigation has something to read.
+    const guard = (name, fn) => (...args) => {
+        try {
+            fn(...args);
+        }
+        catch (err) {
+            logEvent({
+                source: "telemetry",
+                level: "warn",
+                event: "handler_error",
+                fields: { handler: name, error: err instanceof Error ? `${err.name}: ${err.message}` : String(err) },
+            });
+        }
+    };
+    /** Load the SDK graph and build the tracker; idempotent, fail-soft. */
+    async function ensureSdk() {
+        if (sdk || failed)
+            return;
+        try {
+            const createSdk = deps.createSdk ?? (await import("./sdk.js")).createTelemetrySdk;
+            sdk = createSdk(config, {
+                onExportError: (message) => notify(`Telemetry export failed: ${message}. Run \`yagni doctor\` to test the endpoint.`, "warning"),
+            });
+            const version = config.serviceVersion ?? "0.0.0";
+            tracker = new SessionTelemetry({
+                tracer: trace.getTracer(PREFIX, version),
+                meter: metrics.getMeter(PREFIX, version),
+                logger: logs.getLogger(PREFIX, version),
+                config,
+                ...(deps.now ? { now: deps.now } : {}),
+            });
+        }
+        catch (err) {
+            failed = true;
+            sdk = null;
+            tracker = null;
+            notify(`Telemetry export could not start: ${err?.message ?? String(err)}`, "warning");
+        }
+    }
+    pi.on("session_start", async (_event, ctx) => {
+        ctx0 = ctx;
+        await ensureSdk();
+        if (!tracker)
+            return;
+        try {
+            let sessionId;
+            try {
+                const file = ctx.sessionManager?.getSessionFile?.();
+                if (file)
+                    sessionId = basename(file, ".jsonl");
+            }
+            catch {
+                // ephemeral session
+            }
+            tracker.sessionStart(sessionId ?? env.YAGNI_SESSION_ID);
+        }
+        catch {
+            // never break session start
+        }
+    });
+    pi.on("before_agent_start", guard("before_agent_start", (event) => tracker?.interactionStart(event?.prompt)));
+    pi.on("turn_start", guard("turn_start", (event) => tracker?.turnStart(event?.turnIndex)));
+    pi.on("turn_end", guard("turn_end", () => tracker?.turnEnd()));
+    pi.on("before_provider_request", guard("before_provider_request", (event) => {
+        const payload = event?.payload;
+        const model = payload?.model ?? payload?.modelId;
+        tracker?.llmStart(typeof model === "string" ? model : undefined);
+    }));
+    pi.on("after_provider_response", guard("after_provider_response", (event) => {
+        tracker?.llmResponseHeaders(event?.status, event?.headers);
+    }));
+    pi.on("message_end", guard("message_end", (event) => {
+        const msg = event?.message;
+        if (!msg || msg.role !== "assistant")
+            return;
+        tracker?.assistantMessageEnd(msg);
+    }));
+    pi.on("tool_execution_start", guard("tool_execution_start", (event) => {
+        if (!event?.toolCallId || !event?.toolName)
+            return;
+        tracker?.toolStart(event.toolCallId, event.toolName, event.args);
+    }));
+    pi.on("tool_execution_end", guard("tool_execution_end", (event) => {
+        if (!event?.toolCallId)
+            return;
+        tracker?.toolEnd(event.toolCallId, { isError: !!event.isError, resultBytes: byteLength(event.result) });
+    }));
+    // tool_result carries the typed details (edit patch, bash command): the
+    // productivity counters (lines of code, commits, PRs) come from here.
+    pi.on("tool_result", guard("tool_result", (event) => {
+        if (!event || event.isError || !tracker)
+            return;
+        if (event.toolName === "edit") {
+            const patch = event.details?.patch;
+            const { added, removed } = countPatchLines(patch);
+            tracker.linesOfCode(added, removed);
+        }
+        else if (event.toolName === "write") {
+            tracker.linesOfCode(countContentLines(event.input?.content), 0);
+        }
+        else if (event.toolName === "bash") {
+            const command = event.input?.command;
+            tracker.bashSucceeded(typeof command === "string" ? command : undefined);
+        }
+    }));
+    pi.on("agent_end", guard("agent_end", () => tracker?.interactionEnd()));
+    // Quit: flush and shut down, bounded, so a blackholing collector cannot
+    // hold the exit. Session replacement (/new, /resume, /fork, reload): close
+    // the open spans and flush in the background — the process lives on and
+    // the same providers serve the next session, so nothing waits.
+    pi.on("session_shutdown", async (event) => {
+        try {
+            tracker?.close();
+            if (!sdk)
+                return;
+            if (event?.reason === "quit") {
+                await sdk.shutdown();
+                sdk = null;
+                tracker = null;
+            }
+            else {
+                void sdk.forceFlush().catch(() => { });
+            }
+        }
+        catch {
+            // never block exit
+        }
+    });
+    return {
+        enabled: true,
+        config,
+        get tracker() {
+            return tracker;
+        },
+        toolDecision: guard("tool_decision", (input) => tracker?.toolDecision(input)),
+        permissionModeChanged: guard("permission_mode_changed", (from, to) => tracker?.permissionModeChanged(from, to)),
+    };
+}
+//# sourceMappingURL=register.js.map

package/dist/extension/telemetry/sdk.d.ts

@@ -0,0 +1,63 @@
+/**
+ * OpenTelemetry SDK bootstrap for one YAGNI Code process: a tracer, meter,
+ * and logger provider, each with the OTLP exporter the config picked
+ * (gRPC, http/protobuf, or http/json), plus a diag hook that turns export
+ * failures into ONE in-session notice instead of silence.
+ *
+ * Deliberately built from the signal SDKs (`sdk-trace`, `sdk-metrics`,
+ * `sdk-logs`) rather than `sdk-node`: no auto-instrumentation, no Prometheus
+ * server, no propagators — this is a client-only process that pushes its own
+ * spans. Providers are process-global (the OTel API allows one of each), so
+ * the extension initializes once per process even though pi fires
+ * session_start again on /new, /resume, and /fork.
+ *
+ * Everything is fail-soft. Telemetry must never block a launch or a prompt:
+ * a bad exporter config degrades to "not exporting", reported through the
+ * status callback, never a throw into pi.
+ */
+import { type Resource } from "@opentelemetry/resources";
+import { LoggerProvider, type LogRecordExporter } from "@opentelemetry/sdk-logs";
+import { MeterProvider, type PushMetricExporter } from "@opentelemetry/sdk-metrics";
+import { TracerProvider, type SpanExporter } from "@opentelemetry/sdk-trace";
+import type { SignalConfig, TelemetryConfig } from "./config.js";
+export interface TelemetryExporters {
+    traces?: SpanExporter;
+    metrics?: PushMetricExporter;
+    logs?: LogRecordExporter;
+}
+export interface TelemetrySdkOptions {
+    /** Injected exporters (tests use the SDKs' in-memory ones). */
+    exporters?: TelemetryExporters;
+    /** Simple (synchronous) processors instead of batching — tests + the doctor probe. */
+    simpleProcessors?: boolean;
+    /** Called on the first export failure with a one-line, human-readable reason. */
+    onExportError?: (message: string) => void;
+}
+export interface TelemetrySdk {
+    tracerProvider: TracerProvider;
+    meterProvider: MeterProvider;
+    loggerProvider: LoggerProvider;
+    resource: Resource;
+    /** Flush every processor (bounded), then shut the providers down. */
+    shutdown(): Promise<void>;
+    /** Flush without shutting down (used between /go stages). */
+    forceFlush(): Promise<void>;
+}
+/** Build the trace exporter for a signal config. */
+export declare function makeTraceExporter(cfg: SignalConfig): SpanExporter;
+export declare function makeMetricExporter(cfg: SignalConfig, temporality: TelemetryConfig["metricsTemporality"]): PushMetricExporter;
+export declare function makeLogExporter(cfg: SignalConfig): LogRecordExporter;
+/**
+ * Create and register the providers. Returns null (and reports) when the
+ * config produced no exporter — never throws.
+ */
+export declare function createTelemetrySdk(config: TelemetryConfig, opts?: TelemetrySdkOptions): TelemetrySdk;
+/**
+ * Shutdown/flush bound. A blackholing collector (a corp collector with the
+ * VPN down) must not hold quit for long: the batch processors already flush
+ * every few seconds, so at most one interval of records is at risk.
+ */
+export declare const FLUSH_TIMEOUT_MS = 1500;
+/** Let a timeout never keep the process alive on its own (Node timers only). */
+export declare function unrefTimer(timer: unknown): void;
+//# sourceMappingURL=sdk.d.ts.map

package/dist/extension/telemetry/sdk.js

@@ -0,0 +1,207 @@
+/**
+ * OpenTelemetry SDK bootstrap for one YAGNI Code process: a tracer, meter,
+ * and logger provider, each with the OTLP exporter the config picked
+ * (gRPC, http/protobuf, or http/json), plus a diag hook that turns export
+ * failures into ONE in-session notice instead of silence.
+ *
+ * Deliberately built from the signal SDKs (`sdk-trace`, `sdk-metrics`,
+ * `sdk-logs`) rather than `sdk-node`: no auto-instrumentation, no Prometheus
+ * server, no propagators — this is a client-only process that pushes its own
+ * spans. Providers are process-global (the OTel API allows one of each), so
+ * the extension initializes once per process even though pi fires
+ * session_start again on /new, /resume, and /fork.
+ *
+ * Everything is fail-soft. Telemetry must never block a launch or a prompt:
+ * a bad exporter config degrades to "not exporting", reported through the
+ * status callback, never a throw into pi.
+ */
+import { Metadata } from "@grpc/grpc-js";
+import { diag, DiagLogLevel, metrics, trace } from "@opentelemetry/api";
+import { logs } from "@opentelemetry/api-logs";
+import { OTLPLogExporter as LogGrpcExporter } from "@opentelemetry/exporter-logs-otlp-grpc";
+import { OTLPLogExporter as LogHttpExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPLogExporter as LogProtoExporter } from "@opentelemetry/exporter-logs-otlp-proto";
+import { OTLPMetricExporter as MetricGrpcExporter } from "@opentelemetry/exporter-metrics-otlp-grpc";
+import { AggregationTemporalityPreference, OTLPMetricExporter as MetricHttpExporter, } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPMetricExporter as MetricProtoExporter } from "@opentelemetry/exporter-metrics-otlp-proto";
+import { OTLPTraceExporter as TraceGrpcExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
+import { OTLPTraceExporter as TraceHttpExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { OTLPTraceExporter as TraceProtoExporter } from "@opentelemetry/exporter-trace-otlp-proto";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchLogRecordProcessor, LoggerProvider, SimpleLogRecordProcessor, } from "@opentelemetry/sdk-logs";
+import { MeterProvider, PeriodicExportingMetricReader, } from "@opentelemetry/sdk-metrics";
+import { BatchSpanProcessor, SimpleSpanProcessor, TracerProvider, } from "@opentelemetry/sdk-trace";
+import { logEvent } from "../errorSink.js";
+/**
+ * gRPC exporters take headers as grpc `Metadata`, not a record. Built from the
+ * resolved config rather than left to the exporter's own `process.env` read,
+ * so the doctor probe (which runs in-process with a synthetic env) and a
+ * session see the same headers.
+ */
+function toMetadata(headers) {
+    const md = new Metadata();
+    for (const [k, v] of Object.entries(headers))
+        md.set(k, v);
+    return md;
+}
+/** Build the trace exporter for a signal config. */
+export function makeTraceExporter(cfg) {
+    return pick(cfg.protocol, {
+        grpc: () => new TraceGrpcExporter({ url: cfg.url, metadata: toMetadata(cfg.headers) }),
+        proto: () => new TraceProtoExporter({ url: cfg.url, headers: cfg.headers }),
+        json: () => new TraceHttpExporter({ url: cfg.url, headers: cfg.headers }),
+    });
+}
+export function makeMetricExporter(cfg, temporality) {
+    const temporalityPreference = temporality === "cumulative" ? AggregationTemporalityPreference.CUMULATIVE : AggregationTemporalityPreference.DELTA;
+    return pick(cfg.protocol, {
+        grpc: () => new MetricGrpcExporter({ url: cfg.url, metadata: toMetadata(cfg.headers), temporalityPreference }),
+        proto: () => new MetricProtoExporter({ url: cfg.url, headers: cfg.headers, temporalityPreference }),
+        json: () => new MetricHttpExporter({ url: cfg.url, headers: cfg.headers, temporalityPreference }),
+    });
+}
+export function makeLogExporter(cfg) {
+    return pick(cfg.protocol, {
+        grpc: () => new LogGrpcExporter({ url: cfg.url, metadata: toMetadata(cfg.headers) }),
+        proto: () => new LogProtoExporter({ url: cfg.url, headers: cfg.headers }),
+        json: () => new LogHttpExporter({ url: cfg.url, headers: cfg.headers }),
+    });
+}
+function pick(protocol, ctors) {
+    if (protocol === "http/protobuf")
+        return ctors.proto();
+    if (protocol === "http/json")
+        return ctors.json();
+    return ctors.grpc();
+}
+/**
+ * A diag logger for exporter failures. OTel routes them — a 403 from a bad
+ * API key, ECONNREFUSED, a 404 on the wrong path — through `diag.error` via
+ * the global error handler, so this is the only place they surface. The
+ * FIRST one is forwarded to the session as a notice (one, never a stream);
+ * EVERY one is written to the local error sink (~/.yagni-code error log),
+ * so a later "why is nothing in Datadog" investigation has the full trail.
+ */
+function makeDiagLogger(onExportError) {
+    let reported = false;
+    const noop = () => { };
+    return {
+        verbose: noop,
+        debug: noop,
+        info: noop,
+        warn: noop,
+        error: (message, ...args) => {
+            const text = [message, ...args]
+                .map((a) => (a instanceof Error ? a.message : typeof a === "string" ? a : safeJson(a)))
+                .filter(Boolean)
+                .join(" ")
+                .slice(0, 500);
+            logEvent({ source: "telemetry", level: "warn", event: "export_error", fields: { error: text } });
+            if (reported || !onExportError)
+                return;
+            reported = true;
+            try {
+                onExportError(text);
+            }
+            catch {
+                // A failing notice must not take the session down.
+            }
+        },
+    };
+}
+function safeJson(v) {
+    try {
+        return JSON.stringify(v) ?? "";
+    }
+    catch {
+        return String(v);
+    }
+}
+function buildResource(config) {
+    return resourceFromAttributes({
+        ...config.resourceAttributes,
+        "service.name": config.serviceName,
+        ...(config.serviceVersion ? { "service.version": config.serviceVersion } : {}),
+    });
+}
+/**
+ * Create and register the providers. Returns null (and reports) when the
+ * config produced no exporter — never throws.
+ */
+export function createTelemetrySdk(config, opts = {}) {
+    diag.setLogger(makeDiagLogger(opts.onExportError), { logLevel: DiagLogLevel.ERROR, suppressOverrideMessage: true });
+    const resource = buildResource(config);
+    const traceExporter = config.traces.enabled ? (opts.exporters?.traces ?? makeTraceExporter(config.traces)) : undefined;
+    const metricExporter = config.metrics.enabled
+        ? (opts.exporters?.metrics ?? makeMetricExporter(config.metrics, config.metricsTemporality))
+        : undefined;
+    const logExporter = config.logs.enabled ? (opts.exporters?.logs ?? makeLogExporter(config.logs)) : undefined;
+    const tracerProvider = new TracerProvider({
+        resource,
+        spanProcessors: traceExporter
+            ? [
+                opts.simpleProcessors
+                    ? new SimpleSpanProcessor({ exporter: traceExporter })
+                    : new BatchSpanProcessor({ exporter: traceExporter, scheduledDelayMillis: config.traces.exportIntervalMs }),
+            ]
+            : [],
+    });
+    const meterProvider = new MeterProvider({
+        resource,
+        readers: metricExporter
+            ? [
+                new PeriodicExportingMetricReader({
+                    exporter: metricExporter,
+                    exportIntervalMillis: config.metrics.exportIntervalMs,
+                }),
+            ]
+            : [],
+    });
+    const loggerProvider = new LoggerProvider({
+        resource,
+        processors: logExporter
+            ? [
+                opts.simpleProcessors
+                    ? new SimpleLogRecordProcessor({ exporter: logExporter })
+                    : new BatchLogRecordProcessor({ exporter: logExporter, scheduledDelayMillis: config.logs.exportIntervalMs }),
+            ]
+            : [],
+    });
+    // Register globally so any OTel-aware code in the process (an MCP client,
+    // a future hook) parents into the same providers. The API refuses a second
+    // registration and returns false; that is fine — a re-init keeps the first.
+    trace.setGlobalTracerProvider(tracerProvider);
+    metrics.setGlobalMeterProvider(meterProvider);
+    logs.setGlobalLoggerProvider(loggerProvider);
+    const bounded = (p, ms) => Promise.race([p, new Promise((resolve) => unrefTimer(setTimeout(resolve, ms)))]);
+    return {
+        tracerProvider,
+        meterProvider,
+        loggerProvider,
+        resource,
+        async forceFlush() {
+            await bounded(Promise.allSettled([tracerProvider.forceFlush(), meterProvider.forceFlush(), loggerProvider.forceFlush()]), FLUSH_TIMEOUT_MS);
+        },
+        async shutdown() {
+            // Unregister the globals FIRST, synchronously: a session that replaces
+            // this one (/new, /resume) can then register its own providers without
+            // waiting on a collector that may be blackholing the final flush.
+            trace.disable();
+            metrics.disable();
+            logs.disable();
+            diag.disable();
+            await bounded(Promise.allSettled([tracerProvider.shutdown(), meterProvider.shutdown(), loggerProvider.shutdown()]), FLUSH_TIMEOUT_MS);
+        },
+    };
+}
+/**
+ * Shutdown/flush bound. A blackholing collector (a corp collector with the
+ * VPN down) must not hold quit for long: the batch processors already flush
+ * every few seconds, so at most one interval of records is at risk.
+ */
+export const FLUSH_TIMEOUT_MS = 1_500;
+/** Let a timeout never keep the process alive on its own (Node timers only). */
+export function unrefTimer(timer) {
+    timer?.unref?.();
+}
+//# sourceMappingURL=sdk.js.map