@brizz/sdk 0.1.28 → 0.1.30

package/dist/index.cjs

@@ -1,3155 +1,181 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }
+
+
 
-// src/internal/logger.ts
-function parseLogLevel(level) {
-  if (!level) {
-    return DEFAULT_LOG_LEVEL;
-  }
-  const normalizedLevel = level.toLowerCase().trim();
-  switch (normalizedLevel) {
-    case "debug":
-      return 4 /* DEBUG */;
-    case "info":
-      return 3 /* INFO */;
-    case "warn":
-    case "warning":
-      return 2 /* WARN */;
-    case "error":
-      return 1 /* ERROR */;
-    case "none":
-    case "off":
-    case "silent":
-      return 0 /* NONE */;
-    default: {
-      const numLevel = Number.parseInt(normalizedLevel, 10);
-      if (!Number.isNaN(numLevel) && numLevel >= 0 && numLevel <= 4) {
-        return numLevel;
-      }
-      return DEFAULT_LOG_LEVEL;
-    }
-  }
-}
-function setLogLevel(level) {
-  const resolvedLevel = typeof level === "string" ? parseLogLevel(level) : level;
-  logger.setLevel(resolvedLevel);
-}
-function getLogLevel() {
-  return logger.getLevel();
-}
-var import_api, import_pino, LogLevel, DEFAULT_LOG_LEVEL, PinoLogger, logger;
-var init_logger = __esm({
-  "src/internal/logger.ts"() {
-    "use strict";
-    import_api = require("@opentelemetry/api");
-    import_pino = __toESM(require("pino"), 1);
-    LogLevel = /* @__PURE__ */ ((LogLevel2) => {
-      LogLevel2[LogLevel2["NONE"] = 0] = "NONE";
-      LogLevel2[LogLevel2["ERROR"] = 1] = "ERROR";
-      LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
-      LogLevel2[LogLevel2["INFO"] = 3] = "INFO";
-      LogLevel2[LogLevel2["DEBUG"] = 4] = "DEBUG";
-      return LogLevel2;
-    })(LogLevel || {});
-    DEFAULT_LOG_LEVEL = 2 /* WARN */;
-    PinoLogger = class {
-      _level = DEFAULT_LOG_LEVEL;
-      _pinoLogger = null;
-      constructor() {
-        const envLevel = this.getLogLevelFromEnv();
-        this._level = envLevel;
-      }
-      /**
-       * Lazy initialization of Pino logger to ensure it's created AFTER Jest spies
-       * are set up during tests. This prevents the pino-pretty transport from
-       * bypassing stdout/stderr spies.
-       */
-      ensurePinoLogger() {
-        if (!this._pinoLogger) {
-          this._pinoLogger = (0, import_pino.default)({
-            name: "Brizz",
-            level: this.logLevelToPino(this._level),
-            // Disable transport in test environment to allow proper spy capture
-            transport: this.isProduction() || this.isTest() ? void 0 : {
-              target: "pino-pretty",
-              options: {
-                singleLine: true,
-                colorize: true,
-                translateTime: "HH:MM:ss",
-                ignore: "pid,hostname",
-                messageFormat: "[{name}] {msg}"
-              }
-            }
-          });
-        }
-        return this._pinoLogger;
-      }
-      isProduction() {
-        return process.env["NODE_ENV"] === "production";
-      }
-      isTest() {
-        return process.env["NODE_ENV"] === "test";
-      }
-      getLogLevelFromEnv() {
-        const envLevel = process.env["BRIZZ_LOG_LEVEL"];
-        return envLevel ? parseLogLevel(envLevel) : DEFAULT_LOG_LEVEL;
-      }
-      logLevelToPino(level) {
-        switch (level) {
-          case 4 /* DEBUG */:
-            return "debug";
-          case 3 /* INFO */:
-            return "info";
-          case 2 /* WARN */:
-            return "warn";
-          case 1 /* ERROR */:
-            return "error";
-          default:
-            return "silent";
-        }
-      }
-      formatMeta(meta) {
-        if (meta.length === 0) {
-          return {};
-        }
-        if (meta.length === 1 && typeof meta[0] === "object" && meta[0] !== null) {
-          return meta[0];
-        }
-        return { metadata: meta };
-      }
-      setLevel(level) {
-        this._level = level;
-        if (this._pinoLogger) {
-          this._pinoLogger.level = this.logLevelToPino(level);
-        }
-      }
-      getLevel() {
-        return this._level;
-      }
-      debug = (msg, ...meta) => {
-        if (this._level >= 4 /* DEBUG */) {
-          this.ensurePinoLogger().debug(this.formatMeta(meta), msg);
-        }
-      };
-      info = (msg, ...meta) => {
-        if (this._level >= 3 /* INFO */) {
-          this.ensurePinoLogger().info(this.formatMeta(meta), msg);
-        }
-      };
-      warn = (msg, ...meta) => {
-        if (this._level >= 2 /* WARN */) {
-          this.ensurePinoLogger().warn(this.formatMeta(meta), msg);
-        }
-      };
-      error = (msg, ...meta) => {
-        if (this._level >= 1 /* ERROR */) {
-          this.ensurePinoLogger().error(this.formatMeta(meta), msg);
-        }
-      };
-    };
-    logger = new PinoLogger();
-  }
-});
 
-// src/internal/instrumentation/mcp/semantic-conventions.ts
-var MCP_TOOL_NAME, MCP_TOOL_ARGUMENTS, MCP_TOOL_RESULT, MCP_COMPONENT_TYPE, MCP_COMPONENT_TOOL, MCP_COMPONENT_TOOL_SCHEMA, MCP_TOOL_SCHEMA_PARAMETERS, MCP_TOOL_SCHEMA_OUTPUT, MCP_TOOL_DESCRIPTION, SPAN_NAME_TOOL_REGISTER, MCP_METHOD_NAME, MCP_REQUEST_ID, MCP_SESSION_ID, MCP_PROTOCOL_VERSION, MCP_RESOURCE_URI, RPC_SYSTEM, RPC_SYSTEM_MCP, RPC_RESPONSE_STATUS_CODE, GEN_AI_TOOL_NAME, GEN_AI_PROMPT_NAME, GEN_AI_OPERATION_NAME, GEN_AI_OPERATION_EXECUTE_TOOL, NETWORK_TRANSPORT, ERROR_TYPE, ERROR_TYPE_TOOL, JSONRPC_REQUEST_ID, SPAN_NAME_TOOLS_CALL, MAX_ATTRIBUTE_LENGTH, TRUNCATION_SUFFIX, METHOD_TOOLS_CALL, METHOD_TOOLS_LIST, METHOD_RESOURCES_READ, METHOD_PROMPTS_GET, METHOD_INITIALIZE;
-var init_semantic_conventions = __esm({
-  "src/internal/instrumentation/mcp/semantic-conventions.ts"() {
-    "use strict";
-    MCP_TOOL_NAME = "mcp.tool.name";
-    MCP_TOOL_ARGUMENTS = "mcp.tool.arguments";
-    MCP_TOOL_RESULT = "mcp.tool.result";
-    MCP_COMPONENT_TYPE = "mcp.component.type";
-    MCP_COMPONENT_TOOL = "tool";
-    MCP_COMPONENT_TOOL_SCHEMA = "tool_schema";
-    MCP_TOOL_SCHEMA_PARAMETERS = "mcp.tool.schema.parameters";
-    MCP_TOOL_SCHEMA_OUTPUT = "mcp.tool.schema.output";
-    MCP_TOOL_DESCRIPTION = "mcp.tool.description";
-    SPAN_NAME_TOOL_REGISTER = "mcp.tool.register";
-    MCP_METHOD_NAME = "mcp.method.name";
-    MCP_REQUEST_ID = "mcp.request.id";
-    MCP_SESSION_ID = "mcp.session.id";
-    MCP_PROTOCOL_VERSION = "mcp.protocol.version";
-    MCP_RESOURCE_URI = "mcp.resource.uri";
-    RPC_SYSTEM = "rpc.system";
-    RPC_SYSTEM_MCP = "mcp";
-    RPC_RESPONSE_STATUS_CODE = "rpc.response.status_code";
-    GEN_AI_TOOL_NAME = "gen_ai.tool.name";
-    GEN_AI_PROMPT_NAME = "gen_ai.prompt.name";
-    GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
-    GEN_AI_OPERATION_EXECUTE_TOOL = "execute_tool";
-    NETWORK_TRANSPORT = "network.transport";
-    ERROR_TYPE = "error.type";
-    ERROR_TYPE_TOOL = "tool_error";
-    JSONRPC_REQUEST_ID = "jsonrpc.request.id";
-    SPAN_NAME_TOOLS_CALL = "tools/call";
-    MAX_ATTRIBUTE_LENGTH = 32 * 1024;
-    TRUNCATION_SUFFIX = "\u2026(truncated)";
-    METHOD_TOOLS_CALL = "tools/call";
-    METHOD_TOOLS_LIST = "tools/list";
-    METHOD_RESOURCES_READ = "resources/read";
-    METHOD_PROMPTS_GET = "prompts/get";
-    METHOD_INITIALIZE = "initialize";
-  }
-});
 
-// src/internal/instrumentation/mcp/schemas.ts
-function truncateSchemaAttr(value) {
-  if (value.length <= _MAX_SCHEMA_ATTR_BYTES) {
-    return value;
-  }
-  return `{"_truncated":true,"original_length":${value.length}}`;
-}
-function safeStringify(value) {
-  if (value === null || value === void 0) {
-    return "";
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return "";
-  }
-}
-function emitSchemaSpansFromListResponse(result, transportSessionId, tracer) {
-  if (!transportSessionId) {
-    return;
-  }
-  const tools = extractTools(result);
-  if (tools === void 0) {
-    return;
-  }
-  for (const tool of tools) {
-    const name = typeof tool.name === "string" ? tool.name : void 0;
-    if (!name) {
-      continue;
-    }
-    const span = tracer.startSpan(`${SPAN_NAME_TOOL_REGISTER} ${name}`, {
-      kind: import_api2.SpanKind.INTERNAL
-    });
-    try {
-      stampSchemaAttributes(span, name, transportSessionId, tool);
-      span.setStatus({ code: import_api2.SpanStatusCode.OK });
-    } finally {
-      span.end();
-    }
-  }
-}
-function stampSchemaAttributes(span, toolName, transportSessionId, tool) {
-  if (!span.isRecording()) {
-    logger.warn(
-      `Brizz MCP: schema span is not recording; dropping attributes for ${toolName}`
-    );
-    return;
-  }
-  const description = typeof tool.description === "string" ? tool.description : "";
-  const parameters = truncateSchemaAttr(safeStringify(tool.inputSchema));
-  const outputSchema = tool.outputSchema !== void 0 && tool.outputSchema !== null ? truncateSchemaAttr(safeStringify(tool.outputSchema)) : "";
-  span.setAttribute(RPC_SYSTEM, RPC_SYSTEM_MCP);
-  span.setAttribute(MCP_COMPONENT_TYPE, MCP_COMPONENT_TOOL_SCHEMA);
-  span.setAttribute(MCP_SESSION_ID, transportSessionId);
-  span.setAttribute(MCP_TOOL_NAME, toolName);
-  span.setAttribute(MCP_TOOL_SCHEMA_PARAMETERS, parameters);
-  span.setAttribute(MCP_TOOL_SCHEMA_OUTPUT, outputSchema);
-  span.setAttribute(MCP_TOOL_DESCRIPTION, description);
-}
-function extractTools(result) {
-  if (!result || typeof result !== "object") {
-    return void 0;
-  }
-  const tools = result.tools;
-  if (!Array.isArray(tools)) {
-    return void 0;
-  }
-  return tools.filter(
-    (t) => t !== null && typeof t === "object"
-  );
-}
-var import_api2, _MAX_SCHEMA_ATTR_BYTES;
-var init_schemas = __esm({
-  "src/internal/instrumentation/mcp/schemas.ts"() {
-    "use strict";
-    import_api2 = require("@opentelemetry/api");
-    init_logger();
-    init_semantic_conventions();
-    _MAX_SCHEMA_ATTR_BYTES = 4e3;
-  }
-});
 
-// src/internal/semantic-conventions.ts
-var import_api3, BRIZZ, PROPERTIES, SESSION_ID, PROPERTIES_CONTEXT_KEY, SESSION_OBJECT_CONTEXT_KEY, SESSION_INPUT, SESSION_OUTPUT, SESSION_INPUT_CONTEXT, SESSION_OUTPUT_CONTEXT, SESSION_SPAN_NAME, MUTE_INPUT, MUTE_OUTPUT, SESSION_TITLE_SPAN_NAME, SESSION_TITLE_GENERATION, SESSION_TITLE, INTERRUPT_TOOLS, INTERNAL_EVENT_PREFIX, EXTERNAL_LINK_EVENT_NAME, EXTERNAL_LINK_URL, EXTERNAL_LINK_TITLE, EXTERNAL_LINK_TYPE;
-var init_semantic_conventions2 = __esm({
-  "src/internal/semantic-conventions.ts"() {
-    "use strict";
-    import_api3 = require("@opentelemetry/api");
-    BRIZZ = "brizz";
-    PROPERTIES = "properties";
-    SESSION_ID = "session.id";
-    PROPERTIES_CONTEXT_KEY = (0, import_api3.createContextKey)(PROPERTIES);
-    SESSION_OBJECT_CONTEXT_KEY = (0, import_api3.createContextKey)("brizz.session.object");
-    SESSION_INPUT = "brizz.session.input";
-    SESSION_OUTPUT = "brizz.session.output";
-    SESSION_INPUT_CONTEXT = "brizz.session.input.context";
-    SESSION_OUTPUT_CONTEXT = "brizz.session.output.context";
-    SESSION_SPAN_NAME = "brizz.start_session";
-    MUTE_INPUT = "mute.input";
-    MUTE_OUTPUT = "mute.output";
-    SESSION_TITLE_SPAN_NAME = "brizz.session_title";
-    SESSION_TITLE_GENERATION = "session.title_generation";
-    SESSION_TITLE = "brizz.session.title";
-    INTERRUPT_TOOLS = "brizz.internal.interrupt";
-    INTERNAL_EVENT_PREFIX = "brizz.internal.";
-    EXTERNAL_LINK_EVENT_NAME = "brizz.internal.external_link";
-    EXTERNAL_LINK_URL = "brizz.internal.external_link.url";
-    EXTERNAL_LINK_TITLE = "brizz.internal.external_link.title";
-    EXTERNAL_LINK_TYPE = "brizz.internal.external_link.type";
-  }
-});
 
-// src/internal/instrumentation/mcp/session.ts
-function stampAndPropagateSession(span, sessionId, baseContext = import_api4.context.active()) {
-  if (!sessionId) {
-    return { context: baseContext, sessionId: null };
-  }
-  if (span.isRecording()) {
-    try {
-      span.setAttribute(`${BRIZZ}.${SESSION_ID}`, sessionId);
-    } catch (error) {
-      logger.warn(
-        `Brizz MCP: failed to stamp session id on span: ${String(error)}`
-      );
-    }
-  }
-  try {
-    const prev = baseContext.getValue(PROPERTIES_CONTEXT_KEY);
-    const merged = prev ? { ...prev, [SESSION_ID]: sessionId } : { [SESSION_ID]: sessionId };
-    return {
-      context: baseContext.setValue(PROPERTIES_CONTEXT_KEY, merged),
-      sessionId
-    };
-  } catch (error) {
-    logger.warn(`Brizz MCP: failed to attach session context: ${String(error)}`);
-    return { context: baseContext, sessionId };
-  }
-}
-var import_api4;
-var init_session = __esm({
-  "src/internal/instrumentation/mcp/session.ts"() {
-    "use strict";
-    import_api4 = require("@opentelemetry/api");
-    init_logger();
-    init_semantic_conventions2();
-  }
-});
 
-// src/internal/instrumentation/mcp/patches/attributes.ts
-function deriveSpanName(method, params) {
-  try {
-    if (method === METHOD_TOOLS_CALL) {
-      const name = typeof params?.["name"] === "string" ? params["name"] : "";
-      return name ? `${SPAN_NAME_TOOLS_CALL} ${name}` : SPAN_NAME_TOOLS_CALL;
-    }
-    if (method === METHOD_RESOURCES_READ) {
-      const uri = typeof params?.["uri"] === "string" ? params["uri"] : "";
-      return uri ? `${METHOD_RESOURCES_READ} ${uri}` : METHOD_RESOURCES_READ;
-    }
-    if (method === METHOD_PROMPTS_GET) {
-      const name = typeof params?.["name"] === "string" ? params["name"] : "";
-      return name ? `${METHOD_PROMPTS_GET} ${name}` : METHOD_PROMPTS_GET;
-    }
-    return method;
-  } catch {
-    return method || "mcp";
-  }
-}
-function applyBaseAttributes(span, request) {
-  span.setAttribute(RPC_SYSTEM, RPC_SYSTEM_MCP);
-  if (request.method) {
-    span.setAttribute(MCP_METHOD_NAME, request.method);
-  }
-  if (request.id !== void 0 && request.id !== null) {
-    const id = String(request.id);
-    span.setAttribute(MCP_REQUEST_ID, id);
-    span.setAttribute(JSONRPC_REQUEST_ID, id);
-  }
-}
-function applyClientRequestAttributes(span, request, transportName) {
-  applyBaseAttributes(span, request);
-  applyMethodSpecificRequestAttributes(span, request);
-  if (transportName) {
-    const transport = normalizeTransport(transportName);
-    if (transport) {
-      span.setAttribute(NETWORK_TRANSPORT, transport);
-    }
-  }
-}
-function applyServerRequestAttributes(span, request, protocol) {
-  applyBaseAttributes(span, request);
-  applyMethodSpecificRequestAttributes(span, request);
-  if (request.method === METHOD_TOOLS_CALL) {
-    const args = request.params?.["arguments"];
-    if (args !== void 0) {
-      span.setAttribute(MCP_TOOL_ARGUMENTS, serializeForAttribute(args));
-    }
-  }
-  const sessionId = protocol.sessionId ?? protocol._transport?.sessionId;
-  if (sessionId) {
-    span.setAttribute(MCP_SESSION_ID, String(sessionId));
-  }
-}
-function applyMethodSpecificRequestAttributes(span, request) {
-  const params = request.params ?? {};
-  switch (request.method) {
-    case METHOD_TOOLS_CALL: {
-      const name = typeof params["name"] === "string" ? params["name"] : "";
-      if (name) {
-        span.setAttribute(MCP_TOOL_NAME, name);
-        span.setAttribute(GEN_AI_TOOL_NAME, name);
-      }
-      span.setAttribute(MCP_COMPONENT_TYPE, MCP_COMPONENT_TOOL);
-      span.setAttribute(GEN_AI_OPERATION_NAME, GEN_AI_OPERATION_EXECUTE_TOOL);
-      break;
-    }
-    case METHOD_RESOURCES_READ: {
-      const uri = typeof params["uri"] === "string" ? params["uri"] : "";
-      if (uri) {
-        span.setAttribute(MCP_RESOURCE_URI, uri);
-      }
-      break;
-    }
-    case METHOD_PROMPTS_GET: {
-      const name = typeof params["name"] === "string" ? params["name"] : "";
-      if (name) {
-        span.setAttribute(GEN_AI_PROMPT_NAME, name);
-      }
-      break;
-    }
-    default:
-      break;
-  }
-}
-function applyResultAttributes(span, method, result) {
-  if (method === METHOD_INITIALIZE && result && typeof result === "object") {
-    const protocolVersion = result["protocolVersion"];
-    if (typeof protocolVersion === "string") {
-      span.setAttribute(MCP_PROTOCOL_VERSION, protocolVersion);
-    }
-    return;
-  }
-  if (method !== METHOD_TOOLS_CALL) {
-    return;
-  }
-  const obj = result && typeof result === "object" ? result : null;
-  const content = obj?.["content"] ?? result;
-  span.setAttribute(MCP_TOOL_RESULT, serializeForAttribute(content));
-  if (obj && obj["isError"] === true) {
-    span.setAttribute(ERROR_TYPE, ERROR_TYPE_TOOL);
-    const message = extractToolErrorMessage(obj);
-    span.setStatus({ code: import_api5.SpanStatusCode.ERROR, message });
-  }
-}
-function applyErrorAttributes(span, err) {
-  const error = err;
-  const code = error?.code;
-  if (typeof code === "number") {
-    span.setAttribute(RPC_RESPONSE_STATUS_CODE, code);
-    span.setAttribute(ERROR_TYPE, String(code));
-  } else if (error?.name === "AbortError") {
-    span.setAttribute(ERROR_TYPE, "cancelled");
-  } else if (error?.name === "TimeoutError") {
-    span.setAttribute(ERROR_TYPE, "timeout");
-  } else {
-    span.setAttribute(
-      ERROR_TYPE,
-      error?.constructor?.name || error?.name || "Error"
-    );
-  }
-  try {
-    span.recordException(error);
-  } catch {
-  }
-  span.setStatus({
-    code: import_api5.SpanStatusCode.ERROR,
-    message: typeof error?.message === "string" ? error.message : void 0
-  });
-}
-function serializeForAttribute(value) {
-  const raw = rawSerialize(value);
-  if (raw.length <= MAX_ATTRIBUTE_LENGTH) {
-    return raw;
-  }
-  return raw.slice(0, MAX_ATTRIBUTE_LENGTH - TRUNCATION_SUFFIX.length) + TRUNCATION_SUFFIX;
-}
-function rawSerialize(value) {
-  if (value === null || value === void 0) {
-    return "";
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    try {
-      if (value === null || value === void 0) {
-        return "";
-      }
-      const tag = Object.prototype.toString.call(value);
-      return typeof value.toString === "function" ? (
-        // eslint-disable-next-line @typescript-eslint/no-base-to-string
-        String(value)
-      ) : tag;
-    } catch {
-      return "";
-    }
-  }
-}
-function extractToolErrorMessage(result) {
-  const content = result["content"];
-  if (Array.isArray(content)) {
-    for (const item of content) {
-      if (item && typeof item === "object") {
-        const text = item["text"];
-        if (typeof text === "string") {
-          return text;
-        }
-      }
-    }
-  }
-  return void 0;
-}
-function normalizeTransport(ctorName) {
-  const name = ctorName.toLowerCase();
-  if (name.includes("stdio")) {
-    return "stdio";
-  }
-  if (name.includes("sse")) {
-    return "sse";
-  }
-  if (name.includes("streamablehttp") || name.includes("http")) {
-    return "http";
-  }
-  return null;
-}
-var import_api5;
-var init_attributes = __esm({
-  "src/internal/instrumentation/mcp/patches/attributes.ts"() {
-    "use strict";
-    import_api5 = require("@opentelemetry/api");
-    init_semantic_conventions();
-  }
-});
 
-// src/internal/instrumentation/mcp/patches/protocol.ts
-function patchProtocolPrototype(prototype, tracer) {
-  if (!prototype || typeof prototype !== "object") {
-    return false;
-  }
-  const proto = prototype;
-  if (proto[PATCHED_FLAG]) {
-    logger.debug("Brizz MCP: Protocol.prototype already patched, skipping");
-    return false;
-  }
-  const originalRequest = proto["request"];
-  const originalOnRequest = proto["_onrequest"];
-  if (typeof originalRequest === "function") {
-    proto["request"] = wrapRequest(originalRequest, tracer);
-  } else {
-    logger.debug(
-      "Brizz MCP: Protocol.prototype.request missing \u2014 skipping CLIENT patch"
-    );
-  }
-  if (typeof originalOnRequest === "function") {
-    proto["_onrequest"] = wrapOnRequest(
-      originalOnRequest,
-      tracer
-    );
-  } else {
-    logger.debug(
-      "Brizz MCP: Protocol.prototype._onrequest missing \u2014 skipping SERVER patch"
-    );
-  }
-  proto[PATCHED_FLAG] = true;
-  return true;
-}
-function wrapRequest(original, tracer) {
-  return function wrappedRequest(...args) {
-    const request = args[0];
-    if (!request || typeof request !== "object" || !request.method) {
-      return original.apply(this, args);
-    }
-    const span = safeStartClientSpan(tracer, request, this);
-    if (!span) {
-      return original.apply(this, args);
-    }
-    return executeAroundSpan(span, request.method, () => {
-      const ctx = import_api6.trace.setSpan(import_api6.context.active(), span);
-      return import_api6.context.with(ctx, () => original.apply(this, args));
-    });
-  };
-}
-function wrapOnRequest(original, tracer) {
-  return function wrappedOnRequest(...args) {
-    const request = args[0];
-    if (!request || typeof request !== "object" || !request.method) {
-      return original.apply(this, args);
-    }
-    const handlers = this._requestHandlers;
-    if (!handlers || typeof handlers.get !== "function") {
-      return original.apply(this, args);
-    }
-    const method = request.method;
-    const handler = handlers.get(method) ?? this.fallbackRequestHandler;
-    if (!handler) {
-      return original.apply(this, args);
-    }
-    const started = safeStartServerSpan(tracer, request, this);
-    if (!started) {
-      return original.apply(this, args);
-    }
-    const { span, spanCtx } = started;
-    const transportSessionId = this.sessionId ?? this._transport?.sessionId;
-    const postResult = method === METHOD_TOOLS_LIST ? (result) => {
-      try {
-        emitSchemaSpansFromListResponse(result, transportSessionId, tracer);
-      } catch (error) {
-        logger.warn(
-          `Brizz MCP: failed to emit tools/list schema spans: ${String(error)}`
-        );
-      }
-    } : void 0;
-    const wrappedHandler = (req, extra) => import_api6.context.with(
-      spanCtx,
-      () => executeHandler(span, method, handler, req, extra, postResult)
-    );
-    const hadEntry = handlers.has(method);
-    const prev = handlers.get(method);
-    handlers.set(method, wrappedHandler);
-    const usedFallback = !hadEntry && this.fallbackRequestHandler === handler;
-    const fallbackPrev = usedFallback ? this.fallbackRequestHandler : void 0;
-    if (usedFallback) {
-      this.fallbackRequestHandler = wrappedHandler;
-    }
-    try {
-      return original.apply(this, args);
-    } finally {
-      if (hadEntry) {
-        handlers.set(method, prev);
-      } else {
-        handlers.delete(method);
-      }
-      if (usedFallback) {
-        this.fallbackRequestHandler = fallbackPrev;
-      }
-    }
-  };
-}
-function executeAroundSpan(span, method, run, postResult) {
-  let result;
-  try {
-    result = run();
-  } catch (error) {
-    safeApplyErrorAttributes(span, error);
-    safeEnd(span);
-    throw error;
-  }
-  if (!isThenable(result)) {
-    safeApplyResultAttributes(span, method, result);
-    if (postResult) {
-      postResult(result);
-    }
-    safeEnd(span);
-    return result;
-  }
-  return result.then(
-    (value) => {
-      safeApplyResultAttributes(span, method, value);
-      if (postResult) {
-        postResult(value);
-      }
-      safeEnd(span);
-      return value;
-    },
-    (error) => {
-      safeApplyErrorAttributes(span, error);
-      safeEnd(span);
-      throw error;
-    }
-  );
-}
-function executeHandler(span, method, handler, req, extra, postResult) {
-  return executeAroundSpan(span, method, () => handler(req, extra), postResult);
-}
-function safeStartClientSpan(tracer, request, protocol) {
-  try {
-    const spanName = deriveSpanName(request.method, request.params);
-    const span = tracer.startSpan(spanName, { kind: import_api6.SpanKind.CLIENT });
-    applyClientRequestAttributes(
-      span,
-      request,
-      protocol._transport?.constructor?.name
-    );
-    return span;
-  } catch (error) {
-    logger.debug(`Brizz MCP: failed to open CLIENT span: ${String(error)}`);
-    return null;
-  }
-}
-function safeStartServerSpan(tracer, request, protocol) {
-  try {
-    const parentCtx = extractParentContext(request);
-    const spanName = deriveSpanName(request.method, request.params);
-    const span = tracer.startSpan(
-      spanName,
-      { kind: import_api6.SpanKind.SERVER },
-      parentCtx
-    );
-    applyServerRequestAttributes(span, request, protocol);
-    const sessionId = protocol.sessionId ?? protocol._transport?.sessionId;
-    const { context: sessCtx } = stampAndPropagateSession(span, sessionId, parentCtx);
-    return { span, spanCtx: import_api6.trace.setSpan(sessCtx, span) };
-  } catch (error) {
-    logger.debug(`Brizz MCP: failed to open SERVER span: ${String(error)}`);
-    return null;
-  }
-}
-function extractParentContext(request) {
-  try {
-    const meta = request.params?._meta;
-    if (meta && typeof meta === "object") {
-      return import_api6.propagation.extract(import_api6.context.active(), meta);
-    }
-  } catch (error) {
-    logger.debug(
-      `Brizz MCP: failed to extract parent context from _meta: ${String(error)}`
-    );
-  }
-  return import_api6.context.active();
-}
-function isThenable(value) {
-  return !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
-}
-function safeApplyResultAttributes(span, method, value) {
-  try {
-    applyResultAttributes(span, method, value);
-  } catch (error) {
-    logger.debug(
-      `Brizz MCP: failed to apply result attributes: ${String(error)}`
-    );
-  }
-}
-function safeApplyErrorAttributes(span, err) {
-  try {
-    applyErrorAttributes(span, err);
-  } catch (error) {
-    logger.debug(
-      `Brizz MCP: failed to apply error attributes: ${String(error)}`
-    );
-  }
-}
-function safeEnd(span) {
-  try {
-    span.end();
-  } catch (error) {
-    logger.debug(`Brizz MCP: failed to end span: ${String(error)}`);
-  }
-}
-var import_api6, PATCHED_FLAG;
-var init_protocol = __esm({
-  "src/internal/instrumentation/mcp/patches/protocol.ts"() {
-    "use strict";
-    import_api6 = require("@opentelemetry/api");
-    init_logger();
-    init_schemas();
-    init_semantic_conventions();
-    init_session();
-    init_attributes();
-    PATCHED_FLAG = /* @__PURE__ */ Symbol("brizz.mcp.protocol-patched");
-  }
-});
 
-// src/internal/version.ts
-function getSDKVersion() {
-  return "0.1.28";
-}
-var init_version = __esm({
-  "src/internal/version.ts"() {
-    "use strict";
-  }
-});
 
-// src/internal/instrumentation/mcp/version.ts
-var INSTRUMENTATION_NAME, INSTRUMENTATION_VERSION;
-var init_version2 = __esm({
-  "src/internal/instrumentation/mcp/version.ts"() {
-    "use strict";
-    init_version();
-    INSTRUMENTATION_NAME = "@brizz/sdk/mcp";
-    INSTRUMENTATION_VERSION = getSDKVersion();
-  }
-});
 
-// src/internal/instrumentation/mcp/instrumentation.ts
-function isMCPInstrumentation(value) {
-  return !!value && typeof value === "object" && typeof value.instrumentationName === "string";
-}
-var import_openinference_instrumentation_mcp, import_api7, import_instrumentation, PROTOCOL_MODULE_NAME, PROTOCOL_SUPPORTED_VERSIONS, MCPInstrumentation;
-var init_instrumentation = __esm({
-  "src/internal/instrumentation/mcp/instrumentation.ts"() {
-    "use strict";
-    import_openinference_instrumentation_mcp = require("@arizeai/openinference-instrumentation-mcp");
-    import_api7 = require("@opentelemetry/api");
-    import_instrumentation = require("@opentelemetry/instrumentation");
-    init_logger();
-    init_protocol();
-    init_version2();
-    PROTOCOL_MODULE_NAME = "@modelcontextprotocol/sdk/shared/protocol.js";
-    PROTOCOL_SUPPORTED_VERSIONS = [">=1.0.0 <2"];
-    MCPInstrumentation = class extends import_openinference_instrumentation_mcp.MCPInstrumentation {
-      /**
-       * Dedicated Brizz-named tracer for our SERVER + CLIENT spans.
-       *
-       * Why a separate tracer from the parent class's one: Arize's inherited
-       * transport patches don't emit spans (they only inject propagation
-       * headers), so using our own tracer here keeps Brizz spans attributed to
-       * `@brizz/sdk/mcp` in the dashboard. The parent's `tracer` is a
-       * `protected get` (no setter), so fighting it with assignment is the
-       * wrong tool.
-       */
-      brizzTracer;
-      constructor(_config) {
-        super({ instrumentationConfig: _config?.instrumentationConfig });
-        this.brizzTracer = import_api7.trace.getTracer(INSTRUMENTATION_NAME, INSTRUMENTATION_VERSION);
-      }
-      /**
-       * Extend `super.init()` with our protocol-layer module definition.
-       *
-       * Arize's `init()` returns definitions for the six transport modules
-       * (SSE client/server, stdio client/server, streamable-HTTP client/server)
-       * whose `send`/`start` methods get patched for W3C trace-context
-       * injection. We append one more: `@modelcontextprotocol/sdk/shared/protocol.js`
-       * where our patches open SERVER/CLIENT spans around the handler + outgoing
-       * request. If `super.init()` throws (unlikely but possible across Arize
-       * versions), we gracefully degrade to protocol-only instrumentation.
-       *
-       * The cast at the end satisfies the parent's strongly-typed generic
-       * without leaking the cast into call sites.
-       */
-      init() {
-        let base;
-        try {
-          base = super.init() ?? [];
-        } catch (error) {
-          logger.warn(
-            `Brizz MCP: base Arize init() failed \u2014 transport context propagation disabled: ${String(error)}`
-          );
-          base = [];
-        }
-        const baseArr = Array.isArray(base) ? base : [base];
-        const brizzDef = new import_instrumentation.InstrumentationNodeModuleDefinition(
-          PROTOCOL_MODULE_NAME,
-          PROTOCOL_SUPPORTED_VERSIONS,
-          (module2) => {
-            this.patchProtocolModule(module2);
-            return module2;
-          },
-          (module2) => {
-            this.unpatchProtocolModule(module2);
-            return module2;
-          }
-        );
-        return [...baseArr, brizzDef];
-      }
-      /**
-       * Manually instrument MCP modules for Next.js/Webpack where the
-       * auto-instrumentation module-load hook doesn't fire.
-       *
-       * Forwards the six transport module fields to the inherited Arize
-       * `manuallyInstrument(...)` (context propagation) and applies our
-       * protocol patch if `protocolModule` is provided (SERVER/CLIENT spans).
-       * Both legs are try/catch-guarded — a failure in one shouldn't prevent
-       * the other from taking effect.
-       */
-      manuallyInstrument(modules) {
-        const {
-          clientSSEModule,
-          serverSSEModule,
-          clientStdioModule,
-          serverStdioModule,
-          clientStreamableHTTPModule,
-          serverStreamableHTTPModule,
-          protocolModule
-        } = modules;
-        try {
-          super.manuallyInstrument({
-            clientSSEModule,
-            serverSSEModule,
-            clientStdioModule,
-            serverStdioModule,
-            clientStreamableHTTPModule,
-            serverStreamableHTTPModule
-          });
-        } catch (error) {
-          logger.warn(`Brizz MCP: Arize manuallyInstrument(...) failed: ${String(error)}`);
-        }
-        if (protocolModule) {
-          try {
-            this.patchProtocolModule(protocolModule);
-          } catch (error) {
-            logger.warn(
-              `Brizz MCP: failed to manually patch Protocol module: ${String(error)}`
-            );
-          }
-        }
-      }
-      /**
-       * Apply the SERVER + CLIENT patch to a loaded `protocol.js` module. Shared
-       * by both the automatic module-load callback in `init()` and the manual
-       * `manuallyInstrument(...)` path above so there's exactly one place that
-       * calls `patchProtocolPrototype`.
-       */
-      patchProtocolModule(module2) {
-        const proto = module2?.Protocol?.prototype;
-        if (!proto) {
-          logger.debug(
-            "Brizz MCP: module does not expose Protocol.prototype \u2014 skipping protocol patches"
-          );
-          return;
-        }
-        const ok = patchProtocolPrototype(proto, this.brizzTracer);
-        if (ok) {
-          logger.debug("Brizz MCP: patched Protocol.prototype for SERVER+CLIENT spans");
-        }
-      }
-      /**
-       * Unpatch is intentionally a no-op.
-       *
-       * `patchProtocolPrototype` wraps methods in place and sets a PATCHED_FLAG
-       * Symbol on the prototype to prevent double-patching. Restoring the
-       * originals would require us to hold references across module unloads,
-       * which isn't a pattern we need — instrumentation rarely gets torn down
-       * at runtime, and a process reload is the canonical way to detach.
-       */
-      unpatchProtocolModule(_module) {
-        logger.debug(
-          "Brizz MCP: unpatch is a no-op \u2014 reload the process to cleanly detach"
-        );
-      }
-    };
-  }
-});
 
-// src/internal/instrumentation/mcp/index.ts
-var mcp_exports = {};
-__export(mcp_exports, {
-  MCPInstrumentation: () => MCPInstrumentation,
-  isMCPInstrumentation: () => isMCPInstrumentation
-});
-var init_mcp = __esm({
-  "src/internal/instrumentation/mcp/index.ts"() {
-    "use strict";
-    init_instrumentation();
-  }
-});
 
-// src/internal/instrumentation/vercel-ai/interrupt.ts
-var interrupt_exports = {};
-__export(interrupt_exports, {
-  InterruptPropagator: () => InterruptPropagator,
-  _resetInterruptState: () => _resetInterruptState,
-  createInterruptIntegration: () => createInterruptIntegration
-});
-function isInnerLLMSpan(span) {
-  if (INNER_OPERATION_IDS.has(span.name)) {
-    return true;
-  }
-  const opId = span.attributes["ai.operationId"];
-  return typeof opId === "string" && INNER_OPERATION_IDS.has(opId);
-}
-function setPending(parentSpanId, value) {
-  pendingByParentSpanId.set(parentSpanId, value);
-  while (pendingByParentSpanId.size > MAX_PENDING_ENTRIES) {
-    const oldest = pendingByParentSpanId.keys().next().value;
-    if (oldest === void 0) {
-      break;
-    }
-    pendingByParentSpanId.delete(oldest);
-  }
-}
-function extractInterruptTools(tools) {
-  if (!tools || typeof tools !== "object") {
-    return [];
-  }
-  return Object.entries(tools).filter(
-    ([, t]) => !!t && typeof t === "object" && t.needsApproval
-  ).map(([name]) => name);
-}
-function createInterruptIntegration() {
-  const onStepStart = (event) => {
-    const names = extractInterruptTools(event.tools);
-    if (names.length === 0) {
-      return;
-    }
-    const value = JSON.stringify(names);
-    const span = import_api8.trace.getActiveSpan();
-    if (!span) {
-      return;
-    }
-    span.setAttribute(INTERRUPT_TOOLS, value);
-    setPending(span.spanContext().spanId, value);
-  };
-  return {
-    onStepStart
-  };
-}
-function _resetInterruptState() {
-  if (process.env["NODE_ENV"] !== "test") {
-    return;
-  }
-  pendingByParentSpanId.clear();
-}
-var import_api8, INNER_OPERATION_IDS, MAX_PENDING_ENTRIES, pendingByParentSpanId, InterruptPropagator;
-var init_interrupt = __esm({
-  "src/internal/instrumentation/vercel-ai/interrupt.ts"() {
-    "use strict";
-    import_api8 = require("@opentelemetry/api");
-    init_semantic_conventions2();
-    INNER_OPERATION_IDS = /* @__PURE__ */ new Set([
-      "ai.generateText.doGenerate",
-      "ai.streamText.doStream"
-    ]);
-    MAX_PENDING_ENTRIES = 1024;
-    pendingByParentSpanId = /* @__PURE__ */ new Map();
-    InterruptPropagator = class {
-      onStart(span, _parentContext) {
-        if (!isInnerLLMSpan(span)) {
-          return;
-        }
-        const parentSpanId = span.parentSpanContext?.spanId;
-        if (!parentSpanId) {
-          return;
-        }
-        const value = pendingByParentSpanId.get(parentSpanId);
-        if (!value) {
-          return;
-        }
-        span.setAttribute(INTERRUPT_TOOLS, value);
-        pendingByParentSpanId.delete(parentSpanId);
-      }
-      onEnd() {
-      }
-      async shutdown() {
-      }
-      async forceFlush() {
-      }
-    };
-  }
-});
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  Brizz: () => Brizz,
-  DEFAULT_PII_PATTERNS: () => DEFAULT_PII_PATTERNS,
-  LogLevel: () => LogLevel,
-  Session: () => Session,
-  SessionTitle: () => SessionTitle,
-  SeverityNumber: () => import_api_logs2.SeverityNumber,
-  addExternalLink: () => addExternalLink,
-  callWithMute: () => callWithMute,
-  callWithProperties: () => callWithProperties,
-  callWithSessionId: () => callWithSessionId,
-  detectRuntime: () => detectRuntime,
-  emitEvent: () => emitEvent,
-  emitEventWithSessionId: () => emitEventWithSessionId,
-  getActiveSession: () => getActiveSession,
-  getLogLevel: () => getLogLevel,
-  getMetricsExporter: () => getMetricsExporter,
-  getMetricsReader: () => getMetricsReader,
-  getSpanExporter: () => getSpanExporter,
-  getSpanProcessor: () => getSpanProcessor,
-  init: () => init_exports,
-  logger: () => logger,
-  maskAttributes: () => maskAttributes,
-  maskValue: () => maskValue,
-  setCurrentSpanCustomProperties: () => setCurrentSpanCustomProperties,
-  setLogLevel: () => setLogLevel,
-  startSession: () => startSession,
-  startSessionTitle: () => startSessionTitle,
-  withMute: () => withMute,
-  withProperties: () => withProperties,
-  withSessionId: () => withSessionId
-});
-module.exports = __toCommonJS(src_exports);
+
+
+
+
+
+
+
+
+
+var _chunkNUTJMVD4cjs = require('./chunk-NUTJMVD4.cjs');
+
+
+
+
+
+var _chunkJB6MA2RVcjs = require('./chunk-JB6MA2RV.cjs');
+require('./chunk-LTXMCGVQ.cjs');
+require('./chunk-GCORRK6B.cjs');
 
 // src/internal/instrumentation/auto-init.ts
-var import_auto_instrumentations_node = require("@opentelemetry/auto-instrumentations-node");
-var import_instrumentation3 = require("@opentelemetry/instrumentation");
-var import_instrumentation_anthropic = require("@traceloop/instrumentation-anthropic");
-var import_instrumentation_bedrock = require("@traceloop/instrumentation-bedrock");
-var import_instrumentation_chromadb = require("@traceloop/instrumentation-chromadb");
-var import_instrumentation_cohere = require("@traceloop/instrumentation-cohere");
-var import_instrumentation_llamaindex = require("@traceloop/instrumentation-llamaindex");
-var import_instrumentation_openai = require("@traceloop/instrumentation-openai");
-var import_instrumentation_pinecone = require("@traceloop/instrumentation-pinecone");
-var import_instrumentation_qdrant = require("@traceloop/instrumentation-qdrant");
-var import_instrumentation_together = require("@traceloop/instrumentation-together");
-var import_instrumentation_vertexai = require("@traceloop/instrumentation-vertexai");
-init_logger();
-var autoInstrumentationsLoaded = false;
+var _instrumentation = require('@opentelemetry/instrumentation');
+var _instrumentationanthropic = require('@traceloop/instrumentation-anthropic');
+var _instrumentationbedrock = require('@traceloop/instrumentation-bedrock');
+var _instrumentationchromadb = require('@traceloop/instrumentation-chromadb');
+var _instrumentationcohere = require('@traceloop/instrumentation-cohere');
+var _instrumentationllamaindex = require('@traceloop/instrumentation-llamaindex');
+var _instrumentationopenai = require('@traceloop/instrumentation-openai');
+var _instrumentationpinecone = require('@traceloop/instrumentation-pinecone');
+var _instrumentationqdrant = require('@traceloop/instrumentation-qdrant');
+var _instrumentationtogether = require('@traceloop/instrumentation-together');
 var exceptionLogger = (error) => {
-  logger.error(`Exception in instrumentation: ${String(error)}`);
+  _chunkJB6MA2RVcjs.logger.error(`Exception in instrumentation: ${String(error)}`);
 };
-function loadNodeAutoInstrumentations() {
-  try {
-    const nodeInstrumentations = (0, import_auto_instrumentations_node.getNodeAutoInstrumentations)({
-      // Disabled because @traceloop/instrumentation-openai wraps the same OpenAI
-      // prototype with richer span attributes (gen_ai.input.messages /
-      // gen_ai.output.messages). Leaving both enabled lets the official one win
-      // and route content to log events instead of span attributes, leaving the
-      // Brizz backend parser with no payload to read.
-      "@opentelemetry/instrumentation-openai": { enabled: false }
-    });
-    (0, import_instrumentation3.registerInstrumentations)({ instrumentations: nodeInstrumentations });
-    return nodeInstrumentations;
-  } catch (error) {
-    logger.error(`Failed to load Node.js auto-instrumentations: ${String(error)}`);
-    return [];
-  }
-}
 function loadGenAIInstrumentations() {
   const instrumentations = [];
   const genAIInstrumentationClasses = [
-    { class: import_instrumentation_openai.OpenAIInstrumentation, name: "OpenAI" },
-    { class: import_instrumentation_anthropic.AnthropicInstrumentation, name: "Anthropic" },
-    { class: import_instrumentation_cohere.CohereInstrumentation, name: "Cohere" },
-    { class: import_instrumentation_vertexai.VertexAIInstrumentation, name: "Vertex AI" },
-    { class: import_instrumentation_bedrock.BedrockInstrumentation, name: "Bedrock" },
-    { class: import_instrumentation_pinecone.PineconeInstrumentation, name: "Pinecone" },
-    { class: import_instrumentation_llamaindex.LlamaIndexInstrumentation, name: "LlamaIndex" },
-    { class: import_instrumentation_chromadb.ChromaDBInstrumentation, name: "ChromaDB" },
-    { class: import_instrumentation_qdrant.QdrantInstrumentation, name: "Qdrant" },
-    { class: import_instrumentation_together.TogetherInstrumentation, name: "Together" }
+    { class: _instrumentationopenai.OpenAIInstrumentation, name: "OpenAI" },
+    { class: _instrumentationanthropic.AnthropicInstrumentation, name: "Anthropic" },
+    { class: _instrumentationcohere.CohereInstrumentation, name: "Cohere" },
+    { class: _instrumentationbedrock.BedrockInstrumentation, name: "Bedrock" },
+    { class: _instrumentationpinecone.PineconeInstrumentation, name: "Pinecone" },
+    { class: _instrumentationllamaindex.LlamaIndexInstrumentation, name: "LlamaIndex" },
+    { class: _instrumentationchromadb.ChromaDBInstrumentation, name: "ChromaDB" },
+    { class: _instrumentationqdrant.QdrantInstrumentation, name: "Qdrant" },
+    { class: _instrumentationtogether.TogetherInstrumentation, name: "Together" }
   ];
   for (const config of genAIInstrumentationClasses) {
     try {
       const instrumentation = new config.class({ exceptionLogger });
       instrumentations.push(instrumentation);
-      logger.debug(`Auto-loaded ${config.name} instrumentation`);
+      _chunkJB6MA2RVcjs.logger.debug(`Auto-loaded ${config.name} instrumentation`);
     } catch (error) {
-      logger.error(`Failed to auto-load ${config.name} instrumentation: ${String(error)}`);
+      _chunkJB6MA2RVcjs.logger.error(`Failed to auto-load ${config.name} instrumentation: ${String(error)}`);
     }
   }
   try {
-    (0, import_instrumentation3.registerInstrumentations)({ instrumentations });
-    logger.info(`Auto-registered ${instrumentations.length} GenAI instrumentations`);
+    _instrumentation.registerInstrumentations.call(void 0, { instrumentations });
+    _chunkJB6MA2RVcjs.logger.info(`Auto-registered ${instrumentations.length} GenAI instrumentations`);
   } catch (error) {
-    logger.error(`Failed to register GenAI instrumentations: ${String(error)}`);
+    _chunkJB6MA2RVcjs.logger.error(`Failed to register GenAI instrumentations: ${String(error)}`);
   }
   return instrumentations;
 }
 function loadMCPInstrumentation() {
   void (async () => {
     try {
-      const { MCPInstrumentation: MCPInstrumentation2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
-      const mcp = new MCPInstrumentation2({ exceptionLogger });
-      (0, import_instrumentation3.registerInstrumentations)({ instrumentations: [mcp] });
-      logger.debug("Auto-loaded MCP instrumentation");
+      const { MCPInstrumentation } = await Promise.resolve().then(() => _interopRequireWildcard(require("./mcp-6BDG4SWY.cjs")));
+      const mcp = new MCPInstrumentation({ exceptionLogger });
+      _instrumentation.registerInstrumentations.call(void 0, { instrumentations: [mcp] });
+      _chunkJB6MA2RVcjs.logger.debug("Auto-loaded MCP instrumentation");
     } catch (error) {
-      logger.debug(
+      _chunkJB6MA2RVcjs.logger.debug(
         `MCP instrumentation not loaded (install @modelcontextprotocol/sdk and @arizeai/openinference-instrumentation-mcp if you want MCP support): ${String(error)}`
       );
     }
   })();
 }
+function loadVertexAIInstrumentation() {
+  void (async () => {
+    try {
+      const { VertexAIInstrumentation } = await Promise.resolve().then(() => _interopRequireWildcard(require("@traceloop/instrumentation-vertexai")));
+      const vertexAI = new VertexAIInstrumentation({ exceptionLogger });
+      _instrumentation.registerInstrumentations.call(void 0, { instrumentations: [vertexAI] });
+      _chunkJB6MA2RVcjs.logger.debug("Auto-loaded Vertex AI instrumentation");
+    } catch (error) {
+      _chunkJB6MA2RVcjs.logger.debug(
+        `Vertex AI instrumentation not loaded (install @traceloop/instrumentation-vertexai if you want Vertex AI support): ${String(error)}`
+      );
+    }
+  })();
+}
 function loadVercelAIInterruptIntegration() {
   void (async () => {
     try {
-      const ai = await import("ai");
+      const ai = await Promise.resolve().then(() => _interopRequireWildcard(require("ai")));
       if (typeof ai.registerTelemetryIntegration !== "function") {
-        logger.debug(
+        _chunkJB6MA2RVcjs.logger.debug(
           "AI SDK present but lacks registerTelemetryIntegration (needs ai@>=6); skipping interrupt bridge"
         );
         return;
       }
-      const { createInterruptIntegration: createInterruptIntegration2 } = await Promise.resolve().then(() => (init_interrupt(), interrupt_exports));
-      ai.registerTelemetryIntegration(createInterruptIntegration2());
-      logger.debug("Auto-loaded Vercel AI interrupt bridge");
+      const { createInterruptIntegration } = await Promise.resolve().then(() => _interopRequireWildcard(require("./interrupt-HOP3XPQF.cjs")));
+      ai.registerTelemetryIntegration(createInterruptIntegration());
+      _chunkJB6MA2RVcjs.logger.debug("Auto-loaded Vercel AI interrupt bridge");
     } catch (error) {
-      logger.debug(
+      _chunkJB6MA2RVcjs.logger.debug(
         `Vercel AI interrupt bridge not loaded (install ai@>=6 if you want HITL attribution): ${String(error)}`
       );
     }
   })();
 }
 function autoInitializeInstrumentations() {
-  if (autoInstrumentationsLoaded) {
-    return;
-  }
   try {
-    const nodeInstrumentations = loadNodeAutoInstrumentations();
     const genAIInstrumentations = loadGenAIInstrumentations();
     loadMCPInstrumentation();
+    loadVertexAIInstrumentation();
     loadVercelAIInterruptIntegration();
-    autoInstrumentationsLoaded = true;
-    logger.info(
-      `Auto-initialization complete: ${nodeInstrumentations.length} node + ${genAIInstrumentations.length} GenAI instrumentations`
+    _chunkJB6MA2RVcjs.logger.info(
+      `Auto-initialization complete: ${genAIInstrumentations.length} GenAI instrumentations`
     );
+    return true;
   } catch (error) {
-    logger.error(`Auto-initialization failed: ${String(error)}`);
-    autoInstrumentationsLoaded = false;
+    _chunkJB6MA2RVcjs.logger.error(`Auto-initialization failed: ${String(error)}`);
+    return false;
   }
 }
-autoInitializeInstrumentations();
+var autoInstrumentationsLoaded = autoInitializeInstrumentations();
 
-// src/internal/sdk.ts
-var import_resources3 = require("@opentelemetry/resources");
-var import_sdk_node = require("@opentelemetry/sdk-node");
+// src/index.ts
+var _apilogs = require('@opentelemetry/api-logs');
 
-// src/internal/dsn.ts
-var PLACEHOLDER_SERVICE = "<service-name>";
-var SERVICE_NAME_HEADER = "X-Brizz-Service-Name";
-function parseDSN(dsn) {
-  let parsed;
-  try {
-    parsed = new globalThis.URL(dsn);
-  } catch {
-    return null;
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || !parsed.username || !parsed.host) {
-    return null;
-  }
-  const scheme = parsed.protocol === "https:" ? "https" : "http";
-  let service;
-  try {
-    service = decodeURIComponent(parsed.pathname.replace(/^\//, ""));
-  } catch {
-    return null;
-  }
-  if (service === "" || service === PLACEHOLDER_SERVICE) {
-    return null;
-  }
-  return {
-    scheme,
-    host: parsed.host,
-    bearer: decodeURIComponent(parsed.username),
-    service,
-    baseUrl: `${scheme}://${parsed.host}`
-  };
-}
+// src/init.ts
+var init_exports = {};
 
-// src/internal/config.ts
-init_logger();
-function resolveConfig(options) {
-  const envLogLevel = process.env["BRIZZ_LOG_LEVEL"] || options.logLevel?.toString() || DEFAULT_LOG_LEVEL.toString();
-  let resolvedLogLevel;
-  if (envLogLevel) {
-    resolvedLogLevel = parseLogLevel(envLogLevel);
-  } else if (typeof options.logLevel === "string") {
-    resolvedLogLevel = parseLogLevel(options.logLevel);
-  } else {
-    resolvedLogLevel = options.logLevel || DEFAULT_LOG_LEVEL;
-  }
-  setLogLevel(resolvedLogLevel);
-  let maskingStatus;
-  if (options.masking === true) {
-    maskingStatus = "enabled";
-  } else if (options.masking === false) {
-    maskingStatus = "disabled";
-  } else if (typeof options.masking === "object") {
-    maskingStatus = "custom";
-  } else {
-    maskingStatus = "default-disabled";
-  }
-  logger.debug("Starting configuration resolution", {
-    appName: options.appName,
-    baseUrl: options.baseUrl,
-    hasApiKey: !!options.apiKey,
-    dsnProvided: !!(process.env["BRIZZ_DSN"] || options.dsn),
-    disableBatch: options.disableBatch,
-    logLevel: resolvedLogLevel,
-    headersCount: Object.keys(options.headers || {}).length,
-    masking: maskingStatus
-  });
-  let resolvedMasking;
-  if (options.masking === true) {
-    resolvedMasking = {
-      spanMasking: {},
-      eventMasking: {}
-    };
-  } else if (options.masking && typeof options.masking === "object") {
-    resolvedMasking = options.masking;
-  }
-  const resolvedConfig = {
-    ...options,
-    appName: process.env["BRIZZ_APP_NAME"] || options.appName || "unknown-app",
-    appVersion: process.env["BRIZZ_APP_VERSION"] || options.appVersion,
-    baseUrl: process.env["BRIZZ_BASE_URL"] || options.baseUrl || "https://telemetry.brizz.dev",
-    headers: { ...options.headers },
-    apiKey: process.env["BRIZZ_API_KEY"] || options.apiKey,
-    disableBatch: process.env["BRIZZ_DISABLE_BATCH"] === "true" || !!options.disableBatch,
-    disableSpanExporter: process.env["BRIZZ_DISABLE_SPAN_EXPORTER"] === "true" || !!options.disableSpanExporter,
-    environment: process.env["BRIZZ_ENVIRONMENT"] || options.environment,
-    logLevel: resolvedLogLevel,
-    masking: resolvedMasking
-  };
-  const dsnInput = process.env["BRIZZ_DSN"] || options.dsn;
-  let parsedDSN = null;
-  if (dsnInput) {
-    const kwargConflicts = [];
-    if (options.apiKey !== void 0) {
-      kwargConflicts.push("apiKey");
-    }
-    if (options.baseUrl !== void 0) {
-      kwargConflicts.push("baseUrl");
-    }
-    if (options.appName !== void 0) {
-      kwargConflicts.push("appName");
-    }
-    if (kwargConflicts.length > 0) {
-      throw new Error(
-        `dsn cannot be combined with kwargs ${kwargConflicts.join(", ")}. The DSN bundles bearer, gateway URL, and service name \u2014 choose one configuration style.`
-      );
-    }
-    const envConflicts = ["BRIZZ_API_KEY", "BRIZZ_BASE_URL", "BRIZZ_APP_NAME"].filter(
-      (name) => process.env[name] !== void 0
-    );
-    if (envConflicts.length > 0) {
-      logger.warn(
-        `Ignoring ${envConflicts.join(", ")} \u2014 dsn / BRIZZ_DSN takes precedence.`
-      );
-    }
-    resolvedConfig.apiKey = void 0;
-    resolvedConfig.baseUrl = "https://telemetry.brizz.dev";
-    resolvedConfig.appName = "unknown-app";
-    parsedDSN = parseDSN(dsnInput);
-    if (parsedDSN) {
-      resolvedConfig.appName = parsedDSN.service;
-      resolvedConfig.baseUrl = parsedDSN.baseUrl;
-      resolvedConfig.apiKey = parsedDSN.bearer;
-    }
-  } else if (resolvedConfig.apiKey) {
-    resolvedConfig.headers["Authorization"] = `Bearer ${resolvedConfig.apiKey}`;
-  }
-  if (process.env["BRIZZ_HEADERS"]) {
-    try {
-      const envHeaders = JSON.parse(process.env["BRIZZ_HEADERS"]);
-      Object.assign(resolvedConfig.headers, envHeaders);
-      logger.debug("Added headers from environment variable", {
-        headers: Object.keys(envHeaders)
-      });
-    } catch (error) {
-      logger.error("Failed to parse BRIZZ_HEADERS environment variable", { error });
-      throw new Error("Invalid JSON in BRIZZ_HEADERS environment variable", { cause: error });
-    }
-  }
-  if (dsnInput) {
-    const authHeaderKeys = /* @__PURE__ */ new Set(["authorization", SERVICE_NAME_HEADER.toLowerCase()]);
-    resolvedConfig.headers = Object.fromEntries(
-      Object.entries(resolvedConfig.headers).filter(
-        ([key]) => !authHeaderKeys.has(key.toLowerCase())
-      )
-    );
-    if (parsedDSN) {
-      resolvedConfig.headers["Authorization"] = `Bearer ${parsedDSN.bearer}`;
-      resolvedConfig.headers[SERVICE_NAME_HEADER] = parsedDSN.service;
-    }
-  }
-  logger.debug("Configuration resolved with environment variables", {
-    appName: resolvedConfig.appName,
-    baseUrl: resolvedConfig.baseUrl,
-    hasApiKey: !!resolvedConfig.apiKey,
-    dsnProvided: !!dsnInput,
-    disableBatch: resolvedConfig.disableBatch,
-    envOverrides: {
-      hasEnvApiKey: !!process.env["BRIZZ_API_KEY"],
-      hasEnvBaseUrl: !!process.env["BRIZZ_BASE_URL"],
-      hasEnvDsn: !!process.env["BRIZZ_DSN"],
-      hasEnvBatch: !!process.env["BRIZZ_DISABLE_BATCH"],
-      hasEnvHeaders: !!process.env["BRIZZ_HEADERS"]
-    }
-  });
-  return resolvedConfig;
-}
 
-// src/internal/constants.ts
-var BRIZZ_SDK_VERSION = "brizz.sdk.version";
-var BRIZZ_SDK_LANGUAGE = "brizz.sdk.language";
-var SDK_LANGUAGE = "typescript";
 
-// src/internal/instrumentation/registry.ts
-var import_instrumentation_anthropic2 = require("@traceloop/instrumentation-anthropic");
-var import_instrumentation_bedrock2 = require("@traceloop/instrumentation-bedrock");
-var import_instrumentation_chromadb2 = require("@traceloop/instrumentation-chromadb");
-var import_instrumentation_cohere2 = require("@traceloop/instrumentation-cohere");
-var import_instrumentation_llamaindex2 = require("@traceloop/instrumentation-llamaindex");
-var import_instrumentation_openai2 = require("@traceloop/instrumentation-openai");
-var import_instrumentation_pinecone2 = require("@traceloop/instrumentation-pinecone");
-var import_instrumentation_qdrant2 = require("@traceloop/instrumentation-qdrant");
-var import_instrumentation_together2 = require("@traceloop/instrumentation-together");
-var import_instrumentation_vertexai2 = require("@traceloop/instrumentation-vertexai");
-init_logger();
-init_mcp();
-var InstrumentationRegistry = class _InstrumentationRegistry {
-  static instance;
-  manualModules = null;
-  static getInstance() {
-    if (!_InstrumentationRegistry.instance) {
-      _InstrumentationRegistry.instance = new _InstrumentationRegistry();
-    }
-    return _InstrumentationRegistry.instance;
-  }
-  /**
-   * Set manual instrumentation modules for Next.js/Webpack environments
-   */
-  setManualModules(modules) {
-    this.manualModules = modules;
-    logger.info("Manual instrumentation modules configured for Next.js/Webpack compatibility");
-  }
-  /**
-   * Helper to load instrumentation with optional manual module
-   */
-  loadInstrumentation(InstrumentationClass, name, manualModule, exceptionLogger2) {
-    try {
-      const inst = new InstrumentationClass({
-        exceptionLogger: exceptionLogger2 || ((error) => logger.error(`Exception in instrumentation: ${String(error)}`))
-      });
-      if (manualModule) {
-        inst.manuallyInstrument(manualModule);
-        logger.debug(`Manual instrumentation enabled for ${name}`);
-      }
-      return inst;
-    } catch (error) {
-      logger.error(`Failed to load ${name} instrumentation: ${String(error)}`);
-      return null;
-    }
-  }
-  /**
-   * Get manual instrumentations only.
-   * Auto-instrumentations are handled at import time.
-   */
-  getManualInstrumentations() {
-    if (!this.manualModules || Object.keys(this.manualModules).length === 0) {
-      logger.debug("No manual instrumentation modules configured");
-      return [];
-    }
-    const instrumentations = [];
-    const exceptionLogger2 = (error) => {
-      logger.error(`Exception in manual instrumentation: ${String(error)}`);
-    };
-    this.loadManualInstrumentations(instrumentations, exceptionLogger2);
-    logger.info(`Loaded ${instrumentations.length} manual instrumentations`);
-    return instrumentations;
-  }
-  /**
-   * Load manual instrumentations only (with modules provided by user).
-   * @private
-   */
-  loadManualInstrumentations(instrumentations, exceptionLogger2) {
-    const instrumentationConfigs = [
-      { class: import_instrumentation_openai2.OpenAIInstrumentation, name: "OpenAI", module: this.manualModules?.openAI },
-      { class: import_instrumentation_anthropic2.AnthropicInstrumentation, name: "Anthropic", module: this.manualModules?.anthropic },
-      { class: import_instrumentation_cohere2.CohereInstrumentation, name: "Cohere", module: this.manualModules?.cohere },
-      {
-        class: import_instrumentation_vertexai2.VertexAIInstrumentation,
-        name: "Vertex AI",
-        module: this.manualModules?.google_vertexai
-      },
-      { class: import_instrumentation_bedrock2.BedrockInstrumentation, name: "Bedrock", module: this.manualModules?.bedrock },
-      { class: import_instrumentation_pinecone2.PineconeInstrumentation, name: "Pinecone", module: this.manualModules?.pinecone },
-      {
-        class: import_instrumentation_llamaindex2.LlamaIndexInstrumentation,
-        name: "LlamaIndex",
-        module: this.manualModules?.llamaindex
-      },
-      { class: import_instrumentation_chromadb2.ChromaDBInstrumentation, name: "ChromaDB", module: this.manualModules?.chromadb },
-      { class: import_instrumentation_qdrant2.QdrantInstrumentation, name: "Qdrant", module: this.manualModules?.qdrant },
-      { class: import_instrumentation_together2.TogetherInstrumentation, name: "Together", module: this.manualModules?.together }
-    ];
-    for (const config of instrumentationConfigs) {
-      if (config.module) {
-        const instrumentation = this.loadInstrumentation(
-          config.class,
-          config.name,
-          config.module,
-          exceptionLogger2
-        );
-        if (instrumentation) {
-          instrumentations.push(instrumentation);
-        }
-      }
-    }
-    if (this.manualModules?.langchain?.callbackManagerModule) {
-      const callbackManagerModule = this.manualModules.langchain.callbackManagerModule;
-      void (async () => {
-        try {
-          const { LangChainInstrumentation } = await import("@arizeai/openinference-instrumentation-langchain");
-          const lcInst = new LangChainInstrumentation();
-          lcInst.manuallyInstrument(callbackManagerModule);
-          logger.debug("Manual instrumentation enabled for LangChain");
-        } catch (error) {
-          logger.error(
-            `Failed to load LangChain instrumentation. Ensure @langchain/core is installed: ${String(error)}`
-          );
-        }
-      })();
-    }
-    if (this.manualModules?.mcp) {
-      try {
-        new MCPInstrumentation({ exceptionLogger: exceptionLogger2 }).manuallyInstrument(this.manualModules.mcp);
-        logger.debug("Manual instrumentation enabled for MCP");
-      } catch (error) {
-        logger.error(`Failed to apply MCP instrumentation: ${String(error)}`);
-      }
-    }
-  }
-};
 
-// src/internal/sdk.ts
-init_interrupt();
 
-// src/internal/log/logging.ts
-var import_api_logs = require("@opentelemetry/api-logs");
-var import_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
-var import_resources = require("@opentelemetry/resources");
-var import_sdk_logs2 = require("@opentelemetry/sdk-logs");
-init_logger();
 
-// src/internal/trace/session.ts
-var import_api9 = require("@opentelemetry/api");
-init_logger();
-init_semantic_conventions2();
-function setCurrentSpanCustomProperties(properties) {
-  const current = import_api9.trace.getActiveSpan();
-  if (!current || !current.isRecording()) {
-    return;
-  }
-  for (const [key, value] of Object.entries(properties)) {
-    try {
-      current.setAttribute(`${BRIZZ}.${key}`, value);
-    } catch {
-    }
-  }
-}
-function callWithProperties(properties, fn, thisArg, ...args) {
-  const base = import_api9.context.active();
-  const prev = base.getValue(PROPERTIES_CONTEXT_KEY);
-  const merged = prev ? { ...prev, ...properties } : properties;
-  const next = base.setValue(PROPERTIES_CONTEXT_KEY, merged);
-  return import_api9.context.with(next, fn, thisArg, ...args);
-}
-function withProperties(properties, fn, thisArg) {
-  return function wrapped(...args) {
-    return callWithProperties(
-      properties,
-      fn,
-      thisArg !== void 0 ? thisArg : this,
-      ...args
-    );
-  };
-}
-function muteProperties(options) {
-  const { input = true, output = true } = options;
-  const properties = {};
-  if (input) {
-    properties[MUTE_INPUT] = "true";
-  }
-  if (output) {
-    properties[MUTE_OUTPUT] = "true";
-  }
-  return properties;
-}
-function callWithMute(options, fn, thisArg, ...args) {
-  return callWithProperties(muteProperties(options), fn, thisArg, ...args);
-}
-function withMute(options, fn, thisArg) {
-  return withProperties(muteProperties(options), fn, thisArg);
-}
-function withSessionId(sessionId, fn, thisArg, extraProperties) {
-  const properties = { [SESSION_ID]: sessionId, ...extraProperties };
-  return withProperties(properties, fn, thisArg);
-}
-function callWithSessionId(sessionId, fn, thisArg, ...args) {
-  return callWithProperties({ [SESSION_ID]: sessionId }, fn, thisArg, ...args);
-}
-var Session = class {
-  sessionId;
-  span;
-  inputs = [];
-  outputs = [];
-  inputContexts = [];
-  outputContexts = [];
-  constructor(sessionId, span) {
-    this.sessionId = sessionId;
-    this.span = span;
-  }
-  /**
-   * Append a user turn to session input tracking.
-   *
-   * Each call appends one element to `brizz.session.input` (the text) AND one
-   * element to `brizz.session.input.context` (the per-turn context bag). The
-   * two arrays stay index-aligned — the ingestion pipeline zips them together
-   * so the i-th context bag lands on the i-th user_display conversation item's
-   * `span_attributes` map.
-   *
-   * @param text - Text to append (null becomes a null/"hide marker")
-   * @param context - Optional per-turn context bag to attach to this turn
-   */
-  setInput(text, context6) {
-    this.inputs.push(text);
-    this.inputContexts.push(context6 ?? {});
-    this.span.setAttribute(SESSION_INPUT, JSON.stringify(this.inputs));
-    this.span.setAttribute(SESSION_INPUT_CONTEXT, JSON.stringify(this.inputContexts));
-  }
-  /**
-   * Append an assistant turn to session output tracking.
-   *
-   * Symmetric to {@link setInput} — appends one text element and one
-   * context-bag element to the index-aligned `brizz.session.output` /
-   * `brizz.session.output.context` arrays.
-   *
-   * @param text - Text to append (null becomes a null/"hide marker")
-   * @param context - Optional per-turn context bag to attach to this turn
-   */
-  setOutput(text, context6) {
-    this.outputs.push(text);
-    this.outputContexts.push(context6 ?? {});
-    this.span.setAttribute(SESSION_OUTPUT, JSON.stringify(this.outputs));
-    this.span.setAttribute(SESSION_OUTPUT_CONTEXT, JSON.stringify(this.outputContexts));
-  }
-  /**
-   * Set the session title on the span.
-   *
-   * @param title - The generated title string
-   */
-  setTitle(title) {
-    this.span.setAttribute(SESSION_TITLE, title);
-  }
-  /**
-   * Update custom properties on the session span.
-   * Properties are prefixed with 'brizz.'.
-   *
-   * @param properties - Key-value properties to set on the session
-   */
-  updateProperties(properties) {
-    for (const [key, value] of Object.entries(properties)) {
-      this.span.setAttribute(`${BRIZZ}.${key}`, value);
-    }
-  }
-  /**
-   * Attach an external link (URL) to this session.
-   *
-   * The link surfaces on the session's detail panel in Brizz — use it to
-   * correlate a session with an external record such as a Datadog trace,
-   * Sentry issue, or internal dashboard. Re-sending the same URL is idempotent;
-   * distinct URLs add separate links.
-   *
-   * @param url - The link target
-   * @param options - Optional `title` (defaults to the URL host) and `linkType`
-   *   (free-form category, defaults to `'generic'`)
-   */
-  addExternalLink(url, options) {
-    emitExternalLink(this.sessionId, url, options?.title, options?.linkType);
-  }
-};
-var SessionTitle = class {
-  span;
-  constructor(span) {
-    this.span = span;
-  }
-  /**
-   * Set the generated title on the wrapper span.
-   *
-   * @param title - The generated title string
-   */
-  setTitle(title) {
-    this.span.setAttribute(SESSION_TITLE, title);
-  }
-};
-function getActiveSession() {
-  return import_api9.context.active().getValue(SESSION_OBJECT_CONTEXT_KEY);
-}
-function resolveSessionIdFromContext() {
-  const active = getActiveSession();
-  if (active) {
-    return active.sessionId;
-  }
-  const props = import_api9.context.active().getValue(PROPERTIES_CONTEXT_KEY);
-  return props?.[SESSION_ID];
-}
-function emitExternalLink(sessionId, url, title, linkType) {
-  try {
-    emitEventWithSessionId(sessionId, EXTERNAL_LINK_EVENT_NAME, {
-      [EXTERNAL_LINK_URL]: url,
-      [EXTERNAL_LINK_TITLE]: title ?? "",
-      [EXTERNAL_LINK_TYPE]: linkType ?? "generic"
-    });
-  } catch (error) {
-    logger.warn("addExternalLink: failed to emit external link", error);
-  }
-}
-function addExternalLink(url, options) {
-  const sessionId = options?.sessionId ?? resolveSessionIdFromContext();
-  if (!sessionId) {
-    logger.warn(
-      "addExternalLink called without a resolvable session id; link dropped. Pass options.sessionId or call inside a startSession/callWithSessionId scope."
-    );
-    return;
-  }
-  emitExternalLink(sessionId, url, options?.title, options?.linkType);
-}
-function startSession(sessionId, callback, extraProperties, options) {
-  const isTitle = options?.mode === "title";
-  const spanName = isTitle ? SESSION_TITLE_SPAN_NAME : SESSION_SPAN_NAME;
-  const tracer = import_api9.trace.getTracer("@brizz/sdk");
-  return tracer.startActiveSpan(spanName, (span) => {
-    span.setAttribute(`${BRIZZ}.${SESSION_ID}`, sessionId);
-    if (extraProperties) {
-      for (const [key, value] of Object.entries(extraProperties)) {
-        span.setAttribute(`${BRIZZ}.${key}`, value);
-      }
-    }
-    const session = new Session(sessionId, span);
-    const contextProperties = { [SESSION_ID]: sessionId };
-    if (isTitle) {
-      contextProperties[SESSION_TITLE_GENERATION] = "true";
-    }
-    if (extraProperties) {
-      for (const [key, value] of Object.entries(extraProperties)) {
-        contextProperties[key] = String(value);
-      }
-    }
-    return callWithProperties(contextProperties, () => {
-      const sessionCtx = import_api9.context.active().setValue(SESSION_OBJECT_CONTEXT_KEY, session);
-      return import_api9.context.with(sessionCtx, () => {
-        try {
-          const result = callback(session);
-          if (result && typeof result.then === "function") {
-            return result.then((value) => {
-              span.end();
-              return value;
-            }).catch((error) => {
-              span.recordException(error);
-              span.setStatus({ code: import_api9.SpanStatusCode.ERROR });
-              span.end();
-              throw error;
-            });
-          }
-          span.end();
-          return result;
-        } catch (error) {
-          span.recordException(error);
-          span.setStatus({ code: import_api9.SpanStatusCode.ERROR });
-          span.end();
-          throw error;
-        }
-      });
-    });
-  });
-}
-function startSessionTitle(callback, options) {
-  const resolvedSessionId = options?.sessionId ?? getActiveSession()?.sessionId;
-  const tracer = import_api9.trace.getTracer("@brizz/sdk");
-  return tracer.startActiveSpan(SESSION_TITLE_SPAN_NAME, (span) => {
-    if (resolvedSessionId) {
-      span.setAttribute(`${BRIZZ}.${SESSION_ID}`, resolvedSessionId);
-    }
-    const sessionTitle = new SessionTitle(span);
-    const properties = { [SESSION_TITLE_GENERATION]: "true" };
-    if (resolvedSessionId) {
-      properties[SESSION_ID] = resolvedSessionId;
-    }
-    return callWithProperties(properties, () => {
-      try {
-        const result = callback(sessionTitle);
-        if (result && typeof result.then === "function") {
-          return result.then((value) => {
-            span.end();
-            return value;
-          }).catch((error) => {
-            span.recordException(error);
-            span.setStatus({ code: import_api9.SpanStatusCode.ERROR });
-            span.end();
-            throw error;
-          });
-        }
-        span.end();
-        return result;
-      } catch (error) {
-        span.recordException(error);
-        span.setStatus({ code: import_api9.SpanStatusCode.ERROR });
-        span.end();
-        throw error;
-      }
-    });
-  });
-}
 
-// src/internal/log/logging.ts
-init_version();
 
-// src/internal/log/processors/log-processor.ts
-var import_api10 = require("@opentelemetry/api");
-var import_sdk_logs = require("@opentelemetry/sdk-logs");
-init_logger();
 
-// src/internal/masking/patterns.ts
-var DEFAULT_PII_PATTERNS = [
-  // Phone numbers (US format)
-  {
-    name: "us_phone_numbers",
-    pattern: String.raw`(?:^|[\s])(?:\+?1[-.\s]*)?(?:\([0-9]{3}\)\s?[0-9]{3}[-.\s]?[0-9]{4}|[0-9]{3}[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}|[0-9]{10})(?=[\s]|$)`
-  },
-  // Credit card numbers
-  {
-    name: "credit_cards",
-    pattern: String.raw`\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|6(?:011|5[0-9]{2})[0-9]{12}|(?:2131|1800|35\\d{3})\\d{11})\b`
-  },
-  {
-    name: "credit_cards_with_separators",
-    pattern: String.raw`\b(?:4\\d{3}|5[1-5]\\d{2}|3[47]\\d{2})[-\s]?\\d{4}[-\s]?\\d{4}[-\s]?\\d{4}\b`
-  },
-  // IP addresses (IPv4)
-  {
-    name: "ipv4_addresses",
-    pattern: String.raw`\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(?!\.[0-9])\b`
-  },
-  // API keys/tokens
-  {
-    name: "generic_api_keys",
-    pattern: String.raw`\b(?:[Aa][Pp][Ii][_-]?[Kk][Ee][Yy]|[Tt][Oo][Kk][Ee][Nn]|[Ss][Ee][Cc][Rr][Ee][Tt])[_-]?[=:]?\s*["']?(?:[a-zA-Z0-9\-_.]{20,})["']?\b`
-  },
-  {
-    name: "openai_keys",
-    pattern: String.raw`\bsk[-_][a-zA-Z0-9]{20,}\b`
-  },
-  // AWS Keys
-  {
-    name: "aws_access_keys",
-    pattern: String.raw`\b(?:AKIA|ABIA|ACCA|ASIA)[0-9A-Z]{16}\b`
-  },
-  // GitHub tokens
-  {
-    name: "github_tokens",
-    pattern: String.raw`\bghp_[a-zA-Z0-9]{36}\b`
-  },
-  // Slack tokens
-  {
-    name: "slack_tokens",
-    pattern: String.raw`\bxox[baprs]-[0-9]{10,13}-[0-9]{10,13}-[a-zA-Z0-9]{24,34}\b`
-  },
-  // Stripe keys
-  {
-    name: "stripe_keys",
-    pattern: String.raw`\b(?:sk|pk)_(?:test|live)_[a-zA-Z0-9]{24,}\b`
-  },
-  // JWT tokens
-  {
-    name: "jwt_tokens",
-    pattern: String.raw`\beyJ[A-Za-z0-9_-]{2,}\\.[A-Za-z0-9_-]{2,}\\.[A-Za-z0-9_-]{2,}\b`
-  },
-  // MAC addresses
-  {
-    name: "mac_addresses",
-    pattern: String.raw`\b(?:[0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}\b`
-  },
-  // IPv6 addresses
-  {
-    name: "ipv6_addresses",
-    pattern: String.raw`\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\b`
-  },
-  // Bitcoin addresses
-  {
-    name: "bitcoin_addresses",
-    pattern: String.raw`\b[13][a-km-zA-HJ-NP-Z1-9]{25,34}\b`
-  },
-  // Ethereum addresses
-  {
-    name: "ethereum_addresses",
-    pattern: String.raw`\b0x[a-fA-F0-9]{40}(?![a-fA-F0-9])\b`
-  },
-  // Database connection strings
-  {
-    name: "database_connections",
-    pattern: String.raw`\b(?:[Mm][Oo][Nn][Gg][Oo][Dd][Bb]|[Pp][Oo][Ss][Tt][Gg][Rr][Ee][Ss]|[Mm][Yy][Ss][Qq][Ll]|[Rr][Ee][Dd][Ii][Ss]|[Mm][Ss][Ss][Qq][Ll]|[Oo][Rr][Aa][Cc][Ll][Ee]):\\/\\/[^\\s]+\b`
-  },
-  // Private keys
-  {
-    name: "rsa_private_keys",
-    pattern: "-----BEGIN (?:RSA )?PRIVATE KEY-----"
-  },
-  {
-    name: "pgp_private_keys",
-    pattern: "-----BEGIN PGP PRIVATE KEY BLOCK-----"
-  },
-  {
-    name: "certificates",
-    pattern: "-----BEGIN CERTIFICATE-----"
-  },
-  // Additional API Keys and Tokens
-  {
-    name: "google_oauth",
-    pattern: String.raw`\bya29\\.[a-zA-Z0-9_-]{60,}\b`
-  },
-  {
-    name: "firebase_tokens",
-    pattern: String.raw`\bAAAA[A-Za-z0-9_-]{100,}\b`
-  },
-  {
-    name: "google_app_ids",
-    pattern: String.raw`\b[0-9]+-\w+\.apps\.googleusercontent\.com\b`
-  },
-  {
-    name: "facebook_secrets",
-    pattern: String.raw`\b(facebook_secret|FACEBOOK_SECRET|facebook_app_secret|FACEBOOK_APP_SECRET)[a-z_ =\\s"'\\:]{0,5}[^a-zA-Z0-9][a-f0-9]{32}[^a-zA-Z0-9]`
-  },
-  {
-    name: "github_keys",
-    pattern: String.raw`\b(GITHUB_SECRET|GITHUB_KEY|github_secret|github_key|github_token|GITHUB_TOKEN|github_api_key|GITHUB_API_KEY)[a-z_ =\\s\"'\\:]{0,10}[^a-zA-Z0-9][a-zA-Z0-9]{40}[^a-zA-Z0-9]`
-  },
-  {
-    name: "heroku_keys",
-    pattern: String.raw`\b(heroku_api_key|HEROKU_API_KEY|heroku_secret|HEROKU_SECRET)[a-z_ =\\s\"'\\:]{0,10}[^a-zA-Z0-9-]\\w{8}(?:-\\w{4}){3}-\\w{12}[^a-zA-Z0-9\\-]`
-  },
-  {
-    name: "slack_api_keys",
-    pattern: String.raw`\b(slack_api_key|SLACK_API_KEY|slack_key|SLACK_KEY)[a-z_ =\\s\"'\\:]{0,10}[^a-f0-9][a-f0-9]{32}[^a-f0-9]`
-  },
-  {
-    name: "slack_api_tokens",
-    pattern: String.raw`\b(xox[pb](?:-[a-zA-Z0-9]+){4,})\b`
-  },
-  // Extended Private Keys and Certificates
-  {
-    name: "dsa_private_keys",
-    pattern: String.raw`-----BEGIN DSA PRIVATE KEY-----(?:[a-zA-Z0-9\+\=\/"']|\s)+?-----END DSA PRIVATE KEY-----`
-  },
-  {
-    name: "ec_private_keys",
-    pattern: String.raw`-----BEGIN (?:EC|ECDSA) PRIVATE KEY-----(?:[a-zA-Z0-9\+\=\/"']|\s)+?-----END (?:EC|ECDSA) PRIVATE KEY-----`
-  },
-  {
-    name: "encrypted_private_keys",
-    pattern: String.raw`-----BEGIN ENCRYPTED PRIVATE KEY-----(?:.|\s)+?-----END ENCRYPTED PRIVATE KEY-----`
-  },
-  {
-    name: "ssl_certificates",
-    pattern: String.raw`-----BEGIN CERTIFICATE-----(?:.|\n)+?\s-----END CERTIFICATE-----`
-  },
-  {
-    name: "ssh_dss_public",
-    pattern: String.raw`\bssh-dss [0-9A-Za-z+/]+[=]{2}\b`
-  },
-  {
-    name: "ssh_rsa_public",
-    pattern: String.raw`\bssh-rsa AAAA[0-9A-Za-z+/]+[=]{0,3} [^@]+@[^@]+\b`
-  },
-  {
-    name: "putty_ssh_keys",
-    pattern: String.raw`PuTTY-User-Key-File-2: ssh-(?:rsa|dss)\s*Encryption: none(?:.|\s?)*?Private-MAC:`
-  },
-  // Security and Network
-  {
-    name: "cve_numbers",
-    pattern: String.raw`\b[Cc][Vv][Ee]-\\d{4}-\\d{4,7}\b`
-  },
-  {
-    name: "microsoft_oauth",
-    pattern: String.raw`https://login\.microsoftonline\.com/common/oauth2/v2\.0/token|https://login\.windows\.net/common/oauth2/token`
-  },
-  {
-    name: "postgres_connections",
-    pattern: String.raw`\b(?:[Pp][Oo][Ss][Tt][Gg][Rr][Ee][Ss]|[Pp][Gg][Ss][Qq][Ll])\\:\\/\\/`
-  },
-  {
-    name: "box_links",
-    pattern: String.raw`https://app\.box\.com/[s|l]/\S+`
-  },
-  {
-    name: "dropbox_links",
-    pattern: String.raw`https://www\.dropbox\.com/(?:s|l)/\S+`
-  },
-  // Credit Card Variants
-  {
-    name: "amex_cards",
-    pattern: String.raw`\b3[47][0-9]{13}\b`
-  },
-  {
-    name: "visa_cards",
-    pattern: String.raw`\b4[0-9]{12}(?:[0-9]{3})?\b`
-  },
-  {
-    name: "discover_cards",
-    pattern: String.raw`\b65[4-9][0-9]{13}|64[4-9][0-9]{13}|6011[0-9]{12}\b`
-  }
-];
 
-// src/internal/masking/utils.ts
-init_logger();
-function isValidPatternName(name) {
-  return /^[a-zA-Z0-9_]+$/.test(name);
-}
-function isLikelyReDoSPattern(pattern) {
-  const dangerousPatterns = [
-    // Nested quantifiers like (a+)+, (a*)+, (a+)*
-    /\([^)]*[+*]\)[+*]/,
-    // Alternation with overlapping groups like (a|a)*
-    /\([^)]*\|[^)]*\)[+*]/,
-    // Complex backtracking patterns - but more specific
-    /\([^)]*[+*][^)]*[+*][^)]*\)[+*]/
-  ];
-  return dangerousPatterns.some((dangerous) => dangerous.test(pattern));
-}
-function getGroupedPattern(patternEntry) {
-  let name = patternEntry.name;
-  if (!name || name === "") {
-    name = `pattern_${Math.random().toString(16).slice(2)}`;
-  }
-  if (!isValidPatternName(name)) {
-    throw new Error(
-      `Pattern name '${name}' must only contain alphanumeric characters and underscores`
-    );
-  }
-  if (isLikelyReDoSPattern(patternEntry.pattern)) {
-    throw new Error(`Potentially dangerous ReDoS pattern detected: '${patternEntry.pattern}'`);
-  }
-  try {
-    new RegExp(patternEntry.pattern);
-  } catch (error) {
-    throw new Error(`Invalid regex pattern '${patternEntry.pattern}': ${String(error)}`, {
-      cause: error
-    });
-  }
-  return `(?<${name}>${patternEntry.pattern})`;
-}
-function isIPatternEntry(obj) {
-  return typeof obj === "object" && obj !== null && typeof obj.pattern === "string" && (obj.name === void 0 || typeof obj.name === "string");
-}
-function isIEventMaskingRule(obj) {
-  return typeof obj === "object" && obj !== null && typeof obj.mode === "string" && Array.isArray(obj.patterns) && obj.patterns.every(
-    (p) => isIPatternEntry(p) || typeof p === "string"
-  ) && (obj.attributePattern === void 0 || typeof obj.attributePattern === "string");
-}
-function convertPatternsToPatternEntries(patterns) {
-  const patternEntries = [];
-  for (const pattern of patterns) {
-    if (typeof pattern === "string") {
-      patternEntries.push({ pattern, name: "" });
-    } else if (isIPatternEntry(pattern)) {
-      patternEntries.push(pattern);
-    } else {
-      throw new Error("Patterns must be either strings or PatternEntry instances");
-    }
-  }
-  return patternEntries;
-}
-function compilePatternEntries(patternEntries) {
-  const patternGroups = [];
-  for (const patternEntry of patternEntries) {
-    try {
-      patternGroups.push(getGroupedPattern(patternEntry));
-    } catch (error) {
-      logger.warn(`Invalid pattern '${patternEntry.name}': ${patternEntry.pattern}`, error);
-      continue;
-    }
-  }
-  if (patternGroups.length === 0) {
-    return null;
-  }
-  try {
-    return new RegExp(patternGroups.join("|"));
-  } catch (error) {
-    logger.warn("Failed to compile pattern entries into regex", error);
-    return null;
-  }
-}
-function getCompiledAttributeNamePattern(rule) {
-  if (!rule.attributePattern) {
-    logger.debug("No attribute pattern provided, using default .*");
-    return /.*/;
-  }
-  let compiledPatternString = rule.attributePattern;
-  if (isIEventMaskingRule(rule) && rule.eventNamePattern) {
-    compiledPatternString = `(${compiledPatternString})|(${rule.eventNamePattern})`;
-  }
-  return new RegExp(compiledPatternString);
-}
-function shouldContinueExecution(startTime, iterations, timeoutMs) {
-  if (Date.now() - startTime > timeoutMs) {
-    logger.warn("Regex execution timed out - potential ReDoS pattern detected");
-    return false;
-  }
-  const maxIterations = 1e3;
-  if (iterations > maxIterations) {
-    logger.warn("Regex execution exceeded maximum iterations - potential ReDoS pattern detected");
-    return false;
-  }
-  return true;
-}
-function createGlobalPattern(pattern) {
-  return new RegExp(
-    pattern.source,
-    pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g"
-  );
-}
-function executeRegexWithTimeout(pattern, value, timeoutMs = 100) {
-  const matches = [];
-  const globalPattern = createGlobalPattern(pattern);
-  const startTime = Date.now();
-  let match;
-  let iterations = 0;
-  while ((match = globalPattern.exec(value)) !== null) {
-    if (!shouldContinueExecution(startTime, ++iterations, timeoutMs)) {
-      break;
-    }
-    matches.push(match);
-    if (match[0].length === 0) {
-      globalPattern.lastIndex = match.index + 1;
-    }
-  }
-  return matches;
-}
-function maskStringByPattern(value, pattern, mode = "full") {
-  const matches = [];
-  try {
-    const regexMatches = executeRegexWithTimeout(pattern, value);
-    for (const match of regexMatches) {
-      matches.push({
-        start: match.index,
-        end: match.index + match[0].length,
-        text: match[0],
-        groups: match.groups
-      });
-    }
-  } catch (error) {
-    logger.warn("Regex execution failed, skipping masking", error);
-    return value;
-  }
-  for (const matchInfo of matches.toReversed()) {
-    let patternName = "unknown";
-    if (matchInfo.groups) {
-      for (const [groupName, groupValue] of Object.entries(matchInfo.groups)) {
-        if (groupValue !== void 0) {
-          if (groupName.includes("_") && /\d$/.test(groupName)) {
-            const parts = groupName.split("_");
-            patternName = parts[0] || groupName;
-          } else {
-            patternName = groupName;
-          }
-          break;
-        }
-      }
-    }
-    logger.info(`Masking detected: pattern '${patternName}' found match in value`);
-    const masked = mode === "partial" ? matchInfo.text[0] + "*****" : "*****";
-    value = value.slice(0, matchInfo.start) + masked + value.slice(matchInfo.end);
-  }
-  return value;
-}
-function maskStringByPatternBasedRule(value, rule) {
-  const patternEntries = convertPatternsToPatternEntries(rule.patterns);
-  if (patternEntries.length === 0) {
-    logger.warn("No patterns provided for masking rule, returning original value");
-    return value;
-  }
-  const mode = rule.mode;
-  if (!patternEntries || patternEntries.length === 0) {
-    return mode === "partial" && value ? value[0] + "*****" : "*****";
-  }
-  const compiledPatterns = compilePatternEntries(patternEntries);
-  if (!compiledPatterns) {
-    return value;
-  }
-  return maskStringByPattern(value, compiledPatterns, mode);
-}
-function maskValue(value, rule) {
-  if (typeof value === "string") {
-    return maskStringByPatternBasedRule(value, rule);
-  } else if (typeof value === "boolean" || typeof value === "number") {
-    return maskStringByPatternBasedRule(String(value), rule);
-  } else if (Array.isArray(value)) {
-    return value.map((v) => maskStringByPatternBasedRule(String(v), rule));
-  } else if (value !== null && typeof value === "object") {
-    const result = {};
-    for (const [k, v] of Object.entries(value)) {
-      result[k] = maskValue(v, rule);
-    }
-    return result;
-  } else {
-    throw new Error(`Unsupported value type for masking: ${typeof value}`);
-  }
-}
-function maskAttributes(attributes, rules, outputOriginalValue = false) {
-  if (!attributes || Object.keys(attributes).length === 0) {
-    return {};
-  }
-  const maskedAttributes = { ...attributes };
-  for (const rule of rules) {
-    const compiledAttributeNamePattern = getCompiledAttributeNamePattern(rule);
-    const attributesToMask = compiledAttributeNamePattern ? Object.keys(maskedAttributes).filter((attr) => compiledAttributeNamePattern.test(attr)) : Object.keys(maskedAttributes);
-    for (const attribute of attributesToMask) {
-      const value = maskedAttributes[attribute];
-      if (value === null || value === void 0) {
-        continue;
-      }
-      if (outputOriginalValue) {
-        logger.debug(`Masking attribute '${attribute}' with original value`, { value });
-      }
-      maskedAttributes[attribute] = maskValue(value, rule);
-    }
-  }
-  return maskedAttributes;
-}
 
-// src/internal/log/processors/log-processor.ts
-init_semantic_conventions2();
-var DEFAULT_LOG_MASKING_RULES = [
-  {
-    mode: "partial",
-    attributePattern: "event.name",
-    patterns: DEFAULT_PII_PATTERNS
-  }
-];
-var BrizzSimpleLogRecordProcessor = class extends import_sdk_logs.SimpleLogRecordProcessor {
-  config;
-  constructor(exporter, config) {
-    super(exporter);
-    this.config = config;
-  }
-  onEmit(logRecord) {
-    const maskingConfig = this.config.masking?.eventMasking;
-    if (maskingConfig) {
-      maskLog(logRecord, maskingConfig);
-    }
-    const associationProperties = import_api10.context.active().getValue(PROPERTIES_CONTEXT_KEY);
-    if (associationProperties) {
-      for (const [key, value] of Object.entries(associationProperties)) {
-        logRecord.setAttribute(`${BRIZZ}.${key}`, value);
-      }
-    }
-    super.onEmit(logRecord);
-  }
-};
-var BrizzBatchLogRecordProcessor = class extends import_sdk_logs.BatchLogRecordProcessor {
-  config;
-  constructor(exporter, config) {
-    super(exporter);
-    this.config = config;
-  }
-  onEmit(logRecord) {
-    const maskingConfig = this.config.masking?.eventMasking;
-    if (maskingConfig) {
-      maskLog(logRecord, maskingConfig);
-    }
-    const associationProperties = import_api10.context.active().getValue(PROPERTIES_CONTEXT_KEY);
-    if (associationProperties) {
-      for (const [key, value] of Object.entries(associationProperties)) {
-        logRecord.setAttribute(`${BRIZZ}.${key}`, value);
-      }
-    }
-    super.onEmit(logRecord);
-  }
-};
-function maskLog(logRecord, config) {
-  if (!logRecord.attributes) {
-    return logRecord;
-  }
-  let rules = config.rules || [];
-  if (!config.disableDefaultRules) {
-    rules = [...DEFAULT_LOG_MASKING_RULES, ...rules];
-  }
-  try {
-    if (logRecord.attributes && Object.keys(logRecord.attributes).length > 0) {
-      const attributesRecord = {};
-      for (const [key, value] of Object.entries(logRecord.attributes)) {
-        attributesRecord[key] = value;
-      }
-      const maskedAttributes = maskAttributes(attributesRecord, rules);
-      if (maskedAttributes) {
-        const newAttributes = {};
-        for (const [key, value] of Object.entries(maskedAttributes)) {
-          newAttributes[key] = value;
-        }
-        for (const [key, value] of Object.entries(logRecord.attributes)) {
-          if (key.startsWith(INTERNAL_EVENT_PREFIX)) {
-            newAttributes[key] = value;
-          }
-        }
-        logRecord.setAttributes(newAttributes);
-      }
-    }
-    if (config.maskBody && logRecord.body !== void 0 && logRecord.body !== null) {
-      let maskedBody = logRecord.body;
-      for (const rule of rules) {
-        maskedBody = maskValue(maskedBody, rule);
-      }
-      logRecord.setBody(maskedBody);
-    }
-    return logRecord;
-  } catch (error) {
-    logger.error("Error masking log record:", error);
-    return logRecord;
-  }
-}
 
-// src/internal/log/logging.ts
-var LoggingModule = class _LoggingModule {
-  static instance = null;
-  logExporter = null;
-  logProcessor = null;
-  loggerProvider = null;
-  static getInstance() {
-    if (!_LoggingModule.instance) {
-      throw new Error("Brizz must be initialized before accessing LoggingModule");
-    }
-    return _LoggingModule.instance;
-  }
-  /**
-   * Initialize the logging module with the provided configuration
-   */
-  setup(config) {
-    logger.info("Setting up logging module");
-    this.initLogExporter(config);
-    this.initLogProcessor(config);
-    this.initLoggerProvider(config);
-    _LoggingModule.instance = this;
-    logger.info("Logging module setup completed");
-  }
-  /**
-   * Initialize the log exporter
-   */
-  initLogExporter(config) {
-    if (this.logExporter) {
-      logger.debug("Log exporter already initialized, skipping re-initialization");
-      return;
-    }
-    if (config.customLogExporter) {
-      logger.debug("Using custom log exporter");
-      this.logExporter = config.customLogExporter;
-      logger.debug("Custom log exporter initialized successfully");
-      return;
-    }
-    const logsUrl = config.baseUrl.replace(/\/$/, "") + "/v1/logs";
-    logger.debug("Initializing default OTLP log exporter", { url: logsUrl });
-    const headers = { ...config.headers };
-    this.logExporter = new import_exporter_logs_otlp_http.OTLPLogExporter({
-      url: logsUrl,
-      headers
-    });
-    logger.debug("OTLP log exporter initialized successfully");
-  }
-  /**
-   * Initialize the log processor with masking support
-   */
-  initLogProcessor(config) {
-    if (this.logProcessor) {
-      logger.debug("Log processor already initialized, skipping re-initialization");
-      return;
-    }
-    if (!this.logExporter) {
-      throw new Error("Log exporter must be initialized before processor");
-    }
-    logger.debug("Initializing log processor", {
-      disableBatch: config.disableBatch,
-      hasMasking: !!config.masking?.eventMasking
-    });
-    this.logProcessor = config.disableBatch ? new BrizzSimpleLogRecordProcessor(this.logExporter, config) : new BrizzBatchLogRecordProcessor(this.logExporter, config);
-    logger.debug("Log processor initialized successfully");
-  }
-  /**
-   * Initialize the logger provider
-   */
-  initLoggerProvider(config) {
-    if (this.loggerProvider) {
-      logger.debug("Logger provider already initialized, skipping re-initialization");
-      return;
-    }
-    if (!this.logProcessor) {
-      throw new Error("Log processor must be initialized before logger provider");
-    }
-    logger.debug("Creating resource with service name", {
-      serviceName: config.appName
-    });
-    const resourceAttributes = {
-      ...config.resourceAttributes,
-      "service.name": config.appName,
-      [BRIZZ_SDK_VERSION]: getSDKVersion(),
-      [BRIZZ_SDK_LANGUAGE]: SDK_LANGUAGE
-    };
-    if (config.environment) {
-      resourceAttributes["deployment.environment"] = config.environment;
-    }
-    if (config.appVersion) {
-      resourceAttributes["service.version"] = config.appVersion;
-    }
-    const resource = (0, import_resources.resourceFromAttributes)(resourceAttributes);
-    logger.debug("Creating logger provider with resource");
-    this.loggerProvider = new import_sdk_logs2.LoggerProvider({
-      resource,
-      processors: [this.logProcessor]
-    });
-    logger.debug("Logger provider initialization completed");
-  }
-  /**
-   * Emit a custom event to the telemetry pipeline
-   */
-  emitEvent(name, attributes, body, severityNumber = import_api_logs.SeverityNumber.INFO) {
-    logger.debug("Attempting to emit event", {
-      name,
-      hasAttributes: !!attributes,
-      attributesCount: attributes ? Object.keys(attributes).length : 0,
-      hasBody: !!body,
-      severityNumber
-    });
-    if (!this.loggerProvider) {
-      logger.error("Cannot emit event: Logger provider not initialized");
-      throw new Error("Logging module not initialized");
-    }
-    const logAttributes = { "event.name": name };
-    if (attributes) {
-      Object.assign(logAttributes, attributes);
-      logger.debug("Combined log attributes", { attributes: Object.keys(logAttributes) });
-    }
-    logger.debug("Getting logger instance for brizz_events");
-    const eventLogger = this.loggerProvider.getLogger("brizz.events");
-    logger.debug("Emitting log record with eventName", { eventName: name });
-    try {
-      eventLogger.emit({
-        eventName: name,
-        attributes: logAttributes,
-        severityNumber,
-        body
-      });
-      logger.debug("Event successfully emitted", { eventName: name });
-    } catch (error) {
-      logger.error(`Failed to emit event '${name}'`, { error, eventName: name });
-      logger.error("Log record that failed", {
-        eventName: name,
-        hasAttributes: logAttributes,
-        severityNumber,
-        hasBody: body
-      });
-      throw error instanceof Error ? error : new Error(String(error));
-    }
-  }
-  /**
-   * Check if the module is initialized
-   */
-  isInitialized() {
-    return this.loggerProvider !== null;
-  }
-  /**
-   * Get the logger provider
-   */
-  getLoggerProvider() {
-    return this.loggerProvider;
-  }
-  /**
-   * Shutdown the logging module
-   */
-  async shutdown() {
-    logger.debug("Shutting down logging module");
-    if (this.loggerProvider) {
-      await this.loggerProvider.shutdown();
-      this.loggerProvider = null;
-    }
-    this.logProcessor = null;
-    this.logExporter = null;
-    if (_LoggingModule.instance === this) {
-      _LoggingModule.instance = null;
-    }
-    logger.debug("Logging module shutdown completed");
-  }
-};
-function emitEvent(name, attributes, body, severityNumber = import_api_logs.SeverityNumber.INFO) {
-  return LoggingModule.getInstance().emitEvent(name, attributes, body, severityNumber);
-}
-function emitEventWithSessionId(sessionId, name, attributes, body, severityNumber = import_api_logs.SeverityNumber.INFO) {
-  return callWithSessionId(sessionId, () => {
-    LoggingModule.getInstance().emitEvent(name, attributes, body, severityNumber);
-  });
-}
 
-// src/internal/sdk.ts
-init_logger();
 
-// src/internal/metric/metrics.ts
-var import_exporter_metrics_otlp_http = require("@opentelemetry/exporter-metrics-otlp-http");
-var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
-init_logger();
-var MetricsModule = class _MetricsModule {
-  static instance = null;
-  metricsExporter = null;
-  metricsReader = null;
-  static getInstance() {
-    if (!_MetricsModule.instance) {
-      throw new Error("Brizz must be initialized before accessing MetricsModule");
-    }
-    return _MetricsModule.instance;
-  }
-  /**
-   * Initialize the metrics module with the provided configuration
-   */
-  setup(config) {
-    logger.info("Setting up metrics module");
-    this.initMetricsReader(config);
-    _MetricsModule.instance = this;
-    logger.info("Metrics module setup completed");
-  }
-  /**
-   * Initialize the metrics exporter
-   */
-  initMetricsExporter(config) {
-    if (this.metricsExporter) {
-      logger.debug("Metrics exporter already initialized, skipping re-initialization");
-      return;
-    }
-    const metricsUrl = config.baseUrl.replace(/\/$/, "") + "/v1/metrics";
-    logger.debug("Initializing metrics exporter", { url: metricsUrl });
-    this.metricsExporter = new import_exporter_metrics_otlp_http.OTLPMetricExporter({
-      url: metricsUrl,
-      headers: config.headers
-    });
-    logger.debug("Metrics exporter initialized successfully");
-  }
-  /**
-   * Initialize the metrics reader
-   */
-  initMetricsReader(config) {
-    if (this.metricsReader) {
-      logger.debug("Metrics reader already initialized, skipping re-initialization");
-      return;
-    }
-    if (config.customMetricReader) {
-      logger.debug("Using custom metric reader");
-      this.metricsReader = config.customMetricReader;
-      logger.debug("Custom metric reader initialized successfully");
-      return;
-    }
-    logger.debug(
-      "Using default metrics flow - creating OTLP exporter and PeriodicExportingMetricReader"
-    );
-    this.initMetricsExporter(config);
-    if (!this.metricsExporter) {
-      throw new Error("Failed to initialize metrics exporter");
-    }
-    this.metricsReader = new import_sdk_metrics.PeriodicExportingMetricReader({
-      exporter: this.metricsExporter
-    });
-    logger.debug("Default metrics reader initialized successfully");
-  }
-  /**
-   * Get the metrics exporter
-   */
-  getMetricsExporter() {
-    if (!this.metricsExporter) {
-      throw new Error("Metrics module not initialized");
-    }
-    return this.metricsExporter;
-  }
-  /**
-   * Get the metrics reader
-   */
-  getMetricsReader() {
-    if (!this.metricsReader) {
-      throw new Error("Metrics module not initialized");
-    }
-    return this.metricsReader;
-  }
-  /**
-   * Shutdown the metrics module
-   */
-  shutdown() {
-    logger.debug("Shutting down metrics module");
-    this.metricsReader = null;
-    this.metricsExporter = null;
-    if (_MetricsModule.instance === this) {
-      _MetricsModule.instance = null;
-    }
-    logger.debug("Metrics module shutdown completed");
-  }
-};
-function getMetricsExporter() {
-  return MetricsModule.getInstance().getMetricsExporter();
-}
-function getMetricsReader() {
-  return MetricsModule.getInstance().getMetricsReader();
-}
 
-// src/internal/trace/tracing.ts
-var import_exporter_trace_otlp_proto = require("@opentelemetry/exporter-trace-otlp-proto");
-init_logger();
 
-// src/internal/trace/exporters/span-exporter.ts
-var import_core = require("@opentelemetry/core");
-var import_resources2 = require("@opentelemetry/resources");
-init_logger();
-init_version();
-var BrizzSpanExporter = class {
-  _delegate;
-  _brizzResource;
-  _beforeSendSpan;
-  constructor(delegate, config) {
-    this._delegate = delegate;
-    const resourceAttrs = {
-      ...config.resourceAttributes,
-      "service.name": config.appName,
-      [BRIZZ_SDK_VERSION]: getSDKVersion(),
-      [BRIZZ_SDK_LANGUAGE]: SDK_LANGUAGE
-    };
-    if (config.environment) {
-      resourceAttrs["deployment.environment"] = config.environment;
-    }
-    if (config.appVersion) {
-      resourceAttrs["service.version"] = config.appVersion;
-    }
-    this._brizzResource = (0, import_resources2.resourceFromAttributes)(resourceAttrs);
-    this._beforeSendSpan = config.beforeSendSpan;
-  }
-  export(spans, resultCallback) {
-    if (spans.length === 0) {
-      resultCallback({ code: import_core.ExportResultCode.SUCCESS });
-      return;
-    }
-    const patchedSpans = spans.map((span) => ({
-      ...span,
-      resource: span.resource.merge(this._brizzResource),
-      spanContext: span.spanContext.bind(span)
-    }));
-    const filter = this._beforeSendSpan;
-    if (!filter) {
-      this._delegate.export(patchedSpans, resultCallback);
-      return;
-    }
-    const verdicts = patchedSpans.map((span) => {
-      try {
-        return Promise.resolve(filter(span));
-      } catch (error) {
-        logger.warn("beforeSendSpan threw; span will be kept", { error });
-        return Promise.resolve(true);
-      }
-    });
-    Promise.all(verdicts).then((keep) => {
-      const filtered = patchedSpans.filter((_, i) => keep[i] !== false);
-      if (filtered.length === 0) {
-        resultCallback({ code: import_core.ExportResultCode.SUCCESS });
-        return;
-      }
-      this._delegate.export(filtered, resultCallback);
-      return;
-    }).catch((error) => {
-      logger.warn("beforeSendSpan rejected; all spans will be kept", { error });
-      this._delegate.export(patchedSpans, resultCallback);
-    });
-  }
-  async shutdown() {
-    return this._delegate.shutdown();
-  }
-  async forceFlush() {
-    return this._delegate.forceFlush?.();
-  }
-};
 
-// src/internal/trace/processors/span-processor.ts
-var import_api11 = require("@opentelemetry/api");
-var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
-init_logger();
-init_semantic_conventions2();
-function applyContextAttributes(span) {
-  const sessionProperties = import_api11.context.active().getValue(PROPERTIES_CONTEXT_KEY);
-  if (sessionProperties) {
-    for (const [key, value] of Object.entries(sessionProperties)) {
-      span.setAttribute(`${BRIZZ}.${key}`, value);
-    }
-  }
-}
-var DEFAULT_MASKING_RULES = [
-  {
-    mode: "partial",
-    patterns: DEFAULT_PII_PATTERNS
-  }
-];
-var BrizzSimpleSpanProcessor = class extends import_sdk_trace_base.SimpleSpanProcessor {
-  config;
-  constructor(spanExporter, config) {
-    super(spanExporter);
-    this.config = config;
-  }
-  onStart(span, parentContext) {
-    applyContextAttributes(span);
-    super.onStart(span, parentContext);
-  }
-  onEnd(span) {
-    const maskingConfig = this.config.masking?.spanMasking;
-    if (maskingConfig) {
-      maskReadableSpan(span, maskingConfig);
-    }
-    super.onEnd(span);
-  }
-};
-var BrizzBatchSpanProcessor = class extends import_sdk_trace_base.BatchSpanProcessor {
-  config;
-  constructor(spanExporter, config) {
-    super(spanExporter);
-    this.config = config;
-  }
-  onStart(span, parentContext) {
-    applyContextAttributes(span);
-    super.onStart(span, parentContext);
-  }
-  onEnd(span) {
-    const maskingConfig = this.config.masking?.spanMasking;
-    if (maskingConfig) {
-      maskReadableSpan(span, maskingConfig);
-    }
-    super.onEnd(span);
-  }
-};
-function maskReadableSpan(span, config) {
-  const attrs = span.attributes;
-  if (!attrs || Object.keys(attrs).length === 0) {
-    return;
-  }
-  let rules = config.rules ? [...config.rules] : [];
-  if (!config.disableDefaultRules) {
-    rules = [...rules, ...DEFAULT_MASKING_RULES];
-  }
-  try {
-    const input = {};
-    for (const [k, v] of Object.entries(attrs)) {
-      input[k] = v;
-    }
-    const masked = maskAttributes(input, rules);
-    for (const [k, v] of Object.entries(masked ?? {})) {
-      if (attrs[k] !== v) {
-        attrs[k] = v;
-      }
-    }
-  } catch (error) {
-    logger.error("Error masking span", { err: error });
-  }
-}
 
-// src/internal/trace/tracing.ts
-var TracingModule = class _TracingModule {
-  static instance = null;
-  spanExporter = null;
-  spanProcessor = null;
-  static getInstance() {
-    if (!_TracingModule.instance) {
-      throw new Error("Brizz must be initialized before accessing TracingModule");
-    }
-    return _TracingModule.instance;
-  }
-  /**
-   * Initialize the tracing module with the provided configuration
-   */
-  setup(config) {
-    logger.info("Setting up tracing module");
-    if (config.disableSpanExporter) {
-      logger.info(
-        "Span exporter disabled via disableSpanExporter; skipping exporter and processor setup"
-      );
-      this.spanExporter = null;
-      this.spanProcessor = null;
-      _TracingModule.instance = this;
-      return;
-    }
-    this.initSpanExporter(config);
-    this.initSpanProcessor(config);
-    _TracingModule.instance = this;
-    logger.info("Tracing module setup completed");
-  }
-  /**
-   * Initialize the span exporter
-   */
-  initSpanExporter(config) {
-    if (this.spanExporter) {
-      logger.debug("Span exporter already initialized, skipping re-initialization");
-      return;
-    }
-    if (config.customSpanExporter) {
-      logger.debug("Using custom span exporter");
-      this.spanExporter = new BrizzSpanExporter(config.customSpanExporter, config);
-      logger.debug("Custom span exporter initialized successfully");
-      return;
-    }
-    const tracesUrl = config.baseUrl.replace(/\/$/, "") + "/v1/traces";
-    logger.debug("Initializing default OTLP span exporter", { url: tracesUrl });
-    const otlpExporter = new import_exporter_trace_otlp_proto.OTLPTraceExporter({
-      url: tracesUrl,
-      headers: config.headers
-    });
-    this.spanExporter = new BrizzSpanExporter(otlpExporter, config);
-    logger.debug("OTLP span exporter initialized successfully");
-  }
-  /**
-   * Initialize the span processor with masking support
-   */
-  initSpanProcessor(config) {
-    if (this.spanProcessor) {
-      logger.debug("Span processor already initialized, skipping re-initialization");
-      return;
-    }
-    if (!this.spanExporter) {
-      throw new Error("Span exporter must be initialized before processor");
-    }
-    logger.debug("Initializing span processor", {
-      disableBatch: config.disableBatch,
-      hasMasking: !!config.masking?.spanMasking
-    });
-    const spanProcessor = config.disableBatch ? new BrizzSimpleSpanProcessor(this.spanExporter, config) : new BrizzBatchSpanProcessor(this.spanExporter, config);
-    logger.debug("Span processor initialized successfully");
-    this.spanProcessor = spanProcessor;
-  }
-  /**
-   * Get the span exporter
-   */
-  getSpanExporter() {
-    if (!this.spanExporter) {
-      throw new Error("Tracing module not initialized");
-    }
-    return this.spanExporter;
-  }
-  /**
-   * Get the span processor
-   */
-  getSpanProcessor() {
-    if (!this.spanProcessor) {
-      throw new Error("Tracing module not initialized");
-    }
-    return this.spanProcessor;
-  }
-  async shutdown() {
-    logger.debug("Shutting down tracing module");
-    if (this.spanProcessor) {
-      await this.spanProcessor.shutdown();
-      this.spanProcessor = null;
-    }
-    if (this.spanExporter) {
-      await this.spanExporter.shutdown();
-      this.spanExporter = null;
-    }
-    _TracingModule.instance = null;
-    logger.debug("Tracing module shutdown completed");
-  }
-};
-function getSpanExporter() {
-  return TracingModule.getInstance().getSpanExporter();
-}
-function getSpanProcessor() {
-  return TracingModule.getInstance().getSpanProcessor();
-}
 
-// src/internal/sdk.ts
-init_version();
-var _Brizz = class __Brizz {
-  static instance = null;
-  /** Flag indicating if SDK initialization has completed successfully */
-  _initialized = false;
-  /** OpenTelemetry sdk instance */
-  _sdk = null;
-  static getInstance() {
-    if (!__Brizz.instance) {
-      throw new Error("Brizz must be initialized before accessing TracingModule");
-    }
-    return __Brizz.instance;
-  }
-  /**
-   * Initialize the Brizz SDK with the provided configuration.
-   *
-   * @param {IBrizzInitializeOptions} options - Configuration options for the SDK
-   * @throws {Error} - If initialization fails
-   *
-   * @example
-   * ```typescript
-   * Brizz.initialize({
-   *   appName: 'my-app',
-   *   baseUrl: 'http://localhost:4318',
-   *   apiKey: 'your-api-key'
-   * });
-   * ```
-   */
-  initialize(options) {
-    if (this._initialized) {
-      logger.warn("Brizz SDK already initialized");
-      return;
-    }
-    logger.info("Starting Brizz SDK initialization");
-    try {
-      const resolvedConfig = resolveConfig(options);
-      this.initializeModules(resolvedConfig);
-      this.setupInstrumentation(options);
-      this.createAndStartNodeSDK(options, resolvedConfig);
-      this._initialized = true;
-      logger.info("Brizz SDK initialization completed successfully", {
-        moduleSystem: this.detectModuleSystem()
-      });
-    } catch (error) {
-      logger.error("Failed to initialize Brizz SDK", { error });
-      throw new Error(`Failed to initialize SDK: ${String(error)}`, { cause: error });
-    }
-  }
-  /**
-   * Set up instrumentation registry and configure manual modules.
-   * @private
-   */
-  setupInstrumentation(options) {
-    const registry = InstrumentationRegistry.getInstance();
-    if (options.instrumentModules && Object.keys(options.instrumentModules).length > 0) {
-      registry.setManualModules(options.instrumentModules);
-    }
-  }
-  /**
-   * Create and start NodeSDK if not disabled.
-   * Only handles manual instrumentations now - auto instrumentations are loaded at import time.
-   * @private
-   */
-  createAndStartNodeSDK(options, resolvedConfig) {
-    if (options.disableNodeSdk) {
-      logger.info("NodeSDK disabled - only telemetry modules initialized");
-      return;
-    }
-    const registry = InstrumentationRegistry.getInstance();
-    const manualInstrumentations = registry.getManualInstrumentations();
-    const resourceAttributes = {
-      ...resolvedConfig.resourceAttributes,
-      "service.name": resolvedConfig.appName,
-      [BRIZZ_SDK_VERSION]: getSDKVersion(),
-      [BRIZZ_SDK_LANGUAGE]: SDK_LANGUAGE
-    };
-    if (resolvedConfig.environment) {
-      resourceAttributes["deployment.environment"] = resolvedConfig.environment;
-    }
-    if (resolvedConfig.appVersion) {
-      resourceAttributes["service.version"] = resolvedConfig.appVersion;
-    }
-    this._sdk = new import_sdk_node.NodeSDK({
-      spanProcessors: resolvedConfig.disableSpanExporter ? [] : [new InterruptPropagator(), getSpanProcessor()],
-      metricReader: getMetricsReader(),
-      resource: (0, import_resources3.resourceFromAttributes)(resourceAttributes),
-      instrumentations: manualInstrumentations
-    });
-    this._sdk.start();
-    if (manualInstrumentations.length > 0) {
-      logger.info(`NodeSDK started with ${manualInstrumentations.length} manual instrumentations`);
-    } else {
-      logger.info("NodeSDK started - using auto-instrumentations loaded at import time");
-    }
-  }
-  /**
-   * Initialize telemetry modules.
-   *
-   * Sets up the tracing, metrics, and logging modules with their
-   * respective exporters and processors.
-   *
-   * @param {IResolvedBrizzConfig} config - Resolved configuration
-   * @private
-   */
-  initializeModules(config) {
-    logger.info("Initializing telemetry modules");
-    logger.debug("Initializing tracing module");
-    const tracingModule = new TracingModule();
-    tracingModule.setup(config);
-    logger.debug("Initializing metrics module");
-    const metricsModule = new MetricsModule();
-    metricsModule.setup(config);
-    logger.debug("Initializing logging module");
-    const loggingModule = new LoggingModule();
-    loggingModule.setup(config);
-    logger.info("All telemetry modules initialized successfully");
-  }
-  /**
-   * Detect the current module system (ESM or CJS) using reliable indicators
-   *
-   * @returns {string} - 'ESM' or 'CJS'
-   * @private
-   */
-  detectModuleSystem() {
-    const inCJS = typeof module !== "undefined" && typeof exports !== "undefined" && typeof require === "function" && typeof __filename === "string" && typeof __dirname === "string" && this === (typeof exports !== "undefined" ? exports : void 0);
-    return inCJS ? "CJS" : "ESM";
-  }
-  /**
-   * Gracefully shutdown the Brizz SDK.
-   *
-   * This method stops all telemetry collection, flushes any pending data,
-   * and releases resources. Should be called before application termination.
-   *
-   * @returns {Promise<void>} - Resolves when shutdown is complete
-   * @throws {Error} - If shutdown fails
-   *
-   * @example
-   * ```typescript
-   * // Shutdown before app exit
-   * await Brizz.shutdown();
-   * ```
-   */
-  async shutdown() {
-    if (!this._initialized) {
-      logger.warn("Brizz SDK not initialized");
-      return;
-    }
-    try {
-      await this.shutdownModules();
-      await this._sdk?.shutdown();
-      this._initialized = false;
-      this._sdk = null;
-      __Brizz.instance = null;
-      logger.info("Brizz SDK shut down successfully");
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("ENOTFOUND")) {
-        logger.debug(`Network error during shutdown (expected in tests): ${error.message}`);
-      } else {
-        logger.error(`Failed to shutdown Brizz SDK: ${String(error)}`);
-        throw error;
-      }
-    }
-  }
-  /**
-   * Shutdown all telemetry modules.
-   * @private
-   */
-  async shutdownModules() {
-    logger.info("Shutting down telemetry modules");
-    try {
-      try {
-        const tracingModule = TracingModule.getInstance();
-        await tracingModule.shutdown();
-      } catch {
-        logger.debug("Tracing module already shut down or not initialized");
-      }
-      try {
-        const metricsModule = MetricsModule.getInstance();
-        metricsModule.shutdown();
-      } catch {
-        logger.debug("Metrics module already shut down or not initialized");
-      }
-      try {
-        const loggingModule = LoggingModule.getInstance();
-        await loggingModule.shutdown();
-      } catch {
-        logger.debug("Logging module already shut down or not initialized");
-      }
-      logger.info("All telemetry modules shut down successfully");
-    } catch (error) {
-      logger.error("Error shutting down modules", { error });
-      throw error;
-    }
-  }
-};
-var Brizz = new _Brizz();
 
-// src/index.ts
-init_logger();
-var import_api_logs2 = require("@opentelemetry/api-logs");
 
-// src/node/runtime.ts
-init_logger();
-function detectRuntime() {
-  const [major, minor] = process.versions.node.split(".").map(Number);
-  const noNodeJSGlobals = typeof __filename === "undefined" && typeof __dirname === "undefined";
-  const noModuleSystem = typeof module === "undefined" && typeof exports === "undefined";
-  const hasRequire = typeof require === "function";
-  const isESM = noNodeJSGlobals && noModuleSystem;
-  const isCJS = hasRequire && typeof module !== "undefined" && typeof exports !== "undefined" && typeof __filename === "string" && typeof __dirname === "string";
-  const supportsLoaderAPI = (major ?? 0) >= 21 || (major ?? 0) === 20 && (minor ?? 0) >= 6 || (major ?? 0) === 18 && (minor ?? 0) >= 19;
-  const supportsRegister = (
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    !!process.features?.typescript || !!globalThis.module?.register
-  );
-  logger.debug("Runtime detection results:", {
-    nodeVersion: `${major ?? 0}.${minor ?? 0}`,
-    isESM,
-    isCJS,
-    supportsLoaderAPI,
-    supportsRegister,
-    detectionLogic: {
-      noNodeJSGlobals,
-      noModuleSystem,
-      hasRequire,
-      esmCondition: `${noNodeJSGlobals} && ${noModuleSystem} = ${isESM}`,
-      cjsCondition: `require && module && exports && __filename && __dirname = ${isCJS}`
-    },
-    checks: {
-      __filename: typeof __filename,
-      __dirname: typeof __dirname,
-      require: typeof require,
-      module: typeof module,
-      exports: typeof exports,
-      "process.features": process.features,
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      "globalThis.module": globalThis.module
-    }
-  });
-  return {
-    isESM,
-    isCJS,
-    nodeVersion: process.versions.node,
-    supportsLoaderAPI,
-    supportsRegister
-  };
-}
 
-// src/init.ts
-var init_exports = {};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Brizz,
-  DEFAULT_PII_PATTERNS,
-  LogLevel,
-  Session,
-  SessionTitle,
-  SeverityNumber,
-  addExternalLink,
-  callWithMute,
-  callWithProperties,
-  callWithSessionId,
-  detectRuntime,
-  emitEvent,
-  emitEventWithSessionId,
-  getActiveSession,
-  getLogLevel,
-  getMetricsExporter,
-  getMetricsReader,
-  getSpanExporter,
-  getSpanProcessor,
-  init,
-  logger,
-  maskAttributes,
-  maskValue,
-  setCurrentSpanCustomProperties,
-  setLogLevel,
-  startSession,
-  startSessionTitle,
-  withMute,
-  withProperties,
-  withSessionId
-});
+
+
+
+
+
+
+
+
+
+exports.Brizz = _chunkNUTJMVD4cjs.Brizz; exports.DEFAULT_PII_PATTERNS = _chunkNUTJMVD4cjs.DEFAULT_PII_PATTERNS; exports.LogLevel = _chunkJB6MA2RVcjs.LogLevel; exports.Session = _chunkNUTJMVD4cjs.Session; exports.SessionTitle = _chunkNUTJMVD4cjs.SessionTitle; exports.SeverityNumber = _apilogs.SeverityNumber; exports.addExternalLink = _chunkNUTJMVD4cjs.addExternalLink; exports.callWithMute = _chunkNUTJMVD4cjs.callWithMute; exports.callWithProperties = _chunkNUTJMVD4cjs.callWithProperties; exports.callWithSessionId = _chunkNUTJMVD4cjs.callWithSessionId; exports.detectRuntime = _chunkNUTJMVD4cjs.detectRuntime; exports.emitEvent = _chunkNUTJMVD4cjs.emitEvent; exports.emitEventWithSessionId = _chunkNUTJMVD4cjs.emitEventWithSessionId; exports.getActiveSession = _chunkNUTJMVD4cjs.getActiveSession; exports.getLogLevel = _chunkJB6MA2RVcjs.getLogLevel; exports.getMetricsExporter = _chunkNUTJMVD4cjs.getMetricsExporter; exports.getMetricsReader = _chunkNUTJMVD4cjs.getMetricsReader; exports.getSpanExporter = _chunkNUTJMVD4cjs.getSpanExporter; exports.getSpanProcessor = _chunkNUTJMVD4cjs.getSpanProcessor; exports.init = init_exports; exports.logger = _chunkJB6MA2RVcjs.logger; exports.maskAttributes = _chunkNUTJMVD4cjs.maskAttributes; exports.maskValue = _chunkNUTJMVD4cjs.maskValue; exports.setCurrentSpanCustomProperties = _chunkNUTJMVD4cjs.setCurrentSpanCustomProperties; exports.setLogLevel = _chunkJB6MA2RVcjs.setLogLevel; exports.startSession = _chunkNUTJMVD4cjs.startSession; exports.startSessionTitle = _chunkNUTJMVD4cjs.startSessionTitle; exports.withMute = _chunkNUTJMVD4cjs.withMute; exports.withProperties = _chunkNUTJMVD4cjs.withProperties; exports.withSessionId = _chunkNUTJMVD4cjs.withSessionId;