@sentry/junior 0.7.0 → 0.9.0

package/dist/{chunk-PY4AI2GZ.js → chunk-ZW4OVKF5.js}

@@ -1,6 +1,3 @@
-// src/chat/observability.ts
-import * as Sentry2 from "@sentry/nextjs";
-
 // src/chat/logging.ts
 import { AsyncLocalStorage } from "async_hooks";
 import * as Sentry from "@sentry/nextjs";
@@ -9,8 +6,7 @@ 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,
-  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]+?-----END [A-Z ]*PRIVATE KEY-----/g
+  /\b[A-Z0-9_]+(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD)\s*[=:]\s*([^\s"']{8,})/gi
 ];
 var LEGACY_KEY_MAP = {
   error: "error.message",
@@ -55,21 +51,42 @@ var ANSI = {
 var CONSOLE_PRIORITY_KEYS = [
   "app.conversation.id",
   "app.turn.id",
-  "app.agent.id",
   "event.name",
   "error.message",
   "messaging.message.id",
+  "app.trace_id",
+  "app.span_id",
+  "app.agent.id",
   "messaging.message.conversation_id",
   "messaging.destination.name",
-  "enduser.id",
   "app.run.id",
-  "app.message.kind",
-  "app.trace_id",
-  "app.span_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();
 }
@@ -82,16 +99,73 @@ function shouldEmitConsole(level) {
   }
   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 = input;
+  let out = redactPrivateKeyBlocks(input);
   for (const pattern of SECRETS_RE) {
     out = out.replace(pattern, (full, token) => {
-      if (full.includes("PRIVATE KEY")) {
-        const lines = full.trim().split("\n");
-        return lines.length >= 2 ? `${lines[0]}
-...redacted...
-${lines[lines.length - 1]}` : "***PRIVATE KEY***";
-      }
       if (typeof token !== "string") {
         return "***";
       }
@@ -268,7 +342,77 @@ function formatConsoleValue(value) {
   }
   return quoteConsoleValue(value);
 }
-function formatConsoleLine(level, body, attributes) {
+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);
@@ -276,27 +420,34 @@ function formatConsoleLine(level, body, attributes) {
   const parts = [
     `${colorize(timestamp, ANSI.gray)} ${colorize(formatConsoleLevel(level), levelColor)} ${body}`
   ];
-  const sortedAttributes = Object.entries(attributes).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;
+  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);
     }
-    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) {
+function emitConsole(level, eventName, body, attributes) {
   if (!shouldEmitConsole(level)) {
     return;
   }
-  const line = formatConsoleLine(level, body, attributes);
+  const line = formatConsoleLine(level, eventName, body, attributes);
   if (level === "error") {
     console.error(line);
     return;
@@ -316,14 +467,10 @@ function emit(level, eventName, attrs = {}, body) {
   const traceAttributes = getTraceCorrelationAttributes();
   const normalizedEventName = toSnakeCase(eventName);
   const message = body ? redactSecrets(body) : normalizedEventName;
-  const attributes = mergeAttributes(
-    contextAttributes,
-    traceAttributes,
-    {
-      "event.name": normalizedEventName,
-      ...attrs
-    }
-  );
+  const attributes = mergeAttributes(contextAttributes, traceAttributes, {
+    "event.name": normalizedEventName,
+    ...attrs
+  });
   for (const sink of logRecordSinks) {
     try {
       sink({
@@ -353,20 +500,27 @@ var log = {
   },
   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);
+    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))) {
+        for (const [key, value] of Object.entries(
+          mergeAttributes(contextStorage.getStore(), attrs)
+        )) {
           scope.setExtra(key, value);
         }
         eventId = sentryCaptureException(normalizedError);
@@ -380,11 +534,17 @@ var log = {
   }
 };
 function withLogContext(context, callback) {
-  const next = mergeAttributes(contextStorage.getStore(), contextToAttributes(context));
+  const next = mergeAttributes(
+    contextStorage.getStore(),
+    contextToAttributes(context)
+  );
   return contextStorage.run(next, callback);
 }
 function setLogContext(context) {
-  const merged = mergeAttributes(contextStorage.getStore(), contextToAttributes(context));
+  const merged = mergeAttributes(
+    contextStorage.getStore(),
+    contextToAttributes(context)
+  );
   contextStorage.enterWith(merged);
 }
 function createLogContextFromRequest(request, context = {}) {
@@ -401,7 +561,9 @@ function createLogContextFromRequest(request, context = {}) {
 function toSpanAttributes(context) {
   const attrs = contextToAttributes(context);
   return Object.fromEntries(
-    Object.entries(attrs).filter(([, value]) => typeof value === "string" && value.length > 0)
+    Object.entries(attrs).filter(
+      ([, value]) => typeof value === "string" && value.length > 0
+    )
   );
 }
 function setSentryTagsFromContext(context) {
@@ -412,11 +574,12 @@ function setSentryTagsFromContext(context) {
     }
   }
   if (context.slackUserId) {
-    Sentry.setUser({ id: context.slackUserId, username: context.slackUserName });
+    Sentry.setUser({
+      id: context.slackUserId,
+      username: context.slackUserName
+    });
   }
 }
-
-// src/chat/observability.ts
 function toSpanAttributeValue(value) {
   if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
     return value;
@@ -424,38 +587,28 @@ function toSpanAttributeValue(value) {
   if (!Array.isArray(value)) {
     return void 0;
   }
-  const sanitized = value.filter((entry) => typeof entry === "string");
+  const sanitized = value.filter(
+    (entry) => typeof entry === "string"
+  );
   return sanitized.length > 0 ? sanitized : void 0;
 }
-function toContextAndAttributes(context, attributes) {
-  return {
-    ...toSpanAttributes(context),
-    ...attributes
-  };
-}
-function logWithLevel(level, eventName, attributes = {}, body) {
-  if (level === "info") {
-    log.info(eventName, attributes, body);
-    return;
-  }
-  if (level === "warn") {
-    log.warn(eventName, attributes, body);
-    return;
-  }
-  log.error(eventName, attributes, body);
-}
 function logInfo(eventName, context = {}, attributes = {}, body) {
-  logWithLevel("info", eventName, toContextAndAttributes(context, attributes), body);
+  log.info(eventName, { ...toSpanAttributes(context), ...attributes }, body);
 }
 function logWarn(eventName, context = {}, attributes = {}, body) {
-  logWithLevel("warn", eventName, toContextAndAttributes(context, attributes), body);
+  log.warn(eventName, { ...toSpanAttributes(context), ...attributes }, body);
 }
 function logError(eventName, context = {}, attributes = {}, body) {
-  logWithLevel("error", eventName, toContextAndAttributes(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, toContextAndAttributes(context, attributes), body);
+  return log.exception(
+    eventName,
+    normalizedError,
+    { ...toSpanAttributes(context), ...attributes },
+    body
+  );
 }
 function setTags(context = {}) {
   setLogContext(context);
@@ -477,7 +630,7 @@ async function withSpan(name, op, context, callback, attributes = {}) {
   }
   return withLogContext(
     context,
-    () => Sentry2.startSpan(
+    () => Sentry.startSpan(
       {
         name,
         op,
@@ -491,7 +644,7 @@ async function withSpan(name, op, context, callback, attributes = {}) {
   );
 }
 function setSpanAttributes(attributes) {
-  const sentry = Sentry2;
+  const sentry = Sentry;
   const span = sentry.getActiveSpan?.();
   if (!span) {
     return;
@@ -508,7 +661,7 @@ function setSpanAttributes(attributes) {
   }
 }
 function setSpanStatus(status) {
-  const sentry = Sentry2;
+  const sentry = Sentry;
   const span = sentry.getActiveSpan?.();
   if (!span) {
     return;
@@ -523,7 +676,7 @@ function toOptionalString(value) {
   return typeof value === "string" && value.trim() ? value : void 0;
 }
 function getActiveTraceId() {
-  const sentry = Sentry2;
+  const sentry = Sentry;
   if (typeof sentry.getActiveSpan !== "function" || typeof sentry.spanToJSON !== "function") {
     return void 0;
   }
@@ -550,6 +703,148 @@ function resolveErrorReference(eventId) {
     ...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 } : {}
+  };
+}
 
 export {
   logInfo,
@@ -563,5 +858,7 @@ export {
   setSpanAttributes,
   setSpanStatus,
   toOptionalString,
-  resolveErrorReference
+  resolveErrorReference,
+  serializeGenAiAttribute,
+  extractGenAiUsageAttributes
 };

package/dist/cli/check.js

@@ -1,9 +1,11 @@
 import {
   parseSkillFile
-} from "../chunk-KT5HARSN.js";
+} from "../chunk-VM3CPAZF.js";
 import {
   parsePluginManifest
-} from "../chunk-VW26MOSO.js";
+} from "../chunk-ZBWWHP6Q.js";
+import "../chunk-KCLEEKYX.js";
+import "../chunk-ZW4OVKF5.js";
 
 // src/cli/check.ts
 import fs from "fs/promises";

package/dist/cli/snapshot-warmup.js

@@ -1,13 +1,14 @@
 import {
   disconnectStateAdapter,
+  resolveRuntimeDependencySnapshot
+} from "../chunk-IJVZEV3K.js";
+import {
   getPluginProviders,
   getPluginRuntimeDependencies,
-  getPluginRuntimePostinstall,
-  resolveRuntimeDependencySnapshot
-} from "../chunk-RKOO42TW.js";
-import "../chunk-Z5E25LRN.js";
-import "../chunk-PY4AI2GZ.js";
-import "../chunk-VW26MOSO.js";
+  getPluginRuntimePostinstall
+} from "../chunk-ZBWWHP6Q.js";
+import "../chunk-KCLEEKYX.js";
+import "../chunk-ZW4OVKF5.js";
 
 // src/cli/snapshot-warmup.ts
 var DEFAULT_RUNTIME = "node22";

package/dist/handlers/queue-callback.js

@@ -1,12 +1,12 @@
 import {
   POST
-} from "../chunk-56WI5Q7P.js";
-import "../chunk-JRKU55W5.js";
-import "../chunk-KT5HARSN.js";
-import "../chunk-RKOO42TW.js";
-import "../chunk-Z5E25LRN.js";
-import "../chunk-PY4AI2GZ.js";
-import "../chunk-VW26MOSO.js";
+} from "../chunk-4G2LA7RO.js";
+import "../chunk-DIMXJUSL.js";
+import "../chunk-VM3CPAZF.js";
+import "../chunk-IJVZEV3K.js";
+import "../chunk-ZBWWHP6Q.js";
+import "../chunk-KCLEEKYX.js";
+import "../chunk-ZW4OVKF5.js";
 export {
   POST
 };

package/dist/handlers/router.d.ts

@@ -6,6 +6,7 @@ type RouteContext = {
  *
  * Supported routes:
  * - `api/health`
+ * - `api/oauth/callback/mcp/:provider`
  * - `api/oauth/callback/:provider`
  */
 declare function GET(request: Request, context: RouteContext): Promise<Response>;