@brizz/sdk 0.1.20 → 0.1.22

package/dist/index.js

@@ -1,131 +1,22 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-
-// src/internal/instrumentation/auto-init.ts
-import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
-import { registerInstrumentations } from "@opentelemetry/instrumentation";
-import { AnthropicInstrumentation } from "@traceloop/instrumentation-anthropic";
-import { BedrockInstrumentation } from "@traceloop/instrumentation-bedrock";
-import { ChromaDBInstrumentation } from "@traceloop/instrumentation-chromadb";
-import { CohereInstrumentation } from "@traceloop/instrumentation-cohere";
-import { LlamaIndexInstrumentation } from "@traceloop/instrumentation-llamaindex";
-import { OpenAIInstrumentation } from "@traceloop/instrumentation-openai";
-import { PineconeInstrumentation } from "@traceloop/instrumentation-pinecone";
-import { QdrantInstrumentation } from "@traceloop/instrumentation-qdrant";
-import { TogetherInstrumentation } from "@traceloop/instrumentation-together";
-import { VertexAIInstrumentation } from "@traceloop/instrumentation-vertexai";
+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 });
+};
 
 // src/internal/logger.ts
 import { DiagLogLevel } from "@opentelemetry/api";
 import pino from "pino";
-var 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 || {});
-var DEFAULT_LOG_LEVEL = 2 /* WARN */;
-var 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 = pino({
-        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);
-    }
-  };
-};
 function parseLogLevel(level) {
   if (!level) {
     return DEFAULT_LOG_LEVEL;
@@ -154,7 +45,6 @@ function parseLogLevel(level) {
     }
   }
 }
-var logger = new PinoLogger();
 function setLogLevel(level) {
   const resolvedLevel = typeof level === "string" ? parseLogLevel(level) : level;
   logger.setLevel(resolvedLevel);
@@ -162,8 +52,813 @@ function setLogLevel(level) {
 function getLogLevel() {
   return logger.getLevel();
 }
+var LogLevel, DEFAULT_LOG_LEVEL, PinoLogger, logger;
+var init_logger = __esm({
+  "src/internal/logger.ts"() {
+    "use strict";
+    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 = pino({
+            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/semantic-conventions.ts
+import { createContextKey } from "@opentelemetry/api";
+var BRIZZ, PROPERTIES, SESSION_ID, PROPERTIES_CONTEXT_KEY, SESSION_OBJECT_CONTEXT_KEY, SESSION_INPUT, SESSION_OUTPUT, SESSION_INPUT_CONTEXT, SESSION_OUTPUT_CONTEXT, SESSION_SPAN_NAME, SESSION_TITLE_SPAN_NAME, SESSION_TITLE_GENERATION, SESSION_TITLE;
+var init_semantic_conventions = __esm({
+  "src/internal/semantic-conventions.ts"() {
+    "use strict";
+    BRIZZ = "brizz";
+    PROPERTIES = "properties";
+    SESSION_ID = "session.id";
+    PROPERTIES_CONTEXT_KEY = createContextKey(PROPERTIES);
+    SESSION_OBJECT_CONTEXT_KEY = 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";
+    SESSION_TITLE_SPAN_NAME = "brizz.session_title";
+    SESSION_TITLE_GENERATION = "session.title_generation";
+    SESSION_TITLE = "brizz.session.title";
+  }
+});
+
+// src/internal/instrumentation/mcp/session.ts
+import { context } from "@opentelemetry/api";
+function stampAndPropagateSession(span, sessionId, baseContext = 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 init_session = __esm({
+  "src/internal/instrumentation/mcp/session.ts"() {
+    "use strict";
+    init_logger();
+    init_semantic_conventions();
+  }
+});
+
+// src/internal/instrumentation/mcp/semantic-conventions.ts
+var MCP_TOOL_NAME, MCP_TOOL_ARGUMENTS, MCP_TOOL_RESULT, MCP_COMPONENT_TYPE, MCP_COMPONENT_TOOL, 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_RESOURCES_READ, METHOD_PROMPTS_GET, METHOD_INITIALIZE;
+var init_semantic_conventions2 = __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_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_RESOURCES_READ = "resources/read";
+    METHOD_PROMPTS_GET = "prompts/get";
+    METHOD_INITIALIZE = "initialize";
+  }
+});
+
+// src/internal/instrumentation/mcp/patches/attributes.ts
+import { SpanStatusCode } from "@opentelemetry/api";
+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: 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: 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 init_attributes = __esm({
+  "src/internal/instrumentation/mcp/patches/attributes.ts"() {
+    "use strict";
+    init_semantic_conventions2();
+  }
+});
+
+// src/internal/instrumentation/mcp/patches/protocol.ts
+import { context as context2, propagation, SpanKind, trace } from "@opentelemetry/api";
+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 = trace.setSpan(context2.active(), span);
+      return context2.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 wrappedHandler = (req, extra) => context2.with(spanCtx, () => executeHandler(span, method, handler, req, extra));
+    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) {
+  let result;
+  try {
+    result = run();
+  } catch (error) {
+    safeApplyErrorAttributes(span, error);
+    safeEnd(span);
+    throw error;
+  }
+  if (!isThenable(result)) {
+    safeApplyResultAttributes(span, method, result);
+    safeEnd(span);
+    return result;
+  }
+  return result.then(
+    (value) => {
+      safeApplyResultAttributes(span, method, value);
+      safeEnd(span);
+      return value;
+    },
+    (error) => {
+      safeApplyErrorAttributes(span, error);
+      safeEnd(span);
+      throw error;
+    }
+  );
+}
+function executeHandler(span, method, handler, req, extra) {
+  return executeAroundSpan(span, method, () => handler(req, extra));
+}
+function safeStartClientSpan(tracer, request, protocol) {
+  try {
+    const spanName = deriveSpanName(request.method, request.params);
+    const span = tracer.startSpan(spanName, { kind: 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: SpanKind.SERVER },
+      parentCtx
+    );
+    applyServerRequestAttributes(span, request, protocol);
+    const sessionId = protocol.sessionId ?? protocol._transport?.sessionId;
+    const { context: sessCtx } = stampAndPropagateSession(span, sessionId, parentCtx);
+    return { span, spanCtx: 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 propagation.extract(context2.active(), meta);
+    }
+  } catch (error) {
+    logger.debug(
+      `Brizz MCP: failed to extract parent context from _meta: ${String(error)}`
+    );
+  }
+  return context2.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 PATCHED_FLAG;
+var init_protocol = __esm({
+  "src/internal/instrumentation/mcp/patches/protocol.ts"() {
+    "use strict";
+    init_logger();
+    init_session();
+    init_attributes();
+    PATCHED_FLAG = /* @__PURE__ */ Symbol("brizz.mcp.protocol-patched");
+  }
+});
+
+// src/internal/version.ts
+function getSDKVersion() {
+  return "0.1.22";
+}
+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
+import { MCPInstrumentation as BaseMCPInstrumentation } from "@arizeai/openinference-instrumentation-mcp";
+import { trace as trace2 } from "@opentelemetry/api";
+import { InstrumentationNodeModuleDefinition } from "@opentelemetry/instrumentation";
+function isMCPInstrumentation(value) {
+  return !!value && typeof value === "object" && typeof value.instrumentationName === "string";
+}
+var PROTOCOL_MODULE_NAME, PROTOCOL_SUPPORTED_VERSIONS, MCPInstrumentation;
+var init_instrumentation = __esm({
+  "src/internal/instrumentation/mcp/instrumentation.ts"() {
+    "use strict";
+    init_logger();
+    init_protocol();
+    init_version2();
+    PROTOCOL_MODULE_NAME = "@modelcontextprotocol/sdk/shared/protocol.js";
+    PROTOCOL_SUPPORTED_VERSIONS = [">=1.0.0 <2"];
+    MCPInstrumentation = class extends BaseMCPInstrumentation {
+      /**
+       * 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 = trace2.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 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/auto-init.ts
+init_logger();
+import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { AnthropicInstrumentation } from "@traceloop/instrumentation-anthropic";
+import { BedrockInstrumentation } from "@traceloop/instrumentation-bedrock";
+import { ChromaDBInstrumentation } from "@traceloop/instrumentation-chromadb";
+import { CohereInstrumentation } from "@traceloop/instrumentation-cohere";
+import { LlamaIndexInstrumentation } from "@traceloop/instrumentation-llamaindex";
+import { OpenAIInstrumentation } from "@traceloop/instrumentation-openai";
+import { PineconeInstrumentation } from "@traceloop/instrumentation-pinecone";
+import { QdrantInstrumentation } from "@traceloop/instrumentation-qdrant";
+import { TogetherInstrumentation } from "@traceloop/instrumentation-together";
+import { VertexAIInstrumentation } from "@traceloop/instrumentation-vertexai";
 var autoInstrumentationsLoaded = false;
 var exceptionLogger = (error) => {
   logger.error(`Exception in instrumentation: ${String(error)}`);
@@ -216,6 +911,20 @@ function loadGenAIInstrumentations() {
   }
   return instrumentations;
 }
+function loadMCPInstrumentation() {
+  void (async () => {
+    try {
+      const { MCPInstrumentation: MCPInstrumentation2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+      const mcp = new MCPInstrumentation2({ exceptionLogger });
+      registerInstrumentations({ instrumentations: [mcp] });
+      logger.debug("Auto-loaded MCP instrumentation");
+    } catch (error) {
+      logger.debug(
+        `MCP instrumentation not loaded (install @modelcontextprotocol/sdk and @arizeai/openinference-instrumentation-mcp if you want MCP support): ${String(error)}`
+      );
+    }
+  })();
+}
 function autoInitializeInstrumentations() {
   if (autoInstrumentationsLoaded) {
     return;
@@ -223,6 +932,7 @@ function autoInitializeInstrumentations() {
   try {
     const nodeInstrumentations = loadNodeAutoInstrumentations();
     const genAIInstrumentations = loadGenAIInstrumentations();
+    loadMCPInstrumentation();
     autoInstrumentationsLoaded = true;
     logger.info(
       `Auto-initialization complete: ${nodeInstrumentations.length} node + ${genAIInstrumentations.length} GenAI instrumentations`
@@ -239,6 +949,7 @@ import { resourceFromAttributes as resourceFromAttributes3 } from "@opentelemetr
 import { NodeSDK } from "@opentelemetry/sdk-node";
 
 // 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;
@@ -327,6 +1038,8 @@ var BRIZZ_SDK_LANGUAGE = "brizz.sdk.language";
 var SDK_LANGUAGE = "typescript";
 
 // src/internal/instrumentation/registry.ts
+init_logger();
+init_mcp();
 import { AnthropicInstrumentation as AnthropicInstrumentation2 } from "@traceloop/instrumentation-anthropic";
 import { BedrockInstrumentation as BedrockInstrumentation2 } from "@traceloop/instrumentation-bedrock";
 import { ChromaDBInstrumentation as ChromaDBInstrumentation2 } from "@traceloop/instrumentation-chromadb";
@@ -441,6 +1154,14 @@ var InstrumentationRegistry = class _InstrumentationRegistry {
         }
       })();
     }
+    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)}`);
+      }
+    }
   }
 };
 
@@ -451,14 +1172,12 @@ import { resourceFromAttributes } from "@opentelemetry/resources";
 import {
   LoggerProvider
 } from "@opentelemetry/sdk-logs";
-
-// src/internal/version.ts
-function getSDKVersion() {
-  return "0.1.20";
-}
+init_logger();
+init_version();
 
 // src/internal/log/processors/log-processor.ts
-import { context } from "@opentelemetry/api";
+init_logger();
+import { context as context3 } from "@opentelemetry/api";
 import { BatchLogRecordProcessor, SimpleLogRecordProcessor } from "@opentelemetry/sdk-logs";
 
 // src/internal/masking/patterns.ts
@@ -870,6 +1589,7 @@ var DEFAULT_PII_PATTERNS = [
 ];
 
 // src/internal/masking/utils.ts
+init_logger();
 function isValidPatternName(name) {
   return /^[a-zA-Z0-9_]+$/.test(name);
 }
@@ -1085,23 +1805,8 @@ function maskAttributes(attributes, rules, outputOriginalValue = false) {
   return maskedAttributes;
 }
 
-// src/internal/semantic-conventions.ts
-import { createContextKey } from "@opentelemetry/api";
-var BRIZZ = "brizz";
-var PROPERTIES = "properties";
-var SESSION_ID = "session.id";
-var PROPERTIES_CONTEXT_KEY = createContextKey(PROPERTIES);
-var SESSION_OBJECT_CONTEXT_KEY = createContextKey("brizz.session.object");
-var SESSION_INPUT = "brizz.session.input";
-var SESSION_OUTPUT = "brizz.session.output";
-var SESSION_INPUT_CONTEXT = "brizz.session.input.context";
-var SESSION_OUTPUT_CONTEXT = "brizz.session.output.context";
-var SESSION_SPAN_NAME = "brizz.start_session";
-var SESSION_TITLE_SPAN_NAME = "brizz.session_title";
-var SESSION_TITLE_GENERATION = "session.title_generation";
-var SESSION_TITLE = "brizz.session.title";
-
 // src/internal/log/processors/log-processor.ts
+init_semantic_conventions();
 var DEFAULT_LOG_MASKING_RULES = [
   {
     mode: "partial",
@@ -1120,7 +1825,7 @@ var BrizzSimpleLogRecordProcessor = class extends SimpleLogRecordProcessor {
     if (maskingConfig) {
       maskLog(logRecord, maskingConfig);
     }
-    const associationProperties = context.active().getValue(PROPERTIES_CONTEXT_KEY);
+    const associationProperties = context3.active().getValue(PROPERTIES_CONTEXT_KEY);
     if (associationProperties) {
       for (const [key, value] of Object.entries(associationProperties)) {
         logRecord.setAttribute(`${BRIZZ}.${key}`, value);
@@ -1140,7 +1845,7 @@ var BrizzBatchLogRecordProcessor = class extends BatchLogRecordProcessor {
     if (maskingConfig) {
       maskLog(logRecord, maskingConfig);
     }
-    const associationProperties = context.active().getValue(PROPERTIES_CONTEXT_KEY);
+    const associationProperties = context3.active().getValue(PROPERTIES_CONTEXT_KEY);
     if (associationProperties) {
       for (const [key, value] of Object.entries(associationProperties)) {
         logRecord.setAttribute(`${BRIZZ}.${key}`, value);
@@ -1359,7 +2064,11 @@ function emitEvent(name, attributes, body, severityNumber = SeverityNumber.INFO)
   return LoggingModule.getInstance().emitEvent(name, attributes, body, severityNumber);
 }
 
+// src/internal/sdk.ts
+init_logger();
+
 // src/internal/metric/metrics.ts
+init_logger();
 import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
 import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
 var MetricsModule = class _MetricsModule {
@@ -1462,11 +2171,14 @@ function getMetricsReader() {
 }
 
 // src/internal/trace/tracing.ts
+init_logger();
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
 
 // src/internal/trace/exporters/span-exporter.ts
 import { ExportResultCode } from "@opentelemetry/core";
 import { resourceFromAttributes as resourceFromAttributes2 } from "@opentelemetry/resources";
+init_logger();
+init_version();
 var BrizzSpanExporter = class {
   _delegate;
   _brizzResource;
@@ -1533,13 +2245,15 @@ var BrizzSpanExporter = class {
 };
 
 // src/internal/trace/processors/span-processor.ts
-import { context as context2 } from "@opentelemetry/api";
+init_logger();
+import { context as context4 } from "@opentelemetry/api";
 import {
   BatchSpanProcessor,
   SimpleSpanProcessor
 } from "@opentelemetry/sdk-trace-base";
+init_semantic_conventions();
 function applyContextAttributes(span) {
-  const sessionProperties = context2.active().getValue(PROPERTIES_CONTEXT_KEY);
+  const sessionProperties = context4.active().getValue(PROPERTIES_CONTEXT_KEY);
   if (sessionProperties) {
     for (const [key, value] of Object.entries(sessionProperties)) {
       span.setAttribute(`${BRIZZ}.${key}`, value);
@@ -1739,13 +2453,26 @@ function getSpanProcessor() {
 }
 
 // src/internal/trace/session.ts
-import { context as context3, trace, SpanStatusCode } from "@opentelemetry/api";
+init_semantic_conventions();
+import { context as context5, trace as trace3, SpanStatusCode as SpanStatusCode2 } from "@opentelemetry/api";
+function setCurrentSpanCustomProperties(properties) {
+  const current = trace3.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 = context3.active();
+  const base = context5.active();
   const prev = base.getValue(PROPERTIES_CONTEXT_KEY);
   const merged = prev ? { ...prev, ...properties } : properties;
   const next = base.setValue(PROPERTIES_CONTEXT_KEY, merged);
-  return context3.with(next, fn, thisArg, ...args);
+  return context5.with(next, fn, thisArg, ...args);
 }
 function withProperties(properties, fn, thisArg) {
   return function wrapped(...args) {
@@ -1787,9 +2514,9 @@ var Session = class {
    * @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, context4) {
+  setInput(text, context6) {
     this.inputs.push(text);
-    this.inputContexts.push(context4 ?? {});
+    this.inputContexts.push(context6 ?? {});
     this.span.setAttribute(SESSION_INPUT, JSON.stringify(this.inputs));
     this.span.setAttribute(SESSION_INPUT_CONTEXT, JSON.stringify(this.inputContexts));
   }
@@ -1803,9 +2530,9 @@ var Session = class {
    * @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, context4) {
+  setOutput(text, context6) {
     this.outputs.push(text);
-    this.outputContexts.push(context4 ?? {});
+    this.outputContexts.push(context6 ?? {});
     this.span.setAttribute(SESSION_OUTPUT, JSON.stringify(this.outputs));
     this.span.setAttribute(SESSION_OUTPUT_CONTEXT, JSON.stringify(this.outputContexts));
   }
@@ -1844,12 +2571,12 @@ var SessionTitle = class {
   }
 };
 function getActiveSession() {
-  return context3.active().getValue(SESSION_OBJECT_CONTEXT_KEY);
+  return context5.active().getValue(SESSION_OBJECT_CONTEXT_KEY);
 }
 function startSession(sessionId, callback, extraProperties, options) {
   const isTitle = options?.mode === "title";
   const spanName = isTitle ? SESSION_TITLE_SPAN_NAME : SESSION_SPAN_NAME;
-  const tracer = trace.getTracer("@brizz/sdk");
+  const tracer = trace3.getTracer("@brizz/sdk");
   return tracer.startActiveSpan(spanName, (span) => {
     span.setAttribute(`${BRIZZ}.${SESSION_ID}`, sessionId);
     if (extraProperties) {
@@ -1868,8 +2595,8 @@ function startSession(sessionId, callback, extraProperties, options) {
       }
     }
     return callWithProperties(contextProperties, () => {
-      const sessionCtx = context3.active().setValue(SESSION_OBJECT_CONTEXT_KEY, session);
-      return context3.with(sessionCtx, () => {
+      const sessionCtx = context5.active().setValue(SESSION_OBJECT_CONTEXT_KEY, session);
+      return context5.with(sessionCtx, () => {
         try {
           const result = callback(session);
           if (result && typeof result.then === "function") {
@@ -1878,7 +2605,7 @@ function startSession(sessionId, callback, extraProperties, options) {
               return value;
             }).catch((error) => {
               span.recordException(error);
-              span.setStatus({ code: SpanStatusCode.ERROR });
+              span.setStatus({ code: SpanStatusCode2.ERROR });
               span.end();
               throw error;
             });
@@ -1887,7 +2614,7 @@ function startSession(sessionId, callback, extraProperties, options) {
           return result;
         } catch (error) {
           span.recordException(error);
-          span.setStatus({ code: SpanStatusCode.ERROR });
+          span.setStatus({ code: SpanStatusCode2.ERROR });
           span.end();
           throw error;
         }
@@ -1897,7 +2624,7 @@ function startSession(sessionId, callback, extraProperties, options) {
 }
 function startSessionTitle(callback, options) {
   const resolvedSessionId = options?.sessionId ?? getActiveSession()?.sessionId;
-  const tracer = trace.getTracer("@brizz/sdk");
+  const tracer = trace3.getTracer("@brizz/sdk");
   return tracer.startActiveSpan(SESSION_TITLE_SPAN_NAME, (span) => {
     if (resolvedSessionId) {
       span.setAttribute(`${BRIZZ}.${SESSION_ID}`, resolvedSessionId);
@@ -1916,7 +2643,7 @@ function startSessionTitle(callback, options) {
             return value;
           }).catch((error) => {
             span.recordException(error);
-            span.setStatus({ code: SpanStatusCode.ERROR });
+            span.setStatus({ code: SpanStatusCode2.ERROR });
             span.end();
             throw error;
           });
@@ -1925,7 +2652,7 @@ function startSessionTitle(callback, options) {
         return result;
       } catch (error) {
         span.recordException(error);
-        span.setStatus({ code: SpanStatusCode.ERROR });
+        span.setStatus({ code: SpanStatusCode2.ERROR });
         span.end();
         throw error;
       }
@@ -1934,6 +2661,7 @@ function startSessionTitle(callback, options) {
 }
 
 // src/internal/sdk.ts
+init_version();
 var _Brizz = class __Brizz {
   static instance = null;
   /** Flag indicating if SDK initialization has completed successfully */
@@ -2131,9 +2859,11 @@ var _Brizz = class __Brizz {
 var Brizz = new _Brizz();
 
 // src/index.ts
+init_logger();
 import { SeverityNumber as SeverityNumber2 } from "@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";
@@ -2202,6 +2932,7 @@ export {
   logger,
   maskAttributes,
   maskValue,
+  setCurrentSpanCustomProperties,
   setLogLevel,
   startSession,
   startSessionTitle,