@j0hanz/superfetch 2.3.0 → 2.4.1

package/dist/cache.js

@@ -1,4 +1,3 @@
-import { LRUCache } from 'lru-cache';
 import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { ErrorCode, McpError, SubscribeRequestSchema, UnsubscribeRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { config } from './config.js';
@@ -105,10 +104,65 @@ export function toResourceUri(cacheKey) {
         return null;
     return buildCacheResourceUri(parts.namespace, parts.urlHash);
 }
-const contentCache = new LRUCache({
+// Cache behavior contract (native implementation):
+// - Max entries: config.cache.maxKeys
+// - TTL in ms: config.cache.ttl * 1000
+// - Access does NOT extend TTL
+class NativeLruCache {
+    max;
+    ttlMs;
+    entries = new Map();
+    constructor({ max, ttlMs }) {
+        this.max = max;
+        this.ttlMs = ttlMs;
+    }
+    get(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return undefined;
+        if (this.isExpired(entry, Date.now())) {
+            this.entries.delete(key);
+            return undefined;
+        }
+        // Refresh LRU order without extending TTL.
+        this.entries.delete(key);
+        this.entries.set(key, entry);
+        return entry.value;
+    }
+    set(key, value) {
+        if (this.max <= 0 || this.ttlMs <= 0)
+            return;
+        this.entries.delete(key);
+        this.entries.set(key, {
+            value,
+            expiresAtMs: Date.now() + this.ttlMs,
+        });
+        this.purgeExpired(Date.now());
+        while (this.entries.size > this.max) {
+            const oldestKey = this.entries.keys().next().value;
+            if (oldestKey === undefined)
+                break;
+            this.entries.delete(oldestKey);
+        }
+    }
+    keys() {
+        this.purgeExpired(Date.now());
+        return [...this.entries.keys()];
+    }
+    purgeExpired(now) {
+        for (const [key, entry] of this.entries) {
+            if (this.isExpired(entry, now)) {
+                this.entries.delete(key);
+            }
+        }
+    }
+    isExpired(entry, now) {
+        return entry.expiresAtMs <= now;
+    }
+}
+const contentCache = new NativeLruCache({
     max: config.cache.maxKeys,
-    ttl: config.cache.ttl * 1000,
-    updateAgeOnGet: false,
+    ttlMs: config.cache.ttl * 1000,
 });
 const updateListeners = new Set();
 export function onCacheUpdate(listener) {

package/dist/config.d.ts

@@ -1,3 +1,4 @@
+export declare const serverVersion: string;
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 export type TransformMetadataFormat = 'markdown' | 'frontmatter';
 interface AuthConfig {
@@ -43,6 +44,7 @@ export declare const config: {
     };
     transform: {
         timeoutMs: number;
+        stageWarnRatio: number;
         metadataFormat: TransformMetadataFormat;
     };
     tools: {

package/dist/config.js

@@ -1,4 +1,5 @@
 import packageJson from '../package.json' with { type: 'json' };
+export const serverVersion = packageJson.version;
 function buildIpv4(parts) {
     return parts.join('.');
 }
@@ -199,6 +200,7 @@ export const config = {
     },
     transform: {
         timeoutMs: TIMEOUT.DEFAULT_TRANSFORM_TIMEOUT_MS,
+        stageWarnRatio: parseFloat(process.env.TRANSFORM_STAGE_WARN_RATIO ?? '0.5'),
         metadataFormat: parseTransformMetadataFormat(process.env.TRANSFORM_METADATA_FORMAT),
     },
     tools: {

package/dist/dom-noise-removal.js

@@ -157,6 +157,16 @@ function getPromoTokens() {
     promoTokensCache = tokens;
     return tokens;
 }
+let promoRegexCache = null;
+function getPromoRegex() {
+    if (promoRegexCache)
+        return promoRegexCache;
+    const tokens = Array.from(getPromoTokens());
+    const escaped = tokens.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    const pattern = `(?:^|[^a-z0-9])(?:${escaped.join('|')})(?:$|[^a-z0-9])`;
+    promoRegexCache = new RegExp(pattern, 'i');
+    return promoRegexCache;
+}
 const HEADER_NOISE_PATTERN = /\b(site-header|masthead|topbar|navbar|nav(?:bar)?|menu|header-nav)\b/i;
 const FIXED_PATTERN = /\b(fixed|sticky)\b/;
 const HIGH_Z_PATTERN = /\bz-(?:4\d|50)\b/;
@@ -261,18 +271,9 @@ function isElementHidden(element) {
 function hasNoiseRole(role) {
     return role !== null && NAVIGATION_ROLES.has(role);
 }
-function tokenizeIdentifierLikeText(value) {
-    return value
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, ' ')
-        .trim()
-        .split(' ')
-        .filter(Boolean);
-}
 function matchesPromoIdOrClass(className, id) {
-    const tokens = tokenizeIdentifierLikeText(`${className} ${id}`);
-    const promoTokens = getPromoTokens();
-    return tokens.some((token) => promoTokens.has(token));
+    const regex = getPromoRegex();
+    return regex.test(className) || regex.test(id);
 }
 function matchesFixedOrHighZIsolate(className) {
     return (FIXED_PATTERN.test(className) ||
@@ -310,9 +311,10 @@ function isNodeListLike(value) {
     return isObject(value) && typeof value.length === 'number';
 }
 function tryGetNodeListItem(nodes, index) {
-    if (typeof nodes.item === 'function')
+    if ('item' in nodes && typeof nodes.item === 'function') {
         return nodes.item(index);
-    return (nodes[index] ?? null);
+    }
+    return nodes[index] ?? null;
 }
 function removeNoiseFromNodeListLike(nodes, shouldCheckNoise) {
     for (let index = nodes.length - 1; index >= 0; index -= 1) {

package/dist/fetch.js

@@ -300,11 +300,11 @@ export function isRawTextContentUrl(url) {
     return hasKnownRawTextExtension(lowerBase);
 }
 function hasKnownRawTextExtension(urlBaseLower) {
-    for (const ext of RAW_TEXT_EXTENSIONS) {
-        if (urlBaseLower.endsWith(ext))
-            return true;
-    }
-    return false;
+    const lastDot = urlBaseLower.lastIndexOf('.');
+    if (lastDot === -1)
+        return false;
+    const ext = urlBaseLower.slice(lastDot);
+    return RAW_TEXT_EXTENSIONS.has(ext);
 }
 const DNS_LOOKUP_TIMEOUT_MS = 5000;
 const SLOW_REQUEST_THRESHOLD_MS = 5000;
@@ -314,25 +314,6 @@ function normalizeLookupResults(addresses, family) {
     }
     return [{ address: addresses, family: family ?? 4 }];
 }
-function findBlockedIpError(list, hostname) {
-    for (const addr of list) {
-        const ip = typeof addr === 'string' ? addr : addr.address;
-        if (!isBlockedIp(ip)) {
-            continue;
-        }
-        return createErrorWithCode(`Blocked IP detected for ${hostname}`, 'EBLOCKED');
-    }
-    return null;
-}
-function findInvalidFamilyError(list, hostname) {
-    for (const addr of list) {
-        const family = typeof addr === 'string' ? 0 : addr.family;
-        if (family === 4 || family === 6)
-            continue;
-        return createErrorWithCode(`Invalid address family returned for ${hostname}`, 'EINVAL');
-    }
-    return null;
-}
 function createNoDnsResultsError(hostname) {
     return createErrorWithCode(`No DNS results returned for ${hostname}`, 'ENODATA');
 }
@@ -358,7 +339,17 @@ function selectLookupResult(list, useAll, hostname) {
     };
 }
 function findLookupError(list, hostname) {
-    return (findInvalidFamilyError(list, hostname) ?? findBlockedIpError(list, hostname));
+    for (const addr of list) {
+        const family = typeof addr === 'string' ? 0 : addr.family;
+        if (family !== 4 && family !== 6) {
+            return createErrorWithCode(`Invalid address family returned for ${hostname}`, 'EINVAL');
+        }
+        const ip = typeof addr === 'string' ? addr : addr.address;
+        if (isBlockedIp(ip)) {
+            return createErrorWithCode(`Blocked IP detected for ${hostname}`, 'EBLOCKED');
+        }
+    }
+    return null;
 }
 function normalizeAndValidateLookupResults(addresses, resolvedFamily, hostname) {
     const list = normalizeLookupResults(addresses, resolvedFamily);

package/dist/http-native.js

@@ -5,8 +5,8 @@ import { URL, URLSearchParams } from 'node:url';
 import { InvalidTokenError, ServerError, } from '@modelcontextprotocol/sdk/server/auth/errors.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
-import { handleDownload } from './cache.js';
-import { config, enableHttpMode } from './config.js';
+import { keys as cacheKeys, handleDownload } from './cache.js';
+import { config, enableHttpMode, serverVersion } from './config.js';
 import { timingSafeEqualUtf8 } from './crypto.js';
 import { normalizeHost } from './host-normalization.js';
 import { acceptsEventStream, isJsonRpcBatchRequest, isMcpRequestBody, } from './mcp-validator.js';
@@ -14,6 +14,7 @@ import { createMcpServer } from './mcp.js';
 import { logError, logInfo, logWarn } from './observability.js';
 import { applyHttpServerTuning, drainConnectionsOnShutdown, } from './server-tuning.js';
 import { composeCloseHandlers, createSessionStore, createSlotTracker, ensureSessionCapacity, reserveSessionSlot, startSessionCleanupLoop, } from './session.js';
+import { getTransformPoolStats } from './transform.js';
 import { isObject } from './type-guards.js';
 function createTransportAdapter(transportImpl) {
     const noopOnClose = () => { };
@@ -580,7 +581,22 @@ async function dispatchRequest(req, res, url, ctx) {
     const { method } = req;
     try {
         if (method === 'GET' && path === '/health') {
-            res.status(200).json({ status: 'ok' });
+            const poolStats = getTransformPoolStats();
+            res.status(200).json({
+                status: 'ok',
+                version: serverVersion,
+                uptime: Math.floor(process.uptime()),
+                timestamp: new Date().toISOString(),
+                stats: {
+                    activeSessions: ctx.store.size(),
+                    cacheKeys: cacheKeys().length,
+                    workerPool: poolStats ?? {
+                        queueDepth: 0,
+                        activeWorkers: 0,
+                        capacity: 0,
+                    },
+                },
+            });
             return;
         }
         if (!(await authenticateRequest(req, res))) {

package/dist/markdown-cleanup.d.ts

@@ -1,16 +1,10 @@
-/**
- * Markdown cleanup utilities for post-processing converted content.
- *
- * Goals:
- * - Never mutate fenced code blocks (``` / ~~~) content.
- * - Keep rules localized and readable.
- * - Avoid multi-pass regexes that accidentally hit code blocks.
- */
-/**
- * Clean up common markdown artifacts and formatting issues.
- * IMPORTANT: All rules are applied ONLY outside fenced code blocks.
- */
+import type { MetadataBlock } from './transform-types.js';
 export declare function cleanupMarkdownArtifacts(content: string): string;
+export declare function extractTitleFromRawMarkdown(content: string): string | undefined;
+export declare function addSourceToMarkdown(content: string, url: string): string;
+export declare function isRawTextContent(content: string): boolean;
+export declare function isLikelyHtmlContent(content: string): boolean;
+export declare function buildMetadataFooter(metadata?: MetadataBlock, fallbackUrl?: string): string;
 /**
  * Promote standalone lines that look like headings to proper markdown headings.
  * Fence-aware: never modifies content inside fenced code blocks.

package/dist/markdown-cleanup.js

@@ -1,11 +1,4 @@
-/**
- * Markdown cleanup utilities for post-processing converted content.
- *
- * Goals:
- * - Never mutate fenced code blocks (``` / ~~~) content.
- * - Keep rules localized and readable.
- * - Avoid multi-pass regexes that accidentally hit code blocks.
- */
+import { config } from './config.js';
 // ─────────────────────────────────────────────────────────────────────────────
 // Fence state helpers
 // ─────────────────────────────────────────────────────────────────────────────
@@ -76,15 +69,6 @@ function splitByFences(content) {
     }
     return segments;
 }
-/**
- * Apply a transformation function only to non-fenced content.
- */
-function mapOutsideFences(content, transform) {
-    const segments = splitByFences(content);
-    return segments
-        .map((seg) => (seg.inFence ? seg.content : transform(seg.content)))
-        .join('\n');
-}
 // ─────────────────────────────────────────────────────────────────────────────
 // Cleanup rules (OUTSIDE fences only)
 // ─────────────────────────────────────────────────────────────────────────────
@@ -165,6 +149,21 @@ function normalizeListsAndSpacing(text) {
     // Collapse excessive blank lines
     return text.replace(/\n{3,}/g, '\n\n');
 }
+function fixConcatenatedProperties(text) {
+    const quotedValuePattern = /([a-z_][a-z0-9_]{0,30}\??:\s+)([\u0022\u201C][^\u0022\u201C\u201D]*[\u0022\u201D])([a-z_][a-z0-9_]{0,30}\??:)/g;
+    let result = text;
+    let iterations = 0;
+    const maxIterations = 3;
+    while (iterations < maxIterations) {
+        const before = result;
+        result = result.replace(quotedValuePattern, '$1$2\n\n$3');
+        if (result === before) {
+            break;
+        }
+        iterations++;
+    }
+    return result;
+}
 const CLEANUP_STEPS = [
     fixOrphanHeadings,
     removeEmptyHeadings,
@@ -173,21 +172,256 @@ const CLEANUP_STEPS = [
     removeTocBlocks,
     tidyLinksAndEscapes,
     normalizeListsAndSpacing,
+    fixConcatenatedProperties,
 ];
 // ─────────────────────────────────────────────────────────────────────────────
 // Public API
 // ─────────────────────────────────────────────────────────────────────────────
-/**
- * Clean up common markdown artifacts and formatting issues.
- * IMPORTANT: All rules are applied ONLY outside fenced code blocks.
- */
+function getLastLine(text) {
+    const index = text.lastIndexOf('\n');
+    return index === -1 ? text : text.slice(index + 1);
+}
 export function cleanupMarkdownArtifacts(content) {
     if (!content)
         return '';
-    const cleaned = mapOutsideFences(content, (outside) => {
-        return CLEANUP_STEPS.reduce((text, step) => step(text), outside);
-    });
-    return cleaned.trim();
+    const segments = splitByFences(content);
+    return segments
+        .map((seg, index) => {
+        if (seg.inFence)
+            return seg.content;
+        const prevSeg = segments[index - 1];
+        const prevLineContext = prevSeg ? getLastLine(prevSeg.content) : '';
+        const lines = seg.content.split('\n');
+        const promotedLines = [];
+        for (let i = 0; i < lines.length; i += 1) {
+            const line = lines[i] ?? '';
+            const prevLine = i > 0 ? (lines[i - 1] ?? '') : prevLineContext;
+            promotedLines.push(processNonFencedLine(line, prevLine));
+        }
+        const promoted = promotedLines.join('\n');
+        return CLEANUP_STEPS.reduce((text, step) => step(text), promoted);
+    })
+        .join('\n')
+        .trim();
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Raw markdown handling + metadata footer
+// ─────────────────────────────────────────────────────────────────────────────
+const HEADING_PATTERN = /^#{1,6}\s/m;
+const LIST_PATTERN = /^(?:[-*+])\s/m;
+const HTML_DOCUMENT_PATTERN = /^(<!doctype|<html)/i;
+function containsMarkdownHeading(content) {
+    return HEADING_PATTERN.test(content);
+}
+function containsMarkdownList(content) {
+    return LIST_PATTERN.test(content);
+}
+function containsFencedCodeBlock(content) {
+    const first = content.indexOf('```');
+    if (first === -1)
+        return false;
+    return content.includes('```', first + 3);
+}
+function looksLikeMarkdown(content) {
+    return (containsMarkdownHeading(content) ||
+        containsMarkdownList(content) ||
+        containsFencedCodeBlock(content));
+}
+function detectLineEnding(content) {
+    return content.includes('\r\n') ? '\r\n' : '\n';
+}
+const FRONTMATTER_DELIMITER = '---';
+function findFrontmatterLines(content) {
+    const lineEnding = detectLineEnding(content);
+    const lines = content.split(lineEnding);
+    if (lines[0] !== FRONTMATTER_DELIMITER)
+        return null;
+    const endIndex = lines.indexOf(FRONTMATTER_DELIMITER, 1);
+    if (endIndex === -1)
+        return null;
+    return { lineEnding, lines, endIndex };
+}
+function stripOptionalQuotes(value) {
+    const trimmed = value.trim();
+    if (trimmed.length < 2)
+        return trimmed;
+    const first = trimmed[0];
+    const last = trimmed[trimmed.length - 1];
+    if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+function parseFrontmatterEntry(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    const separatorIndex = trimmed.indexOf(':');
+    if (separatorIndex <= 0)
+        return null;
+    const key = trimmed.slice(0, separatorIndex).trim().toLowerCase();
+    const value = trimmed.slice(separatorIndex + 1);
+    return { key, value };
+}
+function isTitleKey(key) {
+    return key === 'title' || key === 'name';
+}
+function extractTitleFromHeading(content) {
+    const lineEnding = detectLineEnding(content);
+    const lines = content.split(lineEnding);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let index = 0;
+        while (index < trimmed.length && trimmed[index] === '#') {
+            index += 1;
+        }
+        if (index === 0 || index > 6)
+            return undefined;
+        const nextChar = trimmed[index];
+        if (nextChar !== ' ' && nextChar !== '\t')
+            return undefined;
+        const heading = trimmed.slice(index).trim();
+        return heading.length > 0 ? heading : undefined;
+    }
+    return undefined;
+}
+export function extractTitleFromRawMarkdown(content) {
+    const frontmatter = findFrontmatterLines(content);
+    if (!frontmatter) {
+        return extractTitleFromHeading(content);
+    }
+    const { lines, endIndex } = frontmatter;
+    const entry = lines
+        .slice(1, endIndex)
+        .map((line) => parseFrontmatterEntry(line))
+        .find((parsed) => parsed !== null && isTitleKey(parsed.key));
+    if (!entry)
+        return undefined;
+    const value = stripOptionalQuotes(entry.value);
+    return value || undefined;
+}
+function hasMarkdownSourceLine(content) {
+    const lineEnding = detectLineEnding(content);
+    const lines = content.split(lineEnding);
+    const limit = Math.min(lines.length, 50);
+    for (let index = 0; index < limit; index += 1) {
+        const line = lines[index];
+        if (!line)
+            continue;
+        if (line.trimStart().toLowerCase().startsWith('source:')) {
+            return true;
+        }
+    }
+    return false;
+}
+function addSourceToMarkdownMarkdownFormat(content, url) {
+    if (hasMarkdownSourceLine(content))
+        return content;
+    const lineEnding = detectLineEnding(content);
+    const lines = content.split(lineEnding);
+    const firstNonEmptyIndex = lines.findIndex((line) => line.trim().length > 0);
+    if (firstNonEmptyIndex !== -1) {
+        const firstLine = lines[firstNonEmptyIndex];
+        if (firstLine && /^#{1,6}\s+/.test(firstLine.trim())) {
+            const insertAt = firstNonEmptyIndex + 1;
+            const updated = [
+                ...lines.slice(0, insertAt),
+                '',
+                `Source: ${url}`,
+                '',
+                ...lines.slice(insertAt),
+            ];
+            return updated.join(lineEnding);
+        }
+    }
+    return [`Source: ${url}`, '', content].join(lineEnding);
+}
+export function addSourceToMarkdown(content, url) {
+    const frontmatter = findFrontmatterLines(content);
+    if (config.transform.metadataFormat === 'markdown' && !frontmatter) {
+        return addSourceToMarkdownMarkdownFormat(content, url);
+    }
+    if (!frontmatter) {
+        return `---\nsource: "${url}"\n---\n\n${content}`;
+    }
+    const { lineEnding, lines, endIndex } = frontmatter;
+    const bodyLines = lines.slice(1, endIndex);
+    const hasSource = bodyLines.some((line) => line.trimStart().toLowerCase().startsWith('source:'));
+    if (hasSource)
+        return content;
+    const updatedLines = [
+        lines[0],
+        ...bodyLines,
+        `source: "${url}"`,
+        ...lines.slice(endIndex),
+    ];
+    return updatedLines.join(lineEnding);
+}
+function hasFrontmatter(trimmed) {
+    return trimmed.startsWith('---\n') || trimmed.startsWith('---\r\n');
+}
+function looksLikeHtmlDocument(trimmed) {
+    return HTML_DOCUMENT_PATTERN.test(trimmed);
+}
+function countCommonHtmlTags(content) {
+    const matches = content.match(/<(html|head|body|div|span|script|style|meta|link)\b/gi) ??
+        [];
+    return matches.length;
+}
+export function isRawTextContent(content) {
+    const trimmed = content.trim();
+    const isHtmlDocument = looksLikeHtmlDocument(trimmed);
+    const hasMarkdownFrontmatter = hasFrontmatter(trimmed);
+    const hasTooManyHtmlTags = countCommonHtmlTags(content) > 2;
+    const isMarkdown = looksLikeMarkdown(content);
+    return (!isHtmlDocument &&
+        (hasMarkdownFrontmatter || (!hasTooManyHtmlTags && isMarkdown)));
+}
+export function isLikelyHtmlContent(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return false;
+    if (looksLikeHtmlDocument(trimmed))
+        return true;
+    return countCommonHtmlTags(content) > 2;
+}
+function formatFetchedDate(isoString) {
+    try {
+        const date = new Date(isoString);
+        const day = String(date.getDate()).padStart(2, '0');
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const year = date.getFullYear();
+        return `${day}-${month}-${year}`;
+    }
+    catch {
+        return isoString;
+    }
+}
+export function buildMetadataFooter(metadata, fallbackUrl) {
+    if (!metadata)
+        return '';
+    const lines = ['---', ''];
+    const url = metadata.url || fallbackUrl;
+    const parts = [];
+    if (metadata.title)
+        parts.push(`_${metadata.title}_`);
+    if (metadata.author)
+        parts.push(`_${metadata.author}_`);
+    if (url)
+        parts.push(`[_Original Source_](${url})`);
+    if (metadata.fetchedAt) {
+        const formattedDate = formatFetchedDate(metadata.fetchedAt);
+        parts.push(`_${formattedDate}_`);
+    }
+    if (parts.length > 0) {
+        lines.push(` ${parts.join(' | ')}`);
+    }
+    if (metadata.description) {
+        lines.push(` <sub>${metadata.description}</sub>`);
+    }
+    return lines.join('\n');
 }
 // ─────────────────────────────────────────────────────────────────────────────
 // Heading Promotion (fence-aware)

package/dist/mcp.js

@@ -4,37 +4,53 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { registerCachedContentResource } from './cache.js';
 import { config } from './config.js';
 import { destroyAgents } from './fetch.js';
-import { logError, logInfo } from './observability.js';
+import { logError, logInfo, setMcpServer } from './observability.js';
 import { registerTools } from './tools.js';
 import { shutdownTransformWorkerPool } from './transform.js';
+function getLocalIconData() {
+    try {
+        const iconPath = new URL('../assets/logo.svg', import.meta.url);
+        const buffer = readFileSync(iconPath);
+        return `data:image/svg+xml;base64,${buffer.toString('base64')}`;
+    }
+    catch {
+        return undefined;
+    }
+}
 function createServerInfo() {
+    const localIcon = getLocalIconData();
     return {
         name: config.server.name,
         version: config.server.version,
+        ...(localIcon
+            ? {
+                icons: [
+                    { src: localIcon, mimeType: 'image/svg+xml', sizes: ['any'] },
+                ],
+            }
+            : {}),
     };
 }
 function createServerCapabilities() {
     return {
         tools: { listChanged: true },
         resources: { listChanged: true, subscribe: true },
+        logging: {},
     };
 }
 function createServerInstructions(serverVersion) {
     try {
-        const raw = readFileSync(new URL('./instructions.md', import.meta.url), {
-            encoding: 'utf8',
-        });
-        const resolved = raw.replaceAll('{{SERVER_VERSION}}', serverVersion);
-        return resolved.trim();
+        const raw = readFileSync(new URL('./instructions.md', import.meta.url), 'utf8');
+        return raw.replaceAll('{{SERVER_VERSION}}', serverVersion).trim();
     }
     catch {
-        return `superFetch MCP server |${serverVersion}| A high-performance web content fetching and processing server.`;
+        return `Instructions unavailable | ${serverVersion}`;
     }
 }
 function registerInstructionsResource(server, instructions) {
     server.registerResource('instructions', new ResourceTemplate('internal://instructions', { list: undefined }), {
-        title: 'Server Instructions',
-        description: 'Usage guidance for the superFetch MCP server.',
+        title: `SuperFetch MCP | ${config.server.version}`,
+        description: 'Guidance for using the superFetch MCP server.',
         mimeType: 'text/markdown',
     }, (uri) => ({
         contents: [
@@ -52,7 +68,8 @@ export function createMcpServer() {
         capabilities: createServerCapabilities(),
         instructions,
     });
-    registerTools(server);
+    setMcpServer(server);
+    registerTools(server, getLocalIconData());
     registerCachedContentResource(server);
     registerInstructionsResource(server, instructions);
     return server;

package/dist/observability.d.ts

@@ -1,9 +1,11 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export type LogMetadata = Record<string, unknown>;
 interface RequestContext {
     readonly requestId: string;
     readonly sessionId?: string;
     readonly operationId?: string;
 }
+export declare function setMcpServer(server: McpServer): void;
 export declare function runWithRequestContext<T>(context: RequestContext, fn: () => T): T;
 export declare function getRequestId(): string | undefined;
 export declare function getSessionId(): string | undefined;