@frontmcp/observability 0.0.1

package/index.js

@@ -0,0 +1,3010 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// libs/observability/src/logging/sinks/winston.sink.ts
+var winston_sink_exports = {};
+__export(winston_sink_exports, {
+  WinstonSink: () => WinstonSink
+});
+function mapToWinstonLevel(level) {
+  switch (level) {
+    case "debug":
+    case "verbose":
+      return "debug";
+    case "info":
+      return "info";
+    case "warn":
+      return "warn";
+    case "error":
+      return "error";
+    default:
+      return "info";
+  }
+}
+var WinstonSink;
+var init_winston_sink = __esm({
+  "libs/observability/src/logging/sinks/winston.sink.ts"() {
+    "use strict";
+    WinstonSink = class {
+      constructor(logger) {
+        this.logger = logger;
+      }
+      write(entry) {
+        const { message, level, ...meta } = entry;
+        const winstonLevel = mapToWinstonLevel(level);
+        switch (winstonLevel) {
+          case "debug":
+            this.logger.debug(message, meta);
+            break;
+          case "info":
+            this.logger.info(message, meta);
+            break;
+          case "warn":
+            this.logger.warn(message, meta);
+            break;
+          case "error":
+            this.logger.error(message, meta);
+            break;
+        }
+      }
+    };
+  }
+});
+
+// libs/observability/src/logging/sinks/pino.sink.ts
+var pino_sink_exports = {};
+__export(pino_sink_exports, {
+  PinoSink: () => PinoSink
+});
+function mapToPinoLevel(level) {
+  switch (level) {
+    case "debug":
+    case "verbose":
+      return "debug";
+    case "info":
+      return "info";
+    case "warn":
+      return "warn";
+    case "error":
+      return "error";
+    default:
+      return "info";
+  }
+}
+var PinoSink;
+var init_pino_sink = __esm({
+  "libs/observability/src/logging/sinks/pino.sink.ts"() {
+    "use strict";
+    PinoSink = class {
+      constructor(logger) {
+        this.logger = logger;
+      }
+      write(entry) {
+        const { message, level, ...obj } = entry;
+        const pinoLevel = mapToPinoLevel(level);
+        switch (pinoLevel) {
+          case "debug":
+            this.logger.debug(obj, message);
+            break;
+          case "info":
+            this.logger.info(obj, message);
+            break;
+          case "warn":
+            this.logger.warn(obj, message);
+            break;
+          case "error":
+            this.logger.error(obj, message);
+            break;
+        }
+      }
+    };
+  }
+});
+
+// libs/observability/src/logging/sinks/otlp.sink.ts
+var otlp_sink_exports = {};
+__export(otlp_sink_exports, {
+  OtlpSink: () => OtlpSink
+});
+var OtlpSink;
+var init_otlp_sink = __esm({
+  "libs/observability/src/logging/sinks/otlp.sink.ts"() {
+    "use strict";
+    OtlpSink = class {
+      constructor(options) {
+        this.batch = [];
+        let base = options.endpoint;
+        while (base.endsWith("/")) {
+          base = base.slice(0, -1);
+        }
+        this.endpoint = `${base}/v1/logs`;
+        this.headers = {
+          "Content-Type": "application/json",
+          ...options.headers ?? {}
+        };
+        this.batchSize = options.batchSize ?? 100;
+        this.maxQueueSize = options.maxQueueSize ?? 5e3;
+        this.serviceName = options.serviceName ?? (typeof process !== "undefined" ? process.env?.["OTEL_SERVICE_NAME"] : void 0) ?? "frontmcp-server";
+        const flushMs = options.flushIntervalMs ?? 5e3;
+        if (flushMs > 0) {
+          this.flushTimer = setInterval(() => {
+            void this.flush();
+          }, flushMs);
+          if (this.flushTimer && typeof this.flushTimer === "object" && "unref" in this.flushTimer) {
+            this.flushTimer.unref();
+          }
+        }
+      }
+      write(entry) {
+        this.batch.push(entry);
+        this.enforceCapacity();
+        if (this.batch.length >= this.batchSize) {
+          void this.flush();
+        }
+      }
+      async flush() {
+        if (this.batch.length === 0) return;
+        const entries = this.batch.splice(0);
+        const payload = this.buildOtlpPayload(entries);
+        try {
+          const controller = new AbortController();
+          const timeout = setTimeout(() => controller.abort(), 1e4);
+          try {
+            const response = await fetch(this.endpoint, {
+              method: "POST",
+              headers: this.headers,
+              body: JSON.stringify(payload),
+              signal: controller.signal
+            });
+            clearTimeout(timeout);
+            if (!response.ok) {
+              const body = await response.text().catch(() => "");
+              console.error(`[OtlpSink] Export failed: HTTP ${response.status} \u2014 ${body.slice(0, 200)}`);
+              this.requeue(entries);
+            }
+          } catch (err) {
+            clearTimeout(timeout);
+            console.debug(
+              `[OtlpSink] Export error (${entries.length} entries): ${err instanceof Error ? err.message : err}`
+            );
+            this.requeue(entries);
+          }
+        } catch {
+        }
+      }
+      requeue(entries) {
+        this.batch.unshift(...entries);
+        this.enforceCapacity();
+      }
+      enforceCapacity() {
+        if (this.batch.length > this.maxQueueSize) {
+          this.batch.splice(0, this.batch.length - this.maxQueueSize);
+        }
+      }
+      async close() {
+        if (this.flushTimer) {
+          clearInterval(this.flushTimer);
+          this.flushTimer = void 0;
+        }
+        await this.flush();
+      }
+      /**
+       * Build OTLP Logs JSON payload per the OTel spec.
+       *
+       * @see https://opentelemetry.io/docs/specs/otlp/#otlphttp-request
+       * @see https://opentelemetry.io/docs/specs/otel/logs/data-model/
+       */
+      buildOtlpPayload(entries) {
+        return {
+          resourceLogs: [
+            {
+              resource: {
+                attributes: [{ key: "service.name", value: { stringValue: this.serviceName } }]
+              },
+              scopeLogs: [
+                {
+                  scope: { name: "@frontmcp/observability" },
+                  logRecords: entries.map((entry) => this.entryToLogRecord(entry))
+                }
+              ]
+            }
+          ]
+        };
+      }
+      entryToLogRecord(entry) {
+        const attrs = [];
+        const record = {
+          timeUnixNano: String(new Date(entry.timestamp).getTime() * 1e6),
+          severityNumber: entry.severity_number,
+          severityText: entry.level.toUpperCase(),
+          body: { stringValue: entry.message },
+          attributes: attrs
+        };
+        if (entry.trace_id) {
+          record.traceId = entry.trace_id;
+        }
+        if (entry.span_id) {
+          record.spanId = entry.span_id;
+        }
+        if (entry.trace_flags !== void 0) {
+          record.flags = entry.trace_flags;
+        }
+        if (entry.request_id) {
+          attrs.push({ key: "frontmcp.request.id", value: { stringValue: entry.request_id } });
+        }
+        if (entry.session_id_hash) {
+          attrs.push({ key: "mcp.session.id", value: { stringValue: entry.session_id_hash } });
+        }
+        if (entry.scope_id) {
+          attrs.push({ key: "frontmcp.scope.id", value: { stringValue: entry.scope_id } });
+        }
+        if (entry.flow_name) {
+          attrs.push({ key: "frontmcp.flow.name", value: { stringValue: entry.flow_name } });
+        }
+        if (entry.prefix) {
+          attrs.push({ key: "log.prefix", value: { stringValue: entry.prefix } });
+        }
+        if (entry.elapsed_ms !== void 0) {
+          attrs.push({
+            key: "elapsed_ms",
+            value: Number.isInteger(entry.elapsed_ms) ? { intValue: String(entry.elapsed_ms) } : { doubleValue: entry.elapsed_ms }
+          });
+        }
+        if (entry.error) {
+          attrs.push({ key: "error.type", value: { stringValue: entry.error.type } });
+          attrs.push({ key: "error.message", value: { stringValue: entry.error.message } });
+          if (entry.error.code) {
+            attrs.push({ key: "error.code", value: { stringValue: entry.error.code } });
+          }
+          if (entry.error.error_id) {
+            attrs.push({ key: "error.id", value: { stringValue: entry.error.error_id } });
+          }
+          if (entry.error.stack) {
+            attrs.push({ key: "error.stack", value: { stringValue: entry.error.stack } });
+          }
+        }
+        if (entry.attributes) {
+          for (const [key, value] of Object.entries(entry.attributes)) {
+            if (value == null) continue;
+            if (typeof value === "string") {
+              attrs.push({ key, value: { stringValue: value } });
+            } else if (typeof value === "number") {
+              attrs.push({
+                key,
+                value: Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value }
+              });
+            } else if (typeof value === "boolean") {
+              attrs.push({ key, value: { boolValue: value } });
+            } else {
+              attrs.push({ key, value: { stringValue: JSON.stringify(value) } });
+            }
+          }
+        }
+        return record;
+      }
+    };
+  }
+});
+
+// libs/observability/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CallbackSink: () => CallbackSink,
+  ConsoleSink: () => ConsoleSink,
+  EnduserAttributes: () => EnduserAttributes,
+  FrontMcpAttributes: () => FrontMcpAttributes,
+  FrontMcpPropagator: () => FrontMcpPropagator,
+  HttpAttributes: () => HttpAttributes,
+  LOG_LEVEL_TO_OTEL_SEVERITY: () => LOG_LEVEL_TO_OTEL_SEVERITY,
+  McpAttributes: () => McpAttributes,
+  OTEL_CONFIG: () => OTEL_CONFIG,
+  OTEL_TRACER: () => OTEL_TRACER,
+  ObservabilityPlugin: () => ObservabilityPlugin,
+  OtlpSink: () => OtlpSink,
+  PinoSink: () => PinoSink,
+  PrettySpanExporter: () => PrettySpanExporter,
+  REQUEST_LOG_COLLECTOR: () => REQUEST_LOG_COLLECTOR,
+  RequestLogCollector: () => RequestLogCollector,
+  RpcAttributes: () => RpcAttributes,
+  StdoutSink: () => StdoutSink,
+  StructuredLogTransport: () => StructuredLogTransport,
+  TELEMETRY_ACCESSOR: () => TELEMETRY_ACCESSOR,
+  TelemetryAccessor: () => TelemetryAccessor,
+  TelemetrySpan: () => TelemetrySpan,
+  WinstonSink: () => WinstonSink,
+  assertSpanAttribute: () => assertSpanAttribute,
+  assertSpanExists: () => assertSpanExists,
+  createOTelContextFromTrace: () => createOTelContextFromTrace,
+  createSink: () => createSink,
+  createSinks: () => createSinks,
+  createTestTracer: () => createTestTracer,
+  emitStartupReport: () => emitStartupReport,
+  endSpanError: () => endSpanError,
+  endSpanOk: () => endSpanOk,
+  findSpan: () => findSpan,
+  findSpansByAttribute: () => findSpansByAttribute,
+  frontmcpToOTelSpanContext: () => frontmcpToOTelSpanContext,
+  getFinishedSpans: () => getFinishedSpans,
+  otelToFrontmcpContext: () => otelToFrontmcpContext,
+  recordHookEvent: () => recordHookEvent,
+  redactFields: () => redactFields,
+  reportStartup: () => reportStartup,
+  sessionTracingId: () => sessionTracingId,
+  setAuthMode: () => setAuthMode,
+  setAuthResult: () => setAuthResult,
+  setFetchResponseStatus: () => setFetchResponseStatus,
+  setHttpResponseStatus: () => setHttpResponseStatus,
+  setTransportRequestType: () => setTransportRequestType,
+  setupOTel: () => setupOTel,
+  startAuthSpan: () => startAuthSpan,
+  startFetchSpan: () => startFetchSpan,
+  startHookSpan: () => startHookSpan,
+  startHttpServerSpan: () => startHttpServerSpan,
+  startPromptSpan: () => startPromptSpan,
+  startResourceSpan: () => startResourceSpan,
+  startRpcSpan: () => startRpcSpan,
+  startSpan: () => startSpan,
+  startToolSpan: () => startToolSpan,
+  startTransportSpan: () => startTransportSpan,
+  withSpan: () => withSpan
+});
+module.exports = __toCommonJS(index_exports);
+
+// libs/observability/src/plugin/observability.plugin.ts
+var import_sdk2 = require("@frontmcp/sdk");
+var import_api14 = require("@opentelemetry/api");
+
+// libs/observability/src/otel/otel.tokens.ts
+var OTEL_TRACER = /* @__PURE__ */ Symbol.for("frontmcp:observability:otel-tracer");
+var OTEL_CONFIG = /* @__PURE__ */ Symbol.for("frontmcp:observability:otel-config");
+
+// libs/observability/src/request-log/request-log.tokens.ts
+var REQUEST_LOG_COLLECTOR = /* @__PURE__ */ Symbol.for("frontmcp:observability:request-log-collector");
+
+// libs/observability/src/request-log/request-log.collector.ts
+var RequestLogCollector = class {
+  constructor(context, options) {
+    this.entries = [];
+    this.hooksTriggered = /* @__PURE__ */ new Set();
+    this.authenticated = false;
+    this.status = "ok";
+    this.finalized = false;
+    this.requestId = context.requestId;
+    this.traceId = context.traceId;
+    this.sessionIdHash = context.sessionIdHash;
+    this.scopeId = context.scopeId;
+    this.startTime = /* @__PURE__ */ new Date();
+    this.maxEntries = options?.maxEntries ?? 500;
+    this.onComplete = options?.onRequestComplete;
+  }
+  /**
+   * Add a structured log entry to this request's log.
+   * Called by StructuredLogTransport for each log record that
+   * matches this request's requestId.
+   */
+  addEntry(entry) {
+    if (this.finalized || this.entries.length >= this.maxEntries) return;
+    const logEntry = {
+      timestamp: entry.timestamp,
+      level: entry.level,
+      message: entry.message
+    };
+    if (entry.flow_name) {
+      logEntry.stage = entry.flow_name;
+    }
+    if (entry.elapsed_ms !== void 0) {
+      logEntry.elapsed_ms = entry.elapsed_ms;
+    }
+    if (entry.attributes && Object.keys(entry.attributes).length > 0) {
+      logEntry.attributes = entry.attributes;
+    }
+    this.entries.push(logEntry);
+  }
+  /**
+   * Record a hook stage that was triggered during this request.
+   */
+  addHook(stage) {
+    this.hooksTriggered.add(stage);
+  }
+  /**
+   * Set HTTP request metadata.
+   */
+  setHttpInfo(method, path) {
+    this.httpMethod = method;
+    this.httpPath = path;
+  }
+  /**
+   * Set the MCP JSON-RPC method being invoked.
+   */
+  setRpcMethod(method) {
+    this.rpcMethod = method;
+  }
+  /**
+   * Set the tool name being invoked.
+   */
+  setToolName(name) {
+    this.toolName = name;
+  }
+  /**
+   * Set the resource URI being read.
+   */
+  setResourceUri(uri) {
+    this.resourceUri = uri;
+  }
+  /**
+   * Set the prompt name being invoked.
+   */
+  setPromptName(name) {
+    this.promptName = name;
+  }
+  /**
+   * Set authentication info.
+   */
+  setAuthInfo(type, authenticated) {
+    this.authType = type;
+    this.authenticated = authenticated;
+  }
+  /**
+   * Set request status.
+   */
+  setStatus(status, statusCode) {
+    this.status = status;
+    this.statusCode = statusCode;
+  }
+  /**
+   * Set error details.
+   */
+  setError(error) {
+    this.error = error;
+    this.status = "error";
+  }
+  /**
+   * Finalize and produce the complete RequestLog.
+   * Fires the onRequestComplete callback if configured.
+   */
+  async finalize() {
+    if (this.finalized) {
+      return this.finalizedLog;
+    }
+    this.finalized = true;
+    const log = this.toRequestLog();
+    this.finalizedLog = log;
+    if (this.onComplete) {
+      try {
+        await this.onComplete(log);
+      } catch {
+      }
+    }
+    return log;
+  }
+  /**
+   * Build the RequestLog object from accumulated state.
+   */
+  toRequestLog() {
+    const endTime = /* @__PURE__ */ new Date();
+    return {
+      request_id: this.requestId,
+      trace_id: this.traceId,
+      session_id_hash: this.sessionIdHash,
+      scope_id: this.scopeId,
+      start_time: this.startTime.toISOString(),
+      end_time: endTime.toISOString(),
+      duration_ms: endTime.getTime() - this.startTime.getTime(),
+      http_method: this.httpMethod,
+      http_path: this.httpPath,
+      rpc_method: this.rpcMethod,
+      tool_name: this.toolName,
+      resource_uri: this.resourceUri,
+      prompt_name: this.promptName,
+      auth_type: this.authType,
+      authenticated: this.authenticated,
+      status: this.status,
+      status_code: this.statusCode,
+      error: this.error,
+      hooks_triggered: Array.from(this.hooksTriggered),
+      entries: [...this.entries]
+    };
+  }
+  /**
+   * Check if the collector has been finalized.
+   */
+  isFinalized() {
+    return this.finalized;
+  }
+  /**
+   * Get the number of accumulated entries.
+   */
+  getEntryCount() {
+    return this.entries.length;
+  }
+};
+
+// libs/observability/src/logging/structured-log-transport.ts
+var import_sdk = require("@frontmcp/sdk");
+
+// libs/observability/src/logging/structured-log.types.ts
+var LOG_LEVEL_TO_OTEL_SEVERITY = {
+  debug: 5,
+  // DEBUG
+  verbose: 6,
+  // DEBUG2
+  info: 9,
+  // INFO
+  warn: 13,
+  // WARN
+  error: 17
+  // ERROR
+};
+
+// libs/observability/src/logging/redaction.ts
+var REDACTED = "[REDACTED]";
+function redactFields(obj, fields, maxDepth = 5) {
+  if (fields.length === 0) return obj;
+  const lowerFields = new Set(fields.map((f) => f.toLowerCase()));
+  return redactRecursive(obj, lowerFields, 0, maxDepth);
+}
+function redactRecursive(obj, fields, depth, maxDepth) {
+  if (depth >= maxDepth) return obj;
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (fields.has(key.toLowerCase())) {
+      result[key] = REDACTED;
+    } else if (isPlainObject(value)) {
+      result[key] = redactRecursive(value, fields, depth + 1, maxDepth);
+    } else if (Array.isArray(value)) {
+      result[key] = value.map(
+        (item) => isPlainObject(item) ? redactRecursive(item, fields, depth + 1, maxDepth) : item
+      );
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+// libs/observability/src/logging/structured-log-transport.ts
+var StructuredLogTransport = class extends import_sdk.LogTransportInterface {
+  constructor(sinks, options, contextAccessor) {
+    super();
+    this.sinks = sinks;
+    this.redactFieldNames = options?.redactFields ?? [];
+    this.includeStacks = options?.includeStacks ?? true;
+    this.staticFields = options?.staticFields ?? {};
+    this.getContext = contextAccessor;
+  }
+  log(rec) {
+    const entry = this.buildEntry(rec);
+    if (this.onEntry) {
+      try {
+        this.onEntry(entry);
+      } catch {
+      }
+    }
+    for (const sink of this.sinks) {
+      try {
+        sink.write(entry);
+      } catch {
+      }
+    }
+  }
+  buildEntry(rec) {
+    const levelName = import_sdk.LogLevelName[rec.level] ?? "info";
+    const entry = {
+      ...this.staticFields,
+      timestamp: rec.timestamp.toISOString(),
+      level: levelName,
+      severity_number: LOG_LEVEL_TO_OTEL_SEVERITY[levelName] ?? 9,
+      message: String(rec.message)
+    };
+    if (rec.prefix) {
+      entry.prefix = rec.prefix;
+    }
+    const ctx = this.getContext?.();
+    if (ctx) {
+      entry.trace_id = ctx.traceContext.traceId;
+      entry.span_id = ctx.traceContext.parentId;
+      entry.trace_flags = ctx.traceContext.traceFlags;
+      entry.request_id = ctx.requestId;
+      entry.session_id_hash = ctx.sessionIdHash;
+      entry.scope_id = ctx.scopeId;
+      if (ctx.flowName) {
+        entry.flow_name = ctx.flowName;
+      }
+      entry.elapsed_ms = ctx.elapsed;
+    }
+    this.processArgs(rec.args, entry);
+    return entry;
+  }
+  processArgs(args, entry) {
+    const attributes = {};
+    let hasAttributes = false;
+    for (const arg of args) {
+      if (arg instanceof Error) {
+        entry.error = this.buildError(arg);
+      } else if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
+        const obj = arg;
+        const redacted = this.redactFieldNames.length > 0 ? redactFields(obj, this.redactFieldNames) : obj;
+        Object.assign(attributes, redacted);
+        hasAttributes = true;
+      }
+    }
+    if (hasAttributes) {
+      entry.attributes = attributes;
+    }
+  }
+  buildError(err) {
+    const result = {
+      type: err.constructor.name,
+      message: err.message
+    };
+    if ("code" in err && typeof err.code === "number") {
+      result.code = String(err.code);
+    }
+    if ("errorId" in err && typeof err.errorId === "string") {
+      result.error_id = err.errorId;
+    }
+    if (this.includeStacks && err.stack) {
+      result.stack = err.stack;
+    }
+    return result;
+  }
+};
+StructuredLogTransport = __decorateClass([
+  (0, import_sdk.LogTransport)({
+    name: "StructuredLogTransport",
+    description: "Produces structured log objects and forwards to configurable sinks"
+  })
+], StructuredLogTransport);
+
+// libs/observability/src/logging/sinks/stdout.sink.ts
+var StdoutSink = class {
+  constructor(options) {
+    this.stream = options?.stream ?? process.stdout;
+    this.pretty = options?.pretty ?? false;
+  }
+  write(entry) {
+    const line = this.pretty ? JSON.stringify(entry, null, 2) : JSON.stringify(entry);
+    this.stream.write(line + "\n");
+  }
+};
+
+// libs/observability/src/logging/sinks/console.sink.ts
+var ConsoleSink = class {
+  write(entry) {
+    const method = levelToConsoleMethod(entry.level);
+    const formatted = formatEntry(entry);
+    method(formatted);
+  }
+};
+function formatEntry(entry) {
+  const useAnsi = typeof process !== "undefined" && !!process.stdout?.isTTY;
+  const ts = entry.timestamp.slice(11, 23);
+  const level = entry.level.toUpperCase().padEnd(7);
+  const traceShort = entry.trace_id ? entry.trace_id.slice(0, 8) : "";
+  const reqShort = entry.request_id ? entry.request_id.slice(0, 8) : "";
+  const parts = [];
+  const DIM2 = useAnsi ? "\x1B[2m" : "";
+  const BOLD2 = useAnsi ? "\x1B[1m" : "";
+  const RESET2 = useAnsi ? "\x1B[0m" : "";
+  const levelColor = useAnsi ? LEVEL_COLORS[entry.level] ?? "" : "";
+  parts.push(`${DIM2}[${ts}]${RESET2}`);
+  parts.push(`${BOLD2}${levelColor}${level}${RESET2}`);
+  if (traceShort || reqShort) {
+    parts.push(`${DIM2}[${traceShort}${reqShort ? ":" + reqShort : ""}]${RESET2}`);
+  }
+  if (entry.prefix) parts.push(`${DIM2}[${entry.prefix}]${RESET2}`);
+  parts.push(entry.message);
+  if (entry.attributes && Object.keys(entry.attributes).length > 0) {
+    const attrs = Object.entries(entry.attributes).map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
+    parts.push(`${DIM2}{ ${attrs} }${RESET2}`);
+  }
+  if (entry.error) {
+    parts.push(`[${entry.error.type}: ${entry.error.message}]`);
+  }
+  if (entry.elapsed_ms !== void 0) {
+    parts.push(`${DIM2}(${entry.elapsed_ms}ms)${RESET2}`);
+  }
+  return parts.join(" ");
+}
+var LEVEL_COLORS = {
+  debug: "\x1B[34m",
+  verbose: "\x1B[90m",
+  info: "\x1B[32m",
+  warn: "\x1B[33m",
+  error: "\x1B[31m"
+};
+function levelToConsoleMethod(level) {
+  switch (level) {
+    case "debug":
+    case "verbose":
+      return console.debug;
+    case "info":
+      return console.info;
+    case "warn":
+      return console.warn;
+    case "error":
+      return console.error;
+    default:
+      return console.log;
+  }
+}
+
+// libs/observability/src/logging/sinks/callback.sink.ts
+var CallbackSink = class {
+  constructor(fn) {
+    this.fn = fn;
+  }
+  write(entry) {
+    this.fn(entry);
+  }
+};
+
+// libs/observability/src/logging/sink.factory.ts
+function createSink(config) {
+  switch (config.type) {
+    case "stdout":
+      return new StdoutSink({ stream: config.stream, pretty: config.pretty });
+    case "console":
+      return new ConsoleSink();
+    case "winston": {
+      const { WinstonSink: WinstonSink2 } = (init_winston_sink(), __toCommonJS(winston_sink_exports));
+      return new WinstonSink2(config.logger);
+    }
+    case "pino": {
+      const { PinoSink: PinoSink2 } = (init_pino_sink(), __toCommonJS(pino_sink_exports));
+      return new PinoSink2(config.logger);
+    }
+    case "callback":
+      return new CallbackSink(config.fn);
+    case "otlp": {
+      const { OtlpSink: OtlpSink2 } = (init_otlp_sink(), __toCommonJS(otlp_sink_exports));
+      return new OtlpSink2({
+        endpoint: config.endpoint ?? (typeof process !== "undefined" ? process.env?.["OTEL_EXPORTER_OTLP_ENDPOINT"] : void 0) ?? "http://localhost:4318",
+        headers: config.headers,
+        batchSize: config.batchSize,
+        flushIntervalMs: config.flushIntervalMs,
+        serviceName: config.serviceName
+      });
+    }
+    default:
+      throw new Error(`Unknown sink type: ${config.type}`);
+  }
+}
+function createSinks(configs) {
+  if (configs && configs.length > 0) {
+    return configs.map(createSink);
+  }
+  return [];
+}
+
+// libs/observability/src/telemetry/telemetry.accessor.ts
+var import_api13 = require("@opentelemetry/api");
+
+// libs/observability/src/otel/trace-context-bridge.ts
+var import_api = require("@opentelemetry/api");
+function frontmcpToOTelSpanContext(tc) {
+  return {
+    traceId: tc.traceId,
+    spanId: tc.parentId,
+    traceFlags: tc.traceFlags & import_api.TraceFlags.SAMPLED ? import_api.TraceFlags.SAMPLED : import_api.TraceFlags.NONE,
+    isRemote: true
+  };
+}
+function otelToFrontmcpContext(sc) {
+  const flags = sc.traceFlags.toString(16).padStart(2, "0");
+  return {
+    traceId: sc.traceId,
+    parentId: sc.spanId,
+    traceFlags: sc.traceFlags,
+    raw: `00-${sc.traceId}-${sc.spanId}-${flags}`
+  };
+}
+function createOTelContextFromTrace(tc) {
+  const spanContext = frontmcpToOTelSpanContext(tc);
+  const span = import_api.trace.wrapSpanContext(spanContext);
+  return import_api.trace.setSpan(import_api.context.active(), span);
+}
+
+// libs/observability/src/plugin/observability.hooks.ts
+var import_utils = require("@frontmcp/utils");
+var import_api12 = require("@opentelemetry/api");
+
+// libs/observability/src/otel/spans/http-server.span.ts
+var import_api3 = require("@opentelemetry/api");
+
+// libs/observability/src/otel/otel.types.ts
+var McpAttributes = {
+  /** MCP protocol method name (e.g., "tools/call", "resources/read") */
+  METHOD_NAME: "mcp.method.name",
+  /** MCP session identifier (hashed for privacy) */
+  SESSION_ID: "mcp.session.id",
+  /** MCP resource URI */
+  RESOURCE_URI: "mcp.resource.uri",
+  /** MCP component type: "tool" | "resource" | "prompt" | "resource_template" */
+  COMPONENT_TYPE: "mcp.component.type",
+  /** MCP component key (e.g., "tool:get_weather", "resource:config://db") */
+  COMPONENT_KEY: "mcp.component.key"
+};
+var FrontMcpAttributes = {
+  /** Scope identifier */
+  SCOPE_ID: "frontmcp.scope.id",
+  /** Server/scope name */
+  SERVER_NAME: "frontmcp.server.name",
+  /** Tool name being executed */
+  TOOL_NAME: "frontmcp.tool.name",
+  /** Tool owner class name */
+  TOOL_OWNER: "frontmcp.tool.owner",
+  /** Resource URI being read */
+  RESOURCE_URI: "frontmcp.resource.uri",
+  /** Resource name */
+  RESOURCE_NAME: "frontmcp.resource.name",
+  /** Prompt name being invoked */
+  PROMPT_NAME: "frontmcp.prompt.name",
+  /** Flow name (e.g., "tools:call-tool") */
+  FLOW_NAME: "frontmcp.flow.name",
+  /** Flow stage (e.g., "willExecute") */
+  FLOW_STAGE: "frontmcp.flow.stage",
+  /** Hook stage (e.g., "willValidateInput") */
+  HOOK_STAGE: "frontmcp.hook.stage",
+  /** Hook owner identifier */
+  HOOK_OWNER: "frontmcp.hook.owner",
+  /** Hashed session ID (for trace correlation, not the real session ID) */
+  SESSION_ID_HASH: "frontmcp.session.id_hash",
+  /** Authentication type */
+  AUTH_TYPE: "frontmcp.auth.type",
+  /** Request identifier */
+  REQUEST_ID: "frontmcp.request.id",
+  /** Provider type (e.g., "local", "adapter", "remote") */
+  PROVIDER_TYPE: "frontmcp.provider.type",
+  /** Delegation — original name before namespacing */
+  DELEGATE_ORIGINAL_NAME: "frontmcp.delegate.original_name",
+  // ── Transport ──
+  /** Transport type: "legacy-sse" | "streamable-http" | "stateless-http" */
+  TRANSPORT_TYPE: "frontmcp.transport.type",
+  /** Transport request type: "initialize" | "message" | "elicitResult" | "sseListener" | "extApps" */
+  TRANSPORT_REQUEST_TYPE: "frontmcp.transport.request_type",
+  /** Session protocol */
+  SESSION_PROTOCOL: "frontmcp.session.protocol",
+  /** Whether a new session was created */
+  SESSION_CREATED: "frontmcp.session.created",
+  // ── Auth ──
+  /** Auth mode: "public" | "transparent" | "orchestrated" */
+  AUTH_MODE: "frontmcp.auth.mode",
+  /** Auth result: "authorized" | "unauthorized" | "anonymous" */
+  AUTH_RESULT: "frontmcp.auth.result",
+  // ── OAuth ──
+  /** OAuth grant type: "authorization_code" | "refresh_token" | "anonymous" */
+  OAUTH_GRANT_TYPE: "frontmcp.oauth.grant_type",
+  // ── Elicitation ──
+  /** Elicitation request ID */
+  ELICITATION_ID: "frontmcp.elicitation.id",
+  // ── Agent ──
+  /** Agent name */
+  AGENT_NAME: "frontmcp.agent.name",
+  /** Agent execution loop iterations */
+  AGENT_ITERATIONS: "frontmcp.agent.iterations",
+  /** Agent execution duration in ms */
+  AGENT_EXECUTION_DURATION_MS: "frontmcp.agent.execution_duration_ms",
+  // ── Startup ──
+  /** Total tools registered at startup */
+  STARTUP_TOOLS_COUNT: "frontmcp.startup.tools_count",
+  /** Total resources registered at startup */
+  STARTUP_RESOURCES_COUNT: "frontmcp.startup.resources_count",
+  /** Total prompts registered at startup */
+  STARTUP_PROMPTS_COUNT: "frontmcp.startup.prompts_count",
+  /** Total plugins loaded at startup */
+  STARTUP_PLUGINS_COUNT: "frontmcp.startup.plugins_count",
+  /** Startup initialization duration in ms */
+  STARTUP_DURATION_MS: "frontmcp.startup.duration_ms"
+};
+var HttpAttributes = {
+  METHOD: "http.request.method",
+  STATUS_CODE: "http.response.status_code",
+  URL_PATH: "url.path",
+  URL_FULL: "url.full",
+  URL_SCHEME: "url.scheme",
+  SERVER_ADDRESS: "server.address",
+  SERVER_PORT: "server.port"
+};
+var RpcAttributes = {
+  /** RPC system — "mcp" for MCP protocol */
+  SYSTEM: "rpc.system",
+  /** RPC service name */
+  SERVICE: "rpc.service",
+  /** RPC method */
+  METHOD: "rpc.method",
+  /** JSON-RPC version */
+  JSONRPC_VERSION: "rpc.jsonrpc.version",
+  /** JSON-RPC request ID */
+  JSONRPC_REQUEST_ID: "rpc.jsonrpc.request_id"
+};
+var EnduserAttributes = {
+  /** Client/user ID from auth token */
+  ID: "enduser.id",
+  /** OAuth scopes (space-separated) */
+  SCOPE: "enduser.scope"
+};
+
+// libs/observability/src/otel/spans/span.utils.ts
+var import_api2 = require("@opentelemetry/api");
+function startSpan(tracer, options) {
+  const parentCtx = options.parentContext ?? import_api2.context.active();
+  const span = tracer.startSpan(
+    options.name,
+    {
+      kind: options.kind ?? import_api2.SpanKind.INTERNAL,
+      attributes: options.attributes
+    },
+    parentCtx
+  );
+  const spanContext = import_api2.trace.setSpan(parentCtx, span);
+  return { span, context: spanContext };
+}
+function endSpanOk(span) {
+  span.setStatus({ code: import_api2.SpanStatusCode.OK });
+  span.end();
+}
+function endSpanError(span, error) {
+  const message = typeof error === "string" ? error : error.message;
+  span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message });
+  if (error instanceof Error) {
+    span.recordException(error);
+  }
+  span.end();
+}
+async function withSpan(tracer, options, fn) {
+  const { span, context: spanContext } = startSpan(tracer, options);
+  return import_api2.context.with(spanContext, async () => {
+    try {
+      const result = await fn(span);
+      endSpanOk(span);
+      return result;
+    } catch (err) {
+      endSpanError(span, err instanceof Error ? err : String(err));
+      throw err;
+    }
+  });
+}
+
+// libs/observability/src/otel/spans/http-server.span.ts
+function startHttpServerSpan(tracer, options) {
+  const attributes = {
+    [HttpAttributes.METHOD]: options.method.toUpperCase(),
+    [HttpAttributes.URL_PATH]: options.path
+  };
+  if (options.scheme) {
+    attributes[HttpAttributes.URL_SCHEME] = options.scheme;
+  }
+  if (options.serverAddress) {
+    attributes[HttpAttributes.SERVER_ADDRESS] = options.serverAddress;
+  }
+  if (options.serverPort) {
+    attributes[HttpAttributes.SERVER_PORT] = options.serverPort;
+  }
+  if (options.scopeId) {
+    attributes[FrontMcpAttributes.SCOPE_ID] = options.scopeId;
+  }
+  if (options.requestId) {
+    attributes[FrontMcpAttributes.REQUEST_ID] = options.requestId;
+  }
+  return startSpan(tracer, {
+    name: `${options.method.toUpperCase()} ${options.path}`,
+    kind: import_api3.SpanKind.SERVER,
+    attributes,
+    parentContext: options.parentContext
+  });
+}
+function setHttpResponseStatus(span, statusCode) {
+  span.setAttribute(HttpAttributes.STATUS_CODE, statusCode);
+}
+
+// libs/observability/src/otel/spans/rpc.span.ts
+var import_api4 = require("@opentelemetry/api");
+function startRpcSpan(tracer, options) {
+  const attributes = {
+    [RpcAttributes.SYSTEM]: "mcp",
+    [RpcAttributes.METHOD]: options.method,
+    [RpcAttributes.JSONRPC_VERSION]: "2.0",
+    [McpAttributes.METHOD_NAME]: options.method
+  };
+  if (options.requestId !== void 0) {
+    attributes[RpcAttributes.JSONRPC_REQUEST_ID] = String(options.requestId);
+  }
+  if (options.scopeId) {
+    attributes[FrontMcpAttributes.SCOPE_ID] = options.scopeId;
+  }
+  if (options.serviceName) {
+    attributes[RpcAttributes.SERVICE] = options.serviceName;
+    attributes[FrontMcpAttributes.SERVER_NAME] = options.serviceName;
+  }
+  if (options.sessionIdHash) {
+    attributes[McpAttributes.SESSION_ID] = options.sessionIdHash;
+    attributes[FrontMcpAttributes.SESSION_ID_HASH] = options.sessionIdHash;
+  }
+  return startSpan(tracer, {
+    name: options.method,
+    kind: import_api4.SpanKind.SERVER,
+    attributes,
+    parentContext: options.parentContext
+  });
+}
+
+// libs/observability/src/otel/spans/tool.span.ts
+var import_api5 = require("@opentelemetry/api");
+function startToolSpan(tracer, options) {
+  const attributes = {
+    [FrontMcpAttributes.TOOL_NAME]: options.name,
+    [McpAttributes.COMPONENT_TYPE]: "tool",
+    [McpAttributes.COMPONENT_KEY]: `tool:${options.name}`
+  };
+  if (options.owner) {
+    attributes[FrontMcpAttributes.TOOL_OWNER] = options.owner;
+  }
+  if (options.enduserId) {
+    attributes[EnduserAttributes.ID] = options.enduserId;
+  }
+  if (options.enduserScope) {
+    attributes[EnduserAttributes.SCOPE] = options.enduserScope;
+  }
+  return startSpan(tracer, {
+    name: `tool ${options.name}`,
+    kind: import_api5.SpanKind.INTERNAL,
+    attributes,
+    parentContext: options.parentContext
+  });
+}
+
+// libs/observability/src/otel/spans/resource.span.ts
+var import_api6 = require("@opentelemetry/api");
+function startResourceSpan(tracer, options) {
+  const attributes = {
+    [FrontMcpAttributes.RESOURCE_URI]: options.uri,
+    [McpAttributes.RESOURCE_URI]: options.uri,
+    [McpAttributes.COMPONENT_TYPE]: "resource",
+    [McpAttributes.COMPONENT_KEY]: `resource:${options.uri}`
+  };
+  if (options.name) {
+    attributes[FrontMcpAttributes.RESOURCE_NAME] = options.name;
+  }
+  return startSpan(tracer, {
+    name: `resource ${options.uri}`,
+    kind: import_api6.SpanKind.INTERNAL,
+    attributes,
+    parentContext: options.parentContext
+  });
+}
+
+// libs/observability/src/otel/spans/prompt.span.ts
+var import_api7 = require("@opentelemetry/api");
+function startPromptSpan(tracer, options) {
+  return startSpan(tracer, {
+    name: `prompt ${options.name}`,
+    kind: import_api7.SpanKind.INTERNAL,
+    attributes: {
+      [FrontMcpAttributes.PROMPT_NAME]: options.name,
+      [McpAttributes.COMPONENT_TYPE]: "prompt",
+      [McpAttributes.COMPONENT_KEY]: `prompt:${options.name}`
+    },
+    parentContext: options.parentContext
+  });
+}
+
+// libs/observability/src/otel/spans/transport.span.ts
+var import_api8 = require("@opentelemetry/api");
+function startTransportSpan(tracer, options) {
+  const attributes = {
+    [FrontMcpAttributes.TRANSPORT_TYPE]: options.type
+  };
+  if (options.sessionIdHash) {
+    attributes[FrontMcpAttributes.SESSION_ID_HASH] = options.sessionIdHash;
+  }
+  if (options.sessionCreated !== void 0) {
+    attributes[FrontMcpAttributes.SESSION_CREATED] = options.sessionCreated;
+  }
+  return startSpan(tracer, {
+    name: `transport ${options.type}`,
+    kind: import_api8.SpanKind.INTERNAL,
+    attributes,
+    parentContext: options.parentContext
+  });
+}
+function setTransportRequestType(span, requestType) {
+  span.setAttribute(FrontMcpAttributes.TRANSPORT_REQUEST_TYPE, requestType);
+}
+
+// libs/observability/src/otel/spans/auth.span.ts
+var import_api9 = require("@opentelemetry/api");
+function startAuthSpan(tracer, options) {
+  return startSpan(tracer, {
+    name: `auth ${options.flowName}`,
+    kind: import_api9.SpanKind.INTERNAL,
+    attributes: {
+      [FrontMcpAttributes.FLOW_NAME]: options.flowName
+    },
+    parentContext: options.parentContext
+  });
+}
+function setAuthMode(span, mode) {
+  span.setAttribute(FrontMcpAttributes.AUTH_MODE, mode);
+}
+function setAuthResult(span, result) {
+  span.setAttribute(FrontMcpAttributes.AUTH_RESULT, result);
+}
+
+// libs/observability/src/otel/spans/fetch.span.ts
+var import_api10 = require("@opentelemetry/api");
+function startFetchSpan(tracer, options) {
+  return startSpan(tracer, {
+    name: options.method.toUpperCase(),
+    kind: import_api10.SpanKind.CLIENT,
+    attributes: {
+      [HttpAttributes.METHOD]: options.method.toUpperCase(),
+      [HttpAttributes.URL_FULL]: options.url
+    },
+    parentContext: options.parentContext
+  });
+}
+function setFetchResponseStatus(span, statusCode) {
+  span.setAttribute(HttpAttributes.STATUS_CODE, statusCode);
+}
+
+// libs/observability/src/otel/spans/startup.span.ts
+var import_api11 = require("@opentelemetry/api");
+function emitStartupReport(tracer, data) {
+  const attributes = {
+    [FrontMcpAttributes.STARTUP_TOOLS_COUNT]: data.toolsCount,
+    [FrontMcpAttributes.STARTUP_RESOURCES_COUNT]: data.resourcesCount,
+    [FrontMcpAttributes.STARTUP_PROMPTS_COUNT]: data.promptsCount,
+    [FrontMcpAttributes.STARTUP_PLUGINS_COUNT]: data.pluginsCount,
+    [FrontMcpAttributes.STARTUP_DURATION_MS]: data.durationMs
+  };
+  if (data.scopeId) {
+    attributes[FrontMcpAttributes.SCOPE_ID] = data.scopeId;
+  }
+  const { span } = startSpan(tracer, {
+    name: "frontmcp.startup",
+    kind: import_api11.SpanKind.INTERNAL,
+    attributes
+  });
+  endSpanOk(span);
+}
+
+// libs/observability/src/plugin/observability.hooks.ts
+var SPAN_KEY = /* @__PURE__ */ Symbol.for("frontmcp:otel:span");
+var SPAN_CTX_KEY = /* @__PURE__ */ Symbol.for("frontmcp:otel:span-ctx");
+var EXEC_SPAN_KEY = /* @__PURE__ */ Symbol.for("frontmcp:otel:exec-span");
+var ACTIVE_SPAN_KEY = /* @__PURE__ */ Symbol.for("frontmcp:otel:active-span");
+var ACTIVE_OTEL_CTX_KEY = /* @__PURE__ */ Symbol.for("frontmcp:otel:active-otel-ctx");
+var STAGE_TS_KEY = /* @__PURE__ */ Symbol.for("frontmcp:otel:stage-ts");
+function sessionTracingId(sessionId) {
+  return (0, import_utils.sha256Hex)(sessionId).slice(0, 16);
+}
+function getTracer() {
+  return import_api12.trace.getTracer("@frontmcp/observability");
+}
+function extractContext(flowCtx) {
+  try {
+    const ctx = flowCtx.get?.(/* @__PURE__ */ Symbol.for("frontmcp:CONTEXT"));
+    if (ctx) return ctx;
+  } catch {
+  }
+  return flowCtx.state?.ctx ?? flowCtx.state?.frontmcpContext;
+}
+function storeActiveSpan(flowCtx, span, otelCtx) {
+  try {
+    const ctx = flowCtx.get?.(/* @__PURE__ */ Symbol.for("frontmcp:CONTEXT"));
+    if (ctx && typeof ctx.set === "function") {
+      ctx.set(ACTIVE_SPAN_KEY, span);
+      ctx.set(ACTIVE_OTEL_CTX_KEY, otelCtx);
+    }
+  } catch {
+  }
+}
+function clearActiveSpan(flowCtx) {
+  try {
+    const ctx = flowCtx.get?.(/* @__PURE__ */ Symbol.for("frontmcp:CONTEXT"));
+    if (ctx && typeof ctx.delete === "function") {
+      ctx.delete(ACTIVE_SPAN_KEY);
+      ctx.delete(ACTIVE_OTEL_CTX_KEY);
+    }
+  } catch {
+  }
+}
+function recordStageEvent(span, stageName, state) {
+  const now = Date.now();
+  const prev = state[STAGE_TS_KEY];
+  const attributes = {};
+  if (prev) {
+    attributes["duration_ms"] = now - prev;
+  }
+  state[STAGE_TS_KEY] = now;
+  span.addEvent(`stage.${stageName}`, attributes);
+}
+function onHttpWillTrace(options, flowCtx) {
+  if (options.httpSpans === false) return;
+  const ctx = extractContext(flowCtx);
+  if (!ctx) return;
+  const tracer = getTracer();
+  const parentOTelCtx = createOTelContextFromTrace(ctx.traceContext);
+  const sessionHash = sessionTracingId(ctx.sessionId);
+  const { span, context: spanCtx } = startHttpServerSpan(tracer, {
+    method: ctx.metadata?.customHeaders?.["x-http-method"] ?? "POST",
+    path: ctx.metadata?.customHeaders?.["x-url-path"] ?? "/",
+    scopeId: ctx.scopeId,
+    requestId: ctx.requestId,
+    parentContext: parentOTelCtx
+  });
+  span.setAttribute(McpAttributes.SESSION_ID, sessionHash);
+  span.setAttribute(FrontMcpAttributes.SESSION_ID_HASH, sessionHash);
+  flowCtx.state[SPAN_KEY] = span;
+  flowCtx.state[SPAN_CTX_KEY] = spanCtx;
+  flowCtx.state[STAGE_TS_KEY] = Date.now();
+  recordStageEvent(span, "traceRequest", flowCtx.state);
+}
+function onHttpWillAcquireQuota(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, "acquireQuota", flowCtx.state);
+}
+function onHttpDidAcquireQuota(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, "acquireQuota.done", flowCtx.state);
+}
+function onHttpWillCheckAuth(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, "checkAuthorization", flowCtx.state);
+}
+function onHttpDidCheckAuth(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, "checkAuthorization.done", flowCtx.state);
+}
+function onHttpWillRoute(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, "router", flowCtx.state);
+}
+function onHttpDidRoute(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, "router.done", flowCtx.state);
+}
+function onHttpDidFinalize(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (!span) return;
+  recordStageEvent(span, "finalize", flowCtx.state);
+  const statusCode = flowCtx.state?.statusCode ?? 200;
+  setHttpResponseStatus(span, statusCode);
+  if (statusCode >= 400) {
+    endSpanError(span, `HTTP ${statusCode}`);
+  } else {
+    endSpanOk(span);
+  }
+}
+function onToolWillParse(options, flowCtx) {
+  if (options.executionSpans === false) return;
+  const ctx = extractContext(flowCtx);
+  if (!ctx) return;
+  const tracer = getTracer();
+  const parentOTelCtx = createOTelContextFromTrace(ctx.traceContext);
+  const sessionHash = sessionTracingId(ctx.sessionId);
+  const { span, context: spanCtx } = startRpcSpan(tracer, {
+    method: "tools/call",
+    scopeId: ctx.scopeId,
+    sessionIdHash: sessionHash,
+    parentContext: parentOTelCtx
+  });
+  flowCtx.state[SPAN_KEY] = span;
+  flowCtx.state[SPAN_CTX_KEY] = spanCtx;
+  flowCtx.state[STAGE_TS_KEY] = Date.now();
+  recordStageEvent(span, "parseInput", flowCtx.state);
+}
+function onToolWillFindTool(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, "findTool", flowCtx.state);
+}
+function onToolWillCheckAuth(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, "checkToolAuthorization", flowCtx.state);
+}
+function onToolWillCreateContext(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, "createToolCallContext", flowCtx.state);
+}
+function onToolWillValidateInput(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, "validateInput", flowCtx.state);
+}
+function onToolWillExecute(options, flowCtx) {
+  if (options.executionSpans === false) return;
+  const ctx = extractContext(flowCtx);
+  const rpcCtx = flowCtx.state?.[SPAN_CTX_KEY];
+  const tracer = getTracer();
+  const toolName = flowCtx.state?.input?.name ?? "unknown";
+  const toolOwner = flowCtx.state?._toolOwnerId;
+  const enduser = ctx?.authInfo;
+  const { span: toolSpan, context: toolOTelCtx } = startToolSpan(tracer, {
+    name: toolName,
+    owner: toolOwner,
+    enduserId: enduser?.clientId ?? enduser?.extra?.sub,
+    enduserScope: Array.isArray(enduser?.scopes) ? enduser.scopes.join(" ") : void 0,
+    parentContext: rpcCtx
+  });
+  flowCtx.state[EXEC_SPAN_KEY] = toolSpan;
+  flowCtx.state[STAGE_TS_KEY] = Date.now();
+  recordStageEvent(toolSpan, "execute.start", flowCtx.state);
+  storeActiveSpan(flowCtx, toolSpan, toolOTelCtx);
+}
+function onToolDidExecute(options, flowCtx) {
+  const toolSpan = flowCtx.state?.[EXEC_SPAN_KEY];
+  if (!toolSpan) return;
+  recordStageEvent(toolSpan, "execute.done", flowCtx.state);
+  endSpanOk(toolSpan);
+  flowCtx.state[EXEC_SPAN_KEY] = void 0;
+  clearActiveSpan(flowCtx);
+}
+function onToolWillValidateOutput(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, "validateOutput", flowCtx.state);
+}
+function onToolWillApplyUI(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, "applyUI", flowCtx.state);
+}
+function onToolDidFinalize(flowCtx) {
+  const rpcSpan = flowCtx.state?.[SPAN_KEY];
+  const toolSpan = flowCtx.state?.[EXEC_SPAN_KEY];
+  const error = flowCtx.state?.error;
+  if (error) {
+    if (toolSpan) endSpanError(toolSpan, error instanceof Error ? error : String(error));
+    if (rpcSpan) endSpanError(rpcSpan, error instanceof Error ? error : String(error));
+  } else if (rpcSpan) {
+    recordStageEvent(rpcSpan, "finalize", flowCtx.state);
+    endSpanOk(rpcSpan);
+  }
+}
+function onResourceWillParse(options, flowCtx) {
+  if (options.executionSpans === false) return;
+  const ctx = extractContext(flowCtx);
+  if (!ctx) return;
+  const tracer = getTracer();
+  const parentOTelCtx = createOTelContextFromTrace(ctx.traceContext);
+  const sessionHash = sessionTracingId(ctx.sessionId);
+  const { span, context: spanCtx } = startRpcSpan(tracer, {
+    method: "resources/read",
+    scopeId: ctx.scopeId,
+    sessionIdHash: sessionHash,
+    parentContext: parentOTelCtx
+  });
+  flowCtx.state[SPAN_KEY] = span;
+  flowCtx.state[SPAN_CTX_KEY] = spanCtx;
+  flowCtx.state[STAGE_TS_KEY] = Date.now();
+  recordStageEvent(span, "parseInput", flowCtx.state);
+}
+function onResourceWillFind(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, "findResource", flowCtx.state);
+}
+function onResourceWillExecute(options, flowCtx) {
+  if (options.executionSpans === false) return;
+  const rpcCtx = flowCtx.state?.[SPAN_CTX_KEY];
+  const tracer = getTracer();
+  const uri = flowCtx.state?.input?.uri ?? "unknown";
+  const { span: resSpan, context: resOTelCtx } = startResourceSpan(tracer, { uri, parentContext: rpcCtx });
+  flowCtx.state[EXEC_SPAN_KEY] = resSpan;
+  flowCtx.state[STAGE_TS_KEY] = Date.now();
+  recordStageEvent(resSpan, "execute.start", flowCtx.state);
+  storeActiveSpan(flowCtx, resSpan, resOTelCtx);
+}
+function onResourceDidExecute(flowCtx) {
+  const resSpan = flowCtx.state?.[EXEC_SPAN_KEY];
+  if (!resSpan) return;
+  recordStageEvent(resSpan, "execute.done", flowCtx.state);
+  endSpanOk(resSpan);
+  flowCtx.state[EXEC_SPAN_KEY] = void 0;
+  clearActiveSpan(flowCtx);
+}
+function onResourceDidFinalize(flowCtx) {
+  const rpcSpan = flowCtx.state?.[SPAN_KEY];
+  const resSpan = flowCtx.state?.[EXEC_SPAN_KEY];
+  const error = flowCtx.state?.error;
+  if (error) {
+    if (resSpan) endSpanError(resSpan, error instanceof Error ? error : String(error));
+    if (rpcSpan) endSpanError(rpcSpan, error instanceof Error ? error : String(error));
+  } else if (rpcSpan) {
+    recordStageEvent(rpcSpan, "finalize", flowCtx.state);
+    endSpanOk(rpcSpan);
+  }
+}
+function onPromptWillParse(options, flowCtx) {
+  if (options.executionSpans === false) return;
+  const ctx = extractContext(flowCtx);
+  if (!ctx) return;
+  const tracer = getTracer();
+  const parentOTelCtx = createOTelContextFromTrace(ctx.traceContext);
+  const sessionHash = sessionTracingId(ctx.sessionId);
+  const { span, context: spanCtx } = startRpcSpan(tracer, {
+    method: "prompts/get",
+    scopeId: ctx.scopeId,
+    sessionIdHash: sessionHash,
+    parentContext: parentOTelCtx
+  });
+  flowCtx.state[SPAN_KEY] = span;
+  flowCtx.state[SPAN_CTX_KEY] = spanCtx;
+  flowCtx.state[STAGE_TS_KEY] = Date.now();
+  recordStageEvent(span, "parseInput", flowCtx.state);
+}
+function onPromptWillFind(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, "findPrompt", flowCtx.state);
+}
+function onPromptWillExecute(options, flowCtx) {
+  if (options.executionSpans === false) return;
+  const rpcCtx = flowCtx.state?.[SPAN_CTX_KEY];
+  const tracer = getTracer();
+  const promptName = flowCtx.state?.input?.name ?? "unknown";
+  const { span: promptSpan, context: promptOTelCtx } = startPromptSpan(tracer, {
+    name: promptName,
+    parentContext: rpcCtx
+  });
+  flowCtx.state[EXEC_SPAN_KEY] = promptSpan;
+  flowCtx.state[STAGE_TS_KEY] = Date.now();
+  recordStageEvent(promptSpan, "execute.start", flowCtx.state);
+  storeActiveSpan(flowCtx, promptSpan, promptOTelCtx);
+}
+function onPromptDidExecute(flowCtx) {
+  const promptSpan = flowCtx.state?.[EXEC_SPAN_KEY];
+  if (!promptSpan) return;
+  recordStageEvent(promptSpan, "execute.done", flowCtx.state);
+  endSpanOk(promptSpan);
+  flowCtx.state[EXEC_SPAN_KEY] = void 0;
+  clearActiveSpan(flowCtx);
+}
+function onPromptDidFinalize(flowCtx) {
+  const rpcSpan = flowCtx.state?.[SPAN_KEY];
+  const promptSpan = flowCtx.state?.[EXEC_SPAN_KEY];
+  const error = flowCtx.state?.error;
+  if (error) {
+    if (promptSpan) endSpanError(promptSpan, error instanceof Error ? error : String(error));
+    if (rpcSpan) endSpanError(rpcSpan, error instanceof Error ? error : String(error));
+  } else if (rpcSpan) {
+    recordStageEvent(rpcSpan, "finalize", flowCtx.state);
+    endSpanOk(rpcSpan);
+  }
+}
+function onAgentWillParse(options, flowCtx) {
+  if (options.executionSpans === false) return;
+  const ctx = extractContext(flowCtx);
+  if (!ctx) return;
+  const tracer = getTracer();
+  const parentOTelCtx = createOTelContextFromTrace(ctx.traceContext);
+  const sessionHash = sessionTracingId(ctx.sessionId);
+  const { span, context: spanCtx } = startRpcSpan(tracer, {
+    method: "agents/call",
+    scopeId: ctx.scopeId,
+    sessionIdHash: sessionHash,
+    parentContext: parentOTelCtx
+  });
+  flowCtx.state[SPAN_KEY] = span;
+  flowCtx.state[SPAN_CTX_KEY] = spanCtx;
+  flowCtx.state[STAGE_TS_KEY] = Date.now();
+  recordStageEvent(span, "parseInput", flowCtx.state);
+}
+function onAgentWillFind(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, "findAgent", flowCtx.state);
+}
+function onAgentWillExecute(options, flowCtx) {
+  if (options.executionSpans === false) return;
+  const rpcCtx = flowCtx.state?.[SPAN_CTX_KEY];
+  const tracer = getTracer();
+  const agentName = flowCtx.state?.input?.name ?? "unknown";
+  const { span: agentSpan } = startSpan(tracer, {
+    name: `agent ${agentName}`,
+    kind: import_api12.SpanKind.INTERNAL,
+    attributes: {
+      [FrontMcpAttributes.FLOW_NAME]: "agents:call-agent",
+      [McpAttributes.COMPONENT_TYPE]: "agent",
+      [McpAttributes.COMPONENT_KEY]: `agent:${agentName}`
+    },
+    parentContext: rpcCtx
+  });
+  const agentOTelCtx = import_api12.trace.setSpan(rpcCtx ?? import_api12.context.active(), agentSpan);
+  flowCtx.state[EXEC_SPAN_KEY] = agentSpan;
+  flowCtx.state[STAGE_TS_KEY] = Date.now();
+  recordStageEvent(agentSpan, "execute.start", flowCtx.state);
+  storeActiveSpan(flowCtx, agentSpan, agentOTelCtx);
+}
+function onAgentDidExecute(flowCtx) {
+  const agentSpan = flowCtx.state?.[EXEC_SPAN_KEY];
+  if (!agentSpan) return;
+  recordStageEvent(agentSpan, "execute.done", flowCtx.state);
+  endSpanOk(agentSpan);
+  flowCtx.state[EXEC_SPAN_KEY] = void 0;
+  clearActiveSpan(flowCtx);
+}
+function onAgentDidFinalize(flowCtx) {
+  const rpcSpan = flowCtx.state?.[SPAN_KEY];
+  const agentSpan = flowCtx.state?.[EXEC_SPAN_KEY];
+  const error = flowCtx.state?.error;
+  if (error) {
+    if (agentSpan) endSpanError(agentSpan, error instanceof Error ? error : String(error));
+    if (rpcSpan) endSpanError(rpcSpan, error instanceof Error ? error : String(error));
+  } else if (rpcSpan) {
+    recordStageEvent(rpcSpan, "finalize", flowCtx.state);
+    endSpanOk(rpcSpan);
+  }
+}
+function onGenericFlowWillStart(flowName, options, flowCtx) {
+  if (options.executionSpans === false) return;
+  const ctx = extractContext(flowCtx);
+  if (!ctx) return;
+  const tracer = getTracer();
+  const parentOTelCtx = createOTelContextFromTrace(ctx.traceContext);
+  const sessionHash = sessionTracingId(ctx.sessionId);
+  const { span, context: spanCtx } = startSpan(tracer, {
+    name: flowName,
+    kind: import_api12.SpanKind.INTERNAL,
+    attributes: {
+      [FrontMcpAttributes.FLOW_NAME]: flowName,
+      [McpAttributes.SESSION_ID]: sessionHash,
+      [FrontMcpAttributes.SESSION_ID_HASH]: sessionHash,
+      [FrontMcpAttributes.SCOPE_ID]: ctx.scopeId,
+      [FrontMcpAttributes.REQUEST_ID]: ctx.requestId
+    },
+    parentContext: parentOTelCtx
+  });
+  flowCtx.state[SPAN_KEY] = span;
+  flowCtx.state[SPAN_CTX_KEY] = spanCtx;
+  flowCtx.state[STAGE_TS_KEY] = Date.now();
+}
+function onGenericFlowStage(stageName, flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, stageName, flowCtx.state);
+}
+function onGenericFlowDidFinalize(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (!span) return;
+  const error = flowCtx.state?.error;
+  if (error) {
+    endSpanError(span, error instanceof Error ? error : String(error));
+  } else {
+    endSpanOk(span);
+  }
+}
+function onTransportWillStart(transportType, options, flowCtx) {
+  if (options.transportSpans === false) return;
+  const ctx = extractContext(flowCtx);
+  if (!ctx) return;
+  const tracer = getTracer();
+  const parentOTelCtx = createOTelContextFromTrace(ctx.traceContext);
+  const sessionHash = sessionTracingId(ctx.sessionId);
+  const { span, context: spanCtx } = startTransportSpan(tracer, {
+    type: transportType,
+    sessionIdHash: sessionHash,
+    parentContext: parentOTelCtx
+  });
+  flowCtx.state[SPAN_KEY] = span;
+  flowCtx.state[SPAN_CTX_KEY] = spanCtx;
+  flowCtx.state[STAGE_TS_KEY] = Date.now();
+  recordStageEvent(span, "parseInput", flowCtx.state);
+}
+function onTransportDidRoute(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (!span) return;
+  recordStageEvent(span, "router", flowCtx.state);
+  const requestType = flowCtx.state?.requestType;
+  if (requestType) setTransportRequestType(span, requestType);
+}
+function onTransportStage(stageName, flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, stageName, flowCtx.state);
+}
+function onTransportDidFinalize(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (!span) return;
+  recordStageEvent(span, "cleanup", flowCtx.state);
+  const error = flowCtx.state?.error;
+  if (error) {
+    endSpanError(span, error instanceof Error ? error : String(error));
+  } else {
+    endSpanOk(span);
+  }
+}
+function onAuthWillStart(flowName, options, flowCtx) {
+  if (options.authSpans === false) return;
+  const ctx = extractContext(flowCtx);
+  if (!ctx) return;
+  const tracer = getTracer();
+  const parentOTelCtx = createOTelContextFromTrace(ctx.traceContext);
+  const { span, context: spanCtx } = startAuthSpan(tracer, {
+    flowName,
+    parentContext: parentOTelCtx
+  });
+  flowCtx.state[SPAN_KEY] = span;
+  flowCtx.state[SPAN_CTX_KEY] = spanCtx;
+  flowCtx.state[STAGE_TS_KEY] = Date.now();
+  recordStageEvent(span, "parseInput", flowCtx.state);
+}
+function onAuthDidDetermineMode(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (!span) return;
+  recordStageEvent(span, "determineAuthMode", flowCtx.state);
+  const mode = flowCtx.state?.authMode;
+  if (mode) setAuthMode(span, mode);
+}
+function onAuthStage(stageName, flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (span) recordStageEvent(span, stageName, flowCtx.state);
+}
+function onAuthDidFinalize(flowCtx) {
+  const span = flowCtx.state?.[SPAN_KEY];
+  if (!span) return;
+  const error = flowCtx.state?.error;
+  if (error) {
+    setAuthResult(span, "unauthorized");
+    endSpanError(span, error instanceof Error ? error : String(error));
+  } else {
+    setAuthResult(span, "authorized");
+    endSpanOk(span);
+  }
+}
+function wrapContextFetch(options, flowCtx) {
+  if (options.fetchSpans === false) return;
+  const toolCtx = flowCtx.state?.toolContext ?? flowCtx.state?.toolCallContext;
+  if (!toolCtx || typeof toolCtx.fetch !== "function") return;
+  const originalFetch = toolCtx.fetch.bind(toolCtx);
+  const parentOTelCtx = flowCtx.state?.[SPAN_CTX_KEY];
+  toolCtx.fetch = async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const method = init?.method ?? "GET";
+    const tracer = getTracer();
+    const { span } = startFetchSpan(tracer, { method, url, parentContext: parentOTelCtx });
+    try {
+      const response = await originalFetch(input, init);
+      setFetchResponseStatus(span, response.status);
+      endSpanOk(span);
+      return response;
+    } catch (err) {
+      endSpanError(span, err instanceof Error ? err : String(err));
+      throw err;
+    }
+  };
+}
+function onAgentDidExecuteEnrich(flowCtx) {
+  const agentSpan = flowCtx.state?.[EXEC_SPAN_KEY];
+  if (!agentSpan) return;
+  const meta = flowCtx.state?.executionMeta;
+  if (meta) {
+    if (typeof meta.iterations === "number") {
+      agentSpan.setAttribute(FrontMcpAttributes.AGENT_ITERATIONS, meta.iterations);
+    }
+    if (typeof meta.durationMs === "number") {
+      agentSpan.setAttribute(FrontMcpAttributes.AGENT_EXECUTION_DURATION_MS, meta.durationMs);
+    }
+  }
+}
+function reportStartup(data) {
+  const tracer = getTracer();
+  emitStartupReport(tracer, data);
+}
+
+// libs/observability/src/telemetry/telemetry.accessor.ts
+var TelemetrySpan = class {
+  constructor(span) {
+    this.span = span;
+    this.hasError = false;
+  }
+  /** Set a string/number/boolean attribute */
+  setAttribute(key, value) {
+    this.span.setAttribute(key, value);
+    return this;
+  }
+  /** Set multiple attributes at once */
+  setAttributes(attrs) {
+    this.span.setAttributes(attrs);
+    return this;
+  }
+  /** Add a named event (with optional attributes) */
+  addEvent(name, attributes) {
+    this.span.addEvent(name, attributes);
+    return this;
+  }
+  /** Record an error on this span */
+  recordError(error) {
+    this.span.recordException(error);
+    this.span.setStatus({ code: import_api13.SpanStatusCode.ERROR, message: error.message });
+    this.hasError = true;
+    return this;
+  }
+  /** End the span (preserves ERROR status if already set) */
+  end() {
+    if (!this.hasError) {
+      this.span.setStatus({ code: import_api13.SpanStatusCode.OK });
+    }
+    this.span.end();
+  }
+  /** End the span with error */
+  endWithError(error) {
+    const msg = typeof error === "string" ? error : error.message;
+    if (error instanceof Error) this.span.recordException(error);
+    this.span.setStatus({ code: import_api13.SpanStatusCode.ERROR, message: msg });
+    this.span.end();
+  }
+  /** Get the underlying OTel span (escape hatch) */
+  get raw() {
+    return this.span;
+  }
+};
+var TelemetryAccessor = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.tracer = import_api13.trace.getTracer("@frontmcp/observability");
+    this.fallbackContext = createOTelContextFromTrace(ctx.traceContext);
+    this.sessionHash = sessionTracingId(ctx.sessionId);
+    this.baseAttributes = {
+      [FrontMcpAttributes.REQUEST_ID]: ctx.requestId,
+      [FrontMcpAttributes.SCOPE_ID]: ctx.scopeId,
+      [McpAttributes.SESSION_ID]: this.sessionHash
+    };
+  }
+  /**
+   * Get the active OTel context — prefers the execution span's context
+   * (set by hooks during willExecute), falls back to the request-level trace.
+   */
+  getActiveContext() {
+    const otelCtx = this.ctx.get?.(ACTIVE_OTEL_CTX_KEY);
+    return otelCtx ?? this.fallbackContext;
+  }
+  /**
+   * Get the active execution span (set by auto-instrumentation hooks).
+   * Returns undefined if not inside an instrumented execution stage.
+   */
+  getActiveSpan() {
+    return this.ctx.get?.(ACTIVE_SPAN_KEY);
+  }
+  /**
+   * Start a new child span under the current execution span.
+   *
+   * If called inside a tool's execute(), the span is a child of
+   * the tool execution span. Otherwise falls back to the request trace.
+   *
+   * You MUST call `span.end()` or `span.endWithError()` when done.
+   */
+  startSpan(name, attributes) {
+    const span = this.tracer.startSpan(
+      name,
+      {
+        kind: import_api13.SpanKind.INTERNAL,
+        attributes: { ...this.baseAttributes, ...attributes }
+      },
+      this.getActiveContext()
+    );
+    return new TelemetrySpan(span);
+  }
+  /**
+   * Run a function within a child span. Automatically ended on
+   * success (OK) or error (ERROR + exception recorded).
+   *
+   * @example
+   * ```typescript
+   * const data = await this.telemetry.withSpan('fetch-api', async (span) => {
+   *   span.addEvent('request-sent');
+   *   const res = await this.fetch(url);
+   *   span.setAttribute('status', res.status);
+   *   return res.json();
+   * });
+   * ```
+   */
+  async withSpan(name, fn, attributes) {
+    const telemetrySpan = this.startSpan(name, attributes);
+    try {
+      const result = await fn(telemetrySpan);
+      telemetrySpan.end();
+      return result;
+    } catch (err) {
+      telemetrySpan.endWithError(err instanceof Error ? err : String(err));
+      throw err;
+    }
+  }
+  /**
+   * Add an event to the **active flow execution span**.
+   *
+   * If called inside a tool's execute(), the event appears on the
+   * tool execution span. If no active span exists, creates a
+   * lightweight child span carrying the event.
+   *
+   * @param name — event name (e.g., 'validation-complete', 'cache-hit')
+   * @param attributes — optional event attributes
+   */
+  addEvent(name, attributes) {
+    const activeSpan = this.getActiveSpan();
+    if (activeSpan) {
+      activeSpan.addEvent(name, attributes);
+    } else {
+      const span = this.tracer.startSpan(
+        name,
+        { kind: import_api13.SpanKind.INTERNAL, attributes: this.baseAttributes },
+        this.fallbackContext
+      );
+      if (attributes) span.addEvent(name, attributes);
+      span.setStatus({ code: import_api13.SpanStatusCode.OK });
+      span.end();
+    }
+  }
+  /**
+   * Set attributes on the **active flow execution span**.
+   *
+   * If called inside a tool's execute(), attributes are set on the
+   * tool execution span. If no active span exists, this is a no-op.
+   *
+   * @param attrs — key-value attributes
+   */
+  setAttributes(attrs) {
+    const activeSpan = this.getActiveSpan();
+    if (activeSpan) {
+      activeSpan.setAttributes(attrs);
+    }
+  }
+  /**
+   * Get the trace ID of the current request.
+   * Useful for including in external API calls or logs.
+   */
+  get traceId() {
+    return import_api13.trace.getSpan(this.fallbackContext)?.spanContext().traceId ?? "";
+  }
+  /**
+   * Get the session tracing ID (privacy-safe hash).
+   */
+  get sessionId() {
+    return this.sessionHash;
+  }
+};
+
+// libs/observability/src/telemetry/telemetry.tokens.ts
+var TELEMETRY_ACCESSOR = /* @__PURE__ */ Symbol.for("frontmcp:observability:telemetry-accessor");
+
+// libs/observability/src/plugin/observability.plugin.ts
+var PromptHook = (0, import_sdk2.FlowHooksOf)("prompts:get-prompt");
+var ListPromptsHook = (0, import_sdk2.FlowHooksOf)("prompts:list-prompts");
+var SkillSearchHook = (0, import_sdk2.FlowHooksOf)("skills:search");
+var SkillLoadHook = (0, import_sdk2.FlowHooksOf)("skills:load");
+var CompletionHook = (0, import_sdk2.FlowHooksOf)("completion:complete");
+var LegacySseHook = (0, import_sdk2.FlowHooksOf)("handle:legacy-sse");
+var StreamableHttpHook = (0, import_sdk2.FlowHooksOf)("handle:streamable-http");
+var StatelessHttpHook = (0, import_sdk2.FlowHooksOf)("handle:stateless-http");
+var AuthVerifyHook = (0, import_sdk2.FlowHooksOf)("auth:verify");
+var SessionVerifyHook = (0, import_sdk2.FlowHooksOf)("session:verify");
+var OAuthTokenHook = (0, import_sdk2.FlowHooksOf)("oauth:token");
+var OAuthAuthorizeHook = (0, import_sdk2.FlowHooksOf)("oauth:authorize");
+var OAuthCallbackHook = (0, import_sdk2.FlowHooksOf)("oauth:callback");
+var OAuthProviderCallbackHook = (0, import_sdk2.FlowHooksOf)("oauth:provider-callback");
+var OAuthRegisterHook = (0, import_sdk2.FlowHooksOf)("oauth:register");
+var ElicitRequestHook = (0, import_sdk2.FlowHooksOf)("elicitation:request");
+var ElicitResultHook = (0, import_sdk2.FlowHooksOf)("elicitation:result");
+var SubscribeResourceHook = (0, import_sdk2.FlowHooksOf)("resources:subscribe");
+var UnsubscribeResourceHook = (0, import_sdk2.FlowHooksOf)("resources:unsubscribe");
+var SkillsHttpLlmTxtHook = (0, import_sdk2.FlowHooksOf)("skills-http:llm-txt");
+var SkillsHttpLlmFullTxtHook = (0, import_sdk2.FlowHooksOf)("skills-http:llm-full-txt");
+var SkillsHttpApiHook = (0, import_sdk2.FlowHooksOf)("skills-http:api");
+var WellKnownJwksHook = (0, import_sdk2.FlowHooksOf)("well-known.jwks");
+var WellKnownOAuthServerHook = (0, import_sdk2.FlowHooksOf)("well-known.oauth-authorization-server");
+var WellKnownPrmHook = (0, import_sdk2.FlowHooksOf)("well-known.prm");
+var LoggingSetLevelHook = (0, import_sdk2.FlowHooksOf)("logging:set-level");
+var DEFAULT_TRACING = {
+  httpSpans: true,
+  executionSpans: true,
+  hookSpans: false,
+  fetchSpans: true,
+  flowStageEvents: true,
+  transportSpans: true,
+  authSpans: true,
+  oauthSpans: true,
+  elicitationSpans: true,
+  startupReport: true
+};
+var ObservabilityPlugin = class extends import_sdk2.DynamicPlugin {
+  constructor(options = {}) {
+    super();
+    this.options = resolveOptions(options);
+    this.tracingOpts = this.options.tracing !== false ? this.options.tracing : DEFAULT_TRACING;
+  }
+  get tracingEnabled() {
+    return this.options.tracing !== false;
+  }
+  _httpWillTrace(ctx) {
+    if (this.tracingEnabled) onHttpWillTrace(this.tracingOpts, ctx);
+  }
+  _httpWillQuota(ctx) {
+    if (this.tracingEnabled) onHttpWillAcquireQuota(ctx);
+  }
+  _httpDidSemaphore(ctx) {
+    if (this.tracingEnabled) onHttpDidAcquireQuota(ctx);
+  }
+  _httpWillAuth(ctx) {
+    if (this.tracingEnabled) onHttpWillCheckAuth(ctx);
+  }
+  _httpDidAuth(ctx) {
+    if (this.tracingEnabled) onHttpDidCheckAuth(ctx);
+  }
+  _httpWillRoute(ctx) {
+    if (this.tracingEnabled) onHttpWillRoute(ctx);
+  }
+  _httpDidRoute(ctx) {
+    if (this.tracingEnabled) onHttpDidRoute(ctx);
+  }
+  _httpDidFinalize(ctx) {
+    if (this.tracingEnabled) onHttpDidFinalize(ctx);
+  }
+  _toolWillParse(ctx) {
+    if (this.tracingEnabled) onToolWillParse(this.tracingOpts, ctx);
+  }
+  _toolWillFind(ctx) {
+    if (this.tracingEnabled) onToolWillFindTool(ctx);
+  }
+  _toolWillCheckAuth(ctx) {
+    if (this.tracingEnabled) onToolWillCheckAuth(ctx);
+  }
+  _toolWillCreateCtx(ctx) {
+    if (this.tracingEnabled) onToolWillCreateContext(ctx);
+  }
+  _toolWillValidate(ctx) {
+    if (this.tracingEnabled) onToolWillValidateInput(ctx);
+  }
+  _toolWillExecute(ctx) {
+    if (this.tracingEnabled) onToolWillExecute(this.tracingOpts, ctx);
+  }
+  _toolDidExecute(ctx) {
+    if (this.tracingEnabled) onToolDidExecute(this.tracingOpts, ctx);
+  }
+  _toolWillValidateOut(ctx) {
+    if (this.tracingEnabled) onToolWillValidateOutput(ctx);
+  }
+  _toolWillApplyUI(ctx) {
+    if (this.tracingEnabled) onToolWillApplyUI(ctx);
+  }
+  _toolDidFinalize(ctx) {
+    if (this.tracingEnabled) onToolDidFinalize(ctx);
+  }
+  _resourceWillParse(ctx) {
+    if (this.tracingEnabled) onResourceWillParse(this.tracingOpts, ctx);
+  }
+  _resourceWillFind(ctx) {
+    if (this.tracingEnabled) onResourceWillFind(ctx);
+  }
+  _resourceWillExecute(ctx) {
+    if (this.tracingEnabled) onResourceWillExecute(this.tracingOpts, ctx);
+  }
+  _resourceDidExecute(ctx) {
+    if (this.tracingEnabled) onResourceDidExecute(ctx);
+  }
+  _resourceDidFinalize(ctx) {
+    if (this.tracingEnabled) onResourceDidFinalize(ctx);
+  }
+  _promptWillParse(ctx) {
+    if (this.tracingEnabled) onPromptWillParse(this.tracingOpts, ctx);
+  }
+  _promptWillFind(ctx) {
+    if (this.tracingEnabled) onPromptWillFind(ctx);
+  }
+  _promptWillExecute(ctx) {
+    if (this.tracingEnabled) onPromptWillExecute(this.tracingOpts, ctx);
+  }
+  _promptDidExecute(ctx) {
+    if (this.tracingEnabled) onPromptDidExecute(ctx);
+  }
+  _promptDidFinalize(ctx) {
+    if (this.tracingEnabled) onPromptDidFinalize(ctx);
+  }
+  _agentWillParse(ctx) {
+    if (this.tracingEnabled) onAgentWillParse(this.tracingOpts, ctx);
+  }
+  _agentWillFind(ctx) {
+    if (this.tracingEnabled) onAgentWillFind(ctx);
+  }
+  _agentWillExecute(ctx) {
+    if (this.tracingEnabled) onAgentWillExecute(this.tracingOpts, ctx);
+  }
+  _agentDidExecute(ctx) {
+    if (this.tracingEnabled) onAgentDidExecute(ctx);
+  }
+  _agentDidFinalize(ctx) {
+    if (this.tracingEnabled) onAgentDidFinalize(ctx);
+  }
+  _listToolsWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("tools/list", this.tracingOpts, ctx);
+  }
+  _listToolsDidFind(ctx) {
+    if (this.tracingEnabled) onGenericFlowStage("findTools", ctx);
+  }
+  _listToolsDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _listResourcesWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("resources/list", this.tracingOpts, ctx);
+  }
+  _listResourcesDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _listTemplatesWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("resources/listTemplates", this.tracingOpts, ctx);
+  }
+  _listTemplatesDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _listPromptsWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("prompts/list", this.tracingOpts, ctx);
+  }
+  _listPromptsDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _skillSearchWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("skills/search", this.tracingOpts, ctx);
+  }
+  _skillSearchDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _skillLoadWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("skills/load", this.tracingOpts, ctx);
+  }
+  _skillLoadStage(ctx) {
+    if (this.tracingEnabled) onGenericFlowStage("loadSkills", ctx);
+  }
+  _skillLoadDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _completionWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("completion/complete", this.tracingOpts, ctx);
+  }
+  _completionDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _sseWillParse(ctx) {
+    if (this.tracingEnabled) onTransportWillStart("legacy-sse", this.tracingOpts, ctx);
+  }
+  _sseDidRoute(ctx) {
+    if (this.tracingEnabled) onTransportDidRoute(ctx);
+  }
+  _sseDidInit(ctx) {
+    if (this.tracingEnabled) onTransportStage("onInitialize", ctx);
+  }
+  _sseDidMsg(ctx) {
+    if (this.tracingEnabled) onTransportStage("onMessage", ctx);
+  }
+  _sseDidElicit(ctx) {
+    if (this.tracingEnabled) onTransportStage("onElicitResult", ctx);
+  }
+  _sseDidCleanup(ctx) {
+    if (this.tracingEnabled) onTransportDidFinalize(ctx);
+  }
+  _shttpWillParse(ctx) {
+    if (this.tracingEnabled) onTransportWillStart("streamable-http", this.tracingOpts, ctx);
+  }
+  _shttpDidRoute(ctx) {
+    if (this.tracingEnabled) onTransportDidRoute(ctx);
+  }
+  _shttpDidInit(ctx) {
+    if (this.tracingEnabled) onTransportStage("onInitialize", ctx);
+  }
+  _shttpDidMsg(ctx) {
+    if (this.tracingEnabled) onTransportStage("onMessage", ctx);
+  }
+  _shttpDidElicit(ctx) {
+    if (this.tracingEnabled) onTransportStage("onElicitResult", ctx);
+  }
+  _shttpDidSse(ctx) {
+    if (this.tracingEnabled) onTransportStage("onSseListener", ctx);
+  }
+  _shttpDidExtApps(ctx) {
+    if (this.tracingEnabled) onTransportStage("onExtApps", ctx);
+  }
+  _shttpDidCleanup(ctx) {
+    if (this.tracingEnabled) onTransportDidFinalize(ctx);
+  }
+  _slhttpWillParse(ctx) {
+    if (this.tracingEnabled) onTransportWillStart("stateless-http", this.tracingOpts, ctx);
+  }
+  _slhttpDidHandle(ctx) {
+    if (this.tracingEnabled) onTransportStage("handleRequest", ctx);
+  }
+  _slhttpDidCleanup(ctx) {
+    if (this.tracingEnabled) onTransportDidFinalize(ctx);
+  }
+  _authVerifyWill(ctx) {
+    if (this.tracingEnabled) onAuthWillStart("auth:verify", this.tracingOpts, ctx);
+  }
+  _authVerifyDidMode(ctx) {
+    if (this.tracingEnabled) onAuthDidDetermineMode(ctx);
+  }
+  _authVerifyDidToken(ctx) {
+    if (this.tracingEnabled) onAuthStage("verifyToken", ctx);
+  }
+  _authVerifyDidBuild(ctx) {
+    if (this.tracingEnabled) onAuthDidFinalize(ctx);
+  }
+  _sessionVerifyWill(ctx) {
+    if (this.tracingEnabled) onAuthWillStart("session:verify", this.tracingOpts, ctx);
+  }
+  _sessionVerifyDidJwt(ctx) {
+    if (this.tracingEnabled) onAuthStage("verifyIfJwt", ctx);
+  }
+  _sessionVerifyDidBuild(ctx) {
+    if (this.tracingEnabled) onAuthDidFinalize(ctx);
+  }
+  _oauthTokenWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("oauth/token", this.tracingOpts, ctx);
+  }
+  _oauthTokenDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _oauthAuthzWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("oauth/authorize", this.tracingOpts, ctx);
+  }
+  _oauthAuthzDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _oauthCallbackWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("oauth/callback", this.tracingOpts, ctx);
+  }
+  _oauthCallbackDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _oauthProviderWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("oauth/provider-callback", this.tracingOpts, ctx);
+  }
+  _oauthProviderDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _oauthRegisterWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("oauth/register", this.tracingOpts, ctx);
+  }
+  _oauthRegisterDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _elicitReqWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("elicitation/request", this.tracingOpts, ctx);
+  }
+  _elicitReqDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _elicitResWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("elicitation/result", this.tracingOpts, ctx);
+  }
+  _elicitResDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _subscribeWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("resources/subscribe", this.tracingOpts, ctx);
+  }
+  _subscribeDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _unsubscribeWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("resources/unsubscribe", this.tracingOpts, ctx);
+  }
+  _unsubscribeDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _skillsLlmTxtWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("skills-http/llm-txt", this.tracingOpts, ctx);
+  }
+  _skillsLlmTxtDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _skillsLlmFullTxtWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("skills-http/llm-full-txt", this.tracingOpts, ctx);
+  }
+  _skillsLlmFullTxtDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _skillsApiWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("skills-http/api", this.tracingOpts, ctx);
+  }
+  _skillsApiDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _jwksWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("well-known/jwks", this.tracingOpts, ctx);
+  }
+  _jwksDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _oauthServerWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("well-known/oauth-server", this.tracingOpts, ctx);
+  }
+  _oauthServerDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _prmWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("well-known/prm", this.tracingOpts, ctx);
+  }
+  _prmDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _setLevelWill(ctx) {
+    if (this.tracingEnabled) onGenericFlowWillStart("logging/set-level", this.tracingOpts, ctx);
+  }
+  _setLevelDone(ctx) {
+    if (this.tracingEnabled) onGenericFlowDidFinalize(ctx);
+  }
+  _toolDidCreateCtxFetch(ctx) {
+    if (this.tracingEnabled) wrapContextFetch(this.tracingOpts, ctx);
+  }
+  _agentDidExecuteMeta(ctx) {
+    if (this.tracingEnabled) onAgentDidExecuteEnrich(ctx);
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Startup Report (public method)
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Emit startup telemetry report.
+   * Call after scope.initialize() completes with component counts.
+   */
+  reportStartupTelemetry(data) {
+    if (this.options.tracing === false) return;
+    reportStartup(data);
+  }
+};
+ObservabilityPlugin.defaultOptions = {
+  tracing: DEFAULT_TRACING,
+  logging: false,
+  requestLogs: false
+};
+// ═══════════════════════════════════════════════════════════════════════════
+// Dynamic Providers
+// ═══════════════════════════════════════════════════════════════════════════
+ObservabilityPlugin.dynamicProviders = (input) => {
+  const options = resolveOptions(input);
+  const providers = [];
+  if (options.tracing !== false) {
+    providers.push({
+      name: "observability:tracer",
+      provide: OTEL_TRACER,
+      useValue: import_api14.trace.getTracer("@frontmcp/observability")
+    });
+    providers.push({
+      name: "observability:config",
+      provide: OTEL_CONFIG,
+      useValue: options.tracing
+    });
+    providers.push({
+      name: "observability:telemetry-accessor",
+      provide: TELEMETRY_ACCESSOR,
+      scope: import_sdk2.ProviderScope.CONTEXT,
+      inject: () => [import_sdk2.FRONTMCP_CONTEXT],
+      useFactory: (ctx) => new TelemetryAccessor(ctx)
+    });
+  }
+  if (options.logging !== false) {
+    const loggingOpts = options.logging;
+    const sinks = createSinks(loggingOpts.sinks);
+    const transport = new StructuredLogTransport(
+      sinks,
+      {
+        redactFields: loggingOpts.redactFields,
+        includeStacks: loggingOpts.includeStacks,
+        staticFields: loggingOpts.staticFields
+      },
+      void 0
+    );
+    providers.push({
+      name: "observability:structured-log-transport",
+      provide: StructuredLogTransport,
+      useValue: transport
+    });
+  }
+  if (options.requestLogs !== false) {
+    const requestLogOpts = options.requestLogs;
+    providers.push({
+      name: "observability:request-log-collector",
+      provide: REQUEST_LOG_COLLECTOR,
+      scope: import_sdk2.ProviderScope.CONTEXT,
+      inject: () => [import_sdk2.FRONTMCP_CONTEXT],
+      useFactory: (ctx) => {
+        return new RequestLogCollector(
+          {
+            requestId: ctx.requestId,
+            traceId: ctx.traceContext.traceId,
+            sessionIdHash: sessionTracingId(ctx.sessionId).slice(0, 12),
+            scopeId: ctx.scopeId
+          },
+          requestLogOpts
+        );
+      }
+    });
+  }
+  return providers;
+};
+__decorateClass([
+  import_sdk2.HttpHook.Will("traceRequest", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_httpWillTrace", 1);
+__decorateClass([
+  import_sdk2.HttpHook.Will("acquireQuota", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_httpWillQuota", 1);
+__decorateClass([
+  import_sdk2.HttpHook.Did("acquireSemaphore", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_httpDidSemaphore", 1);
+__decorateClass([
+  import_sdk2.HttpHook.Will("checkAuthorization", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_httpWillAuth", 1);
+__decorateClass([
+  import_sdk2.HttpHook.Did("checkAuthorization", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_httpDidAuth", 1);
+__decorateClass([
+  import_sdk2.HttpHook.Will("router", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_httpWillRoute", 1);
+__decorateClass([
+  import_sdk2.HttpHook.Did("router", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_httpDidRoute", 1);
+__decorateClass([
+  import_sdk2.HttpHook.Did("finalize", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_httpDidFinalize", 1);
+__decorateClass([
+  import_sdk2.ToolHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_toolWillParse", 1);
+__decorateClass([
+  import_sdk2.ToolHook.Will("findTool", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_toolWillFind", 1);
+__decorateClass([
+  import_sdk2.ToolHook.Will("checkToolAuthorization", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_toolWillCheckAuth", 1);
+__decorateClass([
+  import_sdk2.ToolHook.Will("createToolCallContext", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_toolWillCreateCtx", 1);
+__decorateClass([
+  import_sdk2.ToolHook.Will("validateInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_toolWillValidate", 1);
+__decorateClass([
+  import_sdk2.ToolHook.Will("execute", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_toolWillExecute", 1);
+__decorateClass([
+  import_sdk2.ToolHook.Did("execute", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_toolDidExecute", 1);
+__decorateClass([
+  import_sdk2.ToolHook.Will("validateOutput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_toolWillValidateOut", 1);
+__decorateClass([
+  import_sdk2.ToolHook.Will("applyUI", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_toolWillApplyUI", 1);
+__decorateClass([
+  import_sdk2.ToolHook.Did("finalize", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_toolDidFinalize", 1);
+__decorateClass([
+  import_sdk2.ResourceHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_resourceWillParse", 1);
+__decorateClass([
+  import_sdk2.ResourceHook.Will("findResource", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_resourceWillFind", 1);
+__decorateClass([
+  import_sdk2.ResourceHook.Will("execute", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_resourceWillExecute", 1);
+__decorateClass([
+  import_sdk2.ResourceHook.Did("execute", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_resourceDidExecute", 1);
+__decorateClass([
+  import_sdk2.ResourceHook.Did("finalize", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_resourceDidFinalize", 1);
+__decorateClass([
+  PromptHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_promptWillParse", 1);
+__decorateClass([
+  PromptHook.Will("findPrompt", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_promptWillFind", 1);
+__decorateClass([
+  PromptHook.Will("execute", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_promptWillExecute", 1);
+__decorateClass([
+  PromptHook.Did("execute", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_promptDidExecute", 1);
+__decorateClass([
+  PromptHook.Did("finalize", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_promptDidFinalize", 1);
+__decorateClass([
+  import_sdk2.AgentCallHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_agentWillParse", 1);
+__decorateClass([
+  import_sdk2.AgentCallHook.Will("findAgent", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_agentWillFind", 1);
+__decorateClass([
+  import_sdk2.AgentCallHook.Will("execute", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_agentWillExecute", 1);
+__decorateClass([
+  import_sdk2.AgentCallHook.Did("execute", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_agentDidExecute", 1);
+__decorateClass([
+  import_sdk2.AgentCallHook.Did("finalize", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_agentDidFinalize", 1);
+__decorateClass([
+  import_sdk2.ListToolsHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_listToolsWill", 1);
+__decorateClass([
+  import_sdk2.ListToolsHook.Did("findTools", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_listToolsDidFind", 1);
+__decorateClass([
+  import_sdk2.ListToolsHook.Did("parseTools", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_listToolsDone", 1);
+__decorateClass([
+  import_sdk2.ListResourcesHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_listResourcesWill", 1);
+__decorateClass([
+  import_sdk2.ListResourcesHook.Did("parseResources", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_listResourcesDone", 1);
+__decorateClass([
+  import_sdk2.ListResourceTemplatesHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_listTemplatesWill", 1);
+__decorateClass([
+  import_sdk2.ListResourceTemplatesHook.Did("parseTemplates", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_listTemplatesDone", 1);
+__decorateClass([
+  ListPromptsHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_listPromptsWill", 1);
+__decorateClass([
+  ListPromptsHook.Did("parsePrompts", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_listPromptsDone", 1);
+__decorateClass([
+  SkillSearchHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_skillSearchWill", 1);
+__decorateClass([
+  SkillSearchHook.Did("finalize", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_skillSearchDone", 1);
+__decorateClass([
+  SkillLoadHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_skillLoadWill", 1);
+__decorateClass([
+  SkillLoadHook.Will("loadSkills", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_skillLoadStage", 1);
+__decorateClass([
+  SkillLoadHook.Did("finalize", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_skillLoadDone", 1);
+__decorateClass([
+  CompletionHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_completionWill", 1);
+__decorateClass([
+  CompletionHook.Did("finalize", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_completionDone", 1);
+__decorateClass([
+  LegacySseHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_sseWillParse", 1);
+__decorateClass([
+  LegacySseHook.Did("router", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_sseDidRoute", 1);
+__decorateClass([
+  LegacySseHook.Did("onInitialize", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_sseDidInit", 1);
+__decorateClass([
+  LegacySseHook.Did("onMessage", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_sseDidMsg", 1);
+__decorateClass([
+  LegacySseHook.Did("onElicitResult", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_sseDidElicit", 1);
+__decorateClass([
+  LegacySseHook.Did("cleanup", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_sseDidCleanup", 1);
+__decorateClass([
+  StreamableHttpHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_shttpWillParse", 1);
+__decorateClass([
+  StreamableHttpHook.Did("router", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_shttpDidRoute", 1);
+__decorateClass([
+  StreamableHttpHook.Did("onInitialize", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_shttpDidInit", 1);
+__decorateClass([
+  StreamableHttpHook.Did("onMessage", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_shttpDidMsg", 1);
+__decorateClass([
+  StreamableHttpHook.Did("onElicitResult", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_shttpDidElicit", 1);
+__decorateClass([
+  StreamableHttpHook.Did("onSseListener", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_shttpDidSse", 1);
+__decorateClass([
+  StreamableHttpHook.Did("onExtApps", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_shttpDidExtApps", 1);
+__decorateClass([
+  StreamableHttpHook.Did("cleanup", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_shttpDidCleanup", 1);
+__decorateClass([
+  StatelessHttpHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_slhttpWillParse", 1);
+__decorateClass([
+  StatelessHttpHook.Did("handleRequest", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_slhttpDidHandle", 1);
+__decorateClass([
+  StatelessHttpHook.Did("cleanup", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_slhttpDidCleanup", 1);
+__decorateClass([
+  AuthVerifyHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_authVerifyWill", 1);
+__decorateClass([
+  AuthVerifyHook.Did("determineAuthMode", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_authVerifyDidMode", 1);
+__decorateClass([
+  AuthVerifyHook.Did("verifyToken", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_authVerifyDidToken", 1);
+__decorateClass([
+  AuthVerifyHook.Did("buildAuthorization", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_authVerifyDidBuild", 1);
+__decorateClass([
+  SessionVerifyHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_sessionVerifyWill", 1);
+__decorateClass([
+  SessionVerifyHook.Did("verifyIfJwt", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_sessionVerifyDidJwt", 1);
+__decorateClass([
+  SessionVerifyHook.Did("buildAuthorizedOutput", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_sessionVerifyDidBuild", 1);
+__decorateClass([
+  OAuthTokenHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_oauthTokenWill", 1);
+__decorateClass([
+  OAuthTokenHook.Did("buildTokenResponse", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_oauthTokenDone", 1);
+__decorateClass([
+  OAuthAuthorizeHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_oauthAuthzWill", 1);
+__decorateClass([
+  OAuthAuthorizeHook.Did("buildAuthorizeOutput", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_oauthAuthzDone", 1);
+__decorateClass([
+  OAuthCallbackHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_oauthCallbackWill", 1);
+__decorateClass([
+  OAuthCallbackHook.Did("redirectToClient", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_oauthCallbackDone", 1);
+__decorateClass([
+  OAuthProviderCallbackHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_oauthProviderWill", 1);
+__decorateClass([
+  OAuthProviderCallbackHook.Did("handleNextProviderOrComplete", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_oauthProviderDone", 1);
+__decorateClass([
+  OAuthRegisterHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_oauthRegisterWill", 1);
+__decorateClass([
+  OAuthRegisterHook.Did("respondRegistration", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_oauthRegisterDone", 1);
+__decorateClass([
+  ElicitRequestHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_elicitReqWill", 1);
+__decorateClass([
+  ElicitRequestHook.Did("finalize", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_elicitReqDone", 1);
+__decorateClass([
+  ElicitResultHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_elicitResWill", 1);
+__decorateClass([
+  ElicitResultHook.Did("finalize", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_elicitResDone", 1);
+__decorateClass([
+  SubscribeResourceHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_subscribeWill", 1);
+__decorateClass([
+  SubscribeResourceHook.Did("finalize", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_subscribeDone", 1);
+__decorateClass([
+  UnsubscribeResourceHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_unsubscribeWill", 1);
+__decorateClass([
+  UnsubscribeResourceHook.Did("finalize", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_unsubscribeDone", 1);
+__decorateClass([
+  SkillsHttpLlmTxtHook.Will("checkEnabled", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_skillsLlmTxtWill", 1);
+__decorateClass([
+  SkillsHttpLlmTxtHook.Did("generateContent", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_skillsLlmTxtDone", 1);
+__decorateClass([
+  SkillsHttpLlmFullTxtHook.Will("checkEnabled", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_skillsLlmFullTxtWill", 1);
+__decorateClass([
+  SkillsHttpLlmFullTxtHook.Did("generateContent", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_skillsLlmFullTxtDone", 1);
+__decorateClass([
+  SkillsHttpApiHook.Will("checkEnabled", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_skillsApiWill", 1);
+__decorateClass([
+  SkillsHttpApiHook.Did("handleRequest", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_skillsApiDone", 1);
+__decorateClass([
+  WellKnownJwksHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_jwksWill", 1);
+__decorateClass([
+  WellKnownJwksHook.Did("collectData", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_jwksDone", 1);
+__decorateClass([
+  WellKnownOAuthServerHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_oauthServerWill", 1);
+__decorateClass([
+  WellKnownOAuthServerHook.Did("collectData", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_oauthServerDone", 1);
+__decorateClass([
+  WellKnownPrmHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_prmWill", 1);
+__decorateClass([
+  WellKnownPrmHook.Did("collectData", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_prmDone", 1);
+__decorateClass([
+  LoggingSetLevelHook.Will("parseInput", { priority: -1e3 })
+], ObservabilityPlugin.prototype, "_setLevelWill", 1);
+__decorateClass([
+  LoggingSetLevelHook.Did("finalize", { priority: 1e3 })
+], ObservabilityPlugin.prototype, "_setLevelDone", 1);
+__decorateClass([
+  import_sdk2.ToolHook.Did("createToolCallContext", { priority: 999 })
+], ObservabilityPlugin.prototype, "_toolDidCreateCtxFetch", 1);
+__decorateClass([
+  import_sdk2.AgentCallHook.Did("execute", { priority: 999 })
+], ObservabilityPlugin.prototype, "_agentDidExecuteMeta", 1);
+ObservabilityPlugin = __decorateClass([
+  (0, import_sdk2.Plugin)({
+    name: "observability",
+    description: "Full-system OpenTelemetry instrumentation, structured logging, and request logs",
+    providers: [],
+    contextExtensions: [
+      {
+        property: "telemetry",
+        token: TELEMETRY_ACCESSOR,
+        errorMessage: "ObservabilityPlugin is not installed or tracing is disabled. Add ObservabilityPlugin.init() to your plugins array."
+      }
+    ]
+  })
+], ObservabilityPlugin);
+function resolveOptions(input) {
+  return {
+    tracing: resolveTracingOptions(input.tracing),
+    logging: resolveLoggingOptions(input.logging),
+    requestLogs: resolveRequestLogOptions(input.requestLogs)
+  };
+}
+function resolveTracingOptions(input) {
+  if (input === false) return false;
+  if (input === true || input === void 0) return DEFAULT_TRACING;
+  return { ...DEFAULT_TRACING, ...input };
+}
+function resolveLoggingOptions(input) {
+  if (input === false || input === void 0) return false;
+  if (input === true) return {};
+  return input;
+}
+function resolveRequestLogOptions(input) {
+  if (input === false || input === void 0) return false;
+  if (input === true) return {};
+  return input;
+}
+
+// libs/observability/src/otel/context-propagator.ts
+var import_api15 = require("@opentelemetry/api");
+var TRACEPARENT_HEADER = "traceparent";
+var FrontMcpPropagator = class {
+  inject(context, carrier, setter) {
+    const span = import_api15.trace.getSpan(context);
+    if (!span) return;
+    const sc = span.spanContext();
+    if (!sc || !isValidSpanContext(sc)) return;
+    const flags = sc.traceFlags.toString(16).padStart(2, "0");
+    const traceparent = `00-${sc.traceId}-${sc.spanId}-${flags}`;
+    setter.set(carrier, TRACEPARENT_HEADER, traceparent);
+  }
+  extract(context, carrier, getter) {
+    const traceparent = getter.get(carrier, TRACEPARENT_HEADER);
+    const value = Array.isArray(traceparent) ? traceparent[0] : traceparent;
+    if (!value) return context;
+    const parsed = parseTraceparent(value);
+    if (!parsed) return context;
+    const spanContext = {
+      traceId: parsed.traceId,
+      spanId: parsed.parentId,
+      traceFlags: parsed.traceFlags,
+      isRemote: true
+    };
+    const span = import_api15.trace.wrapSpanContext(spanContext);
+    return import_api15.trace.setSpan(context, span);
+  }
+  fields() {
+    return [TRACEPARENT_HEADER];
+  }
+};
+function parseTraceparent(value) {
+  const parts = value.split("-");
+  if (parts.length !== 4) return null;
+  const [version, traceId, parentId, flags] = parts;
+  if (version !== "00") return null;
+  if (!/^[a-f0-9]{32}$/i.test(traceId) || traceId === "00000000000000000000000000000000") return null;
+  if (!/^[a-f0-9]{16}$/i.test(parentId) || parentId === "0000000000000000") return null;
+  if (!/^[0-9a-fA-F]{2}$/.test(flags)) return null;
+  const traceFlags = parseInt(flags, 16);
+  return {
+    traceId: traceId.toLowerCase(),
+    parentId: parentId.toLowerCase(),
+    traceFlags
+  };
+}
+function isValidSpanContext(sc) {
+  return sc.traceId !== "00000000000000000000000000000000" && sc.spanId !== "0000000000000000" && sc.traceId.length === 32 && sc.spanId.length === 16;
+}
+
+// libs/observability/src/otel/otel.setup.ts
+function setupOTel(options) {
+  const serviceName = options?.serviceName ?? process.env["OTEL_SERVICE_NAME"] ?? "frontmcp-server";
+  const exporterType = options?.exporter ?? "console";
+  const endpoint = options?.endpoint ?? process.env["OTEL_EXPORTER_OTLP_ENDPOINT"] ?? "http://localhost:4318";
+  let traceExporter;
+  if (exporterType === "otlp") {
+    try {
+      const { OTLPTraceExporter } = require("@opentelemetry/exporter-trace-otlp-http");
+      traceExporter = new OTLPTraceExporter({ url: `${endpoint}/v1/traces` });
+    } catch {
+      throw new Error(
+        "setupOTel: @opentelemetry/exporter-trace-otlp-http is required for OTLP export. Install it with: npm install @opentelemetry/exporter-trace-otlp-http"
+      );
+    }
+  } else if (exporterType === "console") {
+    const { ConsoleSpanExporter } = require("@opentelemetry/sdk-trace-base");
+    traceExporter = new ConsoleSpanExporter();
+  }
+  try {
+    const { NodeSDK } = require("@opentelemetry/sdk-node");
+    const { Resource } = require("@opentelemetry/resources");
+    const { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } = require("@opentelemetry/semantic-conventions");
+    const resource = new Resource({
+      [ATTR_SERVICE_NAME]: serviceName,
+      ...options?.serviceVersion ? { [ATTR_SERVICE_VERSION]: options.serviceVersion } : {}
+    });
+    const sdk = new NodeSDK({
+      resource,
+      traceExporter
+    });
+    sdk.start();
+    return async () => {
+      await sdk.shutdown();
+    };
+  } catch {
+    throw new Error(
+      "setupOTel: @opentelemetry/sdk-node is required. Install it with: npm install @opentelemetry/sdk-node @opentelemetry/resources @opentelemetry/semantic-conventions"
+    );
+  }
+}
+
+// libs/observability/src/otel/spans/hook.span.ts
+var import_api16 = require("@opentelemetry/api");
+function recordHookEvent(parentSpan, stage, owner) {
+  const attributes = {};
+  if (owner) {
+    attributes[FrontMcpAttributes.HOOK_OWNER] = owner;
+  }
+  parentSpan.addEvent(`hook.${stage}`, attributes);
+}
+function startHookSpan(tracer, options) {
+  const attributes = {
+    [FrontMcpAttributes.HOOK_STAGE]: options.stage
+  };
+  if (options.owner) {
+    attributes[FrontMcpAttributes.HOOK_OWNER] = options.owner;
+  }
+  if (options.flowName) {
+    attributes[FrontMcpAttributes.FLOW_NAME] = options.flowName;
+  }
+  return startSpan(tracer, {
+    name: `hook ${options.stage}`,
+    kind: import_api16.SpanKind.INTERNAL,
+    attributes,
+    parentContext: options.parentContext
+  });
+}
+
+// libs/observability/src/otel/spans/pretty-span-exporter.ts
+var import_api17 = require("@opentelemetry/api");
+var RESET = "\x1B[0m";
+var DIM = "\x1B[2m";
+var BOLD = "\x1B[1m";
+var CYAN = "\x1B[36m";
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var KIND_LABELS = {
+  [import_api17.SpanKind.INTERNAL]: "INTERNAL",
+  [import_api17.SpanKind.SERVER]: "SERVER",
+  [import_api17.SpanKind.CLIENT]: "CLIENT",
+  [import_api17.SpanKind.PRODUCER]: "PRODUCER",
+  [import_api17.SpanKind.CONSUMER]: "CONSUMER"
+};
+var SHOW_ATTRS = /* @__PURE__ */ new Set([
+  "rpc.system",
+  "rpc.method",
+  "rpc.service",
+  "mcp.method.name",
+  "mcp.session.id",
+  "mcp.component.type",
+  "mcp.component.key",
+  "http.request.method",
+  "http.response.status_code",
+  "url.path",
+  "frontmcp.tool.name",
+  "frontmcp.tool.owner",
+  "frontmcp.transport.type",
+  "frontmcp.transport.request_type",
+  "frontmcp.auth.mode",
+  "frontmcp.auth.result",
+  "frontmcp.flow.name",
+  "enduser.id"
+]);
+var PrettySpanExporter = class {
+  constructor() {
+    this.useAnsi = typeof process !== "undefined" && !!process.stdout?.isTTY;
+  }
+  export(spans, resultCallback) {
+    for (const span of spans) {
+      console.log(this.format(span));
+    }
+    resultCallback({ code: 0 });
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+  format(span) {
+    const traceShort = span.spanContext().traceId.slice(0, 8);
+    const durationMs = (span.duration[0] * 1e3 + span.duration[1] / 1e6).toFixed(1);
+    const kind = KIND_LABELS[span.kind] ?? "UNKNOWN";
+    const statusOk = span.status.code !== import_api17.SpanStatusCode.ERROR;
+    const attrs = Object.entries(span.attributes).filter(([k]) => SHOW_ATTRS.has(k)).map(([k, v]) => {
+      const short = k.replace("frontmcp.", "").replace("mcp.", "");
+      return `${short}=${v}`;
+    }).join(" ");
+    const eventCount = span.events.length;
+    const eventSummary = eventCount > 0 ? ` (${eventCount} events)` : "";
+    if (this.useAnsi) {
+      const statusColor = statusOk ? GREEN : RED;
+      const kindColor = span.kind === import_api17.SpanKind.SERVER ? CYAN : DIM;
+      return [
+        `${DIM}\u21B3${RESET}`,
+        `${BOLD}${statusColor}SPAN${RESET}`,
+        `${BOLD}${span.name}${RESET}`,
+        `${DIM}[${traceShort}]${RESET}`,
+        `${YELLOW}${durationMs}ms${RESET}`,
+        `${kindColor}${kind}${RESET}`,
+        attrs ? `${DIM}${attrs}${RESET}` : "",
+        eventSummary ? `${DIM}${eventSummary}${RESET}` : ""
+      ].filter(Boolean).join(" ");
+    }
+    return ["\u21B3 SPAN", span.name, `[${traceShort}]`, `${durationMs}ms`, kind, attrs, eventSummary].filter(Boolean).join(" ");
+  }
+};
+
+// libs/observability/src/logging/sinks/index.ts
+init_winston_sink();
+init_pino_sink();
+init_otlp_sink();
+
+// libs/observability/src/testing/index.ts
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+function createTestTracer(name = "test") {
+  const exporter = new import_sdk_trace_base.InMemorySpanExporter();
+  const provider = new import_sdk_trace_base.BasicTracerProvider();
+  provider.addSpanProcessor(new import_sdk_trace_base.SimpleSpanProcessor(exporter));
+  const tracer = provider.getTracer(name);
+  return {
+    tracer,
+    exporter,
+    provider,
+    cleanup: async () => {
+      exporter.reset();
+      await provider.forceFlush();
+      await provider.shutdown();
+    }
+  };
+}
+function getFinishedSpans(exporter) {
+  return exporter.getFinishedSpans();
+}
+function assertSpanExists(spans, name) {
+  const match = spans.find((s) => s.name === name);
+  if (!match) {
+    const names = spans.map((s) => s.name).join(", ");
+    throw new Error(`Expected span "${name}" but found: [${names}]`);
+  }
+  return match;
+}
+function assertSpanAttribute(span, key, value) {
+  const actual = span.attributes[key];
+  if (actual !== value) {
+    throw new Error(
+      `Expected span "${span.name}" attribute "${key}" to be ${JSON.stringify(value)} but got ${JSON.stringify(actual)}`
+    );
+  }
+}
+function findSpan(spans, name) {
+  return spans.find((s) => s.name === name);
+}
+function findSpansByAttribute(spans, key, value) {
+  return spans.filter((s) => s.attributes[key] === value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CallbackSink,
+  ConsoleSink,
+  EnduserAttributes,
+  FrontMcpAttributes,
+  FrontMcpPropagator,
+  HttpAttributes,
+  LOG_LEVEL_TO_OTEL_SEVERITY,
+  McpAttributes,
+  OTEL_CONFIG,
+  OTEL_TRACER,
+  ObservabilityPlugin,
+  OtlpSink,
+  PinoSink,
+  PrettySpanExporter,
+  REQUEST_LOG_COLLECTOR,
+  RequestLogCollector,
+  RpcAttributes,
+  StdoutSink,
+  StructuredLogTransport,
+  TELEMETRY_ACCESSOR,
+  TelemetryAccessor,
+  TelemetrySpan,
+  WinstonSink,
+  assertSpanAttribute,
+  assertSpanExists,
+  createOTelContextFromTrace,
+  createSink,
+  createSinks,
+  createTestTracer,
+  emitStartupReport,
+  endSpanError,
+  endSpanOk,
+  findSpan,
+  findSpansByAttribute,
+  frontmcpToOTelSpanContext,
+  getFinishedSpans,
+  otelToFrontmcpContext,
+  recordHookEvent,
+  redactFields,
+  reportStartup,
+  sessionTracingId,
+  setAuthMode,
+  setAuthResult,
+  setFetchResponseStatus,
+  setHttpResponseStatus,
+  setTransportRequestType,
+  setupOTel,
+  startAuthSpan,
+  startFetchSpan,
+  startHookSpan,
+  startHttpServerSpan,
+  startPromptSpan,
+  startResourceSpan,
+  startRpcSpan,
+  startSpan,
+  startToolSpan,
+  startTransportSpan,
+  withSpan
+});