@sentry/junior 0.9.3 → 0.9.4

package/dist/{chunk-ZBWWHP6Q.js → chunk-MY7JNCS2.js}

@@ -2,11 +2,854 @@ import {
   discoverInstalledPluginPackageContent,
   pluginRoots
 } from "./chunk-KCLEEKYX.js";
-import {
-  logInfo,
-  logWarn,
-  setSpanAttributes
-} from "./chunk-ZW4OVKF5.js";
+
+// src/chat/logging.ts
+import { AsyncLocalStorage } from "async_hooks";
+import * as Sentry from "@sentry/nextjs";
+var MAX_STRING_VALUE = 1200;
+var SECRETS_RE = [
+  /\b(sk-[A-Za-z0-9_-]{20,})\b/g,
+  /\b(xox[baprs]-[A-Za-z0-9-]{10,})\b/g,
+  /\bBearer\s+([A-Za-z0-9._\-+=]{20,})\b/gi,
+  /\b[A-Z0-9_]+(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD)\s*[=:]\s*([^\s"']{8,})/gi
+];
+var LEGACY_KEY_MAP = {
+  error: "error.message",
+  "error.stack": "exception.stacktrace",
+  "gen_ai.system": "gen_ai.provider.name",
+  "gen_ai.request.messages": "gen_ai.input.messages",
+  "gen_ai.response.text": "gen_ai.output.messages",
+  "messaging.conversation.id": "messaging.message.conversation_id",
+  bytes: "file.size",
+  media_type: "file.mime_type",
+  skillDir: "file.path",
+  root: "file.directory",
+  originalLength: "app.output.original_length",
+  parsedLength: "app.output.parsed_length",
+  directiveMode: "app.output.directive_mode",
+  fileCount: "app.output.file_count",
+  attempt: "app.retry.attempt",
+  steps: "app.ai.steps",
+  toolCalls: "app.ai.tool_calls",
+  toolResults: "app.ai.tool_results",
+  finishReason: "app.ai.finish_reason",
+  sources: "app.ai.sources",
+  generatedFiles: "app.ai.generated_files",
+  resultFiles: "app.ai.result_files",
+  responseMessages: "app.ai.response_messages",
+  stepDiagnostics: "app.ai.step_diagnostics",
+  inferredSkill: "app.skill.name",
+  inferredScore: "app.skill.score"
+};
+var contextStorage = new AsyncLocalStorage();
+var logRecordSinks = /* @__PURE__ */ new Set();
+var ANSI = {
+  reset: "\x1B[0m",
+  faint: "\x1B[2m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  green: "\x1B[32m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m"
+};
+var CONSOLE_PRIORITY_KEYS = [
+  "app.conversation.id",
+  "app.turn.id",
+  "event.name",
+  "error.message",
+  "messaging.message.id",
+  "app.trace_id",
+  "app.span_id",
+  "app.agent.id",
+  "messaging.message.conversation_id",
+  "messaging.destination.name",
+  "app.run.id",
+  "app.message.kind"
+];
+var CONSOLE_PRIORITY_INDEX = new Map(
+  CONSOLE_PRIORITY_KEYS.map((key, index) => [key, index])
+);
+var CONSOLE_ALWAYS_HIDDEN_KEYS = /* @__PURE__ */ new Set([
+  "app.assistant.username",
+  "app.platform",
+  "enduser.id",
+  "enduser.pseudo_id",
+  "http.request.method",
+  "messaging.system",
+  "url.full",
+  "url.path",
+  "user_agent.original"
+]);
+var CONSOLE_DROP_WHEN_COUNTED_KEYS = /* @__PURE__ */ new Set([
+  "app.capability.names",
+  "app.capability.providers",
+  "app.config.keys"
+]);
+var CONSOLE_PREVIEW_KEYS = /* @__PURE__ */ new Set([
+  "gen_ai.input.messages",
+  "gen_ai.output.messages",
+  "gen_ai.tool.call.arguments",
+  "gen_ai.tool.call.result"
+]);
+function getSentryEnvironment() {
+  return (process.env.SENTRY_ENVIRONMENT ?? process.env.NEXT_PUBLIC_SENTRY_ENVIRONMENT ?? process.env.VERCEL_ENV ?? process.env.NODE_ENV ?? "").trim().toLowerCase();
+}
+function shouldSuppressInfoLog(_level) {
+  return false;
+}
+function shouldEmitConsole(level) {
+  if (process.env.NODE_ENV === "test") {
+    return level === "error";
+  }
+  return getSentryEnvironment() !== "production";
+}
+function findNextBlankLineBoundary(input, start) {
+  const lfBoundary = input.indexOf("\n\n", start);
+  const crlfBoundary = input.indexOf("\r\n\r\n", start);
+  if (lfBoundary === -1 && crlfBoundary === -1) {
+    return null;
+  }
+  if (lfBoundary === -1) {
+    return { start: crlfBoundary, end: crlfBoundary + 4 };
+  }
+  if (crlfBoundary === -1 || lfBoundary < crlfBoundary) {
+    return { start: lfBoundary, end: lfBoundary + 2 };
+  }
+  return { start: crlfBoundary, end: crlfBoundary + 4 };
+}
+function redactPrivateKeyBlocks(input) {
+  const beginPrefix = "-----BEGIN ";
+  const footerMarker = "-----";
+  let cursor = 0;
+  let output = "";
+  while (cursor < input.length) {
+    const begin = input.indexOf(beginPrefix, cursor);
+    if (begin === -1) {
+      output += input.slice(cursor);
+      break;
+    }
+    const labelStart = begin + beginPrefix.length;
+    const labelEnd = input.indexOf(footerMarker, labelStart);
+    if (labelEnd === -1) {
+      output += input.slice(cursor);
+      break;
+    }
+    const label = input.slice(labelStart, labelEnd);
+    if (!label.endsWith("PRIVATE KEY")) {
+      output += input.slice(cursor, labelEnd + footerMarker.length);
+      cursor = labelEnd + footerMarker.length;
+      continue;
+    }
+    const header = input.slice(begin, labelEnd + footerMarker.length);
+    const footer = `-----END ${label}-----`;
+    const footerStart = input.indexOf(footer, labelEnd + footerMarker.length);
+    if (footerStart === -1) {
+      const resumeBoundary = findNextBlankLineBoundary(
+        input,
+        labelEnd + footerMarker.length
+      );
+      output += input.slice(cursor, begin);
+      output += `${header}
+...redacted...`;
+      if (!resumeBoundary) {
+        break;
+      }
+      output += input.slice(resumeBoundary.start, resumeBoundary.end);
+      cursor = resumeBoundary.end;
+      continue;
+    }
+    output += input.slice(cursor, begin);
+    output += `${header}
+...redacted...
+${footer}`;
+    cursor = footerStart + footer.length;
+  }
+  return output;
+}
+function redactSecrets(input) {
+  let out = redactPrivateKeyBlocks(input);
+  for (const pattern of SECRETS_RE) {
+    out = out.replace(pattern, (full, token) => {
+      if (typeof token !== "string") {
+        return "***";
+      }
+      if (token.length < 12) {
+        return full.replace(token, "***");
+      }
+      return full.replace(token, `${token.slice(0, 4)}...${token.slice(-4)}`);
+    });
+  }
+  return out;
+}
+function toSnakeCase(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9_]+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+}
+function isSemanticKey(key) {
+  return /^[a-z][a-z0-9_]*(\.[a-z0-9_][a-z0-9_-]*)+$/.test(key);
+}
+function normalizeAttributeKey(key) {
+  const mapped = LEGACY_KEY_MAP[key];
+  if (mapped) {
+    return mapped;
+  }
+  if (isSemanticKey(key)) {
+    return key;
+  }
+  if (key === "platform") return "app.platform";
+  if (key === "request.id") return "app.request.id";
+  const snake = toSnakeCase(key);
+  if (!snake) {
+    return "app.attribute";
+  }
+  return `app.${snake}`;
+}
+function sanitizePrimitive(value) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return void 0;
+    const redacted = redactSecrets(trimmed);
+    return redacted.length > MAX_STRING_VALUE ? `${redacted.slice(0, MAX_STRING_VALUE)}...` : redacted;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : void 0;
+  }
+  if (typeof value === "boolean") return value;
+  if (value instanceof Error) {
+    return redactSecrets(value.message);
+  }
+  try {
+    const json = JSON.stringify(value);
+    if (!json) return void 0;
+    const redacted = redactSecrets(json);
+    return redacted.length > MAX_STRING_VALUE ? `${redacted.slice(0, MAX_STRING_VALUE)}...` : redacted;
+  } catch {
+    return void 0;
+  }
+}
+function sanitizeValue(value) {
+  if (Array.isArray(value)) {
+    const sanitized = value.filter((entry) => typeof entry === "string").map((entry) => sanitizePrimitive(entry)).filter((entry) => typeof entry === "string");
+    return sanitized.length > 0 ? sanitized : void 0;
+  }
+  return sanitizePrimitive(value);
+}
+function contextToAttributes(context) {
+  const attributes = {
+    "app.conversation.id": context.conversationId,
+    "app.turn.id": context.turnId,
+    "app.agent.id": context.agentId,
+    "app.platform": context.platform,
+    "app.request.id": context.requestId,
+    "messaging.system": context.platform === "slack" ? "slack" : context.platform,
+    "messaging.message.conversation_id": context.slackThreadId,
+    "messaging.destination.name": context.slackChannelId,
+    "enduser.id": context.slackUserId,
+    "enduser.pseudo_id": context.slackUserName,
+    "app.run.id": context.runId,
+    "app.assistant.username": context.assistantUserName,
+    "gen_ai.request.model": context.modelId,
+    "app.skill.name": context.skillName,
+    "http.request.method": context.httpMethod,
+    "url.path": context.httpPath,
+    "url.full": context.urlFull,
+    "user_agent.original": context.userAgent
+  };
+  const normalized = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    const sanitized = sanitizeValue(value);
+    if (sanitized !== void 0) normalized[key] = sanitized;
+  }
+  return normalized;
+}
+function getTraceCorrelationAttributes() {
+  const sentry = Sentry;
+  if (typeof sentry.getActiveSpan !== "function" || typeof sentry.spanToJSON !== "function") {
+    return {};
+  }
+  try {
+    const span = sentry.getActiveSpan();
+    if (!span) return {};
+    const json = sentry.spanToJSON(span);
+    const attrs = {};
+    if (json.trace_id) attrs.trace_id = json.trace_id;
+    if (json.span_id) attrs.span_id = json.span_id;
+    return attrs;
+  } catch {
+    return {};
+  }
+}
+function mergeAttributes(...maps) {
+  const merged = {};
+  for (const map of maps) {
+    if (!map) continue;
+    for (const [rawKey, rawValue] of Object.entries(map)) {
+      const key = normalizeAttributeKey(rawKey);
+      const value = sanitizeValue(rawValue);
+      if (value !== void 0) {
+        merged[key] = value;
+      }
+    }
+  }
+  return merged;
+}
+function emitSentry(level, body, attributes) {
+  if (shouldSuppressInfoLog(level)) {
+    return;
+  }
+  const sentry = Sentry;
+  const loggerFn = sentry.logger?.[level];
+  if (typeof loggerFn === "function") {
+    loggerFn(body, attributes);
+    return;
+  }
+  const sentryWithScope = sentry.withScope;
+  const sentryCaptureMessage = sentry.captureMessage;
+  const sentryLevel = level === "warn" ? "warning" : level;
+  if (typeof sentryWithScope === "function" && typeof sentryCaptureMessage === "function") {
+    sentryWithScope((scope) => {
+      for (const [key, value] of Object.entries(attributes)) {
+        scope.setExtra(key, value);
+      }
+      sentryCaptureMessage(body, sentryLevel);
+    });
+    return;
+  }
+  if (typeof sentryCaptureMessage === "function") {
+    sentryCaptureMessage(body, sentryLevel);
+  }
+}
+function formatConsoleLevel(level) {
+  if (level === "debug") return "DBG";
+  if (level === "info") return "INF";
+  if (level === "warn") return "WRN";
+  return "ERR";
+}
+function consoleLevelColor(level) {
+  if (level === "error") return ANSI.red;
+  if (level === "warn") return ANSI.yellow;
+  if (level === "info") return ANSI.green;
+  return ANSI.blue;
+}
+function quoteConsoleValue(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function formatConsoleValue(value) {
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return quoteConsoleValue(JSON.stringify(value));
+  }
+  if (/^[A-Za-z0-9._:/@+-]+$/.test(value)) {
+    return value;
+  }
+  return quoteConsoleValue(value);
+}
+function shouldShowConsoleDestinationName(eventName) {
+  return /^(app_home_|oauth_|queue_|slash_command_|slack_|webhook_)/.test(
+    eventName
+  );
+}
+function shouldShowConsoleModel(level, eventName) {
+  if (level === "warn" || level === "error") {
+    return true;
+  }
+  return eventName.startsWith("ai_") || eventName.startsWith("assistant_") || eventName === "agent_turn_started" || eventName === "agent_turn_completed" || eventName === "agent_turn_provider_error";
+}
+function shouldHideConsoleAttribute(level, eventName, key, attributes) {
+  if (CONSOLE_ALWAYS_HIDDEN_KEYS.has(key)) {
+    return true;
+  }
+  if (CONSOLE_DROP_WHEN_COUNTED_KEYS.has(key)) {
+    return true;
+  }
+  if (key === "app.agent.id" && attributes[key] === attributes["app.turn.id"]) {
+    return true;
+  }
+  if (key === "messaging.message.conversation_id" && attributes[key] === attributes["app.conversation.id"]) {
+    return true;
+  }
+  if (key === "app.message.id" && attributes[key] === attributes["messaging.message.id"]) {
+    return true;
+  }
+  if (key === "messaging.destination.name" && !shouldShowConsoleDestinationName(eventName)) {
+    return true;
+  }
+  if (key === "gen_ai.request.model" && !shouldShowConsoleModel(level, eventName)) {
+    return true;
+  }
+  if (key === "gen_ai.provider.name" && eventName.startsWith("agent_tool_call_") && level !== "warn" && level !== "error") {
+    return true;
+  }
+  if (key === "gen_ai.operation.name" && eventName.startsWith("agent_tool_call_")) {
+    return true;
+  }
+  return false;
+}
+function summarizeConsoleString(value, maxChars) {
+  const collapsed = value.replace(/\s+/g, " ").trim();
+  if (collapsed.length <= maxChars) {
+    return collapsed;
+  }
+  return `${collapsed.slice(0, maxChars)}... [${collapsed.length} chars]`;
+}
+function projectConsoleValue(level, key, value) {
+  if ((level === "debug" || level === "info") && CONSOLE_PREVIEW_KEYS.has(key) && typeof value === "string") {
+    return summarizeConsoleString(
+      value,
+      key === "gen_ai.tool.call.result" ? 220 : 140
+    );
+  }
+  return value;
+}
+function projectConsoleAttributes(level, eventName, attributes) {
+  const projected = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    if (shouldHideConsoleAttribute(level, eventName, key, attributes)) {
+      continue;
+    }
+    const nextValue = projectConsoleValue(level, key, value);
+    if (nextValue !== void 0) {
+      projected[key] = nextValue;
+    }
+  }
+  return projected;
+}
+function formatConsoleLine(level, eventName, body, attributes) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const useColor = process.env.NODE_ENV === "development" && Boolean(process.stdout?.isTTY);
+  const levelColor = consoleLevelColor(level);
+  const colorize = (text, color) => useColor ? `${color}${text}${ANSI.reset}` : text;
+  const parts = [
+    `${colorize(timestamp, ANSI.gray)} ${colorize(formatConsoleLevel(level), levelColor)} ${body}`
+  ];
+  const projectedAttributes = projectConsoleAttributes(
+    level,
+    eventName,
+    attributes
+  );
+  const sortedAttributes = Object.entries(projectedAttributes).sort(
+    ([left], [right]) => {
+      const leftRank = CONSOLE_PRIORITY_INDEX.get(left);
+      const rightRank = CONSOLE_PRIORITY_INDEX.get(right);
+      if (leftRank !== void 0 || rightRank !== void 0) {
+        if (leftRank === void 0) return 1;
+        if (rightRank === void 0) return -1;
+        return leftRank - rightRank;
+      }
+      return left.localeCompare(right);
+    }
+  );
+  for (const [key, value] of sortedAttributes) {
+    const rendered = `${colorize(key, ANSI.cyan)}=${colorize(formatConsoleValue(value), ANSI.faint)}`;
+    parts.push(rendered);
+  }
+  return parts.join(" ");
+}
+function emitConsole(level, eventName, body, attributes) {
+  if (!shouldEmitConsole(level)) {
+    return;
+  }
+  const line = formatConsoleLine(level, eventName, body, attributes);
+  if (level === "error") {
+    console.error(line);
+    return;
+  }
+  if (level === "warn") {
+    console.warn(line);
+    return;
+  }
+  if (level === "info") {
+    console.info(line);
+    return;
+  }
+  console.debug(line);
+}
+function emit(level, eventName, attrs = {}, body) {
+  const contextAttributes = contextStorage.getStore() ?? {};
+  const traceAttributes = getTraceCorrelationAttributes();
+  const normalizedEventName = toSnakeCase(eventName);
+  const message = body ? redactSecrets(body) : normalizedEventName;
+  const attributes = mergeAttributes(contextAttributes, traceAttributes, {
+    "event.name": normalizedEventName,
+    ...attrs
+  });
+  for (const sink of logRecordSinks) {
+    try {
+      sink({
+        level,
+        eventName: normalizedEventName,
+        body: message,
+        attributes
+      });
+    } catch {
+    }
+  }
+  emitConsole(level, normalizedEventName, message, attributes);
+  emitSentry(level, message, attributes);
+}
+var log = {
+  debug(eventName, attrs = {}, body) {
+    emit("debug", eventName, attrs, body);
+  },
+  info(eventName, attrs = {}, body) {
+    emit("info", eventName, attrs, body);
+  },
+  warn(eventName, attrs = {}, body) {
+    emit("warn", eventName, attrs, body);
+  },
+  error(eventName, attrs = {}, body) {
+    emit("error", eventName, attrs, body);
+  },
+  exception(eventName, error, attrs = {}, body) {
+    const normalizedError = error instanceof Error ? error : new Error(String(error));
+    emit(
+      "error",
+      eventName,
+      {
+        ...attrs,
+        "error.type": normalizedError.name,
+        "error.message": normalizedError.message,
+        "exception.type": normalizedError.name,
+        "exception.message": normalizedError.message,
+        "exception.stacktrace": normalizedError.stack
+      },
+      body ?? normalizedError.message
+    );
+    let eventId;
+    const sentryWithScope = Sentry.withScope;
+    const sentryCaptureException = Sentry.captureException;
+    if (typeof sentryWithScope === "function" && typeof sentryCaptureException === "function") {
+      sentryWithScope((scope) => {
+        for (const [key, value] of Object.entries(
+          mergeAttributes(contextStorage.getStore(), attrs)
+        )) {
+          scope.setExtra(key, value);
+        }
+        eventId = sentryCaptureException(normalizedError);
+      });
+      return eventId;
+    }
+    if (typeof sentryCaptureException === "function") {
+      eventId = sentryCaptureException(normalizedError);
+    }
+    return eventId;
+  }
+};
+function withLogContext(context, callback) {
+  const next = mergeAttributes(
+    contextStorage.getStore(),
+    contextToAttributes(context)
+  );
+  return contextStorage.run(next, callback);
+}
+function setLogContext(context) {
+  const merged = mergeAttributes(
+    contextStorage.getStore(),
+    contextToAttributes(context)
+  );
+  contextStorage.enterWith(merged);
+}
+function createLogContextFromRequest(request, context = {}) {
+  const url = new URL(request.url);
+  return {
+    ...context,
+    requestId: context.requestId ?? request.headers.get("x-request-id") ?? void 0,
+    httpMethod: request.method,
+    httpPath: url.pathname,
+    urlFull: url.toString(),
+    userAgent: request.headers.get("user-agent") ?? void 0
+  };
+}
+function toSpanAttributes(context) {
+  const attrs = contextToAttributes(context);
+  return Object.fromEntries(
+    Object.entries(attrs).filter(
+      ([, value]) => typeof value === "string" && value.length > 0
+    )
+  );
+}
+function setSentryTagsFromContext(context) {
+  const attrs = contextToAttributes(context);
+  for (const [key, value] of Object.entries(attrs)) {
+    if (typeof value === "string" && value.length > 0) {
+      Sentry.setTag(key, value);
+    }
+  }
+  if (context.slackUserId) {
+    Sentry.setUser({
+      id: context.slackUserId,
+      username: context.slackUserName
+    });
+  }
+}
+function toSpanAttributeValue(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const sanitized = value.filter(
+    (entry) => typeof entry === "string"
+  );
+  return sanitized.length > 0 ? sanitized : void 0;
+}
+function logInfo(eventName, context = {}, attributes = {}, body) {
+  log.info(eventName, { ...toSpanAttributes(context), ...attributes }, body);
+}
+function logWarn(eventName, context = {}, attributes = {}, body) {
+  log.warn(eventName, { ...toSpanAttributes(context), ...attributes }, body);
+}
+function logError(eventName, context = {}, attributes = {}, body) {
+  log.error(eventName, { ...toSpanAttributes(context), ...attributes }, body);
+}
+function logException(error, eventName, context = {}, attributes = {}, body) {
+  const normalizedError = error instanceof Error ? error : new Error(String(error));
+  return log.exception(
+    eventName,
+    normalizedError,
+    { ...toSpanAttributes(context), ...attributes },
+    body
+  );
+}
+function setTags(context = {}) {
+  setLogContext(context);
+  setSentryTagsFromContext(context);
+}
+function createRequestContext(request, context = {}) {
+  return createLogContextFromRequest(request, context);
+}
+async function withContext(context, callback) {
+  return withLogContext(context, callback);
+}
+async function withSpan(name, op, context, callback, attributes = {}) {
+  const normalizedAttributes = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    const normalizedValue = toSpanAttributeValue(value);
+    if (normalizedValue !== void 0) {
+      normalizedAttributes[key] = normalizedValue;
+    }
+  }
+  return withLogContext(
+    context,
+    () => Sentry.startSpan(
+      {
+        name,
+        op,
+        attributes: {
+          ...toSpanAttributes(context),
+          ...normalizedAttributes
+        }
+      },
+      callback
+    )
+  );
+}
+function setSpanAttributes(attributes) {
+  const sentry = Sentry;
+  const span = sentry.getActiveSpan?.();
+  if (!span) {
+    return;
+  }
+  const setAttribute = span.setAttribute;
+  if (typeof setAttribute !== "function") {
+    return;
+  }
+  for (const [key, value] of Object.entries(attributes)) {
+    const normalizedValue = toSpanAttributeValue(value);
+    if (normalizedValue !== void 0) {
+      setAttribute.call(span, key, normalizedValue);
+    }
+  }
+}
+function setSpanStatus(status) {
+  const sentry = Sentry;
+  const span = sentry.getActiveSpan?.();
+  if (!span) {
+    return;
+  }
+  const setStatus = span.setStatus;
+  if (typeof setStatus !== "function") {
+    return;
+  }
+  setStatus.call(span, status === "ok" ? "ok" : "internal_error");
+}
+function toOptionalString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function getActiveTraceId() {
+  const sentry = Sentry;
+  if (typeof sentry.getActiveSpan !== "function" || typeof sentry.spanToJSON !== "function") {
+    return void 0;
+  }
+  try {
+    const span = sentry.getActiveSpan();
+    if (!span) {
+      return void 0;
+    }
+    return toOptionalString(sentry.spanToJSON(span).trace_id);
+  } catch {
+    return void 0;
+  }
+}
+function resolveErrorReference(eventId) {
+  const traceId = getActiveTraceId();
+  if (!eventId && !traceId) {
+    return null;
+  }
+  if (!traceId) {
+    return null;
+  }
+  return {
+    traceId,
+    ...eventId ? { eventId } : {}
+  };
+}
+var GEN_AI_DEFAULT_MAX_ATTRIBUTE_CHARS = 12e3;
+var GEN_AI_MAX_STRING_CHARS = 2e3;
+var GEN_AI_MAX_ARRAY_ITEMS = 50;
+var GEN_AI_MAX_OBJECT_KEYS = 50;
+function truncateGenAiString(value, maxChars) {
+  return value.length > maxChars ? `${value.slice(0, maxChars)}...` : value;
+}
+function sanitizeGenAiValue(value, seen, depth, keyName) {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const shouldTreatAsBlob = (keyName === "data" || keyName === "base64" || keyName?.endsWith("_base64") === true) && value.length > 256;
+    if (shouldTreatAsBlob) {
+      return `[omitted:${value.length}]`;
+    }
+    return truncateGenAiString(value, GEN_AI_MAX_STRING_CHARS);
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : void 0;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (depth >= 8) {
+    return "[depth_limit]";
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, GEN_AI_MAX_ARRAY_ITEMS).map((entry) => sanitizeGenAiValue(entry, seen, depth + 1)).filter((entry) => entry !== void 0);
+  }
+  if (typeof value !== "object") {
+    return String(value);
+  }
+  if (seen.has(value)) {
+    return "[circular]";
+  }
+  seen.add(value);
+  const record = value;
+  const out = {};
+  for (const [key, entryValue] of Object.entries(record).slice(
+    0,
+    GEN_AI_MAX_OBJECT_KEYS
+  )) {
+    const sanitized = sanitizeGenAiValue(entryValue, seen, depth + 1, key);
+    if (sanitized !== void 0) {
+      out[key] = sanitized;
+    }
+  }
+  return out;
+}
+function serializeGenAiAttribute(value, maxChars = GEN_AI_DEFAULT_MAX_ATTRIBUTE_CHARS) {
+  const sanitized = sanitizeGenAiValue(value, /* @__PURE__ */ new WeakSet(), 0);
+  if (sanitized === void 0) {
+    return void 0;
+  }
+  const serialized = typeof sanitized === "string" ? sanitized : JSON.stringify(sanitized);
+  if (!serialized) {
+    return void 0;
+  }
+  return truncateGenAiString(serialized, maxChars);
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : void 0;
+}
+function toFiniteTokenCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return void 0;
+  }
+  const rounded = Math.floor(value);
+  return rounded >= 0 ? rounded : void 0;
+}
+function readTokenCount(root, keys) {
+  for (const key of keys) {
+    const value = toFiniteTokenCount(root[key]);
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function collectUsageRoots(source) {
+  const sourceRecord = asRecord(source);
+  if (!sourceRecord) {
+    return [];
+  }
+  const roots = [sourceRecord];
+  const usage = asRecord(sourceRecord.usage);
+  if (usage) {
+    roots.push(usage);
+  }
+  const tokenUsage = asRecord(sourceRecord.tokenUsage);
+  if (tokenUsage) {
+    roots.push(tokenUsage);
+  }
+  const providerMetadata = asRecord(sourceRecord.providerMetadata);
+  if (providerMetadata) {
+    roots.push(providerMetadata);
+    const providerUsage = asRecord(providerMetadata.usage);
+    if (providerUsage) {
+      roots.push(providerUsage);
+    }
+  }
+  const response = asRecord(sourceRecord.response);
+  if (response) {
+    roots.push(response);
+    const responseUsage = asRecord(response.usage);
+    if (responseUsage) {
+      roots.push(responseUsage);
+    }
+  }
+  return roots;
+}
+function extractGenAiUsageAttributes(...sources) {
+  const roots = sources.flatMap((source) => collectUsageRoots(source));
+  if (roots.length === 0) {
+    return {};
+  }
+  const inputTokens = roots.map(
+    (root) => readTokenCount(root, [
+      "input_tokens",
+      "inputTokens",
+      "prompt_tokens",
+      "promptTokens",
+      "inputTokenCount",
+      "promptTokenCount"
+    ])
+  ).find((value) => value !== void 0) ?? void 0;
+  const outputTokens = roots.map(
+    (root) => readTokenCount(root, [
+      "output_tokens",
+      "outputTokens",
+      "completion_tokens",
+      "completionTokens",
+      "outputTokenCount",
+      "completionTokenCount"
+    ])
+  ).find((value) => value !== void 0) ?? void 0;
+  return {
+    ...inputTokens !== void 0 ? { "gen_ai.usage.input_tokens": inputTokens } : {},
+    ...outputTokens !== void 0 ? { "gen_ai.usage.output_tokens": outputTokens } : {}
+  };
+}
 
 // src/chat/plugins/manifest.ts
 import { z } from "zod";
@@ -1417,6 +2260,20 @@ function createPluginBroker(provider, deps) {
 }
 
 export {
+  logInfo,
+  logWarn,
+  logError,
+  logException,
+  setTags,
+  createRequestContext,
+  withContext,
+  withSpan,
+  setSpanAttributes,
+  setSpanStatus,
+  toOptionalString,
+  resolveErrorReference,
+  serializeGenAiAttribute,
+  extractGenAiUsageAttributes,
   resolveAuthTokenPlaceholder,
   parsePluginManifest,
   CredentialUnavailableError,