@sentry/junior 0.68.0 → 0.69.0

package/dist/chunk-BBXYXOJW.js

@@ -0,0 +1,1858 @@
+import {
+  sentry_exports
+} from "./chunk-Z3YD6NHK.js";
+
+// src/chat/discovery.ts
+import fs, { statSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function isDirectory(targetPath) {
+  try {
+    return statSync(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(targetPath) {
+  try {
+    return statSync(targetPath).isFile();
+  } catch {
+    return false;
+  }
+}
+function normalizePath(targetPath) {
+  return path.resolve(targetPath);
+}
+function uniqueResolvedPathsInOrder(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const value of values) {
+    const normalized = normalizePath(value);
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    resolved.push(normalized);
+  }
+  return resolved;
+}
+function isNodeModulesPath(candidatePath) {
+  return path.basename(candidatePath) === "node_modules";
+}
+function isInsidePnpmStore(candidatePath) {
+  return candidatePath.split(path.sep).includes(".pnpm");
+}
+function runningFromInstalledPackage() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const marker = `${path.sep}node_modules${path.sep}@sentry${path.sep}junior${path.sep}`;
+  return currentFile.includes(marker);
+}
+function listInstalledPackageNodeModulesDirs() {
+  if (!runningFromInstalledPackage()) {
+    return [];
+  }
+  const dirs = [];
+  let current = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
+  while (true) {
+    if (isNodeModulesPath(current) && !isInsidePnpmStore(current) && isDirectory(current)) {
+      dirs.push(current);
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function listCwdAncestorNodeModulesDirs(cwd) {
+  const resolvedCwd = normalizePath(cwd);
+  const dirs = [];
+  let current = resolvedCwd;
+  while (true) {
+    const nodeModulesDir = path.join(current, "node_modules");
+    if (isDirectory(nodeModulesDir)) {
+      dirs.push(nodeModulesDir);
+    }
+    if (isFile(path.join(current, "package.json"))) {
+      break;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function discoverNodeModulesDirs(cwd = process.cwd(), options) {
+  const explicit = options?.candidateDirs?.filter((dir) => isDirectory(dir)) ?? [];
+  if (explicit.length > 0) {
+    return uniqueResolvedPathsInOrder(explicit);
+  }
+  return uniqueResolvedPathsInOrder([
+    ...listInstalledPackageNodeModulesDirs(),
+    ...listCwdAncestorNodeModulesDirs(cwd)
+  ]);
+}
+function discoverProjectRoots(cwd = process.cwd(), options) {
+  const roots = discoverNodeModulesDirs(
+    cwd,
+    options?.nodeModulesDirs ? { candidateDirs: options.nodeModulesDirs } : void 0
+  ).map((nodeModulesDir) => path.dirname(nodeModulesDir));
+  return uniqueResolvedPathsInOrder([cwd, ...roots]);
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function pathExists(targetPath) {
+  try {
+    fs.accessSync(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasAnyDataMarkers(appDir) {
+  return pathExists(path.join(appDir, "SOUL.md")) || pathExists(path.join(appDir, "WORLD.md"));
+}
+function scoreAppCandidate(appDir) {
+  let score = 0;
+  if (pathExists(path.join(appDir, "SOUL.md"))) {
+    score += 4;
+  }
+  if (pathExists(path.join(appDir, "WORLD.md"))) {
+    score += 2;
+  }
+  if (pathExists(path.join(appDir, "skills"))) {
+    score += 1;
+  }
+  if (pathExists(path.join(appDir, "plugins"))) {
+    score += 1;
+  }
+  return score;
+}
+function resolveCandidateAppDirs(cwd, projectRoots) {
+  const roots = projectRoots ?? discoverProjectRoots(cwd);
+  const resolved = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    const appDir = path.resolve(root, "app");
+    if (!pathExists(appDir)) {
+      continue;
+    }
+    if (seen.has(appDir)) {
+      continue;
+    }
+    seen.add(appDir);
+    resolved.push(appDir);
+  }
+  return resolved;
+}
+function homeDir() {
+  return resolveHomeDir();
+}
+function resolveHomeDir(cwd = process.cwd(), options) {
+  const resolvedCwd = path.resolve(cwd);
+  const directApp = path.resolve(resolvedCwd, "app");
+  if (pathExists(directApp) && hasAnyDataMarkers(directApp)) {
+    return directApp;
+  }
+  const candidates = resolveCandidateAppDirs(
+    resolvedCwd,
+    options?.projectRoots
+  );
+  if (candidates.length === 0) {
+    return directApp;
+  }
+  candidates.sort((left, right) => {
+    const leftScore = scoreAppCandidate(left);
+    const rightScore = scoreAppCandidate(right);
+    if (leftScore !== rightScore) {
+      return rightScore - leftScore;
+    }
+    const leftDistance = path.relative(resolvedCwd, left).split(path.sep).length;
+    const rightDistance = path.relative(resolvedCwd, right).split(path.sep).length;
+    if (leftDistance !== rightDistance) {
+      return leftDistance - rightDistance;
+    }
+    return left.localeCompare(right);
+  });
+  return candidates[0];
+}
+function resolveContentRoots(subdir) {
+  if (subdir === "data") {
+    return [homeDir()];
+  }
+  return [path.join(homeDir(), subdir)];
+}
+function dataRoots() {
+  return unique(resolveContentRoots("data"));
+}
+function skillRoots() {
+  return unique(resolveContentRoots("skills"));
+}
+function pluginRoots() {
+  return unique(resolveContentRoots("plugins"));
+}
+function soulPathCandidates() {
+  const candidates = dataRoots().map((root) => path.join(root, "SOUL.md"));
+  return unique(candidates);
+}
+function worldPathCandidates() {
+  const candidates = dataRoots().map((root) => path.join(root, "WORLD.md"));
+  return unique(candidates);
+}
+var RESERVED_APP_FILES = /* @__PURE__ */ new Set([
+  "SOUL.md",
+  "WORLD.md",
+  "DESCRIPTION.md",
+  "ABOUT.md"
+]);
+function listReferenceFiles() {
+  const appDir = homeDir();
+  try {
+    const entries = fs.readdirSync(appDir, { withFileTypes: true });
+    return entries.filter(
+      (entry) => entry.isFile() && entry.name.endsWith(".md") && !RESERVED_APP_FILES.has(entry.name)
+    ).map((entry) => path.join(appDir, entry.name)).sort();
+  } catch {
+    return [];
+  }
+}
+
+// src/chat/coerce.ts
+function toOptionalString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function toOptionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/chat/logging.ts
+import { AsyncLocalStorage } from "async_hooks";
+import path2 from "path";
+import { styleText } from "util";
+import {
+  ConfigError,
+  configureSync,
+  getConfig,
+  getLogger
+} from "@logtape/logtape";
+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: "exception.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: "app.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: "gen_ai.response.finish_reasons",
+  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"
+};
+function normalizeGenAiFinishReason(reason) {
+  return reason === "toolUse" ? "tool_use" : reason;
+}
+function normalizeGenAiFinishReasons(value) {
+  if (typeof value === "string" && value.trim()) {
+    return [normalizeGenAiFinishReason(value)];
+  }
+  if (!Array.isArray(value)) {
+    return value;
+  }
+  return value.map(
+    (reason) => typeof reason === "string" ? normalizeGenAiFinishReason(reason) : reason
+  );
+}
+var contextStorage = new AsyncLocalStorage();
+var logRecordSinks = /* @__PURE__ */ new Set();
+var LOGTAPE_BODY_KEY = "__logtape_body";
+var ROOT_LOGGER_CATEGORY = ["junior"];
+var CONSOLE_PRIORITY_KEYS = [
+  "gen_ai.conversation.id",
+  "event.name",
+  "app.log.source",
+  "exception.message",
+  "messaging.message.id",
+  "trace_id",
+  "span_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([
+  "gen_ai.agent.name",
+  "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"
+]);
+var SENTRY_TAG_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
+  "app.platform",
+  "messaging.system",
+  "app.actor.type",
+  "gen_ai.agent.name",
+  "gen_ai.request.model",
+  "app.skill.name",
+  "http.request.method",
+  "url.path"
+]);
+function getSentryEnvironment() {
+  return (process.env.SENTRY_ENVIRONMENT ?? process.env.VERCEL_ENV ?? process.env.NODE_ENV ?? "").trim().toLowerCase();
+}
+function shouldSuppressInfoLog(level) {
+  return getSentryEnvironment() === "production" && level === "info";
+}
+function shouldEmitConsole(level) {
+  if (process.env.NODE_ENV === "test") {
+    return level === "error";
+  }
+  return true;
+}
+function isDevelopmentLoggingMode() {
+  if (process.env.NODE_ENV !== "development") {
+    return false;
+  }
+  if (process.env.CI) {
+    return false;
+  }
+  return true;
+}
+function shouldUseDevelopmentConsoleFormat() {
+  if (!isDevelopmentLoggingMode()) {
+    return false;
+  }
+  return process.env.JUNIOR_LOG_FORMAT?.trim().toLowerCase() !== "structured";
+}
+function shouldUsePrettyConsole(level) {
+  if (level === "warn" || level === "error") {
+    return false;
+  }
+  return shouldUseDevelopmentConsoleFormat();
+}
+function shouldUseConsoleColor() {
+  if (!shouldUseDevelopmentConsoleFormat()) {
+    return false;
+  }
+  if (process.env.NO_COLOR) {
+    return false;
+  }
+  return process.env.FORCE_COLOR?.trim() === "1" || Boolean(process.stdout?.isTTY) || Boolean(process.stderr?.isTTY);
+}
+function formatConsoleTimestamp(timestamp) {
+  if (shouldUseDevelopmentConsoleFormat()) {
+    return timestamp.toTimeString().slice(0, 8);
+  }
+  return timestamp.toISOString();
+}
+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 = {
+    "gen_ai.conversation.id": context.conversationId,
+    "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.actor.type": context.actorType,
+    "app.actor.id": context.actorId,
+    "gen_ai.agent.name": 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_exports;
+  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(
+        key === "gen_ai.response.finish_reasons" ? normalizeGenAiFinishReasons(rawValue) : rawValue
+      );
+      if (value !== void 0) {
+        merged[key] = value;
+      }
+    }
+  }
+  return merged;
+}
+function fromLogTapeLevel(level) {
+  if (level === "warning") {
+    return "warn";
+  }
+  if (level === "fatal") {
+    return "error";
+  }
+  if (level === "trace") {
+    return "debug";
+  }
+  return level;
+}
+function getLogSource(category) {
+  if (category.length <= ROOT_LOGGER_CATEGORY.length) {
+    return void 0;
+  }
+  const sourceParts = category.slice(ROOT_LOGGER_CATEGORY.length);
+  return sourceParts.length > 0 ? sourceParts.join(".") : void 0;
+}
+function toEmittedLogRecord(record) {
+  const properties = { ...record.properties };
+  const rawBody = properties[LOGTAPE_BODY_KEY];
+  delete properties[LOGTAPE_BODY_KEY];
+  const attributes = mergeAttributes(properties);
+  const source = getLogSource(record.category);
+  if (source && attributes["app.log.source"] === void 0) {
+    attributes["app.log.source"] = source;
+  }
+  const body = toOptionalString(rawBody) ?? record.message.map(
+    (segment) => typeof segment === "string" ? segment : String(segment ?? "")
+  ).join("");
+  const eventName = toOptionalString(attributes["event.name"]) ?? "log_record_emitted";
+  return {
+    level: fromLogTapeLevel(record.level),
+    eventName,
+    body,
+    attributes
+  };
+}
+function createConsoleSink() {
+  return (record) => {
+    const emitted = toEmittedLogRecord(record);
+    emitConsole(
+      emitted.level,
+      emitted.eventName,
+      emitted.body,
+      emitted.attributes
+    );
+  };
+}
+function createSentrySink() {
+  return (record) => {
+    const emitted = toEmittedLogRecord(record);
+    emitSentry(emitted.level, emitted.body, emitted.attributes);
+  };
+}
+function createRecordSink() {
+  return (record) => {
+    const emitted = toEmittedLogRecord(record);
+    for (const sink of logRecordSinks) {
+      try {
+        sink(emitted);
+      } catch {
+      }
+    }
+  };
+}
+var rootLogger;
+var ownsLogTapeBackend = false;
+var usesDirectEmissionFallback = false;
+function ensureLoggerBackend() {
+  if (rootLogger || usesDirectEmissionFallback) {
+    return;
+  }
+  if (getConfig() !== null) {
+    usesDirectEmissionFallback = true;
+    return;
+  }
+  try {
+    configureSync({
+      sinks: {
+        console: createConsoleSink(),
+        sentry: createSentrySink(),
+        records: createRecordSink()
+      },
+      loggers: [
+        {
+          category: [...ROOT_LOGGER_CATEGORY],
+          sinks: ["console", "sentry", "records"],
+          lowestLevel: "debug"
+        },
+        {
+          category: ["logtape"],
+          sinks: ["console"],
+          lowestLevel: "error"
+        }
+      ],
+      contextLocalStorage: contextStorage
+    });
+    ownsLogTapeBackend = true;
+    rootLogger = getLogger([...ROOT_LOGGER_CATEGORY]);
+  } catch (error) {
+    if (error instanceof ConfigError && getConfig() !== null) {
+      usesDirectEmissionFallback = true;
+      return;
+    }
+    throw error;
+  }
+}
+function getLogTapeLogger(category = []) {
+  ensureLoggerBackend();
+  if (!rootLogger) {
+    throw new Error("LogTape backend is unavailable");
+  }
+  let logger = rootLogger;
+  for (const part of category) {
+    logger = logger.getChild(part);
+  }
+  return logger;
+}
+function emitSentry(level, body, attributes) {
+  if (shouldSuppressInfoLog(level)) {
+    return;
+  }
+  const sentry = sentry_exports;
+  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 consoleLevelStyle(level) {
+  if (level === "error") return "red";
+  if (level === "warn") return "yellow";
+  if (level === "info") return "green";
+  return "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 === "messaging.message.conversation_id" && attributes[key] === attributes["gen_ai.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 abbreviateConsoleId(value) {
+  if (value.length <= 20) {
+    return value;
+  }
+  return `${value.slice(0, 12)}...${value.slice(-4)}`;
+}
+function toRelativeConsolePath(value) {
+  const normalized = value.trim();
+  if (!normalized) {
+    return normalized;
+  }
+  try {
+    const relative = path2.relative(process.cwd(), normalized);
+    if (relative.length > 0 && !relative.startsWith("..") && !path2.isAbsolute(relative)) {
+      return relative;
+    }
+  } catch {
+  }
+  return normalized;
+}
+function pushPrettyConsoleToken(tokens, token) {
+  if (!token || tokens.includes(token)) {
+    return;
+  }
+  tokens.push(token);
+}
+function numericConsoleToken(label, value) {
+  return typeof value === "number" ? `${label}=${value}` : void 0;
+}
+function stringConsoleToken(label, value) {
+  const normalized = toOptionalString(value);
+  return normalized ? `${label}=${normalized}` : void 0;
+}
+function booleanConsoleToken(label, value) {
+  return typeof value === "boolean" ? `${label}=${value ? "yes" : "no"}` : void 0;
+}
+function shouldShowPrettyCorrelation(eventName) {
+  return !(eventName === "plugin_loaded" || eventName === "startup_discovery_summary" || eventName === "capability_catalog_loaded" || eventName.endsWith("_loaded"));
+}
+function getPrettyConsoleSummaryTokens(level, eventName, attributes) {
+  const tokens = [];
+  pushPrettyConsoleToken(
+    tokens,
+    toOptionalString(attributes["app.log.source"]) ?? void 0
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    eventName.startsWith("plugin_heartbeat") ? stringConsoleToken("plugin", attributes["app.plugin.name"]) : toOptionalString(attributes["app.plugin.name"]) ?? void 0
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken("caps", attributes["app.plugin.capability_count"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken("config", attributes["app.plugin.config_key_count"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    booleanConsoleToken("mcp", attributes["app.plugin.has_mcp"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken("plugins", attributes["app.plugin.count"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken("dispatches", attributes["app.dispatch.count"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken("skills", attributes["app.skill.count"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken("capabilities", attributes["app.capability.count"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken("config", attributes["app.config.key_count"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken("chars", attributes["app.message.length"])
+  );
+  pushPrettyConsoleToken(
+    tokens,
+    numericConsoleToken(
+      "attachments",
+      attributes["app.message.attachment_count"]
+    )
+  );
+  const rawAttachmentCount = toOptionalNumber(
+    attributes["app.message.attachment_count"]
+  );
+  const promptAttachmentCount = toOptionalNumber(
+    attributes["app.message.prompt_attachment_count"]
+  );
+  if (promptAttachmentCount !== void 0 && promptAttachmentCount !== rawAttachmentCount) {
+    pushPrettyConsoleToken(
+      tokens,
+      numericConsoleToken("prompt_attachments", promptAttachmentCount)
+    );
+  }
+  const filePath = toOptionalString(attributes["file.path"]);
+  if (filePath && eventName.endsWith("_loaded")) {
+    pushPrettyConsoleToken(tokens, toRelativeConsolePath(filePath));
+  }
+  if (shouldShowPrettyCorrelation(eventName)) {
+    const conversationId = toOptionalString(
+      attributes["gen_ai.conversation.id"]
+    );
+    const messageId = toOptionalString(attributes["messaging.message.id"]);
+    if (conversationId) {
+      pushPrettyConsoleToken(
+        tokens,
+        `conv=${abbreviateConsoleId(conversationId)}`
+      );
+    }
+    if (messageId) {
+      pushPrettyConsoleToken(tokens, `msg=${abbreviateConsoleId(messageId)}`);
+    }
+  }
+  const model = toOptionalString(attributes["gen_ai.request.model"]);
+  if (model && shouldShowConsoleModel(level, eventName)) {
+    pushPrettyConsoleToken(tokens, `model=${model}`);
+  }
+  return tokens;
+}
+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();
+  const useColor = shouldUseConsoleColor();
+  const levelStyle = consoleLevelStyle(level);
+  const colorize = (text, style) => useColor ? styleText(style, text) : text;
+  if (shouldUsePrettyConsole(level)) {
+    const summaryTokens = getPrettyConsoleSummaryTokens(
+      level,
+      eventName,
+      attributes
+    );
+    const summary = [body, ...summaryTokens].join(" ");
+    return [
+      colorize(formatConsoleTimestamp(timestamp), "gray"),
+      colorize(formatConsoleLevel(level), levelStyle),
+      summary
+    ].join(" ");
+  }
+  const parts = [
+    `${colorize(formatConsoleTimestamp(timestamp), "gray")} ${colorize(formatConsoleLevel(level), levelStyle)} ${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, "cyan")}=${colorize(formatConsoleValue(value), "dim")}`;
+    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 emitDirect(level, eventName, body, attributes) {
+  for (const sink of logRecordSinks) {
+    try {
+      sink({
+        level,
+        eventName,
+        body,
+        attributes
+      });
+    } catch {
+    }
+  }
+  emitConsole(level, eventName, body, attributes);
+  emitSentry(level, body, attributes);
+}
+function emitRecord(category, level, eventName, attrs = {}, body) {
+  ensureLoggerBackend();
+  const traceAttributes = getTraceCorrelationAttributes();
+  const normalizedEventName = toSnakeCase(eventName);
+  const message = body ? redactSecrets(body) : normalizedEventName;
+  const source = getLogSource([...ROOT_LOGGER_CATEGORY, ...category]);
+  const contextAttributes = ownsLogTapeBackend ? void 0 : contextStorage.getStore();
+  const attributes = mergeAttributes(contextAttributes, traceAttributes, {
+    "event.name": normalizedEventName,
+    ...source ? { "app.log.source": source } : {},
+    ...attrs
+  });
+  if (usesDirectEmissionFallback) {
+    emitDirect(level, normalizedEventName, message, attributes);
+    return;
+  }
+  const logger = getLogTapeLogger(category);
+  const properties = {
+    [LOGTAPE_BODY_KEY]: message,
+    ...attributes
+  };
+  if (level === "error") {
+    logger.error(`{${LOGTAPE_BODY_KEY}}`, properties);
+    return;
+  }
+  if (level === "warn") {
+    logger.warn(`{${LOGTAPE_BODY_KEY}}`, properties);
+    return;
+  }
+  if (level === "info") {
+    logger.info(`{${LOGTAPE_BODY_KEY}}`, properties);
+    return;
+  }
+  logger.debug(`{${LOGTAPE_BODY_KEY}}`, properties);
+}
+function emit(level, eventName, attrs = {}, body) {
+  emitRecord([], level, eventName, attrs, body);
+}
+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, context) {
+    const normalizedError = error instanceof Error ? error : new Error(String(error));
+    emit(
+      "error",
+      eventName,
+      {
+        ...attrs,
+        "error.type": normalizedError.name,
+        "exception.type": normalizedError.name,
+        "exception.message": normalizedError.message,
+        "exception.stacktrace": normalizedError.stack
+      },
+      body ?? normalizedError.message
+    );
+    let eventId;
+    const sentryWithScope = sentry_exports.withScope;
+    const sentryCaptureException = sentry_exports.captureException;
+    if (typeof sentryWithScope === "function" && typeof sentryCaptureException === "function") {
+      sentryWithScope((scope) => {
+        if (context) {
+          setSentryScopeContext(scope, context);
+        }
+        for (const [key, value] of Object.entries(
+          mergeAttributes(contextStorage.getStore(), attrs)
+        )) {
+          scope.setExtra(key, value);
+        }
+        eventId = sentryCaptureException(normalizedError);
+      });
+      return eventId;
+    }
+    if (typeof sentryCaptureException === "function") {
+      if (context) {
+        setSentryUser(sentryUserIdentityFromContext(context));
+      }
+      eventId = sentryCaptureException(normalizedError);
+    }
+    return eventId;
+  }
+};
+var CHAT_SDK_LEVEL_PRIORITY = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+function resolveChatSdkLogLevel() {
+  if (isDevelopmentLoggingMode()) {
+    return "warn";
+  }
+  return "info";
+}
+function shouldEmitChatSdkLevel(level, minimumLevel) {
+  if (minimumLevel === "silent") {
+    return false;
+  }
+  return CHAT_SDK_LEVEL_PRIORITY[level] >= CHAT_SDK_LEVEL_PRIORITY[minimumLevel];
+}
+function renderChatSdkArgument(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Error) {
+    return value.message;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function formatChatSdkBody(message, args) {
+  const renderedArgs = args.map((arg) => renderChatSdkArgument(arg).trim()).filter((arg) => arg.length > 0);
+  if (renderedArgs.length === 0) {
+    return message;
+  }
+  return `${message} ${renderedArgs.join(" ")}`;
+}
+function createChatSdkLoggerImpl(category, minimumLevel) {
+  const emitChatSdkLog = (level, message, args) => {
+    if (!shouldEmitChatSdkLevel(level, minimumLevel)) {
+      return;
+    }
+    emitRecord(
+      category,
+      level === "warn" ? "warn" : level,
+      level === "error" ? "chat_sdk_error" : level === "warn" ? "chat_sdk_warning" : "chat_sdk_log",
+      args.length > 0 ? {
+        "app.log.args": args.length === 1 ? args[0] : args
+      } : {},
+      formatChatSdkBody(message, args)
+    );
+  };
+  return {
+    child(prefix) {
+      return createChatSdkLoggerImpl([...category, prefix], minimumLevel);
+    },
+    debug(message, ...args) {
+      emitChatSdkLog("debug", message, args);
+    },
+    info(message, ...args) {
+      emitChatSdkLog("info", message, args);
+    },
+    warn(message, ...args) {
+      emitChatSdkLog("warn", message, args);
+    },
+    error(message, ...args) {
+      emitChatSdkLog("error", message, args);
+    }
+  };
+}
+function createChatSdkLogger() {
+  return createChatSdkLoggerImpl(["chat-sdk"], resolveChatSdkLogLevel());
+}
+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 getLogContextAttributes() {
+  return contextStorage.getStore() ?? {};
+}
+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 (!SENTRY_TAG_ATTRIBUTE_KEYS.has(key)) {
+      continue;
+    }
+    if (typeof value === "string" && value.length > 0) {
+      sentry_exports.setTag(key, value);
+    }
+  }
+}
+function sentryUserIdentityFromContext(context) {
+  if (context.slackUserId) {
+    return {
+      id: context.slackUserId,
+      ...context.slackUserName ? { username: context.slackUserName } : {},
+      ...context.slackUserEmail ? { email: context.slackUserEmail } : {}
+    };
+  }
+  return void 0;
+}
+function sentryUserFromIdentity(identity) {
+  return {
+    id: identity.id,
+    ip_address: null,
+    ...identity.username ? { username: identity.username } : {},
+    ...identity.email ? { email: identity.email } : {}
+  };
+}
+function setSentryUser(identity) {
+  if (!identity) return;
+  sentry_exports.setUser(sentryUserFromIdentity(identity));
+}
+function setSentryScopeContext(scope, context) {
+  const attrs = contextToAttributes(context);
+  for (const [key, value] of Object.entries(attrs)) {
+    if (!SENTRY_TAG_ATTRIBUTE_KEYS.has(key)) {
+      continue;
+    }
+    if (typeof value === "string" && value.length > 0) {
+      scope.setTag(key, value);
+    }
+  }
+  const identity = sentryUserIdentityFromContext(context);
+  if (identity) {
+    scope.setUser(sentryUserFromIdentity(identity));
+  }
+  scope.setContext("app", attrs);
+}
+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 normalizeSpanAttributes(attributes) {
+  const normalized = {};
+  for (const [rawKey, value] of Object.entries(attributes)) {
+    const key = normalizeAttributeKey(rawKey);
+    const normalizedValue = toSpanAttributeValue(
+      key === "gen_ai.response.finish_reasons" ? normalizeGenAiFinishReasons(value) : value
+    );
+    if (normalizedValue !== void 0) {
+      normalized[key] = normalizedValue;
+    }
+  }
+  return normalized;
+}
+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,
+    context
+  );
+}
+function setTags(context = {}) {
+  setLogContext(context);
+  setSentryTagsFromContext(context);
+  setSentryUser(sentryUserIdentityFromContext(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 = normalizeSpanAttributes(attributes);
+  return withLogContext(context, () => {
+    const inheritedAttributes = getLogContextAttributes();
+    return sentry_exports.startSpan(
+      {
+        name,
+        op,
+        attributes: {
+          ...inheritedAttributes,
+          ...normalizedAttributes
+        }
+      },
+      callback
+    );
+  });
+}
+function setSpanAttributes(attributes) {
+  const sentry = sentry_exports;
+  const span = sentry.getActiveSpan?.();
+  if (!span) {
+    return;
+  }
+  const setAttribute = span.setAttribute;
+  if (typeof setAttribute !== "function") {
+    return;
+  }
+  for (const [key, value] of Object.entries(
+    normalizeSpanAttributes(attributes)
+  )) {
+    setAttribute.call(span, key, value);
+  }
+}
+function setSpanStatus(status) {
+  const sentry = sentry_exports;
+  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 getActiveTraceId() {
+  const sentry = sentry_exports;
+  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;
+  }
+}
+var TURN_FAILURE_RESPONSE_TEMPLATE = "I ran into an internal error while processing that. Reference: `event_id={eventId}`.";
+function buildTurnFailureResponse(eventId) {
+  return TURN_FAILURE_RESPONSE_TEMPLATE.replace("{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(redactSecrets(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 redactSecrets(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(redactSecrets(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 sumTokenCounts(...values) {
+  let total = 0;
+  let hasValue = false;
+  for (const value of values) {
+    if (value === void 0) {
+      continue;
+    }
+    total += value;
+    hasValue = true;
+  }
+  return hasValue ? total : void 0;
+}
+var PI_USAGE_FIELDS = [
+  ["input", "inputTokens"],
+  ["output", "outputTokens"],
+  ["cacheRead", "cachedInputTokens"],
+  ["cacheWrite", "cacheCreationTokens"],
+  ["totalTokens", "totalTokens"]
+];
+function readPiUsage(source) {
+  const record = asRecord(source);
+  if (!record) {
+    return {};
+  }
+  const usage = asRecord(record.usage) ?? record;
+  const summary = {};
+  for (const [piKey, ourKey] of PI_USAGE_FIELDS) {
+    const value = toFiniteTokenCount(usage[piKey]) ?? toFiniteTokenCount(usage[ourKey]);
+    if (value !== void 0) {
+      summary[ourKey] = value;
+    }
+  }
+  return summary;
+}
+function extractGenAiUsageSummary(...sources) {
+  const summary = {};
+  for (const source of sources) {
+    const single = readPiUsage(source);
+    for (const field of Object.keys(single)) {
+      const value = single[field];
+      if (value === void 0) continue;
+      summary[field] = (summary[field] ?? 0) + value;
+    }
+  }
+  return summary;
+}
+function extractGenAiUsageAttributes(...sources) {
+  const { inputTokens, outputTokens, cachedInputTokens, cacheCreationTokens } = extractGenAiUsageSummary(...sources);
+  const semanticInputTokens = sumTokenCounts(
+    inputTokens,
+    cachedInputTokens,
+    cacheCreationTokens
+  );
+  return {
+    ...semanticInputTokens !== void 0 ? { "gen_ai.usage.input_tokens": semanticInputTokens } : {},
+    ...outputTokens !== void 0 ? { "gen_ai.usage.output_tokens": outputTokens } : {},
+    ...cachedInputTokens !== void 0 ? { "gen_ai.usage.cache_read.input_tokens": cachedInputTokens } : {},
+    ...cacheCreationTokens !== void 0 ? { "gen_ai.usage.cache_creation.input_tokens": cacheCreationTokens } : {}
+  };
+}
+
+// src/package-resolution.ts
+import { statSync as statSync2 } from "fs";
+import { createRequire } from "module";
+import path3 from "path";
+function isDirectory2(targetPath) {
+  try {
+    return statSync2(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile2(targetPath) {
+  try {
+    return statSync2(targetPath).isFile();
+  } catch {
+    return false;
+  }
+}
+function uniqueResolvedPathsInOrder2(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const value of values) {
+    const normalized = path3.resolve(value);
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    resolved.push(normalized);
+  }
+  return resolved;
+}
+function ancestorNodeModulesDirs(cwd) {
+  const dirs = [];
+  let current = path3.resolve(cwd);
+  while (true) {
+    const nodeModulesDir = path3.join(current, "node_modules");
+    if (isDirectory2(nodeModulesDir)) {
+      dirs.push(nodeModulesDir);
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function packageDirInNodeModules(nodeModulesDir, packageName) {
+  const packageDir = path3.join(nodeModulesDir, ...packageName.split("/"));
+  return isDirectory2(packageDir) ? path3.resolve(packageDir) : void 0;
+}
+function isValidPackageSegment(segment) {
+  return Boolean(segment) && segment !== "." && segment !== ".." && !segment.startsWith(".") && /^[A-Za-z0-9._~-]+$/.test(segment);
+}
+function isValidPackageName(packageName) {
+  if (!packageName || packageName.includes("\\") || path3.isAbsolute(packageName)) {
+    return false;
+  }
+  const parts = packageName.split("/");
+  if (parts[0].startsWith("@")) {
+    return parts.length === 2 && parts[0].length > 1 && isValidPackageSegment(parts[0].slice(1)) && isValidPackageSegment(parts[1]);
+  }
+  return parts.length === 1 && isValidPackageSegment(parts[0]);
+}
+function findPackageRoot(entryPath) {
+  let dir = path3.dirname(entryPath);
+  while (dir !== path3.dirname(dir)) {
+    if (isFile2(path3.join(dir, "package.json"))) {
+      return path3.resolve(dir);
+    }
+    dir = path3.dirname(dir);
+  }
+  return void 0;
+}
+function findPackageNodeModulesDir(packageDir, packageName) {
+  const parts = path3.resolve(packageDir).split(path3.sep);
+  const packageParts = packageName.split("/");
+  for (let index = parts.length - 1; index >= 0; index -= 1) {
+    if (parts[index] !== "node_modules") {
+      continue;
+    }
+    const candidatePackageParts = parts.slice(
+      index + 1,
+      index + 1 + packageParts.length
+    );
+    if (candidatePackageParts.join("/") !== packageParts.join("/")) {
+      continue;
+    }
+    return path3.resolve(parts.slice(0, index + 1).join(path3.sep) || path3.sep);
+  }
+  return void 0;
+}
+function resolvePackageWithNode(cwd, packageName) {
+  let requireFromCwd;
+  try {
+    requireFromCwd = createRequire(path3.join(cwd, "package.json"));
+  } catch {
+    return void 0;
+  }
+  for (const specifier of [`${packageName}/package.json`, packageName]) {
+    try {
+      const resolved = requireFromCwd.resolve(specifier);
+      const dir = specifier.endsWith("/package.json") ? path3.dirname(resolved) : findPackageRoot(resolved);
+      if (!dir) {
+        continue;
+      }
+      const nodeModulesDir = findPackageNodeModulesDir(dir, packageName);
+      return {
+        dir,
+        ...nodeModulesDir ? { nodeModulesDir } : {}
+      };
+    } catch {
+    }
+  }
+  return void 0;
+}
+function resolvePackageLocation(cwd, packageName, options) {
+  if (!isValidPackageName(packageName)) {
+    return void 0;
+  }
+  const nodeModulesDirs = uniqueResolvedPathsInOrder2([
+    ...options?.nodeModulesDirs ?? [],
+    ...ancestorNodeModulesDirs(cwd)
+  ]);
+  for (const nodeModulesDir of nodeModulesDirs) {
+    const dir = packageDirInNodeModules(nodeModulesDir, packageName);
+    if (dir) {
+      return { dir, nodeModulesDir };
+    }
+  }
+  return resolvePackageWithNode(cwd, packageName);
+}
+function resolvePackageDir(cwd, packageName) {
+  return resolvePackageLocation(cwd, packageName)?.dir;
+}
+
+// src/chat/plugins/package-discovery.ts
+import path4 from "path";
+function normalizeForGlob(targetPath) {
+  return targetPath.split(path4.sep).join("/");
+}
+function uniqueStringsInOrder(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const value of values) {
+    if (seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    resolved.push(value);
+  }
+  return resolved;
+}
+function pathForTracingInclude(cwd, targetPath) {
+  const relative = path4.relative(cwd, targetPath);
+  if (!relative || path4.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path4.sep}`)) {
+    return null;
+  }
+  const normalized = normalizeForGlob(relative);
+  return normalized.startsWith(".") ? normalized : `./${normalized}`;
+}
+function normalizePluginPackageNames(packageNames) {
+  if (packageNames === void 0) {
+    return [];
+  }
+  if (!Array.isArray(packageNames)) {
+    throw new Error("Plugin package names must be an array");
+  }
+  const normalized = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const packageName of packageNames) {
+    const normalizedPackageName = typeof packageName === "string" ? packageName.trim() : "";
+    if (!normalizedPackageName || !isValidPackageName(normalizedPackageName)) {
+      throw new Error("Plugin package names must be valid npm package names");
+    }
+    if (seen.has(normalizedPackageName)) {
+      continue;
+    }
+    seen.add(normalizedPackageName);
+    normalized.push(normalizedPackageName);
+  }
+  return normalized;
+}
+function formatNodeModulesDirs(candidateNodeModulesDirs) {
+  return candidateNodeModulesDirs.length > 0 ? candidateNodeModulesDirs.join(", ") : "none found";
+}
+function resolvePackageDirFromName(cwd, packageName, candidateNodeModulesDirs) {
+  return resolvePackageLocation(cwd, packageName, {
+    nodeModulesDirs: candidateNodeModulesDirs
+  }) ?? null;
+}
+function readPluginPackageFlags(dir) {
+  const hasRootPluginManifest = isFile(path4.join(dir, "plugin.yaml"));
+  const hasPluginsDir = isDirectory(path4.join(dir, "plugins"));
+  const hasSkillsDir = isDirectory(path4.join(dir, "skills"));
+  if (!hasRootPluginManifest && !hasPluginsDir && !hasSkillsDir) {
+    return null;
+  }
+  return {
+    hasRootPluginManifest,
+    hasPluginsDir,
+    hasSkillsDir
+  };
+}
+function discoverDeclaredPackages(packageNames, candidateNodeModulesDirs, cwd) {
+  const discovered = [];
+  const seenPackageDirs = /* @__PURE__ */ new Set();
+  for (const packageName of packageNames) {
+    const resolved = resolvePackageDirFromName(
+      cwd,
+      packageName,
+      candidateNodeModulesDirs
+    );
+    if (!resolved) {
+      throw new Error(
+        `Plugin package "${packageName}" was configured but could not be resolved from node_modules or package resolution (${formatNodeModulesDirs(candidateNodeModulesDirs)})`
+      );
+    }
+    if (seenPackageDirs.has(resolved.dir)) {
+      continue;
+    }
+    const pluginFlags = readPluginPackageFlags(resolved.dir);
+    if (!pluginFlags) {
+      throw new Error(
+        `Plugin package "${packageName}" was configured but does not contain plugin content; expected plugin.yaml, plugins/, or skills/ in ${resolved.dir}`
+      );
+    }
+    seenPackageDirs.add(resolved.dir);
+    discovered.push({
+      name: packageName,
+      dir: resolved.dir,
+      nodeModulesDir: resolved.nodeModulesDir,
+      ...pluginFlags
+    });
+  }
+  return discovered;
+}
+function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
+  const resolvedCwd = path4.resolve(cwd);
+  const packageNames = normalizePluginPackageNames(options?.packageNames);
+  const nodeModulesDirs = options?.nodeModulesDirs ?? discoverNodeModulesDirs(resolvedCwd);
+  const discoveredPackages = discoverDeclaredPackages(
+    packageNames,
+    nodeModulesDirs,
+    resolvedCwd
+  );
+  const manifestRoots = [];
+  const skillRoots2 = [];
+  const tracingIncludes = [];
+  for (const pkg of discoveredPackages) {
+    const tracingBasePath = pkg.nodeModulesDir ? pathForTracingInclude(
+      resolvedCwd,
+      path4.join(pkg.nodeModulesDir, ...pkg.name.split("/"))
+    ) : pathForTracingInclude(resolvedCwd, pkg.dir);
+    if (pkg.hasRootPluginManifest) {
+      manifestRoots.push(pkg.dir);
+      if (tracingBasePath) {
+        tracingIncludes.push(`${tracingBasePath}/plugin.yaml`);
+      }
+    }
+    if (pkg.hasPluginsDir) {
+      manifestRoots.push(path4.join(pkg.dir, "plugins"));
+      if (tracingBasePath) {
+        tracingIncludes.push(`${tracingBasePath}/plugins/**/*`);
+      }
+    }
+    if (pkg.hasSkillsDir) {
+      skillRoots2.push(path4.join(pkg.dir, "skills"));
+      if (tracingBasePath) {
+        tracingIncludes.push(`${tracingBasePath}/skills/**/*`);
+      }
+    }
+  }
+  return {
+    packageNames: uniqueStringsInOrder(
+      discoveredPackages.map((pkg) => pkg.name)
+    ),
+    packages: discoveredPackages.map((pkg) => ({
+      dir: pkg.dir,
+      hasSkillsDir: pkg.hasSkillsDir,
+      name: pkg.name
+    })),
+    manifestRoots: uniqueStringsInOrder(manifestRoots),
+    skillRoots: uniqueStringsInOrder(skillRoots2),
+    tracingIncludes: uniqueStringsInOrder(tracingIncludes)
+  };
+}
+
+export {
+  homeDir,
+  skillRoots,
+  pluginRoots,
+  soulPathCandidates,
+  worldPathCandidates,
+  listReferenceFiles,
+  toOptionalString,
+  toOptionalNumber,
+  isRecord,
+  normalizeGenAiFinishReason,
+  createChatSdkLogger,
+  getLogContextAttributes,
+  setSentryUser,
+  logInfo,
+  logWarn,
+  logError,
+  logException,
+  setTags,
+  createRequestContext,
+  withContext,
+  withSpan,
+  setSpanAttributes,
+  setSpanStatus,
+  getActiveTraceId,
+  buildTurnFailureResponse,
+  serializeGenAiAttribute,
+  extractGenAiUsageSummary,
+  extractGenAiUsageAttributes,
+  isValidPackageName,
+  resolvePackageDir,
+  normalizePluginPackageNames,
+  discoverInstalledPluginPackageContent
+};