@cyanheads/mcp-ts-core 0.13.11 → 0.13.13

package/dist/utils/internal/logger.d.ts

@@ -41,11 +41,19 @@ interface FileSinkProbe {
  */
 export declare function probeFileSinks(dir: string): Promise<FileSinkProbe>;
 /**
- * Pino `formatters.log` hook. Strips values that break pino-redact's wildcard
- * traversal on Node 25+ — notably `AbortSignal` (via `ctx.signal`) and the
- * method-bearing handles on the framework `Context` (`log`, `state`, `content`,
- * `enrich`, `inputs`, `requestInput`, `notifyResource*`). Acts as a safety net
- * for every log call regardless of how callers shaped their bindings.
+ * Pino `formatters.log` hook, and the bindings of every exported OTel record:
+ * the log-data walk ({@link toLogValue}) over the whole record. pino
+ * therefore never receives an `Error` or a class instance — the method-bearing
+ * handles on the framework `Context` and `ctx.signal` included — whatever
+ * shape a caller gave its bindings. The walk is the only redaction: it is the
+ * one path caller data takes into a written line, since neither pino logger
+ * sets a `mixin`, binds a child, or carries anything in `base` but constants.
+ * Exempt from it are the root correlation fields ({@link CORRELATION_KEYS})
+ * that the record's context supplied, and a root key named after a field pino
+ * writes on the line itself ({@link LINE_FIELDS}) is written as `data_<name>` —
+ * prefixed again while that name is taken. `err` is such a field on a line
+ * carrying an error argument, which {@link Logger} moves the same way before
+ * attaching the error.
  *
  * @internal Exported only for unit testing. Not part of the public API.
  */
@@ -95,8 +103,25 @@ export declare function setOtelLogSink(sink: OtelLogSink | undefined): void;
  *   with one `warning` naming it; the process and the remaining sinks carry on.
  * - Optional OTel log export: once `initializeOpenTelemetry` attaches a Logs API
  *   sink, every record that passes the level filter and rate limit is also emitted
- *   there, redacted like the pino output.
- * - Sensitive field redaction via Pino's `redact` option.
+ *   there, with the same fields as the pino output — except the error argument,
+ *   which is exported as the `exception.*` attributes instead of an `err` field.
+ * - One walk over every record's data ({@link sanitizeLogBindings}), and the only
+ *   redaction: each `Error`, under any key, written as `type`/`message`/`stack`
+ *   (plus a string or `McpError` `code`, an `McpError`'s `data`, and `cause`/`errors`
+ *   in the same shape, a stack shared with the parent error written once); objects
+ *   kept through 15 levels below the record root and one 16 levels down written as
+ *   `'[MaxDepth]'`; at most 400,000 reads — one per object and per other field or
+ *   array element, ten per object at the depth bound — so data a getter, a Proxy, or a
+ *   `toJSON()` builds on every read stops at `'[Truncated]'`; at most 16 MiB
+ *   (16,777,216) characters of strings, field names, and primitives written, repeated
+ *   or not, then `'[Truncated]'` and the walk stops, so a 10 MB string is written whole
+ *   and a 20 MB one is not; repeated content — an object reached again through a shared
+ *   reference, or a string or field name of 1,024 characters or more written again —
+ *   also charged about the characters it writes against 1,000,000, and written as
+ *   `'[Truncated]'` where that runs out; cycles written as `'[Circular]'`; a value
+ *   whose read throws written as `'[Unreadable]'`; and every key the shared matcher
+ *   (`isSensitiveKey`) matches redacted at every depth kept, except the correlation
+ *   fields the record's context supplied, at its root.
  * - Rate limiting per level + message to suppress log storms, configurable via
  *   `MCP_LOG_RATE_LIMIT_THRESHOLD` (0 disables) and `MCP_LOG_RATE_LIMIT_WINDOW_MS`.
  *   Suppressed counts are flushed at `warning` once a window has elapsed, on
@@ -282,6 +307,9 @@ export declare class Logger {
      * For startup paths that end the process before {@link initialize} runs: the
      * records describe what the failing boot was doing, so they are worth more on
      * stderr than discarded. Never writes to stdout, which stdio transport owns.
+     * An error's message is read through the walk, so one whose read throws is
+     * written as `'[Unreadable]'`, one the walk writes no message for is left
+     * off, and neither replaces the error that ended the boot.
      *
      * @example
      * ```ts
@@ -350,8 +378,9 @@ export declare class Logger {
      * Logs an error-level message at `error` severity (RFC 5424 level 3).
      *
      * Use when an operation fails but the server can continue. The `errorOrContext`
-     * parameter accepts either an `Error` (serialized via `pino.stdSerializers.err`) or a
-     * `RequestContext` when no error object is available. Maps to pino `error` level.
+     * parameter accepts either an `Error` (written under `err` as its `type`, `message`,
+     * `stack`, and the other fields every logged Error carries — see {@link sanitizeLogBindings})
+     * or a `RequestContext` when no error object is available. Maps to pino `error` level.
      *
      * @param msg - Human-readable description of the failure.
      * @param errorOrContext - The `Error` to serialize, or a `RequestContext` if no error object exists.

package/dist/utils/internal/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/utils/internal/logger.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,KAAK,cAAc,EAGpB,MAAM,oCAAoC,CAAC;AAI5C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,GACnB,OAAO,GACP,MAAM,GACN,QAAQ,GACR,SAAS,GACT,OAAO,GACP,MAAM,GACN,OAAO,GACP,OAAO,CAAC;AA0DZ,6CAA6C;AAC7C,QAAA,MAAM,eAAe,YAAI,cAAc,EAAE,WAAW,EAAE,kBAAkB,CAAU,CAAC;AAEnF,KAAK,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAErD,yFAAyF;AACzF,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,0FAA0F;AAC1F,UAAU,aAAa;IACrB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;CACjD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAyBxE;AAiGD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzF;AAED;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,WAAW,CAAC;CAC3B;AAED,qEAAqE;AACrE,KAAK,kBAAkB,GACnB,MAAM,GACN,MAAM,GACN,OAAO,GACP,UAAU,GACV,IAAI,GACJ,SAAS,GACT,kBAAkB,EAAE,GACpB;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,CAAA;CAAE,CAAC;AAE1C,8EAA8E;AAC9E,UAAU,WAAW;IACnB,IAAI,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAAC;CACnC;AA+DD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,CAElE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAwB;IACxD,OAAO,CAAC,UAAU,CAAC,CAAa;IAChC,OAAO,CAAC,iBAAiB,CAAC,CAAyB;IACnD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,aAAa,CAA+B;IAEpD,OAAO,CAAC,kBAAkB,CAAgC;IAC1D,OAAO,CAAC,eAAe,CAA+B;IACtD,OAAO,CAAC,aAAa,CAA2D;IAChF,OAAO,CAAC,kBAAkB,CAA6B;IACvD,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,qBAAqB,CAAK;IAClC,OAAO,CAAC,eAAe,CAAS;IAChC,yGAAyG;IACzG,OAAO,CAAC,sBAAsB,CAAS;IAEvC,OAAO,eAEN;IAED;;;;;;;;;;;OAWG;IACH,OAAc,WAAW,IAAI,MAAM,CAElC;YAEa,gBAAgB;IAwE9B,OAAO,CAAC,uBAAuB;IAkB/B;;;;;;;;;;;;;;;;OAgBG;IACU,UAAU,CACrB,KAAK,GAAE,WAAoB,EAC3B,aAAa,CAAC,EAAE,OAAO,GAAG,MAAM,GAC/B,OAAO,CAAC,IAAI,CAAC,CA+Bf;IAED,kFAAkF;IAClF,OAAO,CAAC,sBAAsB;IAY9B;;;;;;;;;;;;OAYG;IACI,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,IAAI,CAgB3C;IAED;;;;;;;OAOG;IACG,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3C;IAED;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;IAO1B;;;;;;;;;;;;;;;;;OAiBG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAmClC;IAED;;;;;;;;;;;;;OAaG;IACI,aAAa,IAAI,OAAO,CAE9B;IAED;;;;;;;;;;;;;;;OAeG;IACI,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAGjD;IAED;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,UAAU;IAyBlB,OAAO,CAAC,aAAa;IAgCrB,OAAO,CAAC,uBAAuB;IA4B/B;;;;;;;;OAQG;IACH,OAAO,CAAC,iBAAiB;IAoBzB,kFAAkF;IAClF,OAAO,CAAC,oBAAoB;IAqB5B;;;;;;;;;;;OAWG;IACI,oBAAoB,IAAI,IAAI,CAiBlC;IAED,OAAO,CAAC,GAAG;IA4BX,OAAO,CAAC,YAAY;IAWpB;;;;;;;;;;;;OAYG;IACI,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI,CAExD;IAED;;;;;;;;;;;OAWG;IACI,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI,CAEvD;IAED;;;;;;;;;;;;OAYG;IACI,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI,CAEzD;IAED;;;;;;;;;;;;OAYG;IACI,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI,CAE1D;IAED;;;;;;;;;;;;;;;OAeG;IACI,KAAK,CACV,GAAG,EAAE,MAAM,EACX,cAAc,EAAE,KAAK,GAAG,cAAc,EACtC,OAAO,CAAC,EAAE,cAAc,GACvB,IAAI,CAEN;IAED;;;;;;;;;;;;;OAaG;IACI,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,cAAc,EAAE,KAAK,GAAG,cAAc,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI,CAE/F;IAED;;;;;;;;;;;;;OAaG;IACI,KAAK,CACV,GAAG,EAAE,MAAM,EACX,cAAc,EAAE,KAAK,GAAG,cAAc,EACtC,OAAO,CAAC,EAAE,cAAc,GACvB,IAAI,CAEN;IAED;;;;;;;;;;;;;OAaG;IACI,KAAK,CACV,GAAG,EAAE,MAAM,EACX,cAAc,EAAE,KAAK,GAAG,cAAc,EACtC,OAAO,CAAC,EAAE,cAAc,GACvB,IAAI,CAEN;IAED;;;;;;;;;;;;OAYG;IACI,KAAK,CACV,GAAG,EAAE,MAAM,EACX,cAAc,EAAE,KAAK,GAAG,cAAc,EACtC,OAAO,CAAC,EAAE,cAAc,GACvB,IAAI,CAEN;IAED;;;;;;;;;;;;;;OAcG;IACI,cAAc,CAAC,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAOlF;CACF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM,QAAuB,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/utils/internal/logger.ts"],"names":[],"mappings":"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"}

package/dist/utils/internal/logger.js

@@ -1,8 +1,8 @@
 import pino from 'pino';
 import { config } from '../../config/index.js';
+import { toLogValue } from './logValue.js';
 import { requestContextService, toCanonicalContext, } from './requestContext.js';
 import { UNTHROTTLED_MESSAGES } from './telemetryMessages.js';
-import { DEFAULT_SENSITIVE_FIELDS, toPinoRedactPaths } from '../security/sensitiveFields.js';
 const mcpToPinoLevel = {
     emerg: 'fatal',
     alert: 'fatal',
@@ -100,13 +100,13 @@ export async function probeFileSinks(dir) {
 function isServerless() {
     return typeof process === 'undefined' || process.env.IS_SERVERLESS === 'true';
 }
-/** Pino redact paths for sensitive fields (top-level, one-deep, two-deep). */
-const SENSITIVE_PINO_FIELDS = toPinoRedactPaths(DEFAULT_SENSITIVE_FIELDS);
 /**
- * Depth cap for {@link sanitizeLogBindings}. Matches the deepest path pino-redact
- * currently traverses (`*.*.field`) plus headroom for nested ad-hoc context.
+ * pino serializers for the process and `interactions.log` loggers. The
+ * log-data walk has already written every `Error` as plain data, so `err`
+ * passes through: pino's default would retype that object as `Object` and
+ * copy any other field it carries.
  */
-const MAX_SANITIZE_DEPTH = 4;
+const PINO_SERIALIZERS = { err: (value) => value };
 /**
  * Hard ceiling on distinct rate-limit keys retained between sweeps.
  *
@@ -133,104 +133,192 @@ const FLUSH_DRAIN_TIMEOUT_MS = 2_000;
  */
 const PRE_INIT_BUFFER_LIMIT = 250;
 /**
- * Recursively sanitizes a value for pino consumption. Returns a JSON-safe
- * replacement, or `undefined` when the value is unsafe and should be dropped.
- *
- * Preserves primitives, plain objects (recursively), and arrays. Converts
- * `Date` → ISO string, `URL` → string. Keeps `Error` instances (pino's err
- * serializer handles them). Drops functions and non-plain class instances
- * such as `AbortSignal`, `Map`, `Set`, `Promise`, storage handles, and any
- * other object whose prototype exposes getters that enforce receiver checks
- * — on Node 25, `for..in` traversal inside `@pinojs/redact` triggers those
- * getters with a non-branded receiver and throws.
+ * The fields a record carries from its request context to correlate it. At the
+ * record's root, each one the context supplied is never redacted, so a name
+ * added through `setSensitiveFields` (`session_id`, `id`) cannot cut every
+ * record off from its request. A caller's key of the same name — in `extra`
+ * when the context lacks that field, anywhere in caller data, and every key of
+ * an `interactions.log` record, which has no context — is matched like any other.
  */
-function sanitizeValue(value, depth) {
-    if (value === null)
-        return null;
-    const t = typeof value;
-    if (t === 'undefined' || t === 'function')
-        return;
-    if (t !== 'object')
-        return value;
-    if (depth >= MAX_SANITIZE_DEPTH)
-        return;
-    if (value instanceof Error)
-        return value;
-    if (value instanceof Date)
-        return value.toISOString();
-    if (value instanceof URL)
-        return value.toString();
-    if (Array.isArray(value)) {
-        return value.map((v) => sanitizeValue(v, depth + 1));
-    }
-    const proto = Object.getPrototypeOf(value);
-    if (proto !== Object.prototype && proto !== null) {
-        return;
-    }
-    const out = {};
-    for (const key of Object.keys(value)) {
-        const sanitized = sanitizeValue(value[key], depth + 1);
-        if (sanitized !== undefined)
-            out[key] = sanitized;
-    }
-    return out;
+const CORRELATION_KEYS = new Set([
+    'operation',
+    'requestId',
+    'sessionId',
+    'spanId',
+    'tenantId',
+    'timestamp',
+    'traceId',
+]);
+/** The `base` the process logger writes on every line: constants only. */
+function processLogBase() {
+    return {
+        env: config.environment,
+        version: config.mcpServerVersion,
+        pid: !isServerless() ? process.pid : undefined,
+    };
 }
 /**
- * Pino `formatters.log` hook. Strips values that break pino-redact's wildcard
- * traversal on Node 25+ — notably `AbortSignal` (via `ctx.signal`) and the
- * method-bearing handles on the framework `Context` (`log`, `state`, `content`,
- * `enrich`, `inputs`, `requestInput`, `notifyResource*`). Acts as a safety net
- * for every log call regardless of how callers shaped their bindings.
+ * The fields the logger's pino instances write on a line themselves: `level`
+ * and `time` before the record and `msg` after it, the process logger's
+ * `base` ({@link processLogBase}), and pino's default `base` — `pid` and
+ * `hostname` — on `interactions.log`. A record key with one of these names
+ * would be a second copy in the line: a transport routes a line by the last
+ * `level` it parses, so a caller's `level: 'high'` would drop the record from
+ * stderr and `combined.log`, and a parser keeps the last `version`, so a
+ * caller's would replace the server's.
+ */
+const LINE_FIELDS = new Set([
+    'level',
+    'time',
+    'msg',
+    ...Object.keys(processLogBase()),
+    'pid',
+    'hostname',
+]);
+/**
+ * The context a record's bindings were projected from, under a key only this
+ * module holds. It rides the spread into pino's record and the OTLP bindings,
+ * where {@link sanitizeLogBindings} reads which correlation fields the context
+ * supplied; the walk never writes a symbol-keyed field.
+ */
+const RECORD_CONTEXT = Symbol('recordContext');
+/** Moves `record[key]` to `data_<key>`, prefixed again while that name is taken. */
+function moveLineField(record, key) {
+    let name = `data_${key}`;
+    while (Object.hasOwn(record, name))
+        name = `data_${name}`;
+    record[name] = record[key];
+    delete record[key];
+}
+/**
+ * Pino `formatters.log` hook, and the bindings of every exported OTel record:
+ * the log-data walk ({@link toLogValue}) over the whole record. pino
+ * therefore never receives an `Error` or a class instance — the method-bearing
+ * handles on the framework `Context` and `ctx.signal` included — whatever
+ * shape a caller gave its bindings. The walk is the only redaction: it is the
+ * one path caller data takes into a written line, since neither pino logger
+ * sets a `mixin`, binds a child, or carries anything in `base` but constants.
+ * Exempt from it are the root correlation fields ({@link CORRELATION_KEYS})
+ * that the record's context supplied, and a root key named after a field pino
+ * writes on the line itself ({@link LINE_FIELDS}) is written as `data_<name>` —
+ * prefixed again while that name is taken. `err` is such a field on a line
+ * carrying an error argument, which {@link Logger} moves the same way before
+ * attaching the error.
  *
  * @internal Exported only for unit testing. Not part of the public API.
  */
 export function sanitizeLogBindings(obj) {
-    return sanitizeValue(obj, 0);
+    const supplied = obj[RECORD_CONTEXT];
+    const written = toLogValue(obj, {
+        exemptRootKey: supplied && ((key) => CORRELATION_KEYS.has(key) && Object.hasOwn(supplied, key)),
+    });
+    // The walk's copy is a fresh object, so renaming in place touches no caller data.
+    for (const key of LINE_FIELDS) {
+        if (Object.hasOwn(written, key))
+            moveLineField(written, key);
+    }
+    return written;
+}
+/**
+ * The walk's copy of `fields` a spread could not read (a getter, a revoked
+ * Proxy): `'[Unreadable]'` where a read failed, and under `key` when nothing
+ * could be read. A log call never throws on data it cannot read.
+ */
+function walkedFields(fields, key) {
+    const walked = toLogValue(fields);
+    return walked !== null && typeof walked === 'object' && !Array.isArray(walked)
+        ? walked
+        : { [key]: walked };
+}
+/**
+ * The bindings a record writes for `context`. `extra` is flattened rather than
+ * nested so the line keeps the shape callers had when `RequestContext` was an
+ * open bag. The projection runs first: `logger.info(msg, ctx)` with a handler
+ * context is a documented call, and that object carries live request machinery
+ * and the user-entered content in `inputs.responses` — none of which belongs in
+ * a log line. The canonical fields are spread again after `extra`, so a caller's
+ * key reusing a canonical name (`requestId`, `traceId`, …) never replaces the
+ * context's value — the first spread only keeps them leading the line. The
+ * canonical fields also ride along under {@link RECORD_CONTEXT}, so the walk
+ * exempts only the correlation fields the context supplied. A context the
+ * projection cannot read is projected from the walk's copy, and one with
+ * nothing readable is written as `context: '[Unreadable]'`.
+ */
+function toBindings(context) {
+    let projected;
+    try {
+        projected = toCanonicalContext((context ?? {}));
+    }
+    catch {
+        const walked = toLogValue(context);
+        if (walked === null || typeof walked !== 'object')
+            return { context: walked };
+        projected = toCanonicalContext(walked);
+    }
+    const { extra, ...canonical } = projected;
+    try {
+        return { ...canonical, ...extra, ...canonical, [RECORD_CONTEXT]: canonical };
+    }
+    catch {
+        return {
+            ...canonical,
+            ...walkedFields(extra, 'extra'),
+            ...canonical,
+            [RECORD_CONTEXT]: canonical,
+        };
+    }
 }
-const SENSITIVE_FIELD_NAMES = new Set(DEFAULT_SENSITIVE_FIELDS);
 /**
- * Converts one sanitized binding into an attribute value: an `Error` becomes
- * the `type`/`message`/`stack` object pino's serializer would have written, and
- * a primitive JSON has no form for becomes its string.
+ * The walk's copy of a log call's error argument, as fields: `{}` when the walk
+ * writes nothing for it, as for a function given `Error.prototype`, which passes
+ * `instanceof Error` and is dropped like any other function.
+ */
+function errorFields(error) {
+    const walked = toLogValue(error);
+    return walked !== null && typeof walked === 'object' ? walked : {};
+}
+/** Whether `value` is an `Error`; a value `instanceof` cannot inspect (a revoked Proxy) is not. */
+function isError(value) {
+    try {
+        return value instanceof Error;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Converts one walked binding into an attribute value. The walk has already
+ * written every `Error` as plain data and redacted every sensitive field, so
+ * all that is left is a primitive JSON has no form for, which becomes its string.
  */
 function toExportValue(value) {
-    if (value instanceof Error)
-        return { message: value.message, stack: value.stack, type: value.name };
     if (Array.isArray(value))
         return value.map(toExportValue);
     if (value !== null && typeof value === 'object') {
-        return toExportAttributes(value);
+        return Object.fromEntries(Object.entries(value).map(([key, field]) => [key, toExportValue(field)]));
     }
     if (typeof value === 'bigint' || typeof value === 'symbol')
         return String(value);
     return value;
 }
-/**
- * Builds exported attributes from sanitized bindings, replacing every field
- * named in {@link DEFAULT_SENSITIVE_FIELDS} at any depth. OTel records bypass
- * pino's `redact`, so without this a value kept out of every file and stream
- * would leave the process in the clear.
- */
-function toExportAttributes(fields) {
-    const out = {};
-    for (const [key, field] of Object.entries(fields)) {
-        out[key] = SENSITIVE_FIELD_NAMES.has(key) ? '[REDACTED]' : toExportValue(field);
-    }
-    return out;
-}
 /**
  * Builds the OTel record for one framework log line: the message as the body,
- * the sanitized and redacted bindings as attributes, and an `Error` as the
- * `exception.*` semantic-convention attributes. Trace context is left to the
- * Logs API, which takes it from the active context at emit time.
+ * the bindings the process log writes as attributes, and an `Error` argument as
+ * the `exception.*` semantic-convention attributes, read through the walk, so a
+ * field whose read throws is exported as `'[Unreadable]'` and one the walk does
+ * not write is left out, rather than failing the log call. Trace context is
+ * left to the Logs API, which takes it from the active context at emit time.
  */
 function toOtelLogRecord(level, msg, bindings, error) {
-    const attributes = toExportAttributes(sanitizeLogBindings(bindings));
+    const attributes = toExportValue(sanitizeLogBindings(bindings));
     if (error) {
-        attributes['exception.type'] = error.name;
-        attributes['exception.message'] = error.message;
-        if (error.stack)
-            attributes['exception.stacktrace'] = error.stack;
+        const { type, message, stack } = errorFields(error);
+        if (type !== undefined)
+            attributes['exception.type'] = toExportValue(type);
+        if (message !== undefined)
+            attributes['exception.message'] = toExportValue(message);
+        if (stack)
+            attributes['exception.stacktrace'] = toExportValue(stack);
     }
     return {
         attributes,
@@ -267,8 +355,25 @@ export function setOtelLogSink(sink) {
  *   with one `warning` naming it; the process and the remaining sinks carry on.
  * - Optional OTel log export: once `initializeOpenTelemetry` attaches a Logs API
  *   sink, every record that passes the level filter and rate limit is also emitted
- *   there, redacted like the pino output.
- * - Sensitive field redaction via Pino's `redact` option.
+ *   there, with the same fields as the pino output — except the error argument,
+ *   which is exported as the `exception.*` attributes instead of an `err` field.
+ * - One walk over every record's data ({@link sanitizeLogBindings}), and the only
+ *   redaction: each `Error`, under any key, written as `type`/`message`/`stack`
+ *   (plus a string or `McpError` `code`, an `McpError`'s `data`, and `cause`/`errors`
+ *   in the same shape, a stack shared with the parent error written once); objects
+ *   kept through 15 levels below the record root and one 16 levels down written as
+ *   `'[MaxDepth]'`; at most 400,000 reads — one per object and per other field or
+ *   array element, ten per object at the depth bound — so data a getter, a Proxy, or a
+ *   `toJSON()` builds on every read stops at `'[Truncated]'`; at most 16 MiB
+ *   (16,777,216) characters of strings, field names, and primitives written, repeated
+ *   or not, then `'[Truncated]'` and the walk stops, so a 10 MB string is written whole
+ *   and a 20 MB one is not; repeated content — an object reached again through a shared
+ *   reference, or a string or field name of 1,024 characters or more written again —
+ *   also charged about the characters it writes against 1,000,000, and written as
+ *   `'[Truncated]'` where that runs out; cycles written as `'[Circular]'`; a value
+ *   whose read throws written as `'[Unreadable]'`; and every key the shared matcher
+ *   (`isSensitiveKey`) matches redacted at every depth kept, except the correlation
+ *   fields the record's context supplied, at its root.
  * - Rate limiting per level + message to suppress log storms, configurable via
  *   `MCP_LOG_RATE_LIMIT_THRESHOLD` (0 disables) and `MCP_LOG_RATE_LIMIT_WINDOW_MS`.
  *   Suppressed counts are flushed at `warning` once a window has elapsed, on
@@ -324,18 +429,11 @@ export class Logger {
         const pinoLevel = mcpToPinoLevel[level] ?? 'info';
         const pinoOptions = {
             level: pinoLevel,
-            base: {
-                env: config.environment,
-                version: config.mcpServerVersion,
-                pid: !isServerless() ? process.pid : undefined,
-            },
-            redact: {
-                paths: SENSITIVE_PINO_FIELDS,
-                censor: '[REDACTED]',
-            },
+            base: processLogBase(),
             formatters: {
                 log: sanitizeLogBindings,
             },
+            serializers: PINO_SERIALIZERS,
         };
         if (isServerless()) {
             return pino(pinoOptions);
@@ -386,13 +484,10 @@ export class Logger {
         if (!destination)
             return;
         return pino({
-            redact: {
-                paths: SENSITIVE_PINO_FIELDS,
-                censor: '[REDACTED]',
-            },
             formatters: {
                 log: sanitizeLogBindings,
             },
+            serializers: PINO_SERIALIZERS,
             transport: {
                 target: 'pino/file',
                 options: { destination },
@@ -723,6 +818,9 @@ export class Logger {
      * For startup paths that end the process before {@link initialize} runs: the
      * records describe what the failing boot was doing, so they are worth more on
      * stderr than discarded. Never writes to stdout, which stdio transport owns.
+     * An error's message is read through the walk, so one whose read throws is
+     * written as `'[Unreadable]'`, one the walk writes no message for is left
+     * off, and neither replaces the error that ended the boot.
      *
      * @example
      * ```ts
@@ -735,7 +833,12 @@ export class Logger {
         // Checked before the records are cleared: a runtime with no stderr keeps them.
         if (typeof process === 'undefined' || typeof process.stderr?.write !== 'function')
             return;
-        const lines = this.pendingRecords.map((record) => `[pre-init ${record.level}] ${record.msg}${record.error ? ` — ${record.error.message}` : ''}`);
+        const lines = this.pendingRecords.map(({ error, level, msg }) => {
+            const message = error && errorFields(error).message;
+            return message === undefined
+                ? `[pre-init ${level}] ${msg}`
+                : `[pre-init ${level}] ${msg} — ${message}`;
+        });
         if (this.droppedPendingRecords > 0) {
             lines.push(`[pre-init] ${this.droppedPendingRecords} further record(s) dropped — buffer holds ${PRE_INIT_BUFFER_LIMIT}.`);
         }
@@ -751,26 +854,24 @@ export class Logger {
         if (!this.isLevelEnabled(level) || this.isRateLimited(level, msg))
             return;
         const pinoLevel = mcpToPinoLevel[level] ?? 'info';
-        // `extra` is flattened rather than nested so the emitted line keeps the
-        // shape callers had when `RequestContext` was an open bag. The projection
-        // runs first: `logger.info(msg, ctx)` with a handler context is a documented
-        // call, and that object carries live request machinery and the user-entered
-        // content in `inputs.responses` — none of which belongs in a log line.
-        // The canonical fields are spread again after `extra`, so a caller's key
-        // reusing a canonical name (`requestId`, `traceId`, …) never replaces the
-        // context's value — the first spread only keeps them leading the line.
-        const { extra, ...canonical } = toCanonicalContext((context ?? {}));
-        const bindings = { ...canonical, ...extra, ...canonical };
-        // Pass the raw Error so pino's `err` serializer (default: `pino.stdSerializers.err`)
-        // runs *after* our `formatters.log` sanitizer. Pre-serializing here would produce
-        // an object whose prototype (`pinoErrProto`) trips the sanitizer's plain-object check.
-        this.pinoLogger[pinoLevel](error ? { ...bindings, err: error } : bindings, msg);
+        const bindings = toBindings(context);
+        // The error argument rides the `err` key; pino's `formatters.log` walk writes
+        // it like any other Error in the record, and the `err` serializer passes the result through.
+        // It leads the record, so the walk, which works in key order, writes it before caller data
+        // can spend the walk's bound. On that line `err` is the logger's own field, so a caller's
+        // `err` moves aside like any line field.
+        if (error && Object.hasOwn(bindings, 'err'))
+            moveLineField(bindings, 'err');
+        this.pinoLogger[pinoLevel](error ? { err: error, ...bindings } : bindings, msg);
         otelLogSink?.emit(toOtelLogRecord(level, msg, bindings, error));
     }
     logWithError(level, msg, errorOrContext, context) {
-        const errorObj = errorOrContext instanceof Error ? errorOrContext : undefined;
-        const actualContext = errorOrContext instanceof Error ? context : errorOrContext;
-        this.log(level, msg, actualContext, errorObj);
+        if (isError(errorOrContext)) {
+            this.log(level, msg, context, errorOrContext);
+        }
+        else {
+            this.log(level, msg, errorOrContext);
+        }
     }
     /**
      * Logs a diagnostic message at `debug` severity (RFC 5424 level 7).
@@ -839,8 +940,9 @@ export class Logger {
      * Logs an error-level message at `error` severity (RFC 5424 level 3).
      *
      * Use when an operation fails but the server can continue. The `errorOrContext`
-     * parameter accepts either an `Error` (serialized via `pino.stdSerializers.err`) or a
-     * `RequestContext` when no error object is available. Maps to pino `error` level.
+     * parameter accepts either an `Error` (written under `err` as its `type`, `message`,
+     * `stack`, and the other fields every logged Error carries — see {@link sanitizeLogBindings})
+     * or a `RequestContext` when no error object is available. Maps to pino `error` level.
      *
      * @param msg - Human-readable description of the failure.
      * @param errorOrContext - The `Error` to serialize, or a `RequestContext` if no error object exists.
@@ -937,12 +1039,20 @@ export class Logger {
      * ```
      */
     logInteraction(interactionName, data) {
+        let record;
+        try {
+            record = { interactionName, ...data };
+        }
+        catch {
+            record = { interactionName, ...walkedFields(data, 'data') };
+        }
         if (!this.interactionLogger) {
-            if (!isServerless() && !this.interactionSinkDropped)
-                this.warning('Interaction logger not available.', (data.context || {}));
+            if (!isServerless() && !this.interactionSinkDropped) {
+                this.warning('Interaction logger not available.', record.context);
+            }
             return;
         }
-        this.interactionLogger.info({ interactionName, ...data });
+        this.interactionLogger.info(record);
     }
 }
 /**