@j0hanz/fetch-url-mcp 1.9.1 → 1.9.2

package/dist/lib/http.js

@@ -18,6 +18,9 @@ import { get as cacheGet, config, getOperationId, getRequestId, logDebug, logErr
 import { BLOCKED_HOST_SUFFIXES, createDnsPreflight, IpBlocker, RawUrlTransformer, SafeDnsResolver, UrlNormalizer, VALIDATION_ERROR_CODE, } from './url.js';
 import { createErrorWithCode, FetchError, isAbortError, isError, isObject, isSystemError, toError, } from './utils.js';
 import { formatZodError } from './zod.js';
+// ═══════════════════════════════════════════════════════════════════
+// FILENAME GENERATION & DOWNLOAD
+// ═══════════════════════════════════════════════════════════════════
 const FILENAME_RULES = {
     MAX_LEN: 200,
     UNSAFE_CHARS: /[<>:"/\\|?*\p{C}]/gu,
@@ -113,6 +116,9 @@ export function handleDownload(res, namespace, hash) {
     res.setHeader('X-Content-Type-Options', 'nosniff');
     res.end(content);
 }
+// ═══════════════════════════════════════════════════════════════════
+// ENCODING DETECTION
+// ═══════════════════════════════════════════════════════════════════
 const UTF8_ENCODING = 'utf-8';
 function getCharsetFromContentType(contentType) {
     if (!contentType)
@@ -152,14 +158,22 @@ function isUnicodeWideEncoding(encoding) {
         normalized === 'unicodefffe' ||
         normalized === 'unicodefeff');
 }
-const BOM_SIGNATURES = [
-    // 4-byte BOMs must come first to avoid false matches with 2-byte prefixes
+const BOM_ENTRIES = [
+    // 4-byte BOMs must come before shorter prefixes to avoid false matches
     { bytes: [0xff, 0xfe, 0x00, 0x00], encoding: 'utf-32le' },
     { bytes: [0x00, 0x00, 0xfe, 0xff], encoding: 'utf-32be' },
     { bytes: [0xef, 0xbb, 0xbf], encoding: 'utf-8' },
     { bytes: [0xff, 0xfe], encoding: 'utf-16le' },
     { bytes: [0xfe, 0xff], encoding: 'utf-16be' },
 ];
+const BOM_BY_FIRST_BYTE = new Map();
+for (const entry of BOM_ENTRIES) {
+    const key = entry.bytes[0];
+    if (key === undefined)
+        continue;
+    const existing = BOM_BY_FIRST_BYTE.get(key);
+    BOM_BY_FIRST_BYTE.set(key, existing ? [...existing, entry] : [entry]);
+}
 function startsWithBytes(buffer, signature) {
     const sigLen = signature.length;
     if (buffer.length < sigLen)
@@ -171,7 +185,15 @@ function startsWithBytes(buffer, signature) {
     return true;
 }
 function detectBomEncoding(buffer) {
-    for (const { bytes, encoding } of BOM_SIGNATURES) {
+    if (buffer.length === 0)
+        return undefined;
+    const first = buffer[0];
+    if (first === undefined)
+        return undefined;
+    const candidates = BOM_BY_FIRST_BYTE.get(first);
+    if (!candidates)
+        return undefined;
+    for (const { bytes, encoding } of candidates) {
         if (startsWithBytes(buffer, bytes))
             return encoding;
     }
@@ -231,6 +253,9 @@ function resolveEncoding(declaredEncoding, sample) {
         return declaredEncoding;
     return detectHtmlDeclaredEncoding(sample);
 }
+// ═══════════════════════════════════════════════════════════════════
+// BINARY DETECTION
+// ═══════════════════════════════════════════════════════════════════
 const BINARY_SIGNATURES = [
     [0x25, 0x50, 0x44, 0x46],
     [0x89, 0x50, 0x4e, 0x47],
@@ -275,6 +300,9 @@ function isBinaryContent(buffer, encoding) {
     }
     return !isUnicodeWideEncoding(encoding) && hasNullByte(buffer, 1000);
 }
+// ═══════════════════════════════════════════════════════════════════
+// FETCH ERRORS
+// ═══════════════════════════════════════════════════════════════════
 function parseRetryAfter(header) {
     if (!header)
         return 60;
@@ -357,6 +385,9 @@ function mapFetchError(error, fallbackUrl, timeoutMs) {
     }
     return createFetchError({ kind: 'network', message: error.message }, url);
 }
+// ═══════════════════════════════════════════════════════════════════
+// REDIRECT FOLLOWING
+// ═══════════════════════════════════════════════════════════════════
 const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
 function isRedirectStatus(status) {
     return REDIRECT_STATUSES.has(status);
@@ -503,6 +534,9 @@ class RedirectFollower {
         }
     }
 }
+// ═══════════════════════════════════════════════════════════════════
+// CONTENT VALIDATION & DECOMPRESSION
+// ═══════════════════════════════════════════════════════════════════
 function resolveResponseError(response, finalUrl) {
     if (response.status === 429) {
         return createFetchError({ kind: 'rate-limited', retryAfter: response.headers.get('retry-after') }, finalUrl);
@@ -633,27 +667,10 @@ function createPumpedStream(initialChunk, reader) {
         },
     });
 }
-async function decodeResponseIfNeeded(response, url, signal) {
-    const encodingHeader = response.headers.get('content-encoding');
-    const parsedEncodings = parseContentEncodings(encodingHeader);
-    if (!parsedEncodings)
-        return response;
-    const encodings = parsedEncodings.filter((token) => token !== 'identity');
-    if (encodings.length === 0)
-        return response;
-    for (const encoding of encodings) {
-        if (!isSupportedContentEncoding(encoding)) {
-            throw createUnsupportedContentEncodingError(url, encodingHeader ?? encoding);
-        }
-    }
-    if (!response.body)
-        return response;
-    const [decodeBranch, passthroughBranch] = response.body.tee();
-    const decodeOrder = encodings
-        .slice()
-        .reverse()
-        .filter(isSupportedContentEncoding);
-    const decompressors = decodeOrder.map((encoding) => createDecompressor(encoding));
+function buildDecodePipeline(body, encodings, url, response, signal) {
+    const [decodeBranch, passthroughBranch] = body.tee();
+    const decodeOrder = encodings.slice().reverse();
+    const decompressors = decodeOrder.map((enc) => createDecompressor(enc));
     const decodeSource = Readable.fromWeb(toNodeReadableStream(decodeBranch, url, 'response:decode-content-encoding'));
     const decodedNodeStream = new PassThrough();
     const decodedPipeline = pipeline([
@@ -664,7 +681,7 @@ async function decodeResponseIfNeeded(response, url, signal) {
     const headers = new Headers(response.headers);
     headers.delete('content-encoding');
     headers.delete('content-length');
-    const abortDecodePipeline = () => {
+    const cleanup = () => {
         decodeSource.destroy();
         for (const decompressor of decompressors) {
             decompressor.destroy();
@@ -672,33 +689,57 @@ async function decodeResponseIfNeeded(response, url, signal) {
         decodedNodeStream.destroy();
     };
     if (signal) {
-        signal.addEventListener('abort', abortDecodePipeline, { once: true });
+        signal.addEventListener('abort', cleanup, { once: true });
     }
     void decodedPipeline.catch((error) => {
         decodedNodeStream.destroy(toError(error));
     });
     const decodedBodyStream = toWebReadableStream(decodedNodeStream, url, 'response:decode-content-encoding');
     const decodedReader = decodedBodyStream.getReader();
+    return {
+        decodedReader,
+        passthroughBranch,
+        decodedNodeStream,
+        headers,
+        cleanup,
+    };
+}
+async function decodeResponseIfNeeded(response, url, signal) {
+    const encodingHeader = response.headers.get('content-encoding');
+    const parsedEncodings = parseContentEncodings(encodingHeader);
+    if (!parsedEncodings)
+        return response;
+    const encodings = parsedEncodings.filter((token) => token !== 'identity');
+    if (encodings.length === 0)
+        return response;
+    for (const encoding of encodings) {
+        if (!isSupportedContentEncoding(encoding)) {
+            throw createUnsupportedContentEncodingError(url, encodingHeader ?? encoding);
+        }
+    }
+    if (!response.body)
+        return response;
+    const pipe = buildDecodePipeline(response.body, encodings.filter(isSupportedContentEncoding), url, response, signal);
     const clearAbortListener = () => {
         if (!signal)
             return;
-        signal.removeEventListener('abort', abortDecodePipeline);
+        signal.removeEventListener('abort', pipe.cleanup);
     };
     try {
-        const first = await decodedReader.read();
+        const first = await pipe.decodedReader.read();
         if (first.done) {
             clearAbortListener();
-            void passthroughBranch.cancel().catch(() => undefined);
+            void pipe.passthroughBranch.cancel().catch(() => undefined);
             return new Response(null, {
                 status: response.status,
                 statusText: response.statusText,
-                headers,
+                headers: pipe.headers,
             });
         }
-        void passthroughBranch.cancel().catch(() => undefined);
-        const body = createPumpedStream(first.value, decodedReader);
+        void pipe.passthroughBranch.cancel().catch(() => undefined);
+        const body = createPumpedStream(first.value, pipe.decodedReader);
         if (signal) {
-            void finished(decodedNodeStream, { cleanup: true })
+            void finished(pipe.decodedNodeStream, { cleanup: true })
                 .catch(() => { })
                 .finally(() => {
                 clearAbortListener();
@@ -707,17 +748,76 @@ async function decodeResponseIfNeeded(response, url, signal) {
         return new Response(body, {
             status: response.status,
             statusText: response.statusText,
-            headers,
+            headers: pipe.headers,
         });
     }
     catch (error) {
         clearAbortListener();
-        abortDecodePipeline();
-        void decodedReader.cancel(error).catch(() => undefined);
-        void passthroughBranch.cancel().catch(() => undefined);
+        pipe.cleanup();
+        void pipe.decodedReader.cancel(error).catch(() => undefined);
+        void pipe.passthroughBranch.cancel().catch(() => undefined);
         throw new FetchError(`Content-Encoding decode failed for ${redactUrl(url)}: ${isError(error) ? error.message : String(error)}`, url);
     }
 }
+// ═══════════════════════════════════════════════════════════════════
+// RESPONSE READING
+// ═══════════════════════════════════════════════════════════════════
+class BoundedBufferTransform extends Transform {
+    byteLimit;
+    captureChunks;
+    url;
+    declaredEncoding;
+    total = 0;
+    chunks = [];
+    effectiveEncoding;
+    encodingResolved = false;
+    constructor(byteLimit, captureChunks, url, declaredEncoding) {
+        super();
+        this.byteLimit = byteLimit;
+        this.captureChunks = captureChunks;
+        this.url = url;
+        this.declaredEncoding = declaredEncoding;
+        this.effectiveEncoding = declaredEncoding ?? 'utf-8';
+    }
+    _transform(chunk, _encoding, callback) {
+        try {
+            const buf = Buffer.isBuffer(chunk)
+                ? chunk
+                : Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+            if (!this.encodingResolved) {
+                this.encodingResolved = true;
+                this.effectiveEncoding =
+                    resolveEncoding(this.declaredEncoding, buf) ??
+                        this.declaredEncoding ??
+                        'utf-8';
+            }
+            if (isBinaryContent(buf, this.effectiveEncoding)) {
+                callback(new FetchError('Detailed content type check failed: binary content detected', this.url, 500, { reason: 'binary_content_detected' }));
+                return;
+            }
+            const newTotal = this.total + buf.length;
+            if (newTotal > this.byteLimit) {
+                const remaining = this.byteLimit - this.total;
+                if (remaining > 0) {
+                    const slice = buf.subarray(0, remaining);
+                    this.total += remaining;
+                    if (this.captureChunks)
+                        this.chunks.push(slice);
+                    this.push(slice);
+                }
+                callback(new MaxBytesError());
+                return;
+            }
+            this.total = newTotal;
+            if (this.captureChunks)
+                this.chunks.push(buf);
+            callback(null, buf);
+        }
+        catch (error) {
+            callback(toError(error));
+        }
+    }
+}
 class ResponseTextReader {
     async read(response, url, maxBytes, signal, encoding) {
         const { buffer, encoding: effectiveEncoding, truncated, } = await this.readBuffer(response, url, maxBytes, signal, encoding);
@@ -738,27 +838,10 @@ class ResponseTextReader {
         if (signal?.aborted)
             throw createFetchError({ kind: 'canceled' }, url);
         const limit = maxBytes <= 0 ? Number.POSITIVE_INFINITY : maxBytes;
-        let buffer;
-        let truncated = false;
-        try {
-            // Try safe blob slicing if available (Node 18+) to avoid OOM
-            const blob = await response.blob();
-            if (Number.isFinite(limit) && blob.size > limit) {
-                const sliced = blob.slice(0, limit);
-                buffer = new Uint8Array(await sliced.arrayBuffer());
-                truncated = true;
-            }
-            else {
-                buffer = new Uint8Array(await blob.arrayBuffer());
-            }
-        }
-        catch {
-            // Fallback if blob() fails
-            const arrayBuffer = await response.arrayBuffer();
-            const length = Math.min(arrayBuffer.byteLength, limit);
-            buffer = new Uint8Array(arrayBuffer, 0, length);
-            truncated = Number.isFinite(limit) && arrayBuffer.byteLength > limit;
-        }
+        const arrayBuffer = await response.arrayBuffer();
+        const truncated = Number.isFinite(limit) && arrayBuffer.byteLength > limit;
+        const length = truncated ? limit : arrayBuffer.byteLength;
+        const buffer = new Uint8Array(arrayBuffer, 0, length);
         const effectiveEncoding = resolveEncoding(encoding, buffer) ?? encoding ?? 'utf-8';
         if (isBinaryContent(buffer, effectiveEncoding)) {
             throw new FetchError('Detailed content type check failed: binary content detected', url, 500, { reason: 'binary_content_detected' });
@@ -773,49 +856,8 @@ class ResponseTextReader {
     async readStreamToBuffer(stream, url, maxBytes, signal, encoding) {
         const byteLimit = maxBytes <= 0 ? Number.POSITIVE_INFINITY : maxBytes;
         const captureChunks = byteLimit !== Number.POSITIVE_INFINITY;
-        let effectiveEncoding = encoding ?? 'utf-8';
-        let encodingResolved = false;
-        let total = 0;
-        const chunks = [];
         const source = Readable.fromWeb(toNodeReadableStream(stream, url, 'response:read-stream-buffer'));
-        const guard = new Transform({
-            transform(chunk, _encoding, callback) {
-                try {
-                    const buf = Buffer.isBuffer(chunk)
-                        ? chunk
-                        : Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
-                    if (!encodingResolved) {
-                        encodingResolved = true;
-                        effectiveEncoding =
-                            resolveEncoding(encoding, buf) ?? encoding ?? 'utf-8';
-                    }
-                    if (isBinaryContent(buf, effectiveEncoding)) {
-                        callback(new FetchError('Detailed content type check failed: binary content detected', url, 500, { reason: 'binary_content_detected' }));
-                        return;
-                    }
-                    const newTotal = total + buf.length;
-                    if (newTotal > byteLimit) {
-                        const remaining = byteLimit - total;
-                        if (remaining > 0) {
-                            const slice = buf.subarray(0, remaining);
-                            total += remaining;
-                            if (captureChunks)
-                                chunks.push(slice);
-                            this.push(slice);
-                        }
-                        callback(new MaxBytesError());
-                        return;
-                    }
-                    total = newTotal;
-                    if (captureChunks)
-                        chunks.push(buf);
-                    callback(null, buf);
-                }
-                catch (error) {
-                    callback(toError(error));
-                }
-            },
-        });
+        const guard = new BoundedBufferTransform(byteLimit, captureChunks, url, encoding);
         const guarded = source.pipe(guard);
         const abortHandler = () => {
             source.destroy();
@@ -828,8 +870,8 @@ class ResponseTextReader {
             const buffer = await consumeBuffer(guarded);
             return {
                 buffer,
-                encoding: effectiveEncoding,
-                size: total,
+                encoding: guard.effectiveEncoding,
+                size: guard.total,
                 truncated: false,
             };
         }
@@ -842,9 +884,9 @@ class ResponseTextReader {
                 source.destroy();
                 guard.destroy();
                 return {
-                    buffer: Buffer.concat(chunks, total),
-                    encoding: effectiveEncoding,
-                    size: total,
+                    buffer: Buffer.concat(guard.chunks, guard.total),
+                    encoding: guard.effectiveEncoding,
+                    size: guard.total,
                     truncated: true,
                 };
             }
@@ -914,14 +956,6 @@ class FetchTelemetry {
     redact(url) {
         return this.redactor.redact(url);
     }
-    contextFields(ctx) {
-        return {
-            ...(ctx.contextRequestId
-                ? { contextRequestId: ctx.contextRequestId }
-                : {}),
-            ...(ctx.operationId ? { operationId: ctx.operationId } : {}),
-        };
-    }
     start(url, method) {
         const safeUrl = this.redactor.redact(url);
         const contextRequestId = this.context.getRequestId();
@@ -936,7 +970,12 @@ class FetchTelemetry {
             ctx.contextRequestId = contextRequestId;
         if (operationId)
             ctx.operationId = operationId;
-        const ctxFields = this.contextFields(ctx);
+        const ctxFields = {
+            ...(ctx.contextRequestId
+                ? { contextRequestId: ctx.contextRequestId }
+                : {}),
+            ...(ctx.operationId ? { operationId: ctx.operationId } : {}),
+        };
         this.publish({
             v: 1,
             type: 'start',
@@ -956,7 +995,12 @@ class FetchTelemetry {
     recordResponse(context, response, contentSize) {
         const duration = performance.now() - context.startTime;
         const durationLabel = `${Math.round(duration)}ms`;
-        const ctxFields = this.contextFields(context);
+        const ctxFields = {
+            ...(context.contextRequestId
+                ? { contextRequestId: context.contextRequestId }
+                : {}),
+            ...(context.operationId ? { operationId: context.operationId } : {}),
+        };
         this.publish({
             v: 1,
             type: 'end',
@@ -991,7 +1035,12 @@ class FetchTelemetry {
         const duration = performance.now() - context.startTime;
         const err = toError(error);
         const code = isSystemError(err) ? err.code : undefined;
-        const ctxFields = this.contextFields(context);
+        const ctxFields = {
+            ...(context.contextRequestId
+                ? { contextRequestId: context.contextRequestId }
+                : {}),
+            ...(context.operationId ? { operationId: context.operationId } : {}),
+        };
         this.publish({
             v: 1,
             type: 'error',
@@ -1060,7 +1109,7 @@ class HttpFetcher {
     }
     async fetchNormalized(normalizedUrl, mode, options) {
         const timeoutMs = this.fetcherConfig.timeout;
-        const headers = buildHeaders();
+        const headers = DEFAULT_HEADERS;
         const signal = buildRequestSignal(timeoutMs, options?.signal);
         const init = buildRequestInit(headers, signal);
         const ctx = this.telemetry.start(normalizedUrl, 'GET');
@@ -1107,9 +1156,6 @@ const DEFAULT_HEADERS = {
     // The undici-based globalThis.fetch manages content negotiation and
     // decompression transparently per the Fetch spec.
 };
-function buildHeaders() {
-    return DEFAULT_HEADERS;
-}
 function buildRequestSignal(timeoutMs, external) {
     if (timeoutMs <= 0)
         return external;
@@ -1123,16 +1169,28 @@ function buildRequestInit(headers, signal) {
         ...(signal ? { signal } : {}),
     };
 }
-const ipBlocker = new IpBlocker(config.security);
-const urlNormalizer = new UrlNormalizer(config.constants, config.security, ipBlocker, BLOCKED_HOST_SUFFIXES);
-const rawUrlTransformer = new RawUrlTransformer(defaultLogger);
-const dnsResolver = new SafeDnsResolver(ipBlocker, config.security, BLOCKED_HOST_SUFFIXES);
-const telemetry = new FetchTelemetry(defaultLogger, defaultContext, defaultRedactor);
-const normalizeRedirectUrl = (url) => urlNormalizer.validateAndNormalize(url);
-const dnsPreflight = createDnsPreflight(dnsResolver);
-const secureRedirectFollower = new RedirectFollower(defaultFetch, normalizeRedirectUrl, dnsPreflight);
-const responseReader = new ResponseTextReader();
-const httpFetcher = new HttpFetcher(config.fetcher, secureRedirectFollower, responseReader, telemetry);
+function createHttpModule() {
+    const ipBlocker = new IpBlocker(config.security);
+    const urlNormalizer = new UrlNormalizer(config.constants, config.security, ipBlocker, BLOCKED_HOST_SUFFIXES);
+    const rawUrlTransformer = new RawUrlTransformer(defaultLogger);
+    const dnsResolver = new SafeDnsResolver(ipBlocker, config.security, BLOCKED_HOST_SUFFIXES);
+    const tel = new FetchTelemetry(defaultLogger, defaultContext, defaultRedactor);
+    const normalizeRedirectUrl = (url) => urlNormalizer.validateAndNormalize(url);
+    const dnsPreflight = createDnsPreflight(dnsResolver);
+    const secureRedirectFollower = new RedirectFollower(defaultFetch, normalizeRedirectUrl, dnsPreflight);
+    const responseReader = new ResponseTextReader();
+    const httpFetcher = new HttpFetcher(config.fetcher, secureRedirectFollower, responseReader, tel);
+    return {
+        ipBlocker,
+        urlNormalizer,
+        rawUrlTransformer,
+        telemetry: tel,
+        secureRedirectFollower,
+        responseReader,
+        httpFetcher,
+    };
+}
+const { ipBlocker, urlNormalizer, rawUrlTransformer, telemetry, secureRedirectFollower, responseReader, httpFetcher, } = createHttpModule();
 export function isBlockedIp(ip) {
     return ipBlocker.isBlockedIp(ip);
 }

package/dist/lib/mcp-tools.d.ts

@@ -17,7 +17,7 @@ declare const jsonRpcResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
     result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strict>, z.ZodObject<{
     jsonrpc: z.ZodLiteral<"2.0">;
-    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>;
+    id: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodNull]>>;
     error: z.ZodObject<{
         code: z.ZodNumber;
         message: z.ZodString;
@@ -35,7 +35,7 @@ declare const jsonRpcMessageSchema: z.ZodUnion<readonly [z.ZodObject<{
     result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strict>, z.ZodObject<{
     jsonrpc: z.ZodLiteral<"2.0">;
-    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>;
+    id: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodNull]>>;
     error: z.ZodObject<{
         code: z.ZodNumber;
         message: z.ZodString;
@@ -60,7 +60,5 @@ export declare function createToolErrorResponse(message: string, url: string, ex
     details?: Record<string, unknown>;
 }): ToolErrorResponse;
 export declare function handleToolError(error: unknown, url: string, fallbackMessage?: string): ToolErrorResponse;
-export { registerServerLifecycleCleanup, registerTaskHandlers, cancelTasksForOwner, abortAllTaskExecutions, } from './task-handlers.js';
-export { readNestedRecord, withSignal, TRUNCATION_MARKER, type InlineContentResult, appendTruncationMarker, type PipelineResult, type SharedFetchStage, executeFetchPipeline, type MarkdownPipelineResult, parseCachedMarkdownResult, markdownTransform, serializeMarkdownResult, performSharedFetch, } from './fetch-pipeline.js';
-export { type ProgressNotificationParams, type ProgressNotification, type ToolHandlerExtra, type ProgressReporter, createProgressReporter, } from './progress.js';
+export {};
 //# sourceMappingURL=mcp-tools.d.ts.map

package/dist/lib/mcp-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-tools.d.ts","sourceRoot":"","sources":["../../src/lib/mcp-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;AAC/C,UAAU,gBAAgB;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAGD,QAAA,MAAM,oBAAoB;;;;;kBAKxB,CAAC;AAeH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;oBAGzB,CAAC;AACH,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;sBAGxB,CAAC;AACH,KAAK,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAC3D,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACjE,KAAK,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAC/D,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAE5D;AACD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,cAAc,CAEtE;AACD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,OAAO,GACZ,IAAI,IAAI,mBAAmB,CAE7B;AACD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,kBAAkB,CAE1E;AAaD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAG7E;AAeD,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAChC,OAAO,CAUT;AAMD,KAAK,iBAAiB,GAAG,cAAc,GAAG;IACxC,OAAO,EAAE,IAAI,CAAC;CACf,CAAC;AAsCF,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE;IACN,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,GACA,iBAAiB,CAenB;AAiCD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,MAAM,EACX,eAAe,SAAqB,GACnC,iBAAiB,CAYnB;AASD,OAAO,EACL,8BAA8B,EAC9B,oBAAoB,EACpB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,gBAAgB,EAChB,UAAU,EACV,iBAAiB,EACjB,KAAK,mBAAmB,EACxB,sBAAsB,EACtB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,oBAAoB,EACpB,KAAK,sBAAsB,EAC3B,yBAAyB,EACzB,iBAAiB,EACjB,uBAAuB,EACvB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,sBAAsB,GACvB,MAAM,eAAe,CAAC"}
+{"version":3,"file":"mcp-tools.d.ts","sourceRoot":"","sources":["../../src/lib/mcp-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;AAC/C,UAAU,gBAAgB;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAGD,QAAA,MAAM,oBAAoB;;;;;kBAKxB,CAAC;AAeH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;oBAGzB,CAAC;AACH,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;sBAGxB,CAAC;AACH,KAAK,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAC3D,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACjE,KAAK,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAC/D,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAE5D;AACD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,cAAc,CAEtE;AACD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,OAAO,GACZ,IAAI,IAAI,mBAAmB,CAE7B;AACD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,kBAAkB,CAE1E;AAUD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAG7E;AACD,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAChC,OAAO,CAUT;AAMD,KAAK,iBAAiB,GAAG,cAAc,GAAG;IACxC,OAAO,EAAE,IAAI,CAAC;CACf,CAAC;AA6BF,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE;IACN,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,GACA,iBAAiB,CAenB;AAQD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,MAAM,EACX,eAAe,SAAqB,GACnC,iBAAiB,CA2BnB"}

package/dist/lib/mcp-tools.js

@@ -11,12 +11,12 @@ const jsonRpcRequestSchema = z.strictObject({
 });
 const jsonRpcResultResponseSchema = z.strictObject({
     jsonrpc: z.literal('2.0'),
-    id: z.union([z.string(), z.number()]),
+    id: jsonRpcRequestIdSchema,
     result: z.record(z.string(), z.unknown()),
 });
 const jsonRpcErrorResponseSchema = z.strictObject({
     jsonrpc: z.literal('2.0'),
-    id: z.union([z.string(), z.number(), z.null()]).optional(),
+    id: jsonRpcRequestIdSchema.or(z.null()).optional(),
     error: z.strictObject({
         code: z.number().int(),
         message: z.string(),
@@ -48,29 +48,19 @@ function parseAcceptMediaTypes(header) {
         return [];
     return header
         .split(',')
-        .map((value) => extractAcceptMediaType(value.trim()))
-        .filter((value) => value.length > 0);
-}
-function extractAcceptMediaType(value) {
-    return value.split(';', 1)[0]?.trim().toLowerCase() ?? '';
+        .map((v) => v.split(';', 1)[0]?.trim().toLowerCase() ?? '')
+        .filter((v) => v.length > 0);
 }
 export function acceptsEventStream(header) {
     const mediaTypes = parseAcceptMediaTypes(header);
     return mediaTypes.some((mediaType) => mediaType === 'text/event-stream');
 }
-function hasAcceptedMediaType(mediaTypes, exact, wildcardPrefix) {
-    return mediaTypes.some((mediaType) => typeof mediaType === 'string' &&
-        mediaType.length > 0 &&
-        (mediaType === '*/*' ||
-            mediaType === exact ||
-            mediaType === wildcardPrefix));
-}
 export function acceptsJsonAndEventStream(header) {
     const mediaTypes = parseAcceptMediaTypes(header);
-    const acceptsJson = hasAcceptedMediaType(mediaTypes, 'application/json', 'application/*');
+    const acceptsJson = mediaTypes.some((m) => m === '*/*' || m === 'application/json' || m === 'application/*');
     if (!acceptsJson)
         return false;
-    return hasAcceptedMediaType(mediaTypes, 'text/event-stream', 'text/*');
+    return mediaTypes.some((m) => m === '*/*' || m === 'text/event-stream' || m === 'text/*');
 }
 const PUBLIC_ERROR_REASONS = new Set(['aborted', 'queue_full', 'timeout']);
 function sanitizeToolErrorDetails(details) {
@@ -89,14 +79,6 @@ function sanitizeToolErrorDetails(details) {
     }
     return Object.keys(sanitized).length > 0 ? sanitized : undefined;
 }
-function resolvePublicFetchErrorCode(error) {
-    const { code: detailsCode, reason } = error.details;
-    if (typeof detailsCode === 'string')
-        return detailsCode;
-    if (reason === 'queue_full')
-        return 'queue_full';
-    return undefined;
-}
 export function createToolErrorResponse(message, url, extra) {
     const errorContent = {
         error: message,
@@ -117,47 +99,29 @@ function isValidationError(error) {
         isSystemError(error) &&
         error.code === 'VALIDATION_ERROR');
 }
-function isHandledToolError(error) {
-    return error instanceof FetchError || isValidationError(error);
-}
-function resolveToolErrorMessage(error, fallbackMessage) {
-    if (isHandledToolError(error)) {
-        return error.message;
-    }
-    if (error instanceof Error) {
-        return `${fallbackMessage}: ${error.message}`;
-    }
-    return `${fallbackMessage}: Unknown error`;
-}
-function resolveToolErrorCode(error) {
-    if (error instanceof FetchError) {
-        return resolvePublicFetchErrorCode(error) ?? error.code;
-    }
-    if (isValidationError(error))
-        return 'VALIDATION_ERROR';
-    if (isAbortError(error))
-        return 'ABORTED';
-    return 'FETCH_ERROR';
-}
 export function handleToolError(error, url, fallbackMessage = 'Operation failed') {
-    const message = resolveToolErrorMessage(error, fallbackMessage);
-    const code = resolveToolErrorCode(error);
     if (error instanceof FetchError) {
+        const { code: detailsCode, reason } = error.details;
+        const code = (typeof detailsCode === 'string'
+            ? detailsCode
+            : reason === 'queue_full'
+                ? 'queue_full'
+                : undefined) ?? error.code;
         const details = sanitizeToolErrorDetails(error.details);
-        return createToolErrorResponse(message, url, {
+        return createToolErrorResponse(error.message, url, {
             code,
             statusCode: error.statusCode,
             ...(details ? { details } : {}),
         });
     }
+    if (isValidationError(error)) {
+        return createToolErrorResponse(error.message, url, {
+            code: 'VALIDATION_ERROR',
+        });
+    }
+    const code = isAbortError(error) ? 'ABORTED' : 'FETCH_ERROR';
+    const message = error instanceof Error
+        ? `${fallbackMessage}: ${error.message}`
+        : `${fallbackMessage}: Unknown error`;
     return createToolErrorResponse(message, url, { code });
 }
-/* -------------------------------------------------------------------------------------------------
- * Re-exports from split modules
- *
- * Preserves backward compatibility — consumers import from 'lib/mcp-tools.js'
- * without changes. Direct imports from the sub-modules are preferred for new code.
- * ------------------------------------------------------------------------------------------------- */
-export { registerServerLifecycleCleanup, registerTaskHandlers, cancelTasksForOwner, abortAllTaskExecutions, } from './task-handlers.js';
-export { readNestedRecord, withSignal, TRUNCATION_MARKER, appendTruncationMarker, executeFetchPipeline, parseCachedMarkdownResult, markdownTransform, serializeMarkdownResult, performSharedFetch, } from './fetch-pipeline.js';
-export { createProgressReporter, } from './progress.js';