@autter/runtime-node 1.3.4 → 1.5.0

package/dist/index.cjs

@@ -1,61 +1,76 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  captureException: () => captureException,
-  captureMessage: () => captureMessage,
-  createBrowserRelayFetchHandler: () => createBrowserRelayFetchHandler,
-  createBrowserRelayHandler: () => createBrowserRelayHandler,
-  emitLlmSelftestTrace: () => emitLlmSelftestTrace,
-  initAutterServer: () => initAutterServer,
-  installAutterAutoFlush: () => installAutterAutoFlush,
-  instrumentLlmClient: () => instrumentLlmClient,
-  makeSafeCapture: () => makeSafeCapture,
-  redactAttributes: () => redactAttributes,
-  reportOutcome: () => reportOutcome,
-  sanitizeBrowserPayload: () => sanitizeBrowserPayload,
-  startCaughtExceptionSampler: () => startCaughtExceptionSampler,
-  trackLlmCall: () => trackLlmCall,
-  withLlmCall: () => withLlmCall,
-  withProcessSpan: () => withProcessSpan
-});
-module.exports = __toCommonJS(index_exports);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkP4VRTFAVcjs = require('./chunk-P4VRTFAV.cjs');
+
+
+var _chunkL6SRL65Jcjs = require('./chunk-L6SRL65J.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkGI47WGRRcjs = require('./chunk-GI47WGRR.cjs');
 
 // src/relay.ts
-var IpWindow = class {
-  constructor(limitPerMinute) {
+var IpWindow = (_class = class {
+  constructor(limitPerMinute) {;_class.prototype.__init.call(this);
     this.limitPerMinute = limitPerMinute;
   }
-  limitPerMinute;
-  windows = /* @__PURE__ */ new Map();
+  
+  __init() {this.windows = /* @__PURE__ */ new Map()}
   allow(ip) {
     const start = Math.floor(Date.now() / 6e4) * 6e4;
     const entry = this.windows.get(ip);
@@ -67,10 +82,10 @@ var IpWindow = class {
     entry.count += 1;
     return entry.count <= this.limitPerMinute;
   }
-};
+}, _class);
 function firstForwardedFor(value) {
   const raw = Array.isArray(value) ? value[0] : value;
-  return raw ? (raw.split(",")[0] ?? "").trim() : "";
+  return raw ? (_nullishCoalesce(raw.split(",")[0], () => ( ""))).trim() : "";
 }
 var DEFAULT_ENDPOINT = "https://otlp.autter.dev";
 var DEFAULT_MAX_BODY = 64 * 1024;
@@ -87,7 +102,120 @@ var EVENT_TYPES = /* @__PURE__ */ new Set([
   "timing"
 ]);
 var SEVERITIES = /* @__PURE__ */ new Set(["fatal", "error", "warning", "info"]);
-function sanitizeBrowserPayload(raw) {
+var CONTEXT_MAX_DEPTH = 6;
+var CONTEXT_MAX_NODES = 256;
+var CONTEXT_MAX_STRING = 4e3;
+var CONTEXT_MAX_ARRAY = 100;
+var CONTEXT_MAX_KEYS = 100;
+function byteLength(text) {
+  return new TextEncoder().encode(text).length;
+}
+function boundContext(value) {
+  let nodes = 0;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (v, depth) => {
+    if (v === null) return null;
+    const t = typeof v;
+    if (t === "string") return v.slice(0, CONTEXT_MAX_STRING);
+    if (t === "number" || t === "boolean") return v;
+    if (t !== "object") return void 0;
+    if (depth >= CONTEXT_MAX_DEPTH || nodes >= CONTEXT_MAX_NODES) return void 0;
+    const obj = v;
+    if (seen.has(obj)) return void 0;
+    seen.add(obj);
+    let isArr = false;
+    try {
+      isArr = Array.isArray(v);
+    } catch (e2) {
+      return void 0;
+    }
+    if (isArr) {
+      const arr = v;
+      const out2 = [];
+      let len = 0;
+      try {
+        len = arr.length;
+      } catch (e3) {
+        return out2;
+      }
+      for (let i = 0; i < len && i < CONTEXT_MAX_ARRAY; i++) {
+        if (nodes >= CONTEXT_MAX_NODES) break;
+        nodes++;
+        let el;
+        try {
+          el = walk(arr[i], depth + 1);
+        } catch (e4) {
+          el = void 0;
+        }
+        if (el !== void 0) out2.push(el);
+      }
+      return out2;
+    }
+    let keys;
+    try {
+      keys = Object.keys(obj);
+    } catch (e5) {
+      return void 0;
+    }
+    const out = {};
+    for (let i = 0; i < keys.length && i < CONTEXT_MAX_KEYS; i++) {
+      if (nodes >= CONTEXT_MAX_NODES) break;
+      const key = keys[i];
+      if (key === void 0) continue;
+      nodes++;
+      let child;
+      try {
+        child = walk(obj[key], depth + 1);
+      } catch (e6) {
+        child = void 0;
+      }
+      if (child !== void 0) out[key] = child;
+    }
+    return out;
+  };
+  let result;
+  try {
+    result = walk(value, 0);
+  } catch (e7) {
+    result = void 0;
+  }
+  return result && typeof result === "object" ? result : {};
+}
+async function readBodyBounded(request, maxBody) {
+  const body = request.body;
+  if (!body) {
+    const text = await request.text();
+    return byteLength(text) > maxBody ? { tooLarge: true } : { tooLarge: false, text };
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    total += value.byteLength;
+    if (total > maxBody) {
+      void Promise.resolve().then(() => reader.cancel()).catch(() => {
+      });
+      return { tooLarge: true };
+    }
+    chunks.push(value);
+  }
+  const buf = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    buf.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return { tooLarge: false, text: new TextDecoder().decode(buf) };
+}
+function relayContext(raw, redactor) {
+  const bounded = boundContext(raw);
+  return Array.isArray(bounded) ? {} : { context: redactor(bounded) };
+}
+var defaultRelayRedactor = _chunkP4VRTFAVcjs.makeRedactor.call(void 0, true);
+function sanitizeBrowserPayload(raw, redactor = defaultRelayRedactor) {
   if (typeof raw !== "object" || raw === null) return null;
   const p = raw;
   if (p.version !== 1) return null;
@@ -104,16 +232,16 @@ function sanitizeBrowserPayload(raw) {
       type: e.type,
       timestamp: e.timestamp,
       ...typeof e.severity === "string" && SEVERITIES.has(e.severity) ? { severity: e.severity } : {},
-      message: typeof e.message === "string" ? e.message.slice(0, 4e3) : "",
-      ...typeof e.name === "string" ? { name: e.name.slice(0, 200) } : {},
+      message: typeof e.message === "string" ? redactor.text(e.message.slice(0, 4512)).slice(0, 4e3) : "",
+      ...typeof e.name === "string" ? { name: redactor.text(e.name.slice(0, 712)).slice(0, 200) } : {},
       ...typeof e.durationMs === "number" && Number.isFinite(e.durationMs) ? { durationMs: Math.max(0, Math.min(12e4, e.durationMs)) } : {},
-      ...typeof e.stack === "string" ? { stack: e.stack.slice(0, 32e3) } : {},
+      ...typeof e.stack === "string" ? { stack: redactor.text(e.stack.slice(0, 32512)).slice(0, 32e3) } : {},
       ...typeof e.errorType === "string" ? { errorType: e.errorType.slice(0, 200) } : {},
       ...typeof e.filename === "string" ? { filename: e.filename.split("?")[0].slice(0, 1e3) } : {},
       ...typeof e.line === "number" ? { line: e.line } : {},
       ...typeof e.column === "number" ? { column: e.column } : {},
       ...typeof e.route === "string" ? { route: e.route.split("?")[0].slice(0, 1e3) } : {},
-      ...typeof e.context === "object" && e.context !== null ? { context: e.context } : {}
+      ...typeof e.context === "object" && e.context !== null ? relayContext(e.context, redactor) : {}
     });
   }
   return {
@@ -122,11 +250,16 @@ function sanitizeBrowserPayload(raw) {
     service: p.service.slice(0, 200),
     environment: p.environment.slice(0, 100),
     ...typeof p.release === "string" ? { release: p.release.slice(0, 200) } : {},
+    // @autter/runtime-browser version, for the ingester's compat records.
+    ...typeof p.sdk === "string" && /^\d{1,6}\.\d{1,6}\.\d{1,6}[0-9A-Za-z.+-]{0,20}$/.test(p.sdk) ? { sdk: p.sdk } : {},
     events
   };
 }
 function forward(payload, opts) {
-  const url = `${(opts.endpoint ?? DEFAULT_ENDPOINT).replace(/\/$/, "")}/v1/browser`;
+  const endpoint = (_nullishCoalesce(opts.endpoint, () => ( DEFAULT_ENDPOINT))).replace(/\/$/, "");
+  const url = `${endpoint}/v1/browser`;
+  const compat = opts.compatCheck !== false;
+  if (compat) _chunkGI47WGRRcjs.ensureCompatConfigured.call(void 0, endpoint);
   void fetch(url, {
     method: "POST",
     headers: {
@@ -135,15 +268,24 @@ function forward(payload, opts) {
     },
     body: JSON.stringify(payload),
     signal: AbortSignal.timeout(1e4)
+  }).then((response) => {
+    if (!compat) return;
+    const types = new Set(
+      (_nullishCoalesce(payload.events, () => ( []))).map((e) => String(e.type))
+    );
+    _chunkGI47WGRRcjs.observeIngesterResponse.call(void 0, { status: response.status, headers: response.headers });
+    for (const feature of _chunkGI47WGRRcjs.featuresForBrowserEvents.call(void 0, types)) _chunkGI47WGRRcjs.noteCompatFeature.call(void 0, feature);
+    _chunkGI47WGRRcjs.noteRelayRejection.call(void 0, types, response.status, response.headers);
   }).catch((err) => {
-    (opts.onError ?? ((e) => console.warn("autter relay forward failed:", e)))(
+    (_nullishCoalesce(opts.onError, () => ( ((e) => console.warn("autter relay forward failed:", e)))))(
       err
     );
   });
 }
 function createBrowserRelayFetchHandler(opts) {
-  const maxBody = opts.maxBodyBytes ?? DEFAULT_MAX_BODY;
-  const limiter = opts.perIpRateLimit === false ? null : new IpWindow(opts.perIpRateLimit ?? 120);
+  const maxBody = _nullishCoalesce(opts.maxBodyBytes, () => ( DEFAULT_MAX_BODY));
+  const redactor = opts.redact === void 0 || opts.redact === true ? defaultRelayRedactor : _chunkP4VRTFAVcjs.makeRedactor.call(void 0, opts.redact);
+  const limiter = opts.perIpRateLimit === false ? null : new IpWindow(_nullishCoalesce(opts.perIpRateLimit, () => ( 120)));
   return async (request) => {
     if (request.method !== "POST") {
       return new Response(null, { status: 405 });
@@ -156,21 +298,28 @@ function createBrowserRelayFetchHandler(opts) {
         });
       }
     }
-    const text = await request.text();
-    if (text.length > maxBody) {
+    let bounded;
+    try {
+      bounded = await readBodyBounded(request, maxBody);
+    } catch (e8) {
+      return new Response(JSON.stringify({ error: "invalid json" }), {
+        status: 400
+      });
+    }
+    if (bounded.tooLarge) {
       return new Response(JSON.stringify({ error: "payload too large" }), {
         status: 413
       });
     }
     let raw;
     try {
-      raw = JSON.parse(text);
-    } catch {
+      raw = JSON.parse(bounded.text);
+    } catch (e9) {
       return new Response(JSON.stringify({ error: "invalid json" }), {
         status: 400
       });
     }
-    const payload = sanitizeBrowserPayload(raw);
+    const payload = sanitizeBrowserPayload(raw, redactor);
     if (!payload) {
       return new Response(JSON.stringify({ error: "invalid payload" }), {
         status: 400
@@ -181,8 +330,9 @@ function createBrowserRelayFetchHandler(opts) {
   };
 }
 function createBrowserRelayHandler(opts) {
-  const maxBody = opts.maxBodyBytes ?? DEFAULT_MAX_BODY;
-  const limiter = opts.perIpRateLimit === false ? null : new IpWindow(opts.perIpRateLimit ?? 120);
+  const maxBody = _nullishCoalesce(opts.maxBodyBytes, () => ( DEFAULT_MAX_BODY));
+  const redactor = opts.redact === void 0 || opts.redact === true ? defaultRelayRedactor : _chunkP4VRTFAVcjs.makeRedactor.call(void 0, opts.redact);
+  const limiter = opts.perIpRateLimit === false ? null : new IpWindow(_nullishCoalesce(opts.perIpRateLimit, () => ( 120)));
   function respond(res, status, body) {
     res.statusCode = status;
     if (body) {
@@ -193,7 +343,7 @@ function createBrowserRelayHandler(opts) {
     }
   }
   function handleParsed(raw, res) {
-    const payload = sanitizeBrowserPayload(raw);
+    const payload = sanitizeBrowserPayload(raw, redactor);
     if (!payload) {
       respond(res, 400, { error: "invalid payload" });
       return;
@@ -207,7 +357,7 @@ function createBrowserRelayHandler(opts) {
       return;
     }
     if (limiter) {
-      const ip = firstForwardedFor(req.headers["x-forwarded-for"]) || req.socket?.remoteAddress || "unknown";
+      const ip = firstForwardedFor(req.headers["x-forwarded-for"]) || _optionalChain([req, 'access', _ => _.socket, 'optionalAccess', _2 => _2.remoteAddress]) || "unknown";
       if (!limiter.allow(ip)) {
         respond(res, 429, { error: "rate limit exceeded" });
         return;
@@ -218,7 +368,7 @@ function createBrowserRelayHandler(opts) {
       if (typeof raw === "string" || Buffer.isBuffer(raw)) {
         try {
           raw = JSON.parse(raw.toString());
-        } catch {
+        } catch (e10) {
           respond(res, 400, { error: "invalid json" });
           return;
         }
@@ -243,7 +393,7 @@ function createBrowserRelayHandler(opts) {
       if (aborted) return;
       try {
         handleParsed(JSON.parse(Buffer.concat(chunks).toString()), res);
-      } catch {
+      } catch (e11) {
         respond(res, 400, { error: "invalid json" });
       }
     });
@@ -254,466 +404,162 @@ function createBrowserRelayHandler(opts) {
 }
 
 // src/server.ts
-var import_node_http = require("http");
-var import_node_crypto = require("crypto");
-var import_api2 = require("@opentelemetry/api");
-var import_core2 = require("@opentelemetry/core");
-var import_exporter_metrics_otlp_http = require("@opentelemetry/exporter-metrics-otlp-http");
-var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
-var import_instrumentation_http = require("@opentelemetry/instrumentation-http");
-var import_resources = require("@opentelemetry/resources");
-var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
-var import_sdk_node = require("@opentelemetry/sdk-node");
-var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
-var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
-
-// src/lifecycle.ts
-var import_core = require("@opentelemetry/core");
-var debugEnabled = process.env.AUTTER_DEBUG === "1" || process.env.AUTTER_DEBUG === "true";
-function setDebugMode(enabled) {
-  debugEnabled = enabled;
-}
-function isDebugEnabled() {
-  return debugEnabled;
-}
-function debugLog(...args) {
-  if (debugEnabled) {
-    console.error("[autter]", ...args);
-  }
-}
-var TelemetryStats = class {
-  /** Captures queued via our APIs and not yet seen leaving an exporter. */
-  pendingCaptures = 0;
-  markCaptured(count = 1) {
-    this.pendingCaptures += count;
-  }
-  /** An exporter batch left the process successfully. */
-  onExported(spanCount) {
-    this.pendingCaptures = Math.max(0, this.pendingCaptures - spanCount);
-    if (debugEnabled && spanCount > 0) {
-      debugLog(`exported ${spanCount} span${spanCount === 1 ? "" : "s"}`);
-    }
-  }
-  markAllFlushed() {
-    this.pendingCaptures = 0;
-  }
-};
-var telemetryStats = new TelemetryStats();
-var CountingExporter = class {
-  constructor(inner) {
+var _http = require('http');
+var _crypto = require('crypto');
+
+
+
+
+
+
+var _api = require('@opentelemetry/api');
+var _core = require('@opentelemetry/core');
+
+
+
+var _exportermetricsotlphttp = require('@opentelemetry/exporter-metrics-otlp-http');
+var _exportertraceotlphttp = require('@opentelemetry/exporter-trace-otlp-http');
+var _instrumentationhttp = require('@opentelemetry/instrumentation-http');
+var _resources = require('@opentelemetry/resources');
+var _sdkmetrics = require('@opentelemetry/sdk-metrics');
+var _sdknode = require('@opentelemetry/sdk-node');
+
+
+
+
+
+
+
+var _sdktracebase = require('@opentelemetry/sdk-trace-base');
+
+
+
+var _semanticconventions = require('@opentelemetry/semantic-conventions');
+
+// src/redact-exporter.ts
+
+
+
+
+
+var scrubbedResources = /* @__PURE__ */ new WeakMap();
+function redactResource(resource, redactor) {
+  const cached = scrubbedResources.get(resource);
+  if (cached) return cached;
+  const scrubbed = new (0, _resources.Resource)(redactor.exported(resource.attributes));
+  scrubbedResources.set(resource, scrubbed);
+  return scrubbed;
+}
+function redactSpan(span, redactor) {
+  const status = span.status.message ? { ...span.status, message: redactor.text(span.status.message) } : span.status;
+  return {
+    name: redactor.text(span.name),
+    kind: span.kind,
+    spanContext: () => span.spanContext(),
+    parentSpanId: span.parentSpanId,
+    startTime: span.startTime,
+    endTime: span.endTime,
+    status,
+    attributes: redactor.exported(span.attributes),
+    links: span.links.map(
+      (link) => link.attributes ? { ...link, attributes: redactor.exported(link.attributes) } : link
+    ),
+    events: span.events.map((event) => ({
+      ...event,
+      name: redactor.text(event.name),
+      ...event.attributes ? { attributes: redactor.exported(event.attributes) } : {}
+    })),
+    duration: span.duration,
+    ended: span.ended,
+    resource: redactResource(span.resource, redactor),
+    instrumentationLibrary: span.instrumentationLibrary,
+    droppedAttributesCount: span.droppedAttributesCount,
+    droppedEventsCount: span.droppedEventsCount,
+    droppedLinksCount: span.droppedLinksCount
+  };
+}
+var RedactingSpanExporter = class {
+  constructor(inner, redactor) {
     this.inner = inner;
+    this.redactor = redactor;
   }
-  inner;
+  
+  
   export(spans, resultCallback) {
-    this.inner.export(spans, (result) => {
-      if (result.code === import_core.ExportResultCode.SUCCESS) {
-        telemetryStats.onExported(spans.length);
+    const redactor = this.redactor();
+    let scrubbed = spans;
+    let failed = 0;
+    if (redactor.enabled) {
+      scrubbed = [];
+      for (const span of spans) {
+        try {
+          scrubbed.push(redactSpan(span, redactor));
+        } catch (e12) {
+          failed++;
+        }
       }
-      resultCallback(result);
-    });
+    }
+    if (!failed) {
+      this.inner.export(scrubbed, resultCallback);
+      return;
+    }
+    const error = new Error(`autter-runtime: ${failed} span(s) could not be redacted and were not exported`);
+    const fail = () => resultCallback({ code: _core.ExportResultCode.FAILED, error });
+    if (!scrubbed.length) {
+      fail();
+      return;
+    }
+    this.inner.export(
+      scrubbed,
+      (result) => result.code === _core.ExportResultCode.SUCCESS ? fail() : resultCallback(result)
+    );
   }
   shutdown() {
     return this.inner.shutdown();
   }
   forceFlush() {
-    return this.inner.forceFlush?.() ?? Promise.resolve();
+    return _nullishCoalesce(_optionalChain([this, 'access', _3 => _3.inner, 'access', _4 => _4.forceFlush, 'optionalCall', _5 => _5()]), () => ( Promise.resolve()));
   }
 };
-var flushTargets = /* @__PURE__ */ new Map();
-function registerFlushTarget(key, target) {
-  flushTargets.set(key, target);
-}
-function unregisterFlushTargets() {
-  flushTargets.clear();
-}
-function activeFlushTargets() {
-  return [...flushTargets.values()];
-}
-var DEFAULT_SIGNALS = ["SIGINT", "SIGTERM"];
-var SIGNAL_EXIT_CODES = {
-  SIGINT: 130,
-  SIGTERM: 143
-};
-function installAutterAutoFlush(options = {}) {
-  const logger = options.logger ?? console;
-  const log = options.log !== false;
-  const warnOnUnflushedExit = options.warnOnUnflushedExit !== false;
-  const timeoutMs = Math.max(100, options.timeoutMs ?? 3e3);
-  const signals = options.signals ?? DEFAULT_SIGNALS;
-  const flushOnUncaughtException = options.flushOnUncaughtException !== false;
-  let disposed = false;
-  let inFlight = null;
-  const doFlush = async () => {
-    const targets = options.targets ?? activeFlushTargets();
-    if (targets.length === 0) return true;
-    let timer;
-    const timedOut = new Promise((resolve) => {
-      timer = setTimeout(() => resolve(false), timeoutMs);
-    });
-    const drained = Promise.allSettled(
-      targets.map(
-        (target) => Promise.resolve().then(() => target.forceFlush())
-      )
-    ).then(
-      (results) => results.every((result) => result.status === "fulfilled")
-    );
-    let ok;
-    try {
-      ok = await Promise.race([drained, timedOut]);
-    } finally {
-      clearTimeout(timer);
-    }
-    if (ok) {
-      telemetryStats.markAllFlushed();
-      if (log) {
-        logger.log("[autter] telemetry flushed");
-      }
-    } else {
-      logger.error(
-        `[autter] flush did not finish within ${timeoutMs}ms \u2014 some telemetry may be lost`
-      );
-    }
-    return ok;
-  };
-  const flush = (reason = "exit") => {
-    if (disposed) return Promise.resolve(false);
-    if (!inFlight) {
-      inFlight = doFlush().finally(() => {
-        inFlight = null;
-      });
-    }
-    if (isDebugEnabled()) debugLog(`auto-flush requested on ${reason}`);
-    return inFlight;
-  };
-  const signalCounts = /* @__PURE__ */ new Map();
-  let handlingUncaughtException = false;
-  const onUncaughtException = (error) => {
-    if (process.listenerCount("uncaughtException") > 1) return;
-    if (handlingUncaughtException) return;
-    handlingUncaughtException = true;
-    logger.error(error instanceof Error ? error.stack ?? error.message : String(error));
-    const keepAlive = setTimeout(() => {
-    }, timeoutMs + 50);
-    void flush("uncaughtException").finally(() => {
-      clearTimeout(keepAlive);
-      process.exit(1);
-    });
-  };
-  const onSignal = (signal) => {
-    const count = (signalCounts.get(signal) ?? 0) + 1;
-    signalCounts.set(signal, count);
-    const exitCode = SIGNAL_EXIT_CODES[signal] ?? 1;
-    if (count > 1) {
-      process.exit(exitCode);
-    }
-    const otherHandlers = process.listenerCount(signal) - 1;
-    if (otherHandlers > 0) {
-      void flush(signal);
+var RedactingMetricExporter = class {
+  constructor(inner, redactor) {
+    this.inner = inner;
+    this.redactor = redactor;
+  }
+  
+  
+  export(metrics2, resultCallback) {
+    const redactor = this.redactor();
+    if (!redactor.enabled) {
+      this.inner.export(metrics2, resultCallback);
       return;
     }
-    void flush(signal).finally(() => {
-      process.exit(exitCode);
-    });
-  };
-  const MAX_BEFORE_EXIT_FLUSHES = 10;
-  let beforeExitFlushes = 0;
-  const onBeforeExit = () => {
-    if (disposed) return;
-    const targets = options.targets ?? activeFlushTargets();
-    const worthIt = beforeExitFlushes === 0 ? targets.length > 0 : telemetryStats.pendingCaptures > 0;
-    if (!worthIt || beforeExitFlushes >= MAX_BEFORE_EXIT_FLUSHES) return;
-    beforeExitFlushes++;
-    const keepAlive = setTimeout(() => {
-    }, timeoutMs);
-    void flush("beforeExit").finally(() => clearTimeout(keepAlive));
-  };
-  const onExit = () => {
-    if (!warnOnUnflushedExit || disposed) return;
-    const pending = telemetryStats.pendingCaptures;
-    if (pending > 0) {
-      logger.error(
-        `[autter] process exiting with ~${pending} captured item(s) never confirmed exported \u2014 await autter.shutdown() on graceful shutdown`
-      );
-    }
-  };
-  const signalHandlers = /* @__PURE__ */ new Map();
-  process.on("beforeExit", onBeforeExit);
-  if (flushOnUncaughtException) {
-    process.on("uncaughtException", onUncaughtException);
-  }
-  for (const signal of signals) {
-    const handler = () => onSignal(signal);
-    signalHandlers.set(signal, handler);
-    process.on(signal, handler);
-  }
-  process.on("exit", onExit);
-  return {
-    flush,
-    dispose() {
-      disposed = true;
-      process.removeListener("beforeExit", onBeforeExit);
-      process.removeListener("uncaughtException", onUncaughtException);
-      process.removeListener("exit", onExit);
-      for (const [signal, handler] of signalHandlers) {
-        process.removeListener(signal, handler);
-      }
-      signalHandlers.clear();
-    }
-  };
-}
-
-// src/redact.ts
-var SENSITIVE_KEY_PATTERNS = [
-  /e-?mail/,
-  /pass(word|wd|phrase)|^pass$/,
-  /token/,
-  /secret/,
-  /credential/,
-  /(api|access|secret|private|consumer|client|signing|encryption)-?[_.]?key/,
-  /^-?x?-?authorization$|^auth(-|_|$)|bearer/,
-  /cookie/,
-  /phone|msisdn/,
-  /\bssn\b|social[-_ ]?security/,
-  /cvv|cvc|card([-_. ]?(number|num|no))?$/,
-  /credit[-_.]?card/,
-  /connection[-_.]?string/,
-  /recovery[-_.]?code|\botp\b|magic[-_.]?link/
-];
-var PRIVATE_KEY_BLOCK_RE = /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/g;
-var EMAIL_VALUE_RE = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi;
-var JWT_RE = /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g;
-var OPENAI_KEY_RE = /\bsk-[A-Za-z0-9]{20,}\b/g;
-var GITHUB_TOKEN_RE = /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g;
-var AWS_KEY_RE = /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g;
-var SLACK_TOKEN_RE = /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g;
-var BEARER_RE = /\bbearer\s+[A-Za-z0-9._~+/=-]{10,}/gi;
-var URL_CREDENTIALS_RE = /\b([a-z][a-z0-9+.-]*:\/\/)[^\s/:@]+:[^\s/@]+@/gi;
-function toCaseInsensitive(pattern) {
-  return typeof pattern === "string" ? new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i") : new RegExp(pattern.source, pattern.flags.includes("i") ? pattern.flags : `${pattern.flags}i`);
-}
-function compile(options) {
-  const keyPatterns = [...SENSITIVE_KEY_PATTERNS];
-  const valuePatterns = [
-    JWT_RE,
-    OPENAI_KEY_RE,
-    GITHUB_TOKEN_RE,
-    AWS_KEY_RE,
-    SLACK_TOKEN_RE,
-    BEARER_RE
-  ];
-  if (options?.additionalKeyPatterns) {
-    for (const p of options.additionalKeyPatterns) {
-      keyPatterns.push(toCaseInsensitive(p));
-    }
-  }
-  if (options?.additionalValuePatterns) {
-    for (const p of options.additionalValuePatterns) {
-      if (!valuePatterns.some((existing) => existing.source === (typeof p === "string" ? p : p.source))) {
-        valuePatterns.push(typeof p === "string" ? new RegExp(p, "gi") : p);
-      }
-    }
-  }
-  return {
-    keyPatterns,
-    valuePatterns,
-    urlCredentials: URL_CREDENTIALS_RE,
-    privateKeyBlock: PRIVATE_KEY_BLOCK_RE,
-    mask: options?.mask ?? "[redacted]",
-    scrubEmailValues: options?.scrubEmailValues !== false
-  };
-}
-function redactString(value, r) {
-  let out = value.replace(r.privateKeyBlock, r.mask);
-  for (const re of r.valuePatterns) {
-    out = out.replace(re, r.mask);
-  }
-  out = out.replace(r.urlCredentials, "$1" + r.mask + "@");
-  if (r.scrubEmailValues) {
-    out = out.replace(EMAIL_VALUE_RE, r.mask);
-  }
-  return out;
-}
-var MAX_REDACTION_DEPTH = 64;
-var MAX_REDACTION_WORK = 1e4;
-var MAX_COLLECTION_ENTRIES = 1e3;
-function canTraverse(depth, state) {
-  if (depth > MAX_REDACTION_DEPTH || state.remainingWork <= 0) return false;
-  state.remainingWork -= 1;
-  return true;
-}
-function redactValue(value, r, state, depth) {
-  if (typeof value === "string") return redactString(value, r);
-  let isArray = false;
-  try {
-    isArray = Array.isArray(value);
-  } catch {
-    return r.mask;
-  }
-  if (isArray) {
-    return redactArray(value, r, state, depth);
-  }
-  if (typeof value === "object" && value !== null) {
-    return redactObject(value, r, state, depth);
-  }
-  return value;
-}
-function redactArray(value, r, state, depth) {
-  const existing = state.ancestors.get(value);
-  if (existing) return r.mask;
-  if (!canTraverse(depth, state)) return r.mask;
-  const out = [];
-  state.ancestors.set(value, out);
-  let length;
-  try {
-    length = value.length;
-  } catch {
-    state.ancestors.delete(value);
-    return r.mask;
-  }
-  const limit = Math.min(length, MAX_COLLECTION_ENTRIES);
-  for (let i = 0; i < limit; i += 1) {
-    let item;
+    let resource;
     try {
-      item = value[i];
-    } catch {
-      out.push(r.mask);
-      continue;
-    }
-    out.push(redactValue(item, r, state, depth + 1));
-  }
-  if (length > limit) {
-    out.push(r.mask);
-  }
-  state.ancestors.delete(value);
-  return out;
-}
-function redactObject(value, r, state, depth) {
-  const existing = state.ancestors.get(value);
-  if (existing) return r.mask;
-  if (!canTraverse(depth, state)) return r.mask;
-  const out = {};
-  state.ancestors.set(value, out);
-  let count = 0;
-  let truncated = false;
-  try {
-    for (const key in value) {
-      if (!Object.prototype.propertyIsEnumerable.call(
-        value,
-        key
-      )) {
-        continue;
-      }
-      if (count >= MAX_COLLECTION_ENTRIES) {
-        truncated = true;
-        break;
-      }
-      let nestedValue;
-      try {
-        nestedValue = value[key];
-      } catch {
-        out[key] = r.mask;
-        count += 1;
-        continue;
-      }
-      count += 1;
-      out[key] = isSensitiveKey(key, nestedValue, r) ? r.mask : redactValue(
-        nestedValue,
-        r,
-        state,
-        depth + 1
-      );
-    }
-  } catch {
-    truncated = true;
-  }
-  if (truncated) {
-    out.__redaction_truncated__ = r.mask;
-  }
-  state.ancestors.delete(value);
-  return out;
-}
-var USAGE_TOKEN_KEYS = /* @__PURE__ */ new Set([
-  "input_tokens",
-  "output_tokens",
-  "prompt_tokens",
-  "completion_tokens",
-  "total_tokens",
-  "token_count",
-  "gen_ai.usage.input_tokens",
-  "gen_ai.usage.output_tokens",
-  "gen_ai.usage.prompt_tokens",
-  "gen_ai.usage.completion_tokens",
-  "gen_ai.usage.total_tokens",
-  "gen_ai.usage.token_count"
-]);
-function isSensitiveKey(key, value, r) {
-  const lowered = key.toLowerCase();
-  if (USAGE_TOKEN_KEYS.has(lowered)) {
-    return !(typeof value === "number" && Number.isFinite(value) && value >= 0);
-  }
-  return r.keyPatterns.some((re) => re.test(lowered));
-}
-function redactAttributes(attributes, options) {
-  const r = compile(options);
-  return redactWith(attributes, r);
-}
-function redactWith(attributes, r) {
-  const out = {};
-  if (!attributes) return out;
-  const state = {
-    ancestors: /* @__PURE__ */ new WeakMap(),
-    remainingWork: MAX_REDACTION_WORK
-  };
-  let count = 0;
-  let truncated = false;
-  try {
-    for (const key in attributes) {
-      if (!Object.prototype.propertyIsEnumerable.call(
-        attributes,
-        key
-      )) {
-        continue;
-      }
-      if (count >= MAX_COLLECTION_ENTRIES || state.remainingWork <= 0) {
-        truncated = true;
-        break;
-      }
-      let value;
-      try {
-        value = attributes[key];
-      } catch {
-        out[key] = r.mask;
-        count += 1;
-        state.remainingWork -= 1;
-        continue;
-      }
-      count += 1;
-      state.remainingWork -= 1;
-      if (value === void 0) continue;
-      out[key] = isSensitiveKey(key, value, r) ? r.mask : redactValue(value, r, state, 0);
+      resource = redactResource(metrics2.resource, redactor);
+    } catch (error) {
+      resultCallback({ code: _core.ExportResultCode.FAILED, error });
+      return;
     }
-  } catch {
-    truncated = true;
+    this.inner.export({ ...metrics2, resource }, resultCallback);
   }
-  if (truncated) {
-    out.__redaction_truncated__ = r.mask;
+  forceFlush() {
+    return this.inner.forceFlush();
   }
-  return out;
-}
-function makeRedactor(options) {
-  if (options === false) {
-    return (attributes) => ({ ...attributes ?? {} });
+  shutdown() {
+    return this.inner.shutdown();
   }
-  const r = compile(options === true ? void 0 : options);
-  return (attributes) => redactWith(attributes, r);
-}
+  selectAggregationTemporality(instrumentType) {
+    return this.inner.selectAggregationTemporality ? this.inner.selectAggregationTemporality(instrumentType) : _sdkmetrics.AggregationTemporality.CUMULATIVE;
+  }
+};
 
 // src/memory.ts
-var import_node_perf_hooks = require("perf_hooks");
-var import_node_v8 = require("v8");
-var import_api = require("@opentelemetry/api");
+var _perf_hooks = require('perf_hooks');
+var _v8 = require('v8');
+
 function startMemoryMetrics() {
-  const meter = import_api.metrics.getMeter("autter-process-memory");
+  const meter = _api.metrics.getMeter("autter-process-memory");
   const rss = meter.createObservableGauge("autter.process.memory.rss", { unit: "By" });
   const heapUsed = meter.createObservableGauge("autter.process.memory.heap.used", { unit: "By" });
   const heapLimit = meter.createObservableGauge("autter.process.memory.heap.limit", { unit: "By" });
@@ -727,9 +573,9 @@ function startMemoryMetrics() {
   const callbacks = [
     [rss, (result) => result.observe(process.memoryUsage().rss)],
     [heapUsed, (result) => result.observe(process.memoryUsage().heapUsed)],
-    [heapLimit, (result) => result.observe((0, import_node_v8.getHeapStatistics)().heap_size_limit)],
+    [heapLimit, (result) => result.observe(_v8.getHeapStatistics.call(void 0, ).heap_size_limit)],
     [containerLimit, (result) => {
-      const constrained = process.constrainedMemory?.() ?? 0;
+      const constrained = _nullishCoalesce(_optionalChain([process, 'access', _6 => _6.constrainedMemory, 'optionalCall', _7 => _7()]), () => ( 0));
       if (constrained > 0) result.observe(constrained);
     }],
     [afterGc, (result) => {
@@ -739,7 +585,7 @@ function startMemoryMetrics() {
     [gcDuration, (result) => result.observe(durationMs)]
   ];
   for (const [instrument, callback] of callbacks) instrument.addCallback(callback);
-  const observer = new import_node_perf_hooks.PerformanceObserver((list) => {
+  const observer = new (0, _perf_hooks.PerformanceObserver)((list) => {
     for (const entry of list.getEntries()) {
       collections++;
       durationMs += entry.duration;
@@ -753,6 +599,383 @@ function startMemoryMetrics() {
   };
 }
 
+// src/requests.ts
+var _async_hooks = require('async_hooks');
+
+var REQUEST_STATE = /* @__PURE__ */ Symbol.for("autter.runtime.request");
+var BOUND = /* @__PURE__ */ Symbol.for("autter.runtime.bound");
+var CAPTURED = /* @__PURE__ */ new WeakSet();
+var capturer = () => {
+};
+function setRequestExceptionCapturer(fn) {
+  capturer = fn;
+}
+function markCaptured(error) {
+  if (error && typeof error === "object") CAPTURED.add(error);
+}
+function expressRouteOf(req) {
+  const props = req;
+  const path = _optionalChain([props, 'optionalAccess', _8 => _8.route, 'optionalAccess', _9 => _9.path]);
+  if (typeof path !== "string" || path === "") return null;
+  const base = typeof _optionalChain([props, 'optionalAccess', _10 => _10.baseUrl]) === "string" ? props.baseUrl : "";
+  const route = base + path;
+  return route.startsWith("/") ? route : null;
+}
+function defaultShouldCapture(error) {
+  return error instanceof _chunkP4VRTFAVcjs.RuntimeError || _chunkP4VRTFAVcjs.errorCodeOf.call(void 0, error) !== void 0 || _chunkP4VRTFAVcjs.responseStatusOf.call(void 0, error) >= 500;
+}
+function captureAtBoundary(error, state, rule = void 0) {
+  const wanted = typeof rule === "function" ? rule(error) : rule === void 0 ? defaultShouldCapture(error) : rule;
+  if (!wanted) return;
+  if (error && typeof error === "object" && CAPTURED.has(error)) return;
+  markCaptured(error);
+  try {
+    if (state && !state.sealed) _chunkP4VRTFAVcjs.local.run(state, () => capturer(error));
+    else capturer(error);
+  } catch (e13) {
+  }
+}
+function bindEmitter(emitter, state) {
+  const target = emitter;
+  if (!target || typeof target !== "object" || target[BOUND]) return;
+  target[BOUND] = true;
+  const wrappers = /* @__PURE__ */ new WeakMap();
+  const wrap = (listener) => {
+    if (typeof listener !== "function") return listener;
+    let wrapped = wrappers.get(listener);
+    if (!wrapped) {
+      wrapped = function(...args) {
+        return _chunkP4VRTFAVcjs.local.run(
+          state,
+          () => listener.apply(this, args)
+        );
+      };
+      wrappers.set(listener, wrapped);
+    }
+    return wrapped;
+  };
+  for (const method of [
+    "on",
+    "addListener",
+    "prependListener",
+    "once",
+    "prependOnceListener"
+  ]) {
+    const original = target[method];
+    if (typeof original !== "function") continue;
+    target[method] = function(event, listener) {
+      return original.call(this, event, wrap(listener));
+    };
+  }
+  for (const method of ["removeListener", "off"]) {
+    const original = target[method];
+    if (typeof original !== "function") continue;
+    target[method] = function(event, listener) {
+      const wrapped = typeof listener === "function" ? _nullishCoalesce(wrappers.get(listener), () => ( listener)) : listener;
+      return original.call(this, event, wrapped);
+    };
+  }
+}
+function exposeHeaderValue(current, header) {
+  const text = Array.isArray(current) ? current.join(", ") : String(_nullishCoalesce(current, () => ( "")));
+  const names = text.split(",").map((item) => item.trim().toLowerCase()).filter(Boolean);
+  if (names.includes("*") || names.includes(header)) return null;
+  return names.length ? `${text}, ${header}` : header;
+}
+function exposeOnCors(res, header) {
+  const original = res.writeHead;
+  res.writeHead = function(...args) {
+    try {
+      const inline = args.slice(1).find(
+        (arg) => !!arg && typeof arg === "object" && !Array.isArray(arg)
+      );
+      const inlineKey = (name) => inline ? Object.keys(inline).find((key) => key.toLowerCase() === name) : void 0;
+      const cors = res.getHeader("access-control-allow-origin") !== void 0 || inlineKey("access-control-allow-origin") !== void 0;
+      if (cors) {
+        const key = inlineKey("access-control-expose-headers");
+        const value = exposeHeaderValue(
+          key && inline ? inline[key] : res.getHeader("access-control-expose-headers"),
+          header
+        );
+        if (value && key && inline) inline[key] = value;
+        else if (value) res.setHeader("access-control-expose-headers", value);
+      }
+    } catch (e14) {
+    }
+    return original.apply(this, args);
+  };
+}
+function pathOf(req) {
+  const raw = _nullishCoalesce(_nullishCoalesce(req.originalUrl, () => ( req.url)), () => ( "/"));
+  return raw.split(/[?#]/)[0] || "/";
+}
+function finishRequest(state, input) {
+  if (state.sealed) return;
+  state.name = (_nullishCoalesce(input.name, () => ( `${input.method} ${input.route}`))).slice(0, 200);
+  state.outcome = _chunkP4VRTFAVcjs.requestOutcome.call(void 0, {
+    ...state.explicitOutcome ? { explicit: state.outcome } : {},
+    ...state.error !== void 0 ? { error: state.error } : {},
+    ...state.errorThrown ? { thrown: true } : {},
+    status: input.status,
+    aborted: input.aborted
+  });
+  const span = _api.trace.getActiveSpan();
+  if (_optionalChain([span, 'optionalAccess', _11 => _11.isRecording, 'call', _12 => _12()])) span.setAttribute("autter.operation.outcome", state.outcome);
+  if (input.span) {
+    const remote = _api.trace.wrapSpanContext(input.span);
+    _api.context.with(
+      _api.trace.setSpan(_api.context.active(), remote),
+      () => _chunkP4VRTFAVcjs.reportExplicitFailure.call(void 0, state)
+    );
+  } else _chunkP4VRTFAVcjs.reportExplicitFailure.call(void 0, state);
+  _chunkP4VRTFAVcjs.emitSummary.call(void 0, state, {
+    http: {
+      "http.request.method": input.method,
+      "http.route": input.route,
+      "http.response.status_code": input.status,
+      "autter.request.aborted": input.aborted
+    },
+    ...input.span ? { span: input.span } : {}
+  });
+}
+function beginNodeRequest(req, res, options, route) {
+  const header = (_nullishCoalesce(options.requestIdHeader, () => ( _chunkP4VRTFAVcjs.DEFAULT_REQUEST_ID_HEADER))).toLowerCase();
+  const requestId = _chunkP4VRTFAVcjs.resolveRequestId.call(void 0, 
+    options.trustRequestId === false ? void 0 : req.headers[header]
+  );
+  const method = (_nullishCoalesce(req.method, () => ( "GET"))).toUpperCase();
+  const path = pathOf(req);
+  const state = _chunkP4VRTFAVcjs.createRequestState.call(void 0, {
+    name: `${method} ${_chunkP4VRTFAVcjs.normalizeRoutePath.call(void 0, path)}`,
+    requestId,
+    req,
+    res
+  });
+  req[REQUEST_STATE] = state;
+  try {
+    if (!res.headersSent) res.setHeader(header, requestId);
+    exposeOnCors(res, header);
+  } catch (e15) {
+  }
+  const span = _api.trace.getActiveSpan();
+  if (_optionalChain([span, 'optionalAccess', _13 => _13.isRecording, 'call', _14 => _14()]))
+    span.setAttributes({
+      "autter.request.id": requestId,
+      "autter.operation.kind": "request"
+    });
+  const spanContext = _optionalChain([span, 'optionalAccess', _15 => _15.spanContext, 'call', _16 => _16()]);
+  bindEmitter(req, state);
+  bindEmitter(res, state);
+  let finished = false;
+  const done = () => {
+    finishRequest(state, {
+      method,
+      route: _nullishCoalesce(_nullishCoalesce(_optionalChain([route, 'optionalCall', _17 => _17()]), () => ( expressRouteOf(req))), () => ( _chunkP4VRTFAVcjs.normalizeRoutePath.call(void 0, path))),
+      status: res.statusCode,
+      aborted: !finished,
+      ...spanContext ? { span: spanContext } : {}
+    });
+  };
+  res.once("finish", () => {
+    finished = true;
+    done();
+  });
+  res.once("close", done);
+  return state;
+}
+function autterRequests(options = {}) {
+  const ignored = _chunkP4VRTFAVcjs.compileIgnore.call(void 0, options.ignore);
+  return function autterRequestsMiddleware(req, res, next) {
+    if (req[REQUEST_STATE] || ignored(pathOf(req))) {
+      next();
+      return;
+    }
+    const state = beginNodeRequest(req, res, options);
+    _chunkP4VRTFAVcjs.local.run(state, () => next());
+  };
+}
+function autterErrorResponse(options = {}) {
+  return function autterErrorResponseMiddleware(error, req, res, next) {
+    const state = req[REQUEST_STATE];
+    if (state) _chunkP4VRTFAVcjs.noteOperationError.call(void 0, error, true, state);
+    captureAtBoundary(error, state, options.capture);
+    if (res.headersSent) {
+      next(error);
+      return;
+    }
+    const header = (_nullishCoalesce(options.requestIdHeader, () => ( _chunkP4VRTFAVcjs.DEFAULT_REQUEST_ID_HEADER))).toLowerCase();
+    const inbound = _optionalChain([req, 'access', _18 => _18.headers, 'optionalAccess', _19 => _19[header]]);
+    const requestId = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _20 => _20.requestId]), () => ( (typeof inbound === "string" ? inbound.slice(0, 128) : void 0)));
+    res.statusCode = _chunkP4VRTFAVcjs.responseStatusOf.call(void 0, error);
+    res.setHeader("content-type", "application/json; charset=utf-8");
+    res.end(JSON.stringify(_chunkP4VRTFAVcjs.toClientError.call(void 0, error, requestId)));
+  };
+}
+var RESOURCE = /* @__PURE__ */ Symbol.for("autter.runtime.resource");
+function autterFastify(fastify, options, done) {
+  const opts = _nullishCoalesce(options, () => ( {}));
+  const header = (_nullishCoalesce(opts.requestIdHeader, () => ( _chunkP4VRTFAVcjs.DEFAULT_REQUEST_ID_HEADER))).toLowerCase();
+  const ignored = _chunkP4VRTFAVcjs.compileIgnore.call(void 0, opts.ignore);
+  const stateOf = (request) => request[REQUEST_STATE];
+  fastify.addHook("onRequest", ((request, reply, next) => {
+    if (ignored(request.url) || request.raw[REQUEST_STATE]) {
+      next();
+      return;
+    }
+    const requestId = _chunkP4VRTFAVcjs.resolveRequestId.call(void 0, 
+      opts.trustRequestId === false ? void 0 : request.headers[header]
+    );
+    const method = String(_nullishCoalesce(request.method, () => ( "GET"))).toUpperCase();
+    const state = _chunkP4VRTFAVcjs.createRequestState.call(void 0, {
+      name: `${method} ${_chunkP4VRTFAVcjs.normalizeRoutePath.call(void 0, request.url)}`,
+      requestId,
+      req: request.raw,
+      res: reply.raw
+    });
+    request[REQUEST_STATE] = state;
+    request.raw[REQUEST_STATE] = state;
+    reply.header(header, requestId);
+    const span = _api.trace.getActiveSpan();
+    if (_optionalChain([span, 'optionalAccess', _21 => _21.isRecording, 'call', _22 => _22()]))
+      span.setAttributes({
+        "autter.request.id": requestId,
+        "autter.operation.kind": "request"
+      });
+    const spanContext = _optionalChain([span, 'optionalAccess', _23 => _23.spanContext, 'call', _24 => _24()]);
+    bindEmitter(request.raw, state);
+    bindEmitter(reply.raw, state);
+    let finished = false;
+    const finish = (aborted) => finishRequest(state, {
+      method,
+      route: _nullishCoalesce(_nullishCoalesce(_optionalChain([request, 'access', _25 => _25.routeOptions, 'optionalAccess', _26 => _26.url]), () => ( request.routerPath)), () => ( _chunkP4VRTFAVcjs.normalizeRoutePath.call(void 0, request.url))),
+      status: reply.raw.statusCode || reply.statusCode,
+      aborted,
+      ...spanContext ? { span: spanContext } : {}
+    });
+    reply.raw.once("finish", () => {
+      finished = true;
+      finish(false);
+    });
+    reply.raw.once("close", () => finish(!finished));
+    _chunkP4VRTFAVcjs.local.run(state, () => {
+      request[RESOURCE] = new (0, _async_hooks.AsyncResource)("autter-request");
+      next();
+    });
+  }));
+  fastify.addHook("preHandler", ((request, _reply, next) => {
+    const resource = request[RESOURCE];
+    if (resource) resource.runInAsyncScope(() => next());
+    else next();
+  }));
+  fastify.addHook("onSend", ((request, reply, payload, next) => {
+    try {
+      if (stateOf(request) && reply.getHeader("access-control-allow-origin") !== void 0) {
+        const value = exposeHeaderValue(reply.getHeader("access-control-expose-headers"), header);
+        if (value) reply.header("access-control-expose-headers", value);
+      }
+    } catch (e16) {
+    }
+    next(null, payload);
+  }));
+  fastify.addHook("onError", ((request, _reply, error, next) => {
+    const state = stateOf(request);
+    if (state) _chunkP4VRTFAVcjs.noteOperationError.call(void 0, error, true, state);
+    captureAtBoundary(error, state);
+    next();
+  }));
+  done();
+}
+autterFastify[/* @__PURE__ */ Symbol.for("skip-override")] = true;
+autterFastify[/* @__PURE__ */ Symbol.for("fastify.display-name")] = "autter-runtime";
+function withHeaders(response, header, requestId) {
+  const apply = (target) => {
+    target.headers.set(header, requestId);
+    if (target.headers.get("access-control-allow-origin") !== null) {
+      const value = exposeHeaderValue(
+        _nullishCoalesce(target.headers.get("access-control-expose-headers"), () => ( "")),
+        header
+      );
+      if (value) target.headers.set("access-control-expose-headers", value);
+    }
+    return target;
+  };
+  try {
+    return apply(response);
+  } catch (e17) {
+    try {
+      return apply(new Response(response.body, response));
+    } catch (e18) {
+      return response;
+    }
+  }
+}
+function withRuntimeRequest(handler, options = {}) {
+  const header = (_nullishCoalesce(options.requestIdHeader, () => ( _chunkP4VRTFAVcjs.DEFAULT_REQUEST_ID_HEADER))).toLowerCase();
+  const ignored = _chunkP4VRTFAVcjs.compileIgnore.call(void 0, options.ignore);
+  return async (request, ...rest) => {
+    let pathname = "/";
+    try {
+      pathname = new URL(request.url, "http://localhost").pathname;
+    } catch (e19) {
+    }
+    if (ignored(pathname)) return handler(request, ...rest);
+    const requestId = _chunkP4VRTFAVcjs.resolveRequestId.call(void 0, 
+      options.trustRequestId === false ? void 0 : request.headers.get(header)
+    );
+    const method = String(_nullishCoalesce(request.method, () => ( "GET"))).toUpperCase();
+    const route = _nullishCoalesce(options.route, () => ( _chunkP4VRTFAVcjs.normalizeRoutePath.call(void 0, pathname)));
+    const state = _chunkP4VRTFAVcjs.createRequestState.call(void 0, {
+      name: `${method} ${_nullishCoalesce(options.name, () => ( route))}`,
+      requestId,
+      req: request
+    });
+    const span = _api.trace.getActiveSpan();
+    if (_optionalChain([span, 'optionalAccess', _27 => _27.isRecording, 'call', _28 => _28()]))
+      span.setAttributes({
+        "autter.request.id": requestId,
+        "autter.operation.kind": "request"
+      });
+    const spanContext = _optionalChain([span, 'optionalAccess', _29 => _29.spanContext, 'call', _30 => _30()]);
+    let status = 500;
+    try {
+      const response = await _chunkP4VRTFAVcjs.local.run(state, async () => {
+        try {
+          return await handler(request, ...rest);
+        } catch (error) {
+          _chunkP4VRTFAVcjs.noteOperationError.call(void 0, error, true, state);
+          captureAtBoundary(error, state, true);
+          throw error;
+        }
+      });
+      status = response.status;
+      return withHeaders(response, header, requestId);
+    } finally {
+      const aborted = _optionalChain([request, 'access', _31 => _31.signal, 'optionalAccess', _32 => _32.aborted]) === true;
+      finishRequest(state, {
+        method,
+        route,
+        name: `${method} ${_nullishCoalesce(options.name, () => ( route))}`,
+        status,
+        aborted,
+        ...spanContext ? { span: spanContext } : {}
+      });
+      if (options.waitUntil) {
+        try {
+          options.waitUntil(_chunkP4VRTFAVcjs.flushRuntimeLogs.call(void 0, ).catch(() => {
+          }));
+        } catch (e20) {
+        }
+      }
+    }
+  };
+}
+function startHookRequest(res) {
+  const req = res.req;
+  if (!req || req[REQUEST_STATE]) return;
+  const state = beginNodeRequest(req, res, {});
+  _chunkP4VRTFAVcjs.local.enterWith(state);
+}
+
 // src/server.ts
 var LLM_MARKER_ATTRIBUTES = [
   "gen_ai.operation.name",
@@ -769,10 +992,10 @@ var LlmAwareSampler = class {
   constructor(delegate) {
     this.delegate = delegate;
   }
-  delegate;
+  
   shouldSample(ctx, traceId, spanName, spanKind, attributes, links) {
     if (isLlmSpan(spanName, attributes)) {
-      return { decision: import_sdk_trace_base.SamplingDecision.RECORD_AND_SAMPLED };
+      return { decision: _sdktracebase.SamplingDecision.RECORD_AND_SAMPLED };
     }
     return this.delegate.shouldSample(
       ctx,
@@ -791,7 +1014,7 @@ var RecordUnsampledSampler = class {
   constructor(delegate) {
     this.delegate = delegate;
   }
-  delegate;
+  
   shouldSample(ctx, traceId, spanName, spanKind, attributes, links) {
     const result = this.delegate.shouldSample(
       ctx,
@@ -801,8 +1024,8 @@ var RecordUnsampledSampler = class {
       attributes,
       links
     );
-    if (result.decision === import_sdk_trace_base.SamplingDecision.NOT_RECORD) {
-      return { ...result, decision: import_sdk_trace_base.SamplingDecision.RECORD };
+    if (result.decision === _sdktracebase.SamplingDecision.NOT_RECORD) {
+      return { ...result, decision: _sdktracebase.SamplingDecision.RECORD };
     }
     return result;
   }
@@ -815,14 +1038,14 @@ var RETENTION_MAX_BUFFERED_SPANS = 5e3;
 var RETENTION_SWEEP_INTERVAL_MS = 1e4;
 var RETENTION_TRACE_TTL_MS = 3e4;
 function spanIndicatesError(span) {
-  if (span.status.code === import_api2.SpanStatusCode.ERROR) return true;
+  if (span.status.code === _api.SpanStatusCode.ERROR) return true;
   return span.events.some((event) => event.name === "exception");
 }
 var TAIL_RETAINED_ATTR = "autter.tail_retained";
 function withSampledFlag(span) {
   const spanContext = {
     ...span.spanContext(),
-    traceFlags: span.spanContext().traceFlags | import_api2.TraceFlags.SAMPLED
+    traceFlags: span.spanContext().traceFlags | _api.TraceFlags.SAMPLED
   };
   return {
     name: span.name,
@@ -844,29 +1067,29 @@ function withSampledFlag(span) {
     droppedLinksCount: span.droppedLinksCount
   };
 }
-var ErrorTraceRetentionProcessor = class {
-  constructor(inner, retainErrors = true, slowThresholdMs = 0) {
+var ErrorTraceRetentionProcessor = (_class2 = class {
+  constructor(inner, retainErrors = true, slowThresholdMs = 0) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);
     this.inner = inner;
     this.retainErrors = retainErrors;
     this.slowThresholdMs = slowThresholdMs;
     this.sweeper = setInterval(() => this.sweep(), RETENTION_SWEEP_INTERVAL_MS);
-    this.sweeper.unref?.();
-  }
-  inner;
-  retainErrors;
-  slowThresholdMs;
-  traces = /* @__PURE__ */ new Map();
-  bufferedSpans = 0;
-  sweeper;
+    _optionalChain([this, 'access', _33 => _33.sweeper, 'access', _34 => _34.unref, 'optionalCall', _35 => _35()]);
+  }
+  
+  
+  
+  __init2() {this.traces = /* @__PURE__ */ new Map()}
+  __init3() {this.bufferedSpans = 0}
+  
   onStart(_span, _parentContext) {
   }
   onEnd(span) {
     const ctx = span.spanContext();
-    if ((ctx.traceFlags & import_api2.TraceFlags.SAMPLED) !== 0) return;
+    if ((ctx.traceFlags & _api.TraceFlags.SAMPLED) !== 0) return;
     const entry = this.entryFor(ctx.traceId);
     if (entry.retained) {
       this.forward(span);
-    } else if (this.retainErrors && spanIndicatesError(span) || this.slowThresholdMs > 0 && span.kind === import_api2.SpanKind.SERVER && span.duration[0] * 1e3 + span.duration[1] / 1e6 >= this.slowThresholdMs) {
+    } else if (this.retainErrors && spanIndicatesError(span) || this.slowThresholdMs > 0 && span.kind === _api.SpanKind.SERVER && span.duration[0] * 1e3 + span.duration[1] / 1e6 >= this.slowThresholdMs) {
       entry.retained = true;
       this.flush(entry);
       this.forward(span);
@@ -881,8 +1104,8 @@ var ErrorTraceRetentionProcessor = class {
   }
   /** Promote the active trace, if any — called on captured errors. */
   retainActiveTrace() {
-    const active2 = import_api2.trace.getActiveSpan()?.spanContext();
-    if (!active2 || (active2.traceFlags & import_api2.TraceFlags.SAMPLED) !== 0) return;
+    const active2 = _optionalChain([_api.trace, 'access', _36 => _36.getActiveSpan, 'call', _37 => _37(), 'optionalAccess', _38 => _38.spanContext, 'call', _39 => _39()]);
+    if (!active2 || (active2.traceFlags & _api.TraceFlags.SAMPLED) !== 0) return;
     const entry = this.entryFor(active2.traceId);
     if (entry.retained) return;
     entry.retained = true;
@@ -937,10 +1160,10 @@ var ErrorTraceRetentionProcessor = class {
       if (entry.firstSeenAtMs <= cutoff) this.drop(traceId);
     }
   }
-};
+}, _class2);
 function llmBaseAttributes(info) {
   return {
-    "gen_ai.operation.name": info.operation ?? "chat",
+    "gen_ai.operation.name": _nullishCoalesce(info.operation, () => ( "chat")),
     // Both keys: gen_ai.system is the pre-1.37 semconv name and what
     // most tooling still matches on.
     "gen_ai.provider.name": info.provider,
@@ -970,97 +1193,106 @@ function usageAttributes(usage) {
   return attrs;
 }
 async function runLlmSpan(tracer, info, fn) {
-  const span = tracer.startSpan(`${info.operation ?? "chat"} ${info.model}`, {
-    kind: import_api2.SpanKind.CLIENT,
+  const span = tracer.startSpan(`${_nullishCoalesce(info.operation, () => ( "chat"))} ${info.model}`, {
+    kind: _api.SpanKind.CLIENT,
     attributes: llmBaseAttributes(info)
   });
-  const setResponseModel = (model) => span.setAttribute("gen_ai.response.model", model);
+  const usage = {};
+  let responseModel;
+  const setResponseModel = (model) => {
+    responseModel = model;
+    span.setAttribute("gen_ai.response.model", model);
+  };
   const handle = {
-    setUsage: (usage) => span.setAttributes(usageAttributes(usage)),
-    setCost: (usd) => span.setAttribute("autter.llm.cost_usd", usd),
+    setUsage: (next) => {
+      Object.assign(usage, next);
+      span.setAttributes(usageAttributes(next));
+    },
+    setCost: (usd) => {
+      usage.costUsd = usd;
+      span.setAttribute("autter.llm.cost_usd", usd);
+    },
     setResponseModel,
     setModel: setResponseModel,
-    setAttributes: (attributes) => span.setAttributes(attributes)
+    setAttributes: (attributes) => span.setAttributes(activeRedactor(attributes))
   };
   try {
-    const result = await import_api2.context.with(
-      import_api2.trace.setSpan(import_api2.context.active(), span),
+    const result = await _api.context.with(
+      _api.trace.setSpan(_api.context.active(), span),
       () => fn(handle)
     );
-    span.setStatus({ code: import_api2.SpanStatusCode.OK });
+    span.setStatus({ code: _api.SpanStatusCode.OK });
     return result;
   } catch (err) {
-    if (err instanceof Error) {
-      span.recordException(err);
-      span.setAttribute("error.type", err.name);
-    }
-    span.setStatus({
-      code: import_api2.SpanStatusCode.ERROR,
-      message: err instanceof Error ? err.message : String(err)
-    });
+    recordError(span, err);
+    if (err instanceof Error) span.setAttribute("error.type", err.name);
     throw err;
   } finally {
     span.end();
+    _chunkP4VRTFAVcjs.recordOperationAiUsage.call(void 0, { ...usage, model: _nullishCoalesce(responseModel, () => ( info.model)) });
   }
 }
 function recordLlmCall(tracer, call) {
-  const durationMs = Math.max(0, call.durationMs ?? 0);
+  _chunkP4VRTFAVcjs.recordOperationAiUsage.call(void 0, { ...call, model: call.model });
+  const durationMs = Math.max(0, _nullishCoalesce(call.durationMs, () => ( 0)));
   const endTime = /* @__PURE__ */ new Date();
   const startTime = new Date(endTime.getTime() - durationMs);
   const span = tracer.startSpan(
-    `${call.operation ?? "chat"} ${call.model}`,
+    `${_nullishCoalesce(call.operation, () => ( "chat"))} ${call.model}`,
     {
-      kind: import_api2.SpanKind.CLIENT,
+      kind: _api.SpanKind.CLIENT,
       startTime,
       attributes: { ...llmBaseAttributes(call), ...usageAttributes(call) }
     }
   );
   if (call.error !== void 0 && call.error !== null) {
+    recordError(span, call.error);
     if (call.error instanceof Error) {
-      span.recordException(call.error);
       span.setAttribute("error.type", call.error.name);
     }
-    span.setStatus({
-      code: import_api2.SpanStatusCode.ERROR,
-      message: call.error instanceof Error ? call.error.message : String(call.error)
-    });
   } else {
-    span.setStatus({ code: import_api2.SpanStatusCode.OK });
+    span.setStatus({ code: _api.SpanStatusCode.OK });
   }
   span.end(endTime);
 }
-async function runWithSpan(tracer, name, fn, attributes) {
-  const span = tracer.startSpan(name, { attributes });
+async function runWithSpan(tracer, name, fn, attributes, links) {
+  const span = tracer.startSpan(name, {
+    attributes,
+    ..._optionalChain([links, 'optionalAccess', _40 => _40.length]) ? { links } : {}
+  });
   try {
-    const result = await import_api2.context.with(
-      import_api2.trace.setSpan(import_api2.context.active(), span),
+    const result = await _api.context.with(
+      _api.trace.setSpan(_api.context.active(), span),
       fn
     );
-    span.setStatus({ code: import_api2.SpanStatusCode.OK });
+    span.setStatus({ code: _api.SpanStatusCode.OK });
     return result;
   } catch (err) {
-    if (err instanceof Error) span.recordException(err);
-    span.setStatus({
-      code: import_api2.SpanStatusCode.ERROR,
-      message: err instanceof Error ? err.message : String(err)
-    });
+    recordError(span, err);
     throw err;
   } finally {
     span.end();
   }
 }
-function expressRouteOf(req) {
-  const props = req;
-  const path = props?.route?.path;
-  if (typeof path !== "string" || path === "") return null;
-  const base = typeof props?.baseUrl === "string" ? props.baseUrl : "";
-  const route = base + path;
-  return route.startsWith("/") ? route : null;
+function recordError(span, err) {
+  const isError = err instanceof Error;
+  const message = activeRedactor.text(isError ? err.message : String(err));
+  if (isError) {
+    span.addEvent("exception", {
+      "exception.type": err.name,
+      "exception.message": message,
+      ...err.stack ? { "exception.stacktrace": activeRedactor.text(err.stack) } : {}
+    });
+  }
+  span.setStatus({ code: _api.SpanStatusCode.ERROR, message });
+}
+function redactWithActive(attributes) {
+  return activeRedactor(attributes);
 }
 function captureExpressRoute(_span, response) {
-  if (!(response instanceof import_node_http.ServerResponse)) return;
-  const rpcMetadata = (0, import_core2.getRPCMetadata)(import_api2.context.active());
-  if (rpcMetadata?.type !== import_core2.RPCType.HTTP) return;
+  if (!(response instanceof _http.ServerResponse)) return;
+  const rpcMetadata = _core.getRPCMetadata.call(void 0, _api.context.active());
+  if (_optionalChain([rpcMetadata, 'optionalAccess', _41 => _41.type]) !== _core.RPCType.HTTP) return;
   const setRoute = () => {
     if (rpcMetadata.route) return;
     const route = expressRouteOf(response.req);
@@ -1068,33 +1300,60 @@ function captureExpressRoute(_span, response) {
   };
   response.prependListener("finish", setRoute);
   response.prependListener("close", setRoute);
+  if (hookRequests) startHookRequest(response);
+}
+var hookRequests = false;
+function structuredErrorAttributes(error) {
+  const attrs = { ..._chunkP4VRTFAVcjs.errorAttributes.call(void 0, error, { causes: false }) };
+  const internal = _chunkP4VRTFAVcjs.errorInternal.call(void 0, error);
+  if (internal) {
+    try {
+      attrs["autter.error.internal"] = JSON.stringify(
+        activeRedactor(internal)
+      ).slice(0, 4e3);
+    } catch (e21) {
+    }
+  }
+  return attrs;
 }
 var active = null;
 var activeAlwaysOnProvider = null;
-var activeRedactor = makeRedactor(true);
+var activeRedactor = _chunkP4VRTFAVcjs.makeRedactor.call(void 0, true);
 function initAutterServer(options) {
   if (active) return active;
-  const endpoint = (options.endpoint ?? "https://otlp.autter.dev").replace(
+  const endpoint = (_nullishCoalesce(options.endpoint, () => ( "https://otlp.autter.dev"))).replace(
     /\/$/,
     ""
   );
   const headers = { authorization: `Bearer ${options.apiKey}` };
-  const environment = options.environment ?? process.env.NODE_ENV ?? "production";
-  if (isDebugEnabled() || options.debug === true) setDebugMode(true);
-  debugLog(`initialising service=${options.service} endpoint=${endpoint}`);
-  activeRedactor = makeRedactor(options.redactAttributes ?? true);
-  const resource = new import_resources.Resource({
-    [import_semantic_conventions.ATTR_SERVICE_NAME]: options.service,
-    "service.instance.id": (options.instanceId || process.env.AUTTER_RUNTIME_INSTANCE_ID || (0, import_node_crypto.randomUUID)()).slice(0, 128),
-    ...options.release ? { [import_semantic_conventions.ATTR_SERVICE_VERSION]: options.release } : {},
+  const traceExporter = () => new (0, _chunkGI47WGRRcjs.CountingExporter)(
+    new RedactingSpanExporter(
+      new (0, _exportertraceotlphttp.OTLPTraceExporter)({ url: `${endpoint}/v1/traces`, headers }),
+      () => activeRedactor
+    )
+  );
+  const environment = _nullishCoalesce(_nullishCoalesce(options.environment, () => ( process.env.NODE_ENV)), () => ( "production"));
+  if (_chunkGI47WGRRcjs.isDebugEnabled.call(void 0, ) || options.debug === true) _chunkGI47WGRRcjs.setDebugMode.call(void 0, true);
+  _chunkGI47WGRRcjs.debugLog.call(void 0, `initialising service=${options.service} endpoint=${endpoint}`);
+  activeRedactor = _chunkP4VRTFAVcjs.makeRedactor.call(void 0, _nullishCoalesce(options.redactAttributes, () => ( true)));
+  const distro = _nullishCoalesce(options.distro, () => ( _chunkGI47WGRRcjs.SDK_IDENTITY));
+  _chunkGI47WGRRcjs.configureCompatCheck.call(void 0, { endpoint, enabled: options.compatCheck !== false, sdk: distro });
+  const resource = new (0, _resources.Resource)({
+    [_semanticconventions.ATTR_SERVICE_NAME]: options.service,
+    "service.instance.id": (options.instanceId || process.env.AUTTER_RUNTIME_INSTANCE_ID || _crypto.randomUUID.call(void 0, )).slice(0, 128),
+    ...options.release ? { [_semanticconventions.ATTR_SERVICE_VERSION]: options.release } : {},
     "deployment.environment": environment,
+    // OTel semconv for SDK distributions: the ingester records which
+    // Autter SDK version each service runs (version compatibility checks).
+    "telemetry.distro.name": distro.name,
+    "telemetry.distro.version": distro.version,
     // Tells the ingester request metrics arrive on the metrics pipe, so
     // it must not also fold our server spans into usage rollups (that
     // would double-count every sampled request).
     "autter.metrics_wired": true
   });
-  const headSampler = new import_sdk_trace_base.ParentBasedSampler({
-    root: new import_sdk_trace_base.TraceIdRatioBasedSampler(options.traceSampleRate ?? 0.01)
+  const headSampler = new (0, _sdktracebase.ParentBasedSampler)({
+    root: new (0, _sdktracebase.TraceIdRatioBasedSampler)(_nullishCoalesce(options.traceSampleRate, () => ( 0.01)))
   });
   const retainOnError = options.retainTracesOnError !== false;
   const slowThresholdMs = Number.isFinite(options.retainTracesAboveMs) ? Math.max(0, options.retainTracesAboveMs) : 0;
@@ -1102,33 +1361,27 @@ function initAutterServer(options) {
   let sampler = retainTraces ? new RecordUnsampledSampler(headSampler) : headSampler;
   if (options.llmTracing !== false) sampler = new LlmAwareSampler(sampler);
   const errorTraceBuffer = retainTraces ? new ErrorTraceRetentionProcessor(
-    new import_sdk_trace_base.BatchSpanProcessor(
-      new CountingExporter(
-        new import_exporter_trace_otlp_http.OTLPTraceExporter({ url: `${endpoint}/v1/traces`, headers })
-      ),
-      { scheduledDelayMillis: 2e3 }
-    ),
+    new (0, _sdktracebase.BatchSpanProcessor)(traceExporter(), { scheduledDelayMillis: 2e3 }),
     retainOnError,
     slowThresholdMs
   ) : null;
-  const mainSpanProcessor = new import_sdk_trace_base.BatchSpanProcessor(
-    new CountingExporter(
-      new import_exporter_trace_otlp_http.OTLPTraceExporter({ url: `${endpoint}/v1/traces`, headers })
-    )
-  );
-  const metricReader = new import_sdk_metrics.PeriodicExportingMetricReader({
-    exporter: new import_exporter_metrics_otlp_http.OTLPMetricExporter({
-      url: `${endpoint}/v1/metrics`,
-      headers,
-      // Deltas, not lifetime totals: the ingester SUMs data points
-      // into runtime_metrics_1m, and the default (cumulative)
-      // temporality would re-count every past request on each
-      // 60 s export.
-      temporalityPreference: import_exporter_metrics_otlp_http.AggregationTemporalityPreference.DELTA
-    }),
-    exportIntervalMillis: options.metricIntervalMs ?? 6e4
+  const mainSpanProcessor = new (0, _sdktracebase.BatchSpanProcessor)(traceExporter());
+  const metricReader = new (0, _sdkmetrics.PeriodicExportingMetricReader)({
+    exporter: new RedactingMetricExporter(
+      new (0, _exportermetricsotlphttp.OTLPMetricExporter)({
+        url: `${endpoint}/v1/metrics`,
+        headers,
+        // Deltas, not lifetime totals: the ingester SUMs data points
+        // into runtime_metrics_1m, and the default (cumulative)
+        // temporality would re-count every past request on each
+        // 60 s export.
+        temporalityPreference: _exportermetricsotlphttp.AggregationTemporalityPreference.DELTA
+      }),
+      () => activeRedactor
+    ),
+    exportIntervalMillis: _nullishCoalesce(options.metricIntervalMs, () => ( 6e4))
   });
-  const sdk = new import_sdk_node.NodeSDK({
+  const sdk = new (0, _sdknode.NodeSDK)({
     resource,
     sampler,
     spanProcessors: [
@@ -1137,105 +1390,129 @@ function initAutterServer(options) {
     ],
     metricReader,
     views: [
-      new import_sdk_metrics.View({ instrumentName: "http.server.duration", aggregation: new import_sdk_metrics.ExplicitBucketHistogramAggregation(
+      new (0, _sdkmetrics.View)({ instrumentName: "http.server.duration", aggregation: new (0, _sdkmetrics.ExplicitBucketHistogramAggregation)(
         [5, 10, 25, 50, 100, 250, 500, 750, 1e3, 1500, 2e3, 3e3, 5e3, 7500, 1e4, 15e3, 2e4, 3e4, 6e4, 12e4]
       ) }),
-      new import_sdk_metrics.View({ instrumentName: "http.server.request.duration", aggregation: new import_sdk_metrics.ExplicitBucketHistogramAggregation(
+      new (0, _sdkmetrics.View)({ instrumentName: "http.server.request.duration", aggregation: new (0, _sdkmetrics.ExplicitBucketHistogramAggregation)(
         [5e-3, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 0.75, 1, 1.5, 2, 3, 5, 7.5, 10, 15, 20, 30, 60, 120]
       ) })
     ],
     instrumentations: [
-      new import_instrumentation_http.HttpInstrumentation({ responseHook: captureExpressRoute }),
-      ...options.instrumentations ?? []
+      new (0, _instrumentationhttp.HttpInstrumentation)({ responseHook: captureExpressRoute }),
+      ..._nullishCoalesce(options.instrumentations, () => ( []))
     ]
   });
   sdk.start();
   const stopMemoryMetrics = options.memoryMetrics === false ? null : startMemoryMetrics();
-  const alwaysOnProvider = new import_sdk_trace_base.BasicTracerProvider({
+  _chunkGI47WGRRcjs.noteCompatFeature.call(void 0, "endpoint_latency");
+  if (stopMemoryMetrics) _chunkGI47WGRRcjs.noteCompatFeature.call(void 0, "memory_metrics");
+  if (options.llmTracing !== false) _chunkGI47WGRRcjs.noteCompatFeature.call(void 0, "llm_calls");
+  const alwaysOnProvider = new (0, _sdktracebase.BasicTracerProvider)({
     resource,
-    sampler: new import_sdk_trace_base.AlwaysOnSampler(),
+    sampler: new (0, _sdktracebase.AlwaysOnSampler)(),
     spanProcessors: [
-      new import_sdk_trace_base.BatchSpanProcessor(
-        new CountingExporter(
-          new import_exporter_trace_otlp_http.OTLPTraceExporter({ url: `${endpoint}/v1/traces`, headers })
-        ),
-        { scheduledDelayMillis: 2e3 }
-      )
+      new (0, _sdktracebase.BatchSpanProcessor)(traceExporter(), { scheduledDelayMillis: 2e3 })
     ]
   });
   const errorTracer = alwaysOnProvider.getTracer("autter-errors");
   const processTracer = alwaysOnProvider.getTracer("autter-processes");
   const llmTracer = alwaysOnProvider.getTracer("autter-llm");
   function captureException2(error, attributes) {
-    errorTraceBuffer?.retainActiveTrace();
-    telemetryStats.markCaptured();
+    _optionalChain([errorTraceBuffer, 'optionalAccess', _42 => _42.retainActiveTrace, 'call', _43 => _43()]);
+    _chunkGI47WGRRcjs.telemetryStats.markCaptured();
     const isError = error instanceof Error;
-    const message = isError ? error.message : String(error);
+    const message = activeRedactor.text(isError ? error.message : String(error));
+    const stackText = isError && error.stack ? activeRedactor.text(error.stack) : "";
     const redacted = activeRedactor(attributes);
-    const activeSpan = import_api2.trace.getActiveSpan();
-    const reuseActive = activeSpan?.isRecording() === true;
+    const activeSpan = _api.trace.getActiveSpan();
+    const reuseActive = _optionalChain([activeSpan, 'optionalAccess', _44 => _44.isRecording, 'call', _45 => _45()]) === true;
     const span = reuseActive ? activeSpan : errorTracer.startSpan(isError ? error.name : "Error");
-    span.setAttributes({ "autter.severity": "error", ...redacted });
-    if (isError && error.stack) {
-      if (redacted["autter.handled"] === true) {
-        span.addEvent("exception", {
-          "exception.type": error.name,
-          "exception.message": message,
-          "exception.stacktrace": error.stack,
-          "autter.handled": true,
-          "autter.sampled": redacted["autter.sampled"] === true
-        });
-      } else {
-        span.recordException(error);
-      }
+    const structured = structuredErrorAttributes(error);
+    const causes = _chunkP4VRTFAVcjs.errorAttributes.call(void 0, error);
+    const declared = Object.fromEntries(
+      Object.entries(causes).filter(([key]) => key !== "autter.error.internal")
+    );
+    const requestId = _optionalChain([_chunkP4VRTFAVcjs.currentOperation.call(void 0, ), 'optionalAccess', _46 => _46.requestId]);
+    span.setAttributes({
+      "autter.severity": "error",
+      ...redacted,
+      ...structured,
+      ...requestId ? { "autter.request.id": requestId } : {}
+    });
+    markCaptured(error);
+    _chunkP4VRTFAVcjs.noteOperationError.call(void 0, error);
+    _chunkP4VRTFAVcjs.notifyException.call(void 0, error, redacted);
+    if (isError && stackText) {
+      span.addEvent("exception", {
+        "exception.type": error.name,
+        "exception.message": message,
+        "exception.stacktrace": stackText,
+        ...redacted["autter.handled"] === true ? { "autter.handled": true, "autter.sampled": redacted["autter.sampled"] === true } : {},
+        ...declared
+      });
     } else {
-      const stack = new Error().stack?.split("\n").filter((line, i) => i === 0 || !line.includes("captureException")).join("\n");
+      const stack = _optionalChain([new Error(), 'access', _47 => _47.stack, 'optionalAccess', _48 => _48.split, 'call', _49 => _49("\n"), 'access', _50 => _50.filter, 'call', _51 => _51((line, i) => i === 0 || !line.includes("captureException")), 'access', _52 => _52.join, 'call', _53 => _53("\n")]);
       span.addEvent("exception", {
         "exception.type": isError ? error.name : "Error",
         "exception.message": message,
-        ...stack ? { "exception.stacktrace": stack } : {},
-        ...redacted["autter.handled"] === true ? { "autter.handled": true, "autter.sampled": redacted["autter.sampled"] === true } : {}
+        ...stack ? { "exception.stacktrace": activeRedactor.text(stack) } : {},
+        ...redacted["autter.handled"] === true ? { "autter.handled": true, "autter.sampled": redacted["autter.sampled"] === true } : {},
+        ...declared
       });
     }
-    span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message });
+    span.setStatus({ code: _api.SpanStatusCode.ERROR, message });
     if (!reuseActive) span.end();
   }
   function captureMessage2(message, severity = "warning", attributes) {
     if (severity === "error" || severity === "fatal") {
-      errorTraceBuffer?.retainActiveTrace();
+      _optionalChain([errorTraceBuffer, 'optionalAccess', _54 => _54.retainActiveTrace, 'call', _55 => _55()]);
     }
-    telemetryStats.markCaptured();
-    const stack = new Error().stack?.split("\n").filter((line, i) => i === 0 || !line.includes("captureMessage")).join("\n");
+    _chunkGI47WGRRcjs.telemetryStats.markCaptured();
+    const stack = _optionalChain([new Error(), 'access', _56 => _56.stack, 'optionalAccess', _57 => _57.split, 'call', _58 => _58("\n"), 'access', _59 => _59.filter, 'call', _60 => _60((line, i) => i === 0 || !line.includes("captureMessage")), 'access', _61 => _61.join, 'call', _62 => _62("\n")]);
+    const safeMessage = activeRedactor.text(message);
     const span = errorTracer.startSpan("Message", {
       attributes: { "autter.severity": severity, ...activeRedactor(attributes) }
     });
     span.addEvent("exception", {
       "exception.type": "Message",
-      "exception.message": message,
-      ...stack ? { "exception.stacktrace": stack } : {},
+      "exception.message": safeMessage,
+      ...stack ? { "exception.stacktrace": activeRedactor.text(stack) } : {},
       "autter.severity": severity
     });
-    span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message });
+    span.setStatus({ code: _api.SpanStatusCode.ERROR, message: safeMessage });
     span.end();
   }
   function reportOutcome2(name, message, attributes) {
-    errorTraceBuffer?.retainActiveTrace();
-    telemetryStats.markCaptured();
-    const activeSpan = import_api2.trace.getActiveSpan();
-    const reuseActive = activeSpan?.isRecording() === true;
+    _optionalChain([errorTraceBuffer, 'optionalAccess', _63 => _63.retainActiveTrace, 'call', _64 => _64()]);
+    _chunkGI47WGRRcjs.telemetryStats.markCaptured();
+    const activeSpan = _api.trace.getActiveSpan();
+    const reuseActive = _optionalChain([activeSpan, 'optionalAccess', _65 => _65.isRecording, 'call', _66 => _66()]) === true;
     const span = reuseActive ? activeSpan : errorTracer.startSpan("OutcomeFailure");
     const safeOutcome = activeRedactor({ "autter.outcome.name": name.slice(0, 200), "autter.outcome.message": message.slice(0, 1e3) });
-    const safeName = String(safeOutcome["autter.outcome.name"] ?? "operation");
-    const safeMessage = String(safeOutcome["autter.outcome.message"] ?? "failed");
+    const safeName = String(_nullishCoalesce(safeOutcome["autter.outcome.name"], () => ( "operation")));
+    const safeMessage = String(_nullishCoalesce(safeOutcome["autter.outcome.message"], () => ( "failed")));
     span.addEvent("autter.outcome", {
       ...activeRedactor(attributes),
       "autter.outcome.status": "error",
       "autter.outcome.name": safeName,
       "autter.outcome.message": safeMessage
     });
-    span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message: safeMessage });
+    span.setStatus({ code: _api.SpanStatusCode.ERROR, message: safeMessage });
     if (!reuseActive) span.end();
   }
+  _chunkP4VRTFAVcjs.configureRuntimeLogger.call(void 0, {
+    endpoint,
+    apiKey: options.apiKey,
+    service: options.service,
+    environment,
+    distro,
+    release: options.release,
+    options: options.logging,
+    redact: activeRedactor,
+    run: (name, fn, attributes, links) => runWithSpan(processTracer, name, fn, activeRedactor(attributes), links),
+    reportOutcome: reportOutcome2
+  });
+  hookRequests = _optionalChain([options, 'access', _67 => _67.logging, 'optionalAccess', _68 => _68.requests]) === true;
   if (options.captureGlobalErrors !== false) {
     process.on("uncaughtExceptionMonitor", (err) => {
       captureException2(err, { "autter.unhandled": true });
@@ -1246,6 +1523,7 @@ function initAutterServer(options) {
   const flushTarget = {
     forceFlush: async () => {
       const results = await Promise.allSettled([
+        _chunkP4VRTFAVcjs.flushRuntimeLogs.call(void 0, ),
         Promise.resolve().then(() => alwaysOnProvider.forceFlush()),
         Promise.resolve().then(() => mainSpanProcessor.forceFlush()),
         ...errorTraceBuffer ? [Promise.resolve().then(() => errorTraceBuffer.forceFlush())] : [],
@@ -1259,10 +1537,10 @@ function initAutterServer(options) {
       }
     }
   };
-  registerFlushTarget("active-server", flushTarget);
+  _chunkGI47WGRRcjs.registerFlushTarget.call(void 0, "active-server", flushTarget);
   let autoFlushHandle = null;
   if (options.autoFlush !== false) {
-    autoFlushHandle = installAutterAutoFlush();
+    autoFlushHandle = _chunkGI47WGRRcjs.installAutterAutoFlush.call(void 0, );
   }
   const server = {
     captureException: captureException2,
@@ -1272,14 +1550,17 @@ function initAutterServer(options) {
     withLlmCall: (info, fn) => runLlmSpan(llmTracer, info, fn),
     trackLlmCall: (call) => recordLlmCall(llmTracer, call),
     shutdown: async () => {
-      stopMemoryMetrics?.();
+      const logShutdown = await Promise.allSettled([_chunkP4VRTFAVcjs.shutdownRuntimeLogger.call(void 0, )]);
+      hookRequests = false;
+      _optionalChain([stopMemoryMetrics, 'optionalCall', _69 => _69()]);
       active = null;
       activeAlwaysOnProvider = null;
-      autoFlushHandle?.dispose();
+      _optionalChain([autoFlushHandle, 'optionalAccess', _70 => _70.dispose, 'call', _71 => _71()]);
       autoFlushHandle = null;
-      unregisterFlushTargets();
-      telemetryStats.markAllFlushed();
+      _chunkGI47WGRRcjs.unregisterFlushTargets.call(void 0, );
+      _chunkGI47WGRRcjs.telemetryStats.markAllFlushed();
       await Promise.allSettled([alwaysOnProvider.shutdown(), sdk.shutdown()]);
+      if (_optionalChain([logShutdown, 'access', _72 => _72[0], 'optionalAccess', _73 => _73.status]) === "rejected") throw logShutdown[0].reason;
     }
   };
   active = server;
@@ -1291,69 +1572,88 @@ function captureException(error, attributes) {
     active.captureException(error, attributes);
     return;
   }
-  const span = import_api2.trace.getTracer("autter-errors").startSpan(error instanceof Error ? error.name : "Error", { attributes });
-  if (error instanceof Error) span.recordException(error);
-  span.setStatus({
-    code: import_api2.SpanStatusCode.ERROR,
-    message: error instanceof Error ? error.message : String(error)
+  if (loggerOnlyCapture) {
+    loggerOnlyCapture(error, attributes);
+    return;
+  }
+  markCaptured(error);
+  _chunkP4VRTFAVcjs.noteOperationError.call(void 0, error);
+  _chunkP4VRTFAVcjs.notifyException.call(void 0, error, attributes);
+  const span = _api.trace.getTracer("autter-errors").startSpan(error instanceof Error ? error.name : "Error", {
+    attributes: activeRedactor(attributes)
   });
+  recordError(span, error);
   span.end();
 }
+var loggerOnlyCapture = null;
+function setLoggerOnlyCapture(fn) {
+  loggerOnlyCapture = fn;
+}
+function serverActive() {
+  return active !== null;
+}
+setRequestExceptionCapturer((error) => captureException(error));
 function withProcessSpan(name, fn, attributes) {
   if (active) return active.withProcessSpan(name, fn, attributes);
-  return runWithSpan(import_api2.trace.getTracer("autter-processes"), name, fn, attributes);
+  return runWithSpan(
+    _api.trace.getTracer("autter-processes"),
+    name,
+    fn,
+    activeRedactor(attributes)
+  );
 }
 function withLlmCall(info, fn) {
   if (active) return active.withLlmCall(info, fn);
-  return runLlmSpan(import_api2.trace.getTracer("autter-llm"), info, fn);
+  return runLlmSpan(_api.trace.getTracer("autter-llm"), info, fn);
 }
 function trackLlmCall(call) {
   if (active) {
     active.trackLlmCall(call);
     return;
   }
-  recordLlmCall(import_api2.trace.getTracer("autter-llm"), call);
+  recordLlmCall(_api.trace.getTracer("autter-llm"), call);
 }
 function captureMessage(message, severity = "warning", attributes) {
   if (active) {
     active.captureMessage(message, severity, attributes);
     return;
   }
-  const span = import_api2.trace.getTracer("autter-errors").startSpan("Message", {
-    attributes: { "autter.severity": severity, ...attributes }
+  const safeMessage = activeRedactor.text(message);
+  const span = _api.trace.getTracer("autter-errors").startSpan("Message", {
+    attributes: { "autter.severity": severity, ...activeRedactor(attributes) }
   });
   span.addEvent("exception", {
     "exception.type": "Message",
-    "exception.message": message,
+    "exception.message": safeMessage,
     "autter.severity": severity
   });
-  span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message });
+  span.setStatus({ code: _api.SpanStatusCode.ERROR, message: safeMessage });
   span.end();
 }
 function reportOutcome(name, message, attributes) {
   if (active) return active.reportOutcome(name, message, attributes);
-  const span = import_api2.trace.getTracer("autter-outcomes").startSpan("OutcomeFailure");
-  const safeOutcome = redactAttributes({ "autter.outcome.name": name.slice(0, 200), "autter.outcome.message": message.slice(0, 1e3) });
-  const safeName = String(safeOutcome["autter.outcome.name"] ?? "operation");
-  const safeMessage = String(safeOutcome["autter.outcome.message"] ?? "failed");
+  const span = _api.trace.getTracer("autter-outcomes").startSpan("OutcomeFailure");
+  const safeOutcome = _chunkP4VRTFAVcjs.redactAttributes.call(void 0, { "autter.outcome.name": name.slice(0, 200), "autter.outcome.message": message.slice(0, 1e3) });
+  const safeName = String(_nullishCoalesce(safeOutcome["autter.outcome.name"], () => ( "operation")));
+  const safeMessage = String(_nullishCoalesce(safeOutcome["autter.outcome.message"], () => ( "failed")));
   span.addEvent("autter.outcome", {
-    ...redactAttributes(attributes),
+    ..._chunkP4VRTFAVcjs.redactAttributes.call(void 0, attributes),
     "autter.outcome.status": "error",
     "autter.outcome.name": safeName,
     "autter.outcome.message": safeMessage
   });
-  span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message: safeMessage });
+  span.setStatus({ code: _api.SpanStatusCode.ERROR, message: safeMessage });
   span.end();
 }
 function makeSafeCapture(options) {
-  const clean = (attributes) => attributes ? { ...redactAttributes(attributes, options) } : void 0;
+  const clean = (attributes) => attributes ? { ..._chunkP4VRTFAVcjs.redactAttributes.call(void 0, attributes, options) } : void 0;
   return {
     captureException: (error, attributes) => captureException(error, clean(attributes)),
-    captureMessage: (message, severity, attributes) => captureMessage(message, severity ?? "warning", clean(attributes))
+    captureMessage: (message, severity, attributes) => captureMessage(message, _nullishCoalesce(severity, () => ( "warning")), clean(attributes))
   };
 }
 function alwaysOnTracer(name) {
-  return activeAlwaysOnProvider ? activeAlwaysOnProvider.getTracer(name) : import_api2.trace.getTracer(name);
+  return activeAlwaysOnProvider ? activeAlwaysOnProvider.getTracer(name) : _api.trace.getTracer(name);
 }
 function autterLlmTracer() {
   return alwaysOnTracer("autter-llm");
@@ -1373,7 +1673,7 @@ async function emitLlmSelftestTrace() {
       attributes: { "autter.selftest": true }
     },
     (llm) => {
-      traceId = import_api2.trace.getActiveSpan()?.spanContext().traceId ?? "";
+      traceId = _nullishCoalesce(_optionalChain([_api.trace, 'access', _74 => _74.getActiveSpan, 'call', _75 => _75(), 'optionalAccess', _76 => _76.spanContext, 'call', _77 => _77(), 'access', _78 => _78.traceId]), () => ( ""));
       llm.setUsage({ inputTokens: 1, outputTokens: 1 });
       llm.setCost(0);
     }
@@ -1383,7 +1683,10 @@ async function emitLlmSelftestTrace() {
 }
 
 // src/llm-instrument.ts
-var import_api3 = require("@opentelemetry/api");
+
+
+
+
 var CALL_METHODS = /* @__PURE__ */ new Set([
   "create",
   // openai chat/completions/embeddings/responses, anthropic messages
@@ -1398,15 +1701,15 @@ var CALL_METHODS = /* @__PURE__ */ new Set([
   // openai beta structured outputs
 ]);
 function detectProvider(client) {
-  const name = client.constructor?.name?.toLowerCase() ?? "";
+  const name = _nullishCoalesce(_optionalChain([client, 'access', _79 => _79.constructor, 'optionalAccess', _80 => _80.name, 'optionalAccess', _81 => _81.toLowerCase, 'call', _82 => _82()]), () => ( ""));
   for (const known of ["openai", "anthropic", "mistral", "groq", "cohere"]) {
     if (name.includes(known)) return known;
   }
   if (name.includes("google") || name.includes("genai")) return "google";
   const baseUrl = String(
-    client.baseURL ?? client.baseUrl ?? ""
+    _nullishCoalesce(_nullishCoalesce(client.baseURL, () => ( client.baseUrl)), () => ( ""))
   );
-  const host = baseUrl.match(/https?:\/\/([^/]+)/)?.[1] ?? "";
+  const host = _nullishCoalesce(_optionalChain([baseUrl, 'access', _83 => _83.match, 'call', _84 => _84(/https?:\/\/([^/]+)/), 'optionalAccess', _85 => _85[1]]), () => ( ""));
   if (host.includes("openai")) return "openai";
   if (host.includes("anthropic")) return "anthropic";
   if (host.includes("googleapis")) return "google";
@@ -1416,17 +1719,28 @@ function detectProvider(client) {
 }
 function extractUsage(result) {
   const r = result;
-  const usage = r?.usage ?? r?.message?.usage;
-  const meta = r?.usageMetadata;
-  const input = usage?.prompt_tokens ?? usage?.input_tokens ?? meta?.promptTokenCount ?? void 0;
-  const output = usage?.completion_tokens ?? usage?.output_tokens ?? meta?.candidatesTokenCount ?? void 0;
-  const responseModel = r?.model ?? r?.modelVersion;
+  const usage = _nullishCoalesce(_optionalChain([r, 'optionalAccess', _86 => _86.usage]), () => ( _optionalChain([r, 'optionalAccess', _87 => _87.message, 'optionalAccess', _88 => _88.usage])));
+  const meta = _optionalChain([r, 'optionalAccess', _89 => _89.usageMetadata]);
+  const details = _optionalChain([usage, 'optionalAccess', _90 => _90.prompt_tokens_details]);
+  const cached = _nullishCoalesce(_nullishCoalesce(_optionalChain([usage, 'optionalAccess', _91 => _91.cache_read_input_tokens]), () => ( (typeof _optionalChain([details, 'optionalAccess', _92 => _92.cached_tokens]) === "number" ? details.cached_tokens : void 0))), () => ( _optionalChain([meta, 'optionalAccess', _93 => _93.cachedContentTokenCount])));
+  const input = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([usage, 'optionalAccess', _94 => _94.prompt_tokens]), () => ( _optionalChain([usage, 'optionalAccess', _95 => _95.input_tokens]))), () => ( _optionalChain([meta, 'optionalAccess', _96 => _96.promptTokenCount]))), () => ( void 0));
+  const output = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([usage, 'optionalAccess', _97 => _97.completion_tokens]), () => ( _optionalChain([usage, 'optionalAccess', _98 => _98.output_tokens]))), () => ( _optionalChain([meta, 'optionalAccess', _99 => _99.candidatesTokenCount]))), () => ( void 0));
+  const responseModel = _nullishCoalesce(_optionalChain([r, 'optionalAccess', _100 => _100.model]), () => ( _optionalChain([r, 'optionalAccess', _101 => _101.modelVersion])));
   return {
     inputTokens: typeof input === "number" ? input : void 0,
     outputTokens: typeof output === "number" ? output : void 0,
+    cacheReadTokens: typeof cached === "number" ? cached : void 0,
     responseModel: typeof responseModel === "string" ? responseModel : void 0
   };
 }
+function rollUp(model, usage) {
+  _chunkP4VRTFAVcjs.recordOperationAiUsage.call(void 0, {
+    model: _nullishCoalesce(usage.responseModel, () => ( model)),
+    ...usage.inputTokens !== void 0 ? { inputTokens: usage.inputTokens } : {},
+    ...usage.outputTokens !== void 0 ? { outputTokens: usage.outputTokens } : {},
+    ...usage.cacheReadTokens !== void 0 ? { cacheReadTokens: usage.cacheReadTokens } : {}
+  });
+}
 function applyUsage(span, usage) {
   if (usage.inputTokens !== void 0) {
     span.setAttribute("gen_ai.usage.input_tokens", usage.inputTokens);
@@ -1439,14 +1753,10 @@ function applyUsage(span, usage) {
   }
 }
 function endWithError(span, err) {
-  if (err instanceof Error) span.recordException(err);
-  span.setStatus({
-    code: import_api3.SpanStatusCode.ERROR,
-    message: err instanceof Error ? err.message : String(err)
-  });
+  recordError(span, err);
   span.end();
 }
-function wrapStream(stream, span) {
+function wrapStream(stream, span, model) {
   let ended = false;
   const seen = {
     inputTokens: void 0,
@@ -1457,11 +1767,12 @@ function wrapStream(stream, span) {
     if (ended) return;
     ended = true;
     applyUsage(span, seen);
+    rollUp(model, seen);
     span.setAttribute("autter.llm.streamed", true);
     if (err !== void 0) {
       endWithError(span, err);
     } else {
-      span.setStatus({ code: import_api3.SpanStatusCode.OK });
+      span.setStatus({ code: _api.SpanStatusCode.OK });
       span.end();
     }
   };
@@ -1478,6 +1789,7 @@ function wrapStream(stream, span) {
                   const usage = extractUsage(step.value);
                   if (usage.inputTokens !== void 0) seen.inputTokens = usage.inputTokens;
                   if (usage.outputTokens !== void 0) seen.outputTokens = usage.outputTokens;
+                  if (usage.cacheReadTokens !== void 0) seen.cacheReadTokens = usage.cacheReadTokens;
                   if (usage.responseModel) seen.responseModel = usage.responseModel;
                 } else {
                   finish();
@@ -1506,24 +1818,24 @@ function wrapStream(stream, span) {
   });
 }
 function instrumentLlmClient(client, options) {
-  const provider = (options?.provider ?? detectProvider(client)).toLowerCase();
+  const provider = (_nullishCoalesce(_optionalChain([options, 'optionalAccess', _102 => _102.provider]), () => ( detectProvider(client)))).toLowerCase();
   const proxied = /* @__PURE__ */ new WeakMap();
   function resolveUserId() {
-    return typeof options?.userId === "function" ? options.userId() : options?.userId;
+    return typeof _optionalChain([options, 'optionalAccess', _103 => _103.userId]) === "function" ? options.userId() : _optionalChain([options, 'optionalAccess', _104 => _104.userId]);
   }
   function traceCall(fn, self, callPath, args) {
     const request = args[0];
     const operation = /embed/i.test(callPath) ? "embeddings" : "chat";
     const userId = resolveUserId();
     const span = autterLlmTracer().startSpan(`${operation} ${request.model}`, {
-      kind: import_api3.SpanKind.CLIENT,
+      kind: _api.SpanKind.CLIENT,
       attributes: {
         "gen_ai.operation.name": operation,
         "gen_ai.provider.name": provider,
         "gen_ai.system": provider,
         "gen_ai.request.model": request.model,
         ...userId ? { "autter.user_id": userId } : {},
-        ...options?.attributes
+        ...redactWithActive(_optionalChain([options, 'optionalAccess', _105 => _105.attributes]))
       }
     });
     let result;
@@ -1535,20 +1847,24 @@ function instrumentLlmClient(client, options) {
     }
     if (!(result instanceof Promise)) {
       if (result && typeof result === "object" && Symbol.asyncIterator in result) {
-        return wrapStream(result, span);
+        return wrapStream(result, span, request.model);
       }
-      applyUsage(span, extractUsage(result));
-      span.setStatus({ code: import_api3.SpanStatusCode.OK });
+      const usage = extractUsage(result);
+      applyUsage(span, usage);
+      rollUp(request.model, usage);
+      span.setStatus({ code: _api.SpanStatusCode.OK });
       span.end();
       return result;
     }
     return result.then(
       (resolved) => {
         if (resolved && typeof resolved === "object" && Symbol.asyncIterator in resolved) {
-          return wrapStream(resolved, span);
+          return wrapStream(resolved, span, request.model);
         }
-        applyUsage(span, extractUsage(resolved));
-        span.setStatus({ code: import_api3.SpanStatusCode.OK });
+        const usage = extractUsage(resolved);
+        applyUsage(span, usage);
+        rollUp(request.model, usage);
+        span.setStatus({ code: _api.SpanStatusCode.OK });
         span.end();
         return resolved;
       },
@@ -1596,11 +1912,11 @@ function instrumentLlmClient(client, options) {
 }
 
 // src/caught-exceptions.ts
-var import_node_inspector = __toESM(require("inspector"), 1);
+var _inspector = require('inspector'); var _inspector2 = _interopRequireDefault(_inspector);
 function startCaughtExceptionSampler(options = {}) {
-  const rate = Math.max(0, Math.min(1, options.sampleRate ?? 0.01));
-  const cap = Math.max(1, Math.min(100, options.maxPerMinute ?? 10));
-  const session = new import_node_inspector.default.Session();
+  const rate = Math.max(0, Math.min(1, _nullishCoalesce(options.sampleRate, () => ( 0.01))));
+  const cap = Math.max(1, Math.min(100, _nullishCoalesce(options.maxPerMinute, () => ( 10))));
+  const session = new _inspector2.default.Session();
   let active2 = true;
   let minute = 0;
   let sent = 0;
@@ -1616,7 +1932,7 @@ function startCaughtExceptionSampler(options = {}) {
     }
     if (sent >= cap || Math.random() >= rate) return;
     sent++;
-    const frames = message.params.callFrames.slice(0, 8).filter((frame) => frame.url && !frame.url.startsWith("node:")).map((frame) => `    at ${frame.functionName || "anonymous"} (${frame.url.split("?")[0]}:${frame.location.lineNumber + 1}:${(frame.location.columnNumber ?? 0) + 1})`);
+    const frames = message.params.callFrames.slice(0, 8).filter((frame) => frame.url && !frame.url.startsWith("node:")).map((frame) => `    at ${frame.functionName || "anonymous"} (${frame.url.split("?")[0]}:${frame.location.lineNumber + 1}:${(_nullishCoalesce(frame.location.columnNumber, () => ( 0))) + 1})`);
     if (!frames.length) return;
     const error = new Error("Sampled caught exception");
     error.name = "CaughtException";
@@ -1638,22 +1954,245 @@ ${frames.join("\n")}`;
     });
   } };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  captureException,
-  captureMessage,
-  createBrowserRelayFetchHandler,
-  createBrowserRelayHandler,
-  emitLlmSelftestTrace,
-  initAutterServer,
-  installAutterAutoFlush,
-  instrumentLlmClient,
-  makeSafeCapture,
-  redactAttributes,
-  reportOutcome,
-  sanitizeBrowserPayload,
-  startCaughtExceptionSampler,
-  trackLlmCall,
-  withLlmCall,
-  withProcessSpan
-});
+
+// src/logging-only.ts
+
+
+
+
+var activeLogging = null;
+function initAutterLogging(options) {
+  if (activeLogging) return activeLogging;
+  if (serverActive()) {
+    console.warn(
+      "[autter-runtime] initAutterLogging() ignored: initAutterServer() is already active and includes logging"
+    );
+    return {
+      captureException,
+      flush: _chunkP4VRTFAVcjs.flushRuntimeLogs,
+      shutdown: async () => {
+      }
+    };
+  }
+  if (_chunkGI47WGRRcjs.isDebugEnabled.call(void 0, ) || options.debug === true) _chunkGI47WGRRcjs.setDebugMode.call(void 0, true);
+  const endpoint = (_nullishCoalesce(options.endpoint, () => ( "https://otlp.autter.dev"))).replace(/\/$/, "");
+  const environment = _nullishCoalesce(_nullishCoalesce(options.environment, () => ( process.env.NODE_ENV)), () => ( "production"));
+  const redact = _chunkP4VRTFAVcjs.makeRedactor.call(void 0, _nullishCoalesce(options.redactAttributes, () => ( true)));
+  const mode = _nullishCoalesce(options.exceptions, () => ( "auto"));
+  _chunkGI47WGRRcjs.debugLog.call(void 0, `initialising logger-only service=${options.service} endpoint=${endpoint}`);
+  function captureException2(error, attributes) {
+    markCaptured(error);
+    const redacted = redact(attributes);
+    const span = _api.trace.getActiveSpan();
+    if (mode === "auto" && _optionalChain([span, 'optionalAccess', _106 => _106.isRecording, 'call', _107 => _107()])) {
+      _chunkP4VRTFAVcjs.noteOperationError.call(void 0, error);
+      _chunkP4VRTFAVcjs.notifyException.call(void 0, error, redacted);
+      span.setAttributes({ "autter.severity": "error", ...redacted, ...structuredErrorAttributes(error) });
+      const declared = _chunkP4VRTFAVcjs.errorAttributes.call(void 0, error);
+      if (error instanceof Error) {
+        span.addEvent("exception", {
+          "exception.type": error.name,
+          "exception.message": error.message,
+          ...error.stack ? { "exception.stacktrace": error.stack } : {},
+          ...declared
+        });
+      } else {
+        span.addEvent("exception", {
+          "exception.type": "Error",
+          "exception.message": String(error),
+          ...declared
+        });
+      }
+      span.setStatus({
+        code: _api.SpanStatusCode.ERROR,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return;
+    }
+    _chunkP4VRTFAVcjs.notifyException.call(void 0, error, redacted);
+    _chunkP4VRTFAVcjs.captureExceptionAsLog.call(void 0, error, redacted);
+  }
+  const captured = /* @__PURE__ */ new WeakSet();
+  _chunkP4VRTFAVcjs.configureRuntimeLogger.call(void 0, {
+    endpoint,
+    apiKey: _nullishCoalesce(options.apiKey, () => ( "")),
+    service: options.service,
+    environment,
+    ...options.release ? { release: options.release } : {},
+    ...options.logging ? { options: options.logging } : {},
+    redact,
+    reportOutcome: (name, message, attributes) => {
+      _chunkP4VRTFAVcjs.runtimeLogger.error(message, {
+        ...attributes,
+        "autter.outcome.name": name.slice(0, 200),
+        "autter.outcome.message": message.slice(0, 1e3)
+      });
+    },
+    captureThrown: (error) => {
+      if (error && typeof error === "object") {
+        if (captured.has(error)) return;
+        captured.add(error);
+      }
+      captureException2(error);
+    }
+  });
+  setLoggerOnlyCapture(captureException2);
+  const onCrash = (error) => captureException2(error, { "autter.unhandled": true });
+  if (options.captureGlobalErrors !== false)
+    process.on("uncaughtExceptionMonitor", onCrash);
+  _chunkGI47WGRRcjs.registerFlushTarget.call(void 0, "logging", { forceFlush: () => _chunkP4VRTFAVcjs.flushRuntimeLogs.call(void 0, ) });
+  let autoFlushHandle = options.autoFlush === false ? null : _chunkGI47WGRRcjs.installAutterAutoFlush.call(void 0, );
+  const handle = {
+    captureException: captureException2,
+    flush: _chunkP4VRTFAVcjs.flushRuntimeLogs,
+    shutdown: async () => {
+      process.off("uncaughtExceptionMonitor", onCrash);
+      setLoggerOnlyCapture(null);
+      _optionalChain([autoFlushHandle, 'optionalAccess', _108 => _108.dispose, 'call', _109 => _109()]);
+      autoFlushHandle = null;
+      _chunkGI47WGRRcjs.unregisterFlushTargets.call(void 0, );
+      activeLogging = null;
+      await _chunkP4VRTFAVcjs.shutdownRuntimeLogger.call(void 0, );
+    }
+  };
+  activeLogging = handle;
+  return handle;
+}
+
+// src/enrichers.ts
+function headerOf(req, name) {
+  const headers = _optionalChain([req, 'optionalAccess', _110 => _110.headers]);
+  if (!headers) return void 0;
+  if (typeof headers.get === "function") {
+    return _nullishCoalesce(headers.get(name), () => ( void 0));
+  }
+  const value = headers[name.toLowerCase()];
+  if (Array.isArray(value)) return value[0] === void 0 ? void 0 : String(value[0]);
+  return value === void 0 || value === null ? void 0 : String(value);
+}
+function enrichUserAgent() {
+  return (event, { req }) => {
+    const ua = headerOf(req, "user-agent");
+    if (!ua) return;
+    const info = _chunkP4VRTFAVcjs.parseUserAgent.call(void 0, ua);
+    if (info.browser) event.attributes["user_agent.browser"] = info.browser;
+    if (info.os) event.attributes["user_agent.os"] = info.os;
+    event.attributes["user_agent.device"] = info.device;
+    event.attributes["user_agent.bot"] = info.bot;
+  };
+}
+function enrichRequestSize() {
+  return (event, { req, res }) => {
+    const request = Number(headerOf(req, "content-length"));
+    if (Number.isFinite(request) && request >= 0)
+      event.attributes["http.request.body.size"] = request;
+    const raw = _optionalChain([res, 'optionalAccess', _111 => _111.getHeader, 'optionalCall', _112 => _112(
+      "content-length"
+    )]);
+    const response = Number(raw);
+    if (raw !== void 0 && Number.isFinite(response) && response >= 0)
+      event.attributes["http.response.body.size"] = response;
+  };
+}
+var COUNTRY_HEADERS = [
+  "cf-ipcountry",
+  "x-vercel-ip-country",
+  "cloudfront-viewer-country",
+  "x-country-code",
+  "fastly-geo-country-code"
+];
+function enrichEdgeGeo() {
+  return (event, { req }) => {
+    for (const name of COUNTRY_HEADERS) {
+      const value = _optionalChain([headerOf, 'call', _113 => _113(req, name), 'optionalAccess', _114 => _114.trim, 'call', _115 => _115(), 'access', _116 => _116.toUpperCase, 'call', _117 => _117()]);
+      if (value && /^[A-Z]{2}$/.test(value) && value !== "XX" && value !== "T1") {
+        event.attributes["geo.country.iso_code"] = value;
+        return;
+      }
+    }
+  };
+}
+var REGION_VARS = [
+  "AUTTER_REGION",
+  "AWS_REGION",
+  "VERCEL_REGION",
+  "FLY_REGION",
+  "RAILWAY_REPLICA_REGION",
+  "GOOGLE_CLOUD_REGION",
+  "CLOUD_RUN_REGION",
+  "RENDER_REGION",
+  "AZURE_REGION"
+];
+var COMMIT_VARS = [
+  "AUTTER_COMMIT",
+  "GIT_SHA",
+  "GIT_COMMIT",
+  "COMMIT_SHA",
+  "SOURCE_COMMIT",
+  "VERCEL_GIT_COMMIT_SHA",
+  "GITHUB_SHA",
+  "RENDER_GIT_COMMIT",
+  "RAILWAY_GIT_COMMIT_SHA",
+  "CF_PAGES_COMMIT_SHA",
+  "HEROKU_SLUG_COMMIT",
+  "SOURCE_VERSION"
+];
+function enrichDeployment(env = process.env) {
+  const pick = (names) => names.map((name) => _optionalChain([env, 'access', _118 => _118[name], 'optionalAccess', _119 => _119.trim, 'call', _120 => _120()])).find((value) => value);
+  const region = _optionalChain([pick, 'call', _121 => _121(REGION_VARS), 'optionalAccess', _122 => _122.slice, 'call', _123 => _123(0, 64)]);
+  const commit = _optionalChain([pick, 'call', _124 => _124(COMMIT_VARS), 'optionalAccess', _125 => _125.slice, 'call', _126 => _126(0, 64)]);
+  return (event) => {
+    if (region) event.attributes["deployment.region"] = region;
+    if (commit) event.attributes["deployment.commit"] = commit;
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CODE_PATTERN = _chunkP4VRTFAVcjs.CODE_PATTERN; exports.COMPAT_MANIFEST = _chunkGI47WGRRcjs.COMPAT_MANIFEST; exports.INGESTER_VERSION_HEADER = _chunkGI47WGRRcjs.INGESTER_VERSION_HEADER; exports.RuntimeError = _chunkP4VRTFAVcjs.RuntimeError; exports.SDK_IDENTITY = _chunkGI47WGRRcjs.SDK_IDENTITY; exports.autterErrorResponse = autterErrorResponse; exports.autterFastify = autterFastify; exports.autterRequests = autterRequests; exports.captureException = captureException; exports.captureMessage = captureMessage; exports.consoleSink = _chunkP4VRTFAVcjs.consoleSink; exports.createBrowserRelayFetchHandler = createBrowserRelayFetchHandler; exports.createBrowserRelayHandler = createBrowserRelayHandler; exports.createRuntimeLogger = _chunkP4VRTFAVcjs.createRuntimeLogger; exports.defineRuntimeErrors = _chunkP4VRTFAVcjs.defineRuntimeErrors; exports.emitLlmSelftestTrace = emitLlmSelftestTrace; exports.enrichDeployment = enrichDeployment; exports.enrichEdgeGeo = enrichEdgeGeo; exports.enrichRequestSize = enrichRequestSize; exports.enrichUserAgent = enrichUserAgent; exports.errorAttributes = _chunkP4VRTFAVcjs.errorAttributes; exports.evaluateCompat = _chunkGI47WGRRcjs.evaluateCompat; exports.fetchIngesterCompat = _chunkGI47WGRRcjs.fetchIngesterCompat; exports.fileSink = _chunkP4VRTFAVcjs.fileSink; exports.flushRuntimeLogs = _chunkP4VRTFAVcjs.flushRuntimeLogs; exports.initAutterLogging = initAutterLogging; exports.initAutterServer = initAutterServer; exports.installAutterAutoFlush = _chunkGI47WGRRcjs.installAutterAutoFlush; exports.instrumentLlmClient = instrumentLlmClient; exports.isRuntimeErrorLike = _chunkP4VRTFAVcjs.isRuntimeErrorLike; exports.makeSafeCapture = makeSafeCapture; exports.otlpSink = _chunkP4VRTFAVcjs.otlpSink; exports.redactAttributes = _chunkP4VRTFAVcjs.redactAttributes; exports.redactText = _chunkP4VRTFAVcjs.redactText; exports.reportOutcome = reportOutcome; exports.runDoctor = _chunkL6SRL65Jcjs.runDoctor; exports.runInBackground = _chunkP4VRTFAVcjs.runInBackground; exports.runtimeContext = _chunkP4VRTFAVcjs.runtimeContext; exports.runtimeLogStats = _chunkP4VRTFAVcjs.runtimeLogStats; exports.runtimeLogger = _chunkP4VRTFAVcjs.runtimeLogger; exports.sanitizeBrowserPayload = sanitizeBrowserPayload; exports.startCaughtExceptionSampler = startCaughtExceptionSampler; exports.toClientError = _chunkP4VRTFAVcjs.toClientError; exports.trackLlmCall = trackLlmCall; exports.withLlmCall = withLlmCall; exports.withProcessSpan = withProcessSpan; exports.withRuntimeOperation = _chunkP4VRTFAVcjs.withRuntimeOperation; exports.withRuntimeRequest = withRuntimeRequest;