@j0hanz/superfetch 2.4.2 → 2.4.3

package/dist/cache.d.ts

@@ -36,7 +36,12 @@ export declare function get(cacheKey: string | null): CacheEntry | undefined;
 export declare function set(cacheKey: string | null, content: string, metadata: CacheEntryMetadata): void;
 export declare function keys(): readonly string[];
 export declare function isEnabled(): boolean;
-export declare function registerCachedContentResource(server: McpServer, serverIcon?: string): void;
+export interface McpIcon {
+    src: string;
+    mimeType: string;
+    sizes: string[];
+}
+export declare function registerCachedContentResource(server: McpServer, serverIcons?: McpIcon[]): void;
 export declare function generateSafeFilename(url: string, title?: string, hashFallback?: string, extension?: string): string;
 export declare function handleDownload(res: ServerResponse, namespace: string, hash: string): void;
 export {};

package/dist/cache.js

@@ -395,34 +395,24 @@ function notifyResourceUpdate(server, uri, subscriptions) {
         });
     });
 }
-export function registerCachedContentResource(server, serverIcon) {
+export function registerCachedContentResource(server, serverIcons) {
     const isInitialized = attachInitializedGate(server);
     const subscriptions = registerResourceSubscriptionHandlers(server);
-    registerCacheContentResource(server, serverIcon);
+    registerCacheContentResource(server, serverIcons);
     registerCacheUpdateSubscription(server, subscriptions, isInitialized);
 }
 function buildCachedContentResponse(uri, cacheKey) {
     const cached = requireCacheEntry(cacheKey);
     return buildMarkdownContentResponse(uri, cached.content);
 }
-function registerCacheContentResource(server, serverIcon) {
+function registerCacheContentResource(server, serverIcons) {
     server.registerResource('cached-content', new ResourceTemplate('superfetch://cache/{namespace}/{urlHash}', {
         list: listCachedResources,
     }), {
         title: 'Cached Content',
         description: 'Access previously fetched web content from cache. Namespace: markdown. UrlHash: SHA-256 hash of the URL.',
         mimeType: 'text/markdown',
-        ...(serverIcon
-            ? {
-                icons: [
-                    {
-                        src: serverIcon,
-                        mimeType: 'image/svg+xml',
-                        sizes: ['any'],
-                    },
-                ],
-            }
-            : {}),
+        ...(serverIcons ? { icons: serverIcons } : {}),
     }, (uri, params) => {
         const { namespace, urlHash } = resolveCacheParams(params);
         const cacheKey = `${namespace}:${urlHash}`;

package/dist/mcp.js

@@ -7,28 +7,28 @@ import { destroyAgents } from './fetch.js';
 import { logError, logInfo, setMcpServer } from './observability.js';
 import { registerTools } from './tools.js';
 import { shutdownTransformWorkerPool } from './transform.js';
-function getLocalIconData() {
+function getLocalIcons() {
     try {
         const iconPath = new URL('../assets/logo.svg', import.meta.url);
         const buffer = readFileSync(iconPath);
-        return `data:image/svg+xml;base64,${buffer.toString('base64')}`;
+        return [
+            {
+                src: `data:image/svg+xml;base64,${buffer.toString('base64')}`,
+                mimeType: 'image/svg+xml',
+                sizes: ['any'],
+            },
+        ];
     }
     catch {
         return undefined;
     }
 }
 function createServerInfo() {
-    const localIcon = getLocalIconData();
+    const localIcons = getLocalIcons();
     return {
         name: config.server.name,
         version: config.server.version,
-        ...(localIcon
-            ? {
-                icons: [
-                    { src: localIcon, mimeType: 'image/svg+xml', sizes: ['any'] },
-                ],
-            }
-            : {}),
+        ...(localIcons ? { icons: localIcons } : {}),
     };
 }
 function createServerCapabilities() {
@@ -69,9 +69,9 @@ export function createMcpServer() {
         instructions,
     });
     setMcpServer(server);
-    const localIcon = getLocalIconData();
-    registerTools(server, localIcon);
-    registerCachedContentResource(server, localIcon);
+    const localIcons = getLocalIcons();
+    registerTools(server, localIcons);
+    registerCachedContentResource(server, localIcons);
     registerInstructionsResource(server, instructions);
     return server;
 }

package/dist/tools.d.ts

@@ -1,5 +1,6 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { CallToolResult, ContentBlock } from '@modelcontextprotocol/sdk/types.js';
+import * as cache from './cache.js';
 import type { MarkdownTransformResult } from './transform-types.js';
 export interface FetchUrlInput {
     url: string;
@@ -121,5 +122,5 @@ type MarkdownPipelineResult = MarkdownTransformResult & {
 export declare function parseCachedMarkdownResult(cached: string): MarkdownPipelineResult | undefined;
 export declare function fetchUrlToolHandler(input: FetchUrlInput, extra?: ToolHandlerExtra): Promise<ToolResponseBase>;
 export declare function withRequestContextIfMissing<TParams, TResult, TExtra = unknown>(handler: (params: TParams, extra?: TExtra) => Promise<TResult>): (params: TParams, extra?: TExtra) => Promise<TResult>;
-export declare function registerTools(server: McpServer, serverIcon?: string): void;
+export declare function registerTools(server: McpServer, serverIcons?: cache.McpIcon[]): void;
 export {};

package/dist/tools.js

@@ -482,23 +482,13 @@ function resolveRequestIdFromExtra(extra) {
         return String(requestId);
     return undefined;
 }
-export function registerTools(server, serverIcon) {
+export function registerTools(server, serverIcons) {
     server.registerTool(TOOL_DEFINITION.name, {
         title: TOOL_DEFINITION.title,
         description: TOOL_DEFINITION.description,
         inputSchema: TOOL_DEFINITION.inputSchema,
         outputSchema: TOOL_DEFINITION.outputSchema,
         annotations: TOOL_DEFINITION.annotations,
-        ...(serverIcon
-            ? {
-                icons: [
-                    {
-                        src: serverIcon,
-                        mimeType: 'image/svg+xml',
-                        sizes: ['any'],
-                    },
-                ],
-            }
-            : {}),
+        ...(serverIcons ? { icons: serverIcons } : {}),
     }, withRequestContextIfMissing(TOOL_DEFINITION.handler));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/superfetch",
-  "version": "2.4.2",
+  "version": "2.4.3",
   "mcpName": "io.github.j0hanz/superfetch",
   "description": "Intelligent web content fetcher MCP server that converts HTML to clean, AI-readable Markdown",
   "type": "module",