@posthog/mcp 0.21.4 → 0.22.1

package/README.md

@@ -134,6 +134,22 @@ What matters is instance lifetime, not statelessness. A server that is stateless
 (`sessionIdGenerator: undefined`) but keeps one long-lived server object learns ownership from the
 first `tools/list` and keeps it, so none of the above applies to it.
 
+An extra key is not free for a tool that validates strictly (a `.strict()` Zod object, or
+`additionalProperties: false` enforced by the handler): it rejects the call. A low-level server that
+can look up its own tools can resolve ownership without a listing. Return the tool's input schema
+as registered, before PostHog preparation, and the SDK strips the arguments it owns on every
+instance. It never strips a parameter that the returned schema declares. Returning `undefined`
+keeps the behavior above.
+
+```ts
+instrument(server, posthog, {
+  resolveOriginalTool: (toolName) => {
+    const tool = myToolRegistry.get(toolName)
+    return tool ? { inputSchema: tool.inputSchema } : undefined
+  },
+})
+```
+
 The consequence worth knowing: if **your own** tool declares a parameter named `context` and the SDK
 cannot tell that it is yours, its value is recorded as `$mcp_intent`. It never leaves your project,
 and it is capped at 2048 characters. Two ways out, both one line:
@@ -221,7 +237,12 @@ open where the SDK cannot tell who declared it, stripping it requires proof that
   that descriptor itself, so what it declares is known without a listing.
 - Instrumenting a low-level `Server` learns ownership while serving `tools/list`. A fresh instance
   that never served one — `createMcpHandler`, or `@rekog/mcp-nest` in its stateless mode — has no
-  answer, so it records `llm_model` as the self-reported model and strips nothing. A tool that
+  answer, so it records `llm_model` as the self-reported model and strips nothing, unless
+  `resolveOriginalTool` supplies the tool's schema (see `$mcp_intent` above). Return the schema as
+  your `tools/list` advertises it: ownership follows the same rule as a served listing, and a
+  listing served on the instance wins. A Zod schema is read the way the MCP SDK advertises it, so a
+  union, record or refined object lists as an empty object, gains the injected fields and has them
+  stripped; a host that lists its own JSON Schema (an `anyOf`, say) returns that schema. A tool that
   declares its own `llm_model` on such an instance is therefore recorded under `$mcp_llm_model`
   until a listing says otherwise; `captureModel: false` or dropping the property in `beforeSend`
   are the escapes. The SDK never replays your listing handler on the call path to find out.

package/dist/extensions/instrument-lowlevel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrument-lowlevel.d.ts","sourceRoot":"","sources":["../../src/extensions/instrument-lowlevel.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAiD,aAAa,EAAE,MAAM,UAAU,CAAA;AAa5F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAoBxC;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,GAAG,IAAI,CA8BtF"}
+{"version":3,"file":"instrument-lowlevel.d.ts","sourceRoot":"","sources":["../../src/extensions/instrument-lowlevel.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAmE,aAAa,EAAE,MAAM,UAAU,CAAA;AAa9G,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAoBxC;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,GAAG,IAAI,CA8BtF"}

package/dist/extensions/instrument-lowlevel.js

@@ -99,14 +99,26 @@ async function handleToolCallRequest(server, originalCallToolHandler, request, e
             execute: async ()=>(0, external_feedback_js_namespaceObject.handleFeedback)(report, feedbackOptions, data.logger)
         });
     }
+    const originalTool = resolveOriginalTool(data, toolName);
     return await (0, external_instrumentation_js_namespaceObject.captureToolCall)({
         server,
         data,
         request,
         extra,
-        execute: (downstreamRequest)=>runOriginalToolHandler(originalCallToolHandler, downstreamRequest, extra)
+        execute: (downstreamRequest)=>runOriginalToolHandler(originalCallToolHandler, downstreamRequest, extra),
+        parameterOwnership: originalTool && !(toolName && data.toolAnalyticsParameterOwnership.has(toolName)) ? (0, external_analytics_parameters_js_namespaceObject.getAnalyticsParameterOwnership)(originalTool.inputSchema) : void 0,
+        inputSchema: originalTool?.inputSchema
     });
 }
+function resolveOriginalTool(data, toolName) {
+    if (!toolName || !data.options.resolveOriginalTool) return;
+    try {
+        return data.options.resolveOriginalTool(toolName) ?? void 0;
+    } catch (error) {
+        data.logger(`Warning: resolveOriginalTool failed for tool ${toolName} - ${error}`);
+        return;
+    }
+}
 function runOriginalToolHandler(handler, request, extra) {
     if (!handler) throw new Error(`Unknown tool: ${request.params?.name || 'unknown'}`);
     return handler(request, extra);

package/dist/extensions/instrument-lowlevel.mjs

@@ -67,14 +67,26 @@ async function handleToolCallRequest(server, originalCallToolHandler, request, e
             execute: async ()=>handleFeedback(report, feedbackOptions, data.logger)
         });
     }
+    const originalTool = resolveOriginalTool(data, toolName);
     return await captureToolCall({
         server,
         data,
         request,
         extra,
-        execute: (downstreamRequest)=>runOriginalToolHandler(originalCallToolHandler, downstreamRequest, extra)
+        execute: (downstreamRequest)=>runOriginalToolHandler(originalCallToolHandler, downstreamRequest, extra),
+        parameterOwnership: originalTool && !(toolName && data.toolAnalyticsParameterOwnership.has(toolName)) ? getAnalyticsParameterOwnership(originalTool.inputSchema) : void 0,
+        inputSchema: originalTool?.inputSchema
     });
 }
+function resolveOriginalTool(data, toolName) {
+    if (!toolName || !data.options.resolveOriginalTool) return;
+    try {
+        return data.options.resolveOriginalTool(toolName) ?? void 0;
+    } catch (error) {
+        data.logger(`Warning: resolveOriginalTool failed for tool ${toolName} - ${error}`);
+        return;
+    }
+}
 function runOriginalToolHandler(handler, request, extra) {
     if (!handler) throw new Error(`Unknown tool: ${request.params?.name || 'unknown'}`);
     return handler(request, extra);

package/dist/extensions/mcp-payloads.d.ts

@@ -1,34 +1,8 @@
+import { redactPii } from '@posthog/core';
 type JsonRecord = Record<string, unknown>;
-/**
- * Sanitizes agent-narrated free text (`$mcp_intent`, the `send_feedback`
- * fields): structured PII on top of the passes every captured string gets.
- *
- * Every step of the order is load-bearing. The binary gate reads the value as it
- * arrived, because splicing `[redacted]` into a blob — a Luhn-valid run inside
- * base64 is enough — stops it looking like base64 and would ship it whole.
- * Credentials go before PII, because a PII pattern can cut a token in half (a
- * phone-shaped run inside one) and leave the halves behind. PII goes before the
- * URL pass, because the URL rewrite percent-encodes the `@` that the email
- * pattern anchors on.
- */
+export { redactPii };
 export declare function sanitizeFreeText(value: string): string;
-/**
- * Redacts structured personal identifiers (emails, IP addresses, credit-card
- * numbers, US SSNs, and phone numbers) from a free-text string. Intended for the
- * agent-narrated `$mcp_intent` value only — not for structured tool parameters or
- * responses, where the same shapes are often legitimate data. Horizontal Unicode
- * spaces are first normalized to an ASCII space so copy-pasted identifiers still
- * match. Returns a new string; leaves the input's identifiers untouched when
- * nothing matches.
- */
-export declare function redactPii(value: string): string;
 export declare function sanitizeCapturedValue(value: unknown): unknown;
-/**
- * {@link sanitizeCapturedValue} with the intent-grade string pass
- * ({@link sanitizeFreeText}) on every string leaf, so nested agent-narrated
- * values get structured-PII redaction in the load-bearing order too.
- */
 export declare function sanitizeFreeTextValue(value: unknown): unknown;
 export declare function buildCapturedMcpParameters(request: unknown): JsonRecord;
-export {};
 //# sourceMappingURL=mcp-payloads.d.ts.map

package/dist/extensions/mcp-payloads.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-payloads.d.ts","sourceRoot":"","sources":["../../src/extensions/mcp-payloads.ts"],"names":[],"mappings":"AA4HA,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AA2azC;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKtD;AA6DD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAU/C;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE7D;AAyDD,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,CAiBvE"}
+{"version":3,"file":"mcp-payloads.d.ts","sourceRoot":"","sources":["../../src/extensions/mcp-payloads.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,SAAS,EAKV,MAAM,eAAe,CAAA;AAStB,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAMzC,OAAO,EAAE,SAAS,EAAE,CAAA;AAEpB,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE7D;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE7D;AA6BD,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,CAiBvE"}

package/dist/extensions/mcp-payloads.js

@@ -29,334 +29,29 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     buildCapturedMcpParameters: ()=>buildCapturedMcpParameters,
-    redactPii: ()=>redactPii,
+    redactPii: ()=>core_namespaceObject.redactPii,
     sanitizeCapturedValue: ()=>sanitizeCapturedValue,
     sanitizeFreeText: ()=>sanitizeFreeText,
     sanitizeFreeTextValue: ()=>sanitizeFreeTextValue
 });
+const core_namespaceObject = require("@posthog/core");
 const external_truncation_js_namespaceObject = require("./truncation.js");
 const CONTEXT_ARGUMENT_NAME = 'context';
-const REDACTED_VALUE = '[redacted]';
-const BINARY_REDACTED_VALUE = '[binary data redacted - not supported by PostHog MCP analytics]';
-const BASE64_PATTERN = /^[A-Za-z0-9+/\n\r]+=*$/;
-const BASE64URL_PATTERN = /^[A-Za-z0-9_-]+={0,2}$/;
-const BASE64URL_SPECIFIC_CHAR_PATTERN = /[-_]/;
-const BASE64_DATA_URL_PREFIX_PATTERN = /^data:[^,\s]*;base64,/i;
-const BASE64_DATA_URL_PAYLOAD_PATTERN = /^[A-Za-z0-9+/_-]+={0,2}$/;
-const SIZE_GATE = 10240;
-const SCANNED_HEAD_LENGTH = 4 * external_truncation_js_namespaceObject.MAX_STRING_LENGTH;
-const MIN_REDACTED_HEAD_LENGTH = 2 * external_truncation_js_namespaceObject.MAX_STRING_LENGTH;
-const POSTHOG_TOKEN_PATTERN = /\bph[a-z]_[A-Za-z0-9_-]{20,}\b/g;
-const SENSITIVE_KEY_PATTERN = /^(authorization|cookie|set-cookie|x-api-key|api[-_]?key|api[-_]?token|access[-_]?token|refresh[-_]?token|token|password|secret|client[-_]?secret|private[-_]?key)$/i;
-const URL_PATTERN = /[a-z][a-z0-9+.-]{0,63}:[^\s<>"]+/gi;
-const URL_END_PATTERN = /[\s<>"]/;
-const URL_PATTERN_ONCE = new RegExp(URL_PATTERN.source, 'i');
-const URL_AUTHORITY_SEARCH = /[a-z][a-z0-9+.-]{0,63}:\/\//i;
-const URL_AUTHORITY_PATTERN = new RegExp(`^${URL_AUTHORITY_SEARCH.source}`, 'i');
-const URL_AUTHORITY_SEARCH_ALL = new RegExp(URL_AUTHORITY_SEARCH.source, 'gi');
-const URL_FIELD_CHARACTERS = '=&';
-const LEGACY_FIELD_SEPARATOR = ';';
-const URL_TRAILING_PUNCTUATION = ".,;:!?)]}'";
-const MAX_URL_LENGTH = 8192;
-const MAX_URL_QUERY_FIELDS = 128;
-const SENSITIVE_QUERY_KEY_SEGMENT_PATTERN = /(^|[-_./;])(auth|token|secret|password|passwd|pwd|credential|signature|sig|key|hmac|sas|bearer|jwt|session|sessionid)([-_./;]|$)/i;
-const SENSITIVE_QUERY_KEY_EXACT_PATTERN = /^(code|AWSAccessKeyId|GoogleAccessId|Policy)$/i;
-const UNICODE_SPACE_PATTERN = /[\u00A0\u1680\u2000-\u200A\u202F\u205F\u3000]/g;
-const EMAIL_PATTERN = /[A-Za-z0-9._%+-]{1,64}@[A-Za-z0-9.-]{1,255}\.[A-Za-z]{2,24}/g;
-const IPV4_PATTERN = /\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;
-const IPV6_PATTERN = /\b(?:[0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4}\b|(?<![\w:])(?:[0-9A-Fa-f]{1,4}:){1,7}:(?![\w:])|(?<![\w:])(?:[0-9A-Fa-f]{1,4}:){1,6}:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4}){0,5}(?![\w])|(?<![\w:])::(?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4}){0,6})(?![\w])/g;
-const US_SSN_PATTERN = /\b\d{3}[ .-]\d{2}[ .-]\d{4}\b/g;
-const CREDIT_CARD_CANDIDATE_PATTERN = /\b\d(?:[ ./-]?\d){12,}\b/g;
-const DIGIT_GROUP_PATTERN = /\d+/g;
-const PHONE_NANP_PATTERN = /(?<![\w+])(?:\+?1[ ./-]?)?(?:\(\d{3}\)[ ./-]?|\d{3}[ ./-])\d{3}[ ./-]\d{4}(?![\w])/g;
-const PHONE_INTL_PATTERN = /(?<!\w)\+\d{1,3}(?:[ ./()-]{0,2}\d){7,13}(?![\w])/g;
+const SANITIZATION_OPTIONS = {
+    maxStringLength: external_truncation_js_namespaceObject.MAX_STRING_LENGTH,
+    truncationSuffix: external_truncation_js_namespaceObject.TRUNCATION_SUFFIX
+};
 function isRecord(value) {
     return !!value && 'object' == typeof value && !Array.isArray(value);
 }
-function shouldRedactKey(key) {
-    return SENSITIVE_KEY_PATTERN.test(key);
-}
-function shouldRedactQueryKey(key) {
-    return shouldRedactKey(key) || SENSITIVE_QUERY_KEY_SEGMENT_PATTERN.test(key) || SENSITIVE_QUERY_KEY_EXACT_PATTERN.test(key);
-}
-function isBase64DataUrl(value) {
-    const prefix = BASE64_DATA_URL_PREFIX_PATTERN.exec(value);
-    if (!prefix) return false;
-    let payload;
-    try {
-        payload = decodeURIComponent(value.slice(prefix[0].length));
-    } catch  {
-        return false;
-    }
-    return BASE64_DATA_URL_PAYLOAD_PATTERN.test(payload.replace(/[\r\n]/g, ''));
-}
-function exceedsUrlFieldLimit(fields) {
-    return fields.split('&', MAX_URL_QUERY_FIELDS + 1).length > MAX_URL_QUERY_FIELDS;
-}
-function hasLegacySensitiveField(value) {
-    return value.split(LEGACY_FIELD_SEPARATOR).some((piece)=>shouldRedactQueryKey(piece.split('=', 1)[0]));
-}
-function sanitizeUrlFieldValue(key, value, allowNestedUrls) {
-    if (shouldRedactQueryKey(key)) return REDACTED_VALUE;
-    if (value.includes(LEGACY_FIELD_SEPARATOR) && hasLegacySensitiveField(value)) return REDACTED_VALUE;
-    if (!URL_PATTERN_ONCE.test(value)) return value;
-    return allowNestedUrls ? sanitizeUrlsInString(value, {
-        allowNestedUrls: false,
-        stripPunctuation: true
-    }) : REDACTED_VALUE;
-}
-function sanitizeUrlFields(fields, allowNestedUrls) {
-    const sanitized = new URLSearchParams();
-    let changed = false;
-    let lastFieldSensitive = false;
-    for (const [key, value] of new URLSearchParams(fields)){
-        const sanitizedValue = sanitizeUrlFieldValue(key, value, allowNestedUrls);
-        changed ||= sanitizedValue !== value;
-        lastFieldSensitive = shouldRedactQueryKey(key) || sanitizedValue !== value;
-        sanitized.append(key, sanitizedValue);
-    }
-    return {
-        changed,
-        lastFieldSensitive,
-        serialized: sanitized.toString()
-    };
-}
-function splitTrailingPunctuation(value) {
-    let end = value.length;
-    while(end > 0 && URL_TRAILING_PUNCTUATION.includes(value[end - 1]))end--;
-    return {
-        address: value.slice(0, end),
-        suffix: value.slice(end)
-    };
-}
-function sanitizeFragmentTail(tail, headLastFieldSensitive, allowNestedUrls) {
-    if (!headLastFieldSensitive) return sanitizeFragmentPart(tail, allowNestedUrls);
-    return {
-        value: '' === tail ? '' : REDACTED_VALUE,
-        lastFieldSensitive: true
-    };
-}
-function splitFragmentParts(hash) {
-    const fragment = hash.slice(1);
-    const separator = fragment.indexOf('?');
-    if (separator < 0) return {
-        head: fragment,
-        tail: null
-    };
-    return {
-        head: fragment.slice(0, separator),
-        tail: fragment.slice(separator + 1)
-    };
-}
-function sanitizeFragmentPart(part, allowNestedUrls) {
-    if (!part.includes('=')) return {
-        value: sanitizeFragmentText(part, allowNestedUrls),
-        lastFieldSensitive: false
-    };
-    const fields = sanitizeUrlFields(part, allowNestedUrls);
-    return {
-        value: fields.changed ? fields.serialized : part,
-        lastFieldSensitive: fields.lastFieldSensitive
-    };
-}
-function sanitizeFragmentText(text, allowNestedUrls) {
-    if (!allowNestedUrls) return URL_PATTERN_ONCE.test(text) ? REDACTED_VALUE : text;
-    return sanitizeUrlsInString(text, {
-        allowNestedUrls: false,
-        stripPunctuation: true
-    });
-}
-function findEmbeddedAuthorityIndexes(value) {
-    if (!value.includes('://')) return [];
-    const starts = [
-        ...value.matchAll(URL_AUTHORITY_SEARCH_ALL)
-    ].map((match)=>match.index);
-    const indexes = [];
-    const delimiters = {
-        query: false,
-        fragment: false,
-        fragmentQuery: false
-    };
-    let pending = 0;
-    let inFields = false;
-    let lastStructural = '';
-    for(let cursor = 0; cursor < value.length && pending < starts.length; cursor++){
-        if (starts[pending] === cursor) {
-            if (cursor > 0 && '=' !== lastStructural) indexes.push(cursor);
-            pending++;
-        }
-        const character = value[cursor];
-        if (isDelimiter(character, delimiters, lastStructural)) {
-            lastStructural = character;
-            inFields = true;
-        } else if (inFields && URL_FIELD_CHARACTERS.includes(character)) lastStructural = character;
-    }
-    return indexes;
-}
-function isDelimiter(character, seen, lastStructural) {
-    if ('#' === character) return seen.fragment ? false : seen.fragment = true;
-    if ('?' !== character) return false;
-    if (seen.fragment) {
-        if ('=' === lastStructural) return false;
-        return seen.fragmentQuery ? false : seen.fragmentQuery = true;
-    }
-    return seen.query ? false : seen.query = true;
-}
-function sanitizeUrl(value, mode) {
-    const embedded = findEmbeddedAuthorityIndexes(value);
-    if (0 === embedded.length) return sanitizeSingleUrl(value, mode);
-    let result = '';
-    let start = 0;
-    for (const index of embedded){
-        result += sanitizeSingleUrl(value.slice(start, index), {
-            ...mode,
-            stripPunctuation: false
-        });
-        start = index;
-    }
-    return result + sanitizeSingleUrl(value.slice(start), mode);
-}
-function sanitizeSingleUrl(value, mode) {
-    if (value.length > MAX_URL_LENGTH && URL_AUTHORITY_PATTERN.test(value)) return REDACTED_VALUE;
-    const { address, suffix } = mode.stripPunctuation ? splitTrailingPunctuation(value) : {
-        address: value,
-        suffix: ''
-    };
-    let url;
-    try {
-        url = new URL(address);
-    } catch  {
-        return REDACTED_VALUE + suffix;
-    }
-    const query = url.search.slice(1);
-    const hasFragment = '' !== url.hash;
-    const fragment = splitFragmentParts(url.hash);
-    if (exceedsUrlFieldLimit(query) || exceedsUrlFieldLimit(fragment.head) || exceedsUrlFieldLimit(fragment.tail ?? '')) return REDACTED_VALUE + suffix;
-    let changed = false;
-    if (url.username || url.password) {
-        url.username = REDACTED_VALUE;
-        url.password = '';
-        changed = true;
-    }
-    const sanitizedQuery = sanitizeUrlFields(query, mode.allowNestedUrls);
-    if (sanitizedQuery.changed) {
-        url.search = sanitizedQuery.serialized;
-        changed = true;
-    }
-    const sanitizedHead = sanitizeFragmentPart(fragment.head, mode.allowNestedUrls);
-    const sanitizedTail = null === fragment.tail ? null : sanitizeFragmentTail(fragment.tail, sanitizedHead.lastFieldSensitive, mode.allowNestedUrls);
-    const sanitizedHash = null === sanitizedTail ? sanitizedHead.value : `${sanitizedHead.value}?${sanitizedTail.value}`;
-    if (sanitizedHash !== url.hash.slice(1)) {
-        url.hash = sanitizedHash;
-        changed = true;
-    }
-    const trailingFields = hasFragment ? sanitizedTail ?? sanitizedHead : sanitizedQuery;
-    return (changed ? url.toString() : address) + (trailingFields.lastFieldSensitive ? '' : suffix);
-}
-function sanitizeUrlsInString(text, mode) {
-    return text.replace(URL_PATTERN, (match)=>sanitizeUrl(match, {
-            ...mode,
-            stripPunctuation: mode.stripPunctuation && match.length !== text.length
-        }));
-}
-function isBinaryBlob(value) {
-    return value.length >= SIZE_GATE && (BASE64_PATTERN.test(value) || isBase64DataUrl(value) || BASE64URL_SPECIFIC_CHAR_PATTERN.test(value) && BASE64URL_PATTERN.test(value));
-}
-function redactCredentials(value) {
-    return value.replace(POSTHOG_TOKEN_PATTERN, REDACTED_VALUE);
-}
-function redactUrls(value) {
-    return sanitizeUrlsInString(value, {
-        allowNestedUrls: true,
-        stripPunctuation: true
-    });
-}
-function redactCapturedHead(value, redact) {
-    if (value.length > SCANNED_HEAD_LENGTH) {
-        const head = redact(value.slice(0, headLength(value)));
-        if (head.length >= MIN_REDACTED_HEAD_LENGTH) return head + external_truncation_js_namespaceObject.TRUNCATION_SUFFIX;
-    }
-    return redact(value);
-}
-function headLength(value) {
-    let end = SCANNED_HEAD_LENGTH;
-    while(end > 0 && !URL_END_PATTERN.test(value[end - 1]))end--;
-    return end;
-}
-function sanitizeString(value) {
-    return isBinaryBlob(value) ? BINARY_REDACTED_VALUE : redactCapturedHead(value, (head)=>redactUrls(redactCredentials(head)));
-}
 function sanitizeFreeText(value) {
-    if (isBinaryBlob(value)) return BINARY_REDACTED_VALUE;
-    return redactCapturedHead(value, (head)=>redactUrls(redactPii(redactCredentials(head))));
-}
-function passesLuhn(digits) {
-    let sum = 0;
-    let double = false;
-    for(let index = digits.length - 1; index >= 0; index--){
-        let digit = digits.charCodeAt(index) - 48;
-        if (digit < 0 || digit > 9) return false;
-        if (double) {
-            digit *= 2;
-            if (digit > 9) digit -= 9;
-        }
-        sum += digit;
-        double = !double;
-    }
-    return sum % 10 === 0;
-}
-function redactCardInMatch(match) {
-    const groups = [];
-    for(let m = DIGIT_GROUP_PATTERN.exec(match); null !== m; m = DIGIT_GROUP_PATTERN.exec(match))groups.push({
-        digits: m[0],
-        start: m.index,
-        end: m.index + m[0].length
-    });
-    let output = '';
-    let cursor = 0;
-    let first = 0;
-    while(first < groups.length){
-        let digits = '';
-        let matchedLast = -1;
-        for(let last = first; last < groups.length; last++){
-            digits += groups[last].digits;
-            if (digits.length > 19) break;
-            if (digits.length >= 13 && passesLuhn(digits)) matchedLast = last;
-        }
-        if (matchedLast >= 0) {
-            output += match.slice(cursor, groups[first].start) + REDACTED_VALUE;
-            cursor = groups[matchedLast].end;
-            first = matchedLast + 1;
-        } else first++;
-    }
-    return output + match.slice(cursor);
-}
-function redactPii(value) {
-    let result = value.replace(UNICODE_SPACE_PATTERN, ' ');
-    result = result.replace(EMAIL_PATTERN, REDACTED_VALUE);
-    result = result.replace(IPV4_PATTERN, REDACTED_VALUE);
-    result = result.replace(IPV6_PATTERN, REDACTED_VALUE);
-    result = result.replace(CREDIT_CARD_CANDIDATE_PATTERN, redactCardInMatch);
-    result = result.replace(US_SSN_PATTERN, REDACTED_VALUE);
-    result = result.replace(PHONE_NANP_PATTERN, REDACTED_VALUE);
-    result = result.replace(PHONE_INTL_PATTERN, REDACTED_VALUE);
-    return result;
+    return (0, core_namespaceObject.sanitizeFreeText)(value, SANITIZATION_OPTIONS);
 }
 function sanitizeCapturedValue(value) {
-    return sanitizeValueWith(value, sanitizeString);
+    return (0, core_namespaceObject.sanitizeCapturedValue)(value, SANITIZATION_OPTIONS);
 }
 function sanitizeFreeTextValue(value) {
-    return sanitizeValueWith(value, sanitizeFreeText);
-}
-function sanitizeValueWith(value, sanitizeStringFn) {
-    if (null == value) return value;
-    if ('string' == typeof value) return sanitizeStringFn(value);
-    if (Array.isArray(value)) return value.map((item)=>sanitizeValueWith(item, sanitizeStringFn));
-    if (value instanceof Date) return value;
-    if ('object' != typeof value) return value;
-    const result = {};
-    for (const [key, nestedValue] of Object.entries(value))result[key] = shouldRedactKey(key) ? REDACTED_VALUE : sanitizeValueWith(nestedValue, sanitizeStringFn);
-    return result;
+    return (0, core_namespaceObject.sanitizeFreeTextValue)(value, SANITIZATION_OPTIONS);
 }
 function buildCapturedMcpArguments(argumentsValue) {
     if (!isRecord(argumentsValue)) return sanitizeCapturedValue(argumentsValue);