@langwatch/mcp-server 1.0.0 → 2.1.0

package/dist/report-issue-RHZZ33IS.js

@@ -0,0 +1,885 @@
+import {
+  getConfig
+} from "./chunk-WT4PO4A3.js";
+import "./chunk-SAS5OB7F.js";
+
+// ../../packages/redaction/src/markers.ts
+var SECRET_MARKER = "[SECRET]";
+function formatPiiMarker(entity) {
+  return `[${entity}]`;
+}
+
+// ../../packages/redaction/src/secrets.ts
+var SECRETS_REDACTION_MARKER = SECRET_MARKER;
+var REPLACEMENT = SECRETS_REDACTION_MARKER;
+var MAX_SCAN_LENGTH = 25e4;
+var ENTROPY_SAMPLE_LENGTH = 256;
+function shannonEntropyBits(value) {
+  const sample = value.length > ENTROPY_SAMPLE_LENGTH ? value.slice(0, ENTROPY_SAMPLE_LENGTH) : value;
+  const counts = /* @__PURE__ */ new Map();
+  for (const char of sample) {
+    counts.set(char, (counts.get(char) ?? 0) + 1);
+  }
+  let entropy = 0;
+  for (const count of counts.values()) {
+    const probability = count / sample.length;
+    entropy -= probability * Math.log2(probability);
+  }
+  return entropy;
+}
+function countCharClasses(value) {
+  let lower = 0;
+  let upper = 0;
+  let digit = 0;
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code >= 97 && code <= 122) lower++;
+    else if (code >= 65 && code <= 90) upper++;
+    else if (code >= 48 && code <= 57) digit++;
+  }
+  return { lower, upper, digit };
+}
+var TOKEN_START = String.raw`(?<![A-Za-z0-9_-])`;
+var TOKEN_END = String.raw`(?![A-Za-z0-9_-])`;
+var VENDOR_KEY_PATTERNS = [
+  // LangWatch's own API, ingest and legacy personal-access tokens, minted as
+  // `{prefix}{lookupId}_{secret}` by
+  // platform/app/src/server/api-key/api-key-token.utils.ts. Matched on the
+  // prefix plus three body characters, like every other known vendor, so a
+  // truncated or short-bodied one still redacts: `sk-lw-` would otherwise reach
+  // only the generic `sk-` rule and its 20-character floor, and `ik-lw-`
+  // nothing at all. The three-character floor is what keeps the bare prefix,
+  // which documentation and error messages print on its own, from reading as a
+  // key.
+  // The prefixes are duplicated rather than imported because this package is
+  // shared with the SDK and stays dependency-free; a test pins them to the
+  // constants so the two cannot drift.
+  String.raw`(?:sk|ik|pat|vk)-lw-[A-Za-z0-9_-]{3,}`,
+  // GitLab personal, project, deploy, runner and agent tokens.
+  String.raw`gl(?:pat|rt|dt|soat|ptt|cbt|imt|agent|ffct)-[A-Za-z0-9_-]{20,}`,
+  String.raw`npm_[A-Za-z0-9]{36}`,
+  // Google OAuth client secret.
+  String.raw`GOCSPX-[A-Za-z0-9_-]{20,}`,
+  String.raw`mb_[A-Za-z0-9+/=]{40,}`,
+  String.raw`dckr_pat_[A-Za-z0-9_-]{20,}`,
+  // Shopify admin, storefront, custom and private app tokens.
+  String.raw`shp(?:at|ss|ca|pa)_[0-9a-fA-F]{32}`,
+  String.raw`SG\.[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,}`,
+  String.raw`hf_[A-Za-z0-9]{30,}`,
+  String.raw`gsk_[A-Za-z0-9]{40,}`,
+  String.raw`pplx-[A-Za-z0-9]{30,}`,
+  String.raw`nvapi-[A-Za-z0-9_-]{40,}`,
+  String.raw`r8_[A-Za-z0-9]{30,}`,
+  String.raw`xai-[A-Za-z0-9]{40,}`,
+  // Notion integration tokens, current and legacy.
+  String.raw`ntn_[A-Za-z0-9]{30,}`,
+  String.raw`secret_[A-Za-z0-9]{40,}`,
+  String.raw`dop_v1_[0-9a-f]{64}`,
+  String.raw`figd_[A-Za-z0-9_-]{30,}`,
+  String.raw`ATATT[A-Za-z0-9_=-]{100,}`,
+  String.raw`sq0(?:atp|csp)-[A-Za-z0-9_-]{20,}`,
+  String.raw`EAAG[A-Za-z0-9]{60,}`,
+  String.raw`key-[0-9a-f]{32}`,
+  String.raw`re_[A-Za-z0-9_-]{20,}`,
+  String.raw`phx_[A-Za-z0-9]{30,}`,
+  String.raw`lin_api_[A-Za-z0-9]{30,}`,
+  String.raw`sl\.[A-Za-z0-9_-]{60,}`,
+  String.raw`ya29\.[A-Za-z0-9_-]{20,}`,
+  String.raw`sbp_[0-9a-f]{40,}`,
+  String.raw`sntry(?:s|u)_[A-Za-z0-9_.-]{30,}`,
+  String.raw`fw_[A-Za-z0-9]{20,}`,
+  String.raw`gl(?:c|sa)_[A-Za-z0-9]{30,}`,
+  String.raw`NRAK-[A-Za-z0-9]{20,}`,
+  String.raw`PMAK-[A-Za-z0-9]{20,}-[A-Za-z0-9]{20,}`,
+  String.raw`dp\.(?:pt|st|ct|sa)\.[A-Za-z0-9_-]{20,}`,
+  // Airtable personal access token: patXXXXXXXXXXXXXX.<64 hex>.
+  String.raw`pat[A-Za-z0-9]{14}\.[0-9a-f]{64}`,
+  // Telegram bot token: <numeric bot id>:AA<35-char body>.
+  String.raw`[0-9]{8,10}:AA[A-Za-z0-9_-]{33}`
+];
+var VENDOR_KEY_REGEX = new RegExp(
+  `${TOKEN_START}(?:${VENDOR_KEY_PATTERNS.join("|")})${TOKEN_END}`,
+  "g"
+);
+var SHAPED_TOKEN_MIN_BODY = 26;
+var SHAPED_TOKEN_MAX_BODY = 120;
+var SHAPED_TOKEN_MIN_ENTROPY = 3.9;
+function isKeyShapedBody(body) {
+  if (body.length < SHAPED_TOKEN_MIN_BODY || body.length > SHAPED_TOKEN_MAX_BODY) {
+    return false;
+  }
+  const { lower, upper, digit } = countCharClasses(body);
+  if (lower < 2 || upper < 2 || digit < 2) return false;
+  return shannonEntropyBits(body) >= SHAPED_TOKEN_MIN_ENTROPY;
+}
+var DIGEST_PREFIXES = /* @__PURE__ */ new Set([
+  "sha1",
+  "sha224",
+  "sha256",
+  "sha384",
+  "sha512",
+  "sha3",
+  "md4",
+  "md5",
+  "blake2b",
+  "blake2s",
+  "blake3",
+  "crc32",
+  "xxh3",
+  "xxh64",
+  "base32",
+  "base58",
+  "base64",
+  "hex",
+  "uuid",
+  "urn",
+  "cid",
+  "etag",
+  "hash",
+  "digest",
+  "checksum",
+  "integrity"
+]);
+var HEX_BODY_CREDENTIAL_SEGMENTS = [
+  "live",
+  "test",
+  "prod",
+  "sk",
+  "pk",
+  "key",
+  "secret",
+  "token"
+];
+var IDENTIFIER_PREFIXES = /* @__PURE__ */ new Set([
+  "commit",
+  "sha",
+  "sha1",
+  "sha256",
+  "md5",
+  "hash",
+  "digest",
+  "trace",
+  "span",
+  "id",
+  "uuid",
+  "rev",
+  "blob",
+  "tree",
+  "etag",
+  "checksum"
+]);
+var RECORD_ID_PREFIXES = /* @__PURE__ */ new Set([
+  "project",
+  "provider",
+  "card",
+  "eval",
+  "monitor",
+  "scenario",
+  "ses",
+  "sess",
+  "session",
+  "thread",
+  "conv",
+  "langyconv",
+  "span",
+  "trace",
+  "run",
+  "msg",
+  "task",
+  "job",
+  "step",
+  "node",
+  "team",
+  "org",
+  "user",
+  "call",
+  "req",
+  "resp",
+  "chatcmpl",
+  "toolu",
+  "asst",
+  "file",
+  "batch",
+  "evt",
+  "acct",
+  "cus",
+  "sub"
+]);
+var PUBLIC_KEY_PREFIXES = /* @__PURE__ */ new Set(["phc"]);
+function isNonCredentialPrefix(prefix) {
+  const lower = prefix.toLowerCase();
+  return DIGEST_PREFIXES.has(lower) || IDENTIFIER_PREFIXES.has(lower) || RECORD_ID_PREFIXES.has(lower) || PUBLIC_KEY_PREFIXES.has(lower);
+}
+var HEX_BODY_MIN = 24;
+var HEX_BODY_MAX = 128;
+var PLACEHOLDER_VALUE_REGEX = /^(?:x+|\*+|\.+|-+|_+|0+|(?:your|my|our|insert|replace|example|sample|dummy|fake|placeholder|changeme|redacted|removed|hidden|none|null|nil|undefined|todo|tbd|fixme)[a-z0-9_\- ]*)$/i;
+var ENV_REFERENCE_REGEX = /^(?:\$[A-Za-z_][A-Za-z0-9_]*|[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+)$/;
+var CODE_EXPRESSION_REGEX = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+$/;
+var PATH_LIKE_REGEX = /^[~.]{0,2}\/|\/[^/\s]*\.[a-z]{1,5}$/;
+var CONTEXT_VALUE_MIN_LENGTH = 16;
+var CONTEXT_VALUE_MIN_ENTROPY = 2.9;
+function isCredentialValue(value) {
+  if (value.length < CONTEXT_VALUE_MIN_LENGTH) return false;
+  if (PLACEHOLDER_VALUE_REGEX.test(value)) return false;
+  if (ENV_REFERENCE_REGEX.test(value)) return false;
+  if (CODE_EXPRESSION_REGEX.test(value)) return false;
+  if (PATH_LIKE_REGEX.test(value)) return false;
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value)) return false;
+  if (value.includes(SECRETS_REDACTION_MARKER)) return false;
+  return shannonEntropyBits(value) >= CONTEXT_VALUE_MIN_ENTROPY;
+}
+var VERSION_STRING_REGEX = /^v?\d+(?:[._-]\d+)+/;
+var LOOSE_VALUE_MIN_LENGTH = 20;
+var LOOSE_VALUE_MIN_ENTROPY = 3.4;
+function isKeyMaterial(value) {
+  if (value.length < LOOSE_VALUE_MIN_LENGTH) return false;
+  if (!isCredentialValue(value)) return false;
+  if (VERSION_STRING_REGEX.test(value)) return false;
+  if (shannonEntropyBits(value) < LOOSE_VALUE_MIN_ENTROPY) return false;
+  if (/^[0-9a-f]{32,}$/i.test(value)) return true;
+  if (/^[A-Z2-7]{32,}={0,6}$/.test(value)) return true;
+  const { lower, upper, digit } = countCharClasses(value);
+  return digit >= 2 && (lower >= 2 || upper >= 2);
+}
+var CREDENTIAL_QUALIFIERS = /* @__PURE__ */ new Set([
+  "master",
+  "encryption",
+  "signing",
+  "private",
+  "access",
+  "api",
+  "auth",
+  "secret",
+  "refresh",
+  "session",
+  "bearer",
+  "verification",
+  "webhook",
+  "client",
+  "service",
+  "personal",
+  "root",
+  "admin"
+]);
+var QUALIFIER_ALTERNATION = [...CREDENTIAL_QUALIFIERS].join("|");
+var CREDENTIAL_KEYWORD = String.raw`(?:x[_.\- ]?)?(?:` + String.raw`(?:${QUALIFIER_ALTERNATION})[_.\- ]?(?:api[_.\- ]?)?key` + String.raw`|(?:${QUALIFIER_ALTERNATION})?[_.\- ]?(?:api[_.\- ]?)?` + String.raw`(?:token|secret|password|passwd|pwd|credentials?|authorization|cookie)` + String.raw`)`;
+function isBasicAuthPayload(value) {
+  if (value.endsWith("=")) return true;
+  const { lower, upper, digit } = countCharClasses(value);
+  return digit > 0 || lower > 0 && upper > 0;
+}
+var VALUE_RULES = [
+  {
+    id: "pem_private_key",
+    description: "PEM private key block",
+    regex: /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP |ENCRYPTED )?PRIVATE KEY(?: BLOCK)?-----[\s\S]*?-----END (?:RSA |EC |DSA |OPENSSH |PGP |ENCRYPTED )?PRIVATE KEY(?: BLOCK)?-----/g
+  },
+  {
+    // PuTTY's own private-key format, which carries no PEM armour. The body
+    // runs to the end of the file, so it is clamped at the next blank line
+    // rather than allowed to swallow the rest of the payload.
+    id: "putty_private_key",
+    description: "PuTTY private key file",
+    regex: /PuTTY-User-Key-File-\d+:[\s\S]*?(?:\n\s*\n|$)/g
+  },
+  {
+    // A kubeconfig embeds the client certificate and its key as base64. The
+    // key is the credential; the certificate is redacted with it because
+    // together they are a working login.
+    id: "kubeconfig_client_credentials",
+    description: "Embedded kubeconfig client key or certificate",
+    regex: /\b(client-(?:key|certificate)-data:\s*)[A-Za-z0-9+/=]{40,}/g,
+    render: (_m, prefix) => `${prefix}${REPLACEMENT}`
+  },
+  {
+    id: "aws_access_key_id",
+    description: "AWS access key id",
+    regex: /\b(?:AKIA|ASIA|AGPA|AIDA|AROA|ANPA|ANVA)[0-9A-Z]{16}\b/g
+  },
+  {
+    id: "github_token",
+    description: "GitHub token",
+    regex: /\b(?:gh[posru]_[A-Za-z0-9]{36,}|github_pat_[A-Za-z0-9_]{60,})\b/g
+  },
+  {
+    // Provider secret keys share the `sk-` namespace: OpenAI (`sk-proj-...`,
+    // legacy `sk-...`), Anthropic (`sk-ant-...`), LangWatch (`sk-lw-...`), and
+    // others. The body is base64url, so it includes `_` and `-` and has no inner
+    // word boundary; matching the whole token and stopping at the next non-key
+    // char catches modern keys a `[A-Za-z0-9]+\b` rule misses.
+    id: "provider_api_key",
+    description: "Provider API key (sk-...)",
+    regex: /\bsk-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g
+  },
+  {
+    id: "stripe_secret_key",
+    description: "Stripe secret key",
+    regex: /\b[rs]k_(?:live|test)_[A-Za-z0-9]{16,}\b/g
+  },
+  {
+    id: "slack_token",
+    description: "Slack token",
+    regex: /\bxox[abposr]-[A-Za-z0-9-]{10,}\b/g
+  },
+  {
+    id: "google_api_key",
+    description: "Google API key",
+    regex: /\bAIza[0-9A-Za-z_-]{35}\b/g
+  },
+  {
+    id: "vendor_api_key",
+    description: "Developer-service API key (GitLab, npm, Docker Hub, Shopify, SendGrid, Hugging Face, Groq, Notion, Atlassian and others)",
+    regex: VENDOR_KEY_REGEX
+  },
+  {
+    id: "jwt",
+    description: "JSON Web Token",
+    regex: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g
+  },
+  {
+    id: "url_credentials",
+    description: "Password embedded in a connection URL",
+    // scheme://user:password@host -> keep everything but the password. The
+    // scheme length is bounded (real schemes are short) so a long run of
+    // name-like characters costs constant backtracking per position instead
+    // of a quadratic scan on huge inputs.
+    //
+    // The scheme sits in a lookbehind so that the first character the engine
+    // must find is the literal `:`. With the scheme inside the match the
+    // pattern starts with a character class, every lowercase letter in the
+    // text is a candidate start, and each one costs up to 30 characters of
+    // scheme scan before it fails: 6.2 ms on a 200 KB payload, more than every
+    // other rule together. Anchored on `:` the same payload costs 0.09 ms.
+    // The scheme stays outside the match and therefore untouched, which is
+    // what the rule already did with it.
+    regex: /(?<=[a-z][a-z0-9+.-]{0,30})(:\/\/[^\s:@/]+:)([^\s:@/]+)(@)/gi,
+    // The same scheme the lookbehind reads, so a reported match still spans the
+    // whole URL rather than starting at the colon.
+    precededBy: /[a-z][a-z0-9+.-]{0,30}$/i,
+    render: (_m, prefix, _password, at) => `${prefix}${REPLACEMENT}${at}`
+  },
+  {
+    id: "bearer_token",
+    description: "Bearer authorization token",
+    regex: /\b(Bearer\s+)[A-Za-z0-9._~+/-]{10,}=*/gi,
+    render: (_m, prefix) => `${prefix}${REPLACEMENT}`
+  },
+  {
+    // The other Authorization schemes. Unlike `Bearer` these are ordinary
+    // words (`Token`, `OAuth`, `Splunk`), so they are only a credential cue
+    // inside an actual Authorization header: a bare "token acme_live_abcd1234"
+    // in prose is a sentence, not a header, and matching it redacted one.
+    id: "authorization_scheme_token",
+    description: "Non-Bearer authorization scheme token",
+    regex: /\b(Authorization:\s*(?:Token|SSWS|GenieKey|Splunk|OAuth)\s+)[A-Za-z0-9._~+/-]{10,}=*/gi,
+    render: (_m, prefix) => `${prefix}${REPLACEMENT}`
+  },
+  {
+    id: "basic_auth_credentials",
+    description: "Basic authorization credentials",
+    regex: /\b(Basic\s+)([A-Za-z0-9+/]{16,}={0,2})(?![A-Za-z0-9+/=])/g,
+    accept: (groups) => isBasicAuthPayload(groups[2] ?? ""),
+    render: (_m, prefix) => `${prefix}${REPLACEMENT}`
+  },
+  {
+    // The all-hex sibling of the shape rule below, which cannot accept a hex
+    // body without also accepting every digest and trace id in the transcript.
+    // A credential segment in the middle of the token is what makes the
+    // difference, so this rule requires one and refuses identifier prefixes on
+    // top of it.
+    id: "prefixed_hex_api_key",
+    description: "API key with a vendor prefix and an all-hex body",
+    regex: new RegExp(
+      `${TOKEN_START}([A-Za-z][A-Za-z0-9]{1,11})_(?:${HEX_BODY_CREDENTIAL_SEGMENTS.join("|")})_([0-9a-f]{${HEX_BODY_MIN},${HEX_BODY_MAX}})${TOKEN_END}`,
+      "gi"
+    ),
+    accept: (groups) => !IDENTIFIER_PREFIXES.has((groups[1] ?? "").toLowerCase()),
+    precondition: (text) => text.includes("_")
+  },
+  {
+    // The layer that catches a vendor nobody has heard of. A short prefix, a
+    // separator and a high-entropy body is the shape almost every modern key is
+    // minted in, and it needs no vendor knowledge at all.
+    //
+    // The prefix may be upper, lower or mixed case: plenty of vendors mint
+    // `LW_…` or `Xy_…`, and restricting it to lowercase missed them. That also
+    // makes the prefix the shape of a screaming-snake environment variable
+    // NAME, which must survive as a bare name, and does: `AWS_SECRET_ACCESS_KEY`
+    // and `DATABASE_URL_PRODUCTION` are dictionary words with no digits and no
+    // lowercase, so the length floor and the character-mix gate turn them both
+    // away. The digest check lowercases the prefix so `SHA512-…` is still
+    // recognised as a digest.
+    //
+    // A declined match consumes the text it spanned, so in principle a benign
+    // outer match could hide a secret further inside the same unbroken token.
+    // It cannot in practice: a body containing key material inherits that
+    // material's entropy and character mix, so the outer match is accepted and
+    // the secret is redacted along with its prefix.
+    id: "shaped_api_key",
+    description: "High-entropy API key with a vendor-style prefix",
+    regex: new RegExp(
+      `${TOKEN_START}([A-Za-z][A-Za-z0-9]{1,11})[_-]([A-Za-z0-9_+/-]{${SHAPED_TOKEN_MIN_BODY},})${TOKEN_END}`,
+      "g"
+    ),
+    accept: (groups) => !isNonCredentialPrefix(groups[1] ?? "") && isKeyShapedBody(groups[2] ?? ""),
+    precondition: (text) => text.includes("_") || text.includes("-")
+  },
+  {
+    // The layer that needs no shape at all: the text says what the value is.
+    // Up to two filler words are tolerated between the keyword and the
+    // separator, because people write "key now:" and "token here =" as often as
+    // they write "key:".
+    id: "sensitive_assignment",
+    description: "Value assigned to a credential-named field",
+    // One capture for everything that introduces the value, one for the value
+    // itself, so the replacement puts the sentence back and swaps only the
+    // credential.
+    // `key is <value>` was accepted as a separator too, and across a 236 MB
+    // corpus of real traces it caught zero credentials while being the sole
+    // source of English-prose redactions: "a bare digest of an API key is
+    // offline-checkable" lost the words after "key is". A cue that only ever
+    // fires on prose is not a cue, so the strict separator is `:` or `=`.
+    //
+    // A whitespace separator is accepted on a HIGHER bar instead of not at
+    // all, because `Authorization <token>` and `key <token>` do carry real
+    // credentials. Ungated it matched 5,816 further spans over 309 shapes,
+    // mostly prose; gated on the value looking like key material in its own
+    // right it matches 338 over 19 at roughly 87% precision.
+    //
+    // The value class excludes backslash. Span content arrives JSON-encoded,
+    // so a literal two-character `\n` sits inside the text; letting a value run
+    // through one carried it across logical lines and past the `$VAR` and
+    // code-expression guards, which is why `api_key = $OPENAI_API_KEY` was kept
+    // with a real newline and redacted with an escaped one.
+    regex: new RegExp(
+      `((?:^|[\\W_])(?:${CREDENTIAL_KEYWORD})(?:\\s+[A-Za-z]{1,8}){0,2}["'\`]?(?:\\s*[:=]{1,2}\\s*|[ \\t?-]+)["'\`]?)([^\\s"'\`,;<>(){}\\[\\]\\\\]{${CONTEXT_VALUE_MIN_LENGTH},})`,
+      "gi"
+    ),
+    accept: (groups) => {
+      const introduction = groups[1] ?? "";
+      const value = groups[2] ?? "";
+      const strict = /[:=]\s*["'`]?$/.test(introduction);
+      return strict ? isCredentialValue(value) : isKeyMaterial(value);
+    },
+    render: (_m, introduction) => `${introduction}${REPLACEMENT}`
+  }
+];
+var BUILTIN_SECRET_RULES = VALUE_RULES.map(({ id, description }) => ({ id, description }));
+var SENSITIVE_KEY_REGEX = /(?:^|[._-])(?:password|passwd|pwd|secret|api[_-]?key|apikey|access[_-]?token|auth[_-]?token|authorization|auth|bearer|credentials?|private[_-]?key|client[_-]?secret|db[_-]?password|connection[_-]?string|session[_-]?token|refresh[_-]?token|set[_-]?cookie|cookie|x-api-key)(?:$|[._-])/i;
+var CREDENTIAL_NOUNS = /* @__PURE__ */ new Set([
+  "password",
+  "passwd",
+  "pwd",
+  "secret",
+  "authorization",
+  "auth",
+  "bearer",
+  "credential",
+  "credentials",
+  "cookie"
+]);
+function tokenizeAttributeName(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean).map((token) => token.toLowerCase());
+}
+function namesACredential(name) {
+  const tokens = tokenizeAttributeName(name);
+  return tokens.some((token, index) => {
+    if (CREDENTIAL_NOUNS.has(token)) return true;
+    if (token !== "key" && token !== "token") return false;
+    const previous = tokens[index - 1];
+    return previous !== void 0 && CREDENTIAL_QUALIFIERS.has(previous);
+  });
+}
+function isSensitiveAttributeKey(key) {
+  return SENSITIVE_KEY_REGEX.test(key) || namesACredential(key);
+}
+var VALUE_BOUNDARY = /["'`]/;
+function keptLengthAtBoundary(match) {
+  const index = match.search(VALUE_BOUNDARY);
+  return index === -1 ? match.length : index;
+}
+var CUSTOM_VALUE_BOUNDARY = /[\s"'`<>]/;
+function keptLengthForCustomPattern(match) {
+  const index = match.search(CUSTOM_VALUE_BOUNDARY);
+  return index === -1 ? match.length : index;
+}
+function replacementFor(rule, args) {
+  const full = args[0] ?? "";
+  if (rule.accept && !rule.accept(args)) return null;
+  if (rule.render) return rule.render(...args);
+  const kept = keptLengthAtBoundary(full);
+  if (kept === 0) return null;
+  return REPLACEMENT + full.slice(kept);
+}
+function sliceForScan(text) {
+  if (text.length <= MAX_SCAN_LENGTH) return [text];
+  const slices = [];
+  let start = 0;
+  while (start < text.length) {
+    const end = sliceEndAfter(text, start);
+    slices.push(text.slice(start, end));
+    start = end;
+  }
+  return slices;
+}
+function sliceEndAfter(text, start) {
+  const target = Math.min(start + MAX_SCAN_LENGTH, text.length);
+  if (target >= text.length) return text.length;
+  let end;
+  const lastSpace = text.slice(start, target).search(/\s(?=\S*$)/);
+  if (lastSpace > 0) {
+    end = start + lastSpace;
+  } else {
+    const lookahead = text.slice(target, target + SAFE_CUT_LOOKAHEAD);
+    const next = lookahead.search(/\s/);
+    end = next === -1 ? Math.min(target + SAFE_CUT_LOOKAHEAD, text.length) : target + next;
+  }
+  const begin = text.lastIndexOf(PEM_BEGIN, end);
+  const close = text.indexOf(PEM_END, begin);
+  if (begin >= start && close >= end) {
+    end = close + PEM_END.length;
+  }
+  return end;
+}
+var SAFE_CUT_LOOKAHEAD = 4096;
+var PEM_BEGIN = "-----BEGIN";
+var PEM_END = "-----END";
+function redactSecretsInText({
+  text,
+  customPatterns = [],
+  skipRuleIds
+}) {
+  if (typeof text !== "string" || text.length === 0) {
+    return { text, redactedCount: 0 };
+  }
+  const skipped = toSkipSet(skipRuleIds);
+  if (text.length > MAX_SCAN_LENGTH) {
+    let total = 0;
+    const pieces = sliceForScan(text).map((slice) => {
+      const scanned = redactOneSlice(slice, customPatterns, skipped);
+      total += scanned.redactedCount;
+      return scanned.text;
+    });
+    return { text: pieces.join(""), redactedCount: total };
+  }
+  return redactOneSlice(text, customPatterns, skipped);
+}
+function toSkipSet(skipRuleIds) {
+  if (!skipRuleIds || skipRuleIds.length === 0) return null;
+  return new Set(skipRuleIds);
+}
+function redactOneSlice(text, customPatterns, skipped) {
+  let redactedCount = 0;
+  let result = text;
+  for (const rule of VALUE_RULES) {
+    if (skipped?.has(rule.id)) continue;
+    if (rule.precondition && !rule.precondition(result)) continue;
+    result = result.replace(rule.regex, (...args) => {
+      const replacement = replacementFor(rule, args);
+      if (replacement === null) return args[0] ?? "";
+      redactedCount++;
+      return replacement;
+    });
+  }
+  for (const pattern of customPatterns) {
+    result = result.replace(pattern, (...args) => {
+      const full = args[0] ?? "";
+      const kept = keptLengthForCustomPattern(full);
+      if (kept === 0) return full;
+      redactedCount++;
+      return REPLACEMENT + full.slice(kept);
+    });
+  }
+  return { text: result, redactedCount };
+}
+
+// ../../packages/redaction/src/sessionReport.ts
+var EMAIL_MARKER = formatPiiMarker("EMAIL_ADDRESS");
+var PHONE_MARKER = formatPiiMarker("PHONE_NUMBER");
+var CARD_MARKER = formatPiiMarker("CREDIT_CARD");
+var IP_MARKER = formatPiiMarker("IP_ADDRESS");
+var ENV_SECRET_NAME_REGEX = /(?:^|[._-])(?:key|token|secret|password|passwd|pwd|credentials?|auth)(?:$|[._-])/i;
+var MIN_ENV_SECRET_LENGTH = 8;
+function collectSensitiveEnvValues(env) {
+  const values = /* @__PURE__ */ new Set();
+  for (const [name, value] of Object.entries(env)) {
+    if (!value) continue;
+    const trimmed = value.trim();
+    if (trimmed.length < MIN_ENV_SECRET_LENGTH) continue;
+    if (!ENV_SECRET_NAME_REGEX.test(name)) continue;
+    values.add(trimmed);
+  }
+  return [...values].sort((a, b) => b.length - a.length);
+}
+var EMAIL_REGEX = /[A-Za-z0-9._%+-]{1,64}@[A-Za-z0-9.-]{1,253}\.[A-Za-z]{2,24}/g;
+var INTL_PHONE_REGEX = /(?<![\w.+-])\+[1-9]\d{0,2}(?:[\s.-]?(?:\(\d{1,4}\)[\s.-]?)?\d{1,4}){1,5}(?!\d)/g;
+var NATIONAL_PHONE_REGEX = /(?<!\d)(?:\(\d{3}\)[\s.-]?|\d{3}[.-])\d{3}[.-]\d{4}(?!\d)/g;
+var CARD_REGEX = /(?<![\d.-])\d(?:[ -]?\d){12,18}(?![\d.-])/g;
+var IPV4_REGEX = /\b(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\b/g;
+var countDigits = (value) => value.replace(/\D/g, "").length;
+function passesLuhn(digits) {
+  let sum = 0;
+  let double = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let d = digits.charCodeAt(i) - 48;
+    if (double) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+    double = !double;
+  }
+  return sum % 10 === 0;
+}
+function isCardNumber(candidate) {
+  const digits = candidate.replace(/[ -]/g, "");
+  if (!/^\d+$/.test(digits)) return false;
+  const separated = /[ -]/.test(candidate);
+  if (!separated && (digits.length < 14 || digits.length > 16)) return false;
+  if (digits.length < 13 || digits.length > 19) return false;
+  return passesLuhn(digits);
+}
+function isPrivateOrLocalIp(ip) {
+  const parts = ip.split(".").map(Number);
+  const [a = 0, b = 0] = parts;
+  if (a === 0 || a === 10 || a === 127) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a >= 224) return true;
+  return false;
+}
+var SLICE_TARGET = 2e5;
+function sliceLongText(text) {
+  if (text.length <= SLICE_TARGET) return [text];
+  const slices = [];
+  let start = 0;
+  while (start < text.length) {
+    let end = Math.min(start + SLICE_TARGET, text.length);
+    if (end < text.length) {
+      const newline = text.lastIndexOf("\n", end);
+      if (newline > start + SLICE_TARGET / 2) end = newline;
+    }
+    slices.push(text.slice(start, end));
+    start = end;
+  }
+  return slices;
+}
+function redactPiiPatterns(text) {
+  let redactedCount = 0;
+  let result = text.replace(EMAIL_REGEX, () => {
+    redactedCount++;
+    return EMAIL_MARKER;
+  });
+  result = result.replace(CARD_REGEX, (match) => {
+    if (!isCardNumber(match)) return match;
+    redactedCount++;
+    return CARD_MARKER;
+  });
+  result = result.replace(INTL_PHONE_REGEX, (match) => {
+    const digits = countDigits(match);
+    if (digits < 7 || digits > 15) return match;
+    redactedCount++;
+    return PHONE_MARKER;
+  });
+  result = result.replace(NATIONAL_PHONE_REGEX, () => {
+    redactedCount++;
+    return PHONE_MARKER;
+  });
+  result = result.replace(IPV4_REGEX, (match) => {
+    if (isPrivateOrLocalIp(match)) return match;
+    redactedCount++;
+    return IP_MARKER;
+  });
+  return { text: result, redactedCount };
+}
+function scrubEnvLiterals(text, envValues) {
+  let result = text;
+  let redactedCount = 0;
+  for (const value of envValues) {
+    if (!result.includes(value)) continue;
+    const parts = result.split(value);
+    redactedCount += parts.length - 1;
+    result = parts.join(SECRET_MARKER);
+  }
+  return { text: result, redactedCount };
+}
+function redactReportText({
+  text,
+  envValues = []
+}) {
+  if (typeof text !== "string" || text.length === 0) {
+    return { text, redactedCount: 0 };
+  }
+  const envPass = scrubEnvLiterals(text, envValues);
+  let redactedCount = envPass.redactedCount;
+  const pieces = sliceLongText(envPass.text).map((slice) => {
+    const secrets = redactSecretsInText({ text: slice });
+    redactedCount += secrets.redactedCount;
+    const pii = redactPiiPatterns(secrets.text);
+    redactedCount += pii.redactedCount;
+    return pii.text;
+  });
+  return { text: pieces.join(""), redactedCount };
+}
+function redactJsonValue(value, envValues, count) {
+  if (typeof value === "string") {
+    const result = redactReportText({ text: value, envValues });
+    count.redacted += result.redactedCount;
+    return result.text;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => redactJsonValue(item, envValues, count));
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+      if (isSensitiveAttributeKey(key) && entry !== null && entry !== void 0) {
+        out[key] = SECRET_MARKER;
+        count.redacted++;
+        continue;
+      }
+      out[key] = redactJsonValue(entry, envValues, count);
+    }
+    return out;
+  }
+  return value;
+}
+function redactSessionJsonl({
+  jsonl,
+  envValues = []
+}) {
+  let redactedCount = 0;
+  const lines = jsonl.split("\n").map((line) => {
+    if (line.trim().length === 0) return line;
+    try {
+      const parsed = JSON.parse(line);
+      const count = { redacted: 0 };
+      const redacted = redactJsonValue(parsed, envValues, count);
+      redactedCount += count.redacted;
+      return JSON.stringify(redacted);
+    } catch {
+      const result = redactReportText({ text: line, envValues });
+      redactedCount += result.redactedCount;
+      return result.text;
+    }
+  });
+  return { text: lines.join("\n"), redactedCount };
+}
+function truncateJsonlToByteBudget({
+  jsonl,
+  maxBytes
+}) {
+  const encoder = new TextEncoder();
+  if (encoder.encode(jsonl).length <= maxBytes) {
+    return { text: jsonl, truncated: false };
+  }
+  const lines = jsonl.split("\n");
+  const kept = [];
+  let used = 0;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i] ?? "";
+    const size = encoder.encode(line).length + 1;
+    if (used + size > maxBytes) break;
+    kept.unshift(line);
+    used += size;
+  }
+  return { text: kept.join("\n"), truncated: true };
+}
+var REDACTION_AUDIT_URL = "https://github.com/langwatch/langwatch/blob/main/packages/redaction/src/sessionReport.ts";
+
+// src/tools/report-issue.ts
+var MAX_SESSION_BYTES = 8 * 1024 * 1024;
+var REQUEST_TIMEOUT_MS = 6e4;
+function redactReport(params) {
+  const envValues = collectSensitiveEnvValues(process.env);
+  let redactedCount = 0;
+  const titleResult = redactReportText({ text: params.title, envValues });
+  redactedCount += titleResult.redactedCount;
+  let summary;
+  if (params.summary) {
+    const result = redactReportText({ text: params.summary, envValues });
+    summary = result.text;
+    redactedCount += result.redactedCount;
+  }
+  let sessionData;
+  let sessionTruncated = false;
+  if (params.session_content) {
+    const redacted = redactSessionJsonl({
+      jsonl: params.session_content,
+      envValues
+    });
+    redactedCount += redacted.redactedCount;
+    const truncated = truncateJsonlToByteBudget({
+      jsonl: redacted.text,
+      maxBytes: MAX_SESSION_BYTES
+    });
+    sessionData = truncated.text;
+    sessionTruncated = truncated.truncated;
+  }
+  return {
+    title: titleResult.text,
+    summary,
+    sessionData,
+    sessionTruncated,
+    redactedCount
+  };
+}
+async function deliverReport(report, params) {
+  const config = getConfig();
+  const endpoint = config.endpoint.replace(/\/+$/, "");
+  const response = await fetch(`${endpoint}/api/bug-reports`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...config.apiKey ? { authorization: `Bearer ${config.apiKey}` } : {}
+    },
+    body: JSON.stringify({
+      source: "mcp",
+      kind: report.sessionData ? "full_session" : "summary",
+      title: report.title,
+      ...report.summary ? { summary: report.summary } : {},
+      ...report.sessionData ? { sessionData: report.sessionData, sessionTruncated: report.sessionTruncated } : {},
+      ...params.agent ? { agent: params.agent } : {},
+      ...params.contact_email ? { contactEmail: params.contact_email } : {}
+    }),
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  }).catch(() => {
+    throw new Error(
+      `Could not reach ${endpoint} to deliver the report. Retry in a moment; if it keeps failing, email support@langwatch.ai with the same content.`
+    );
+  });
+  if (!response.ok) {
+    const body = (await response.text().catch(() => "")).slice(0, 300);
+    throw new Error(
+      `The reports endpoint answered HTTP ${response.status}: ${body}. Retry in a moment; if it keeps failing, email support@langwatch.ai.`
+    );
+  }
+  const { id } = await response.json();
+  return id;
+}
+async function handleReportIssue(params) {
+  if (!params.user_approved) {
+    throw new Error(
+      `This sends a report to the LangWatch team, so the user must approve it first. Ask the user: "Can I send this issue report to LangWatch to help them fix it?" If they agree, call again with user_approved=true. Secrets and personal data are redacted locally before sending; audit the rules at ${REDACTION_AUDIT_URL}`
+    );
+  }
+  if (!params.summary?.trim() && !params.session_content?.trim()) {
+    throw new Error(
+      "Nothing to report: pass a summary (what you tried, verbatim errors, what you had to figure out), session_content, or both."
+    );
+  }
+  const report = redactReport(params);
+  const id = await deliverReport(report, params);
+  return [
+    `Report sent to the LangWatch team (${id}). Thank you!`,
+    `Redacted ${report.redactedCount} sensitive value${report.redactedCount === 1 ? "" : "s"} locally before sending.`,
+    ...report.sessionTruncated ? ["The session content was truncated to the most recent activity to fit the upload limit."] : [],
+    "Reports like this directly shape what gets fixed next."
+  ].join(" ");
+}
+export {
+  handleReportIssue
+};
+//# sourceMappingURL=report-issue-RHZZ33IS.js.map