@j0hanz/fetch-url-mcp 1.11.7 → 1.12.0

package/dist/resources/index.js

@@ -1,271 +1,6 @@
-import { ResourceTemplate, } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { ErrorCode, McpError, SubscribeRequestSchema, UnsubscribeRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { get as getCacheEntry, getEntryMeta, keys as listCacheKeys, onCacheUpdate, parseCacheKey, toCacheScopeId, } from '../lib/cache.js';
-import { config, logWarn, resolveMcpSessionIdByServer } from '../lib/core.js';
-import { registerServerLifecycleCleanup } from '../lib/mcp-interop.js';
+import { config } from '../lib/core.js';
 import { buildOptionalIcons } from '../lib/utils.js';
-import { isObject } from '../lib/utils.js';
-import { parseCachedPayload, resolveCachedPayloadContent } from '../schemas.js';
 import { FETCH_URL_TOOL_NAME } from '../tools/fetch-url.js';
-const RESOURCE_NOT_FOUND_ERROR_CODE = -32002;
-const CACHE_RESOURCE_TEMPLATE_URI = 'internal://cache/{namespace}/{hash}';
-const CACHE_RESOURCE_PREFIX = 'internal://cache/';
-const CACHE_NAMESPACE_PATTERN = /^[a-z0-9_-]{1,64}$/i;
-const CACHE_HASH_PATTERN = /^[a-f0-9.]{8,64}$/i;
-const MAX_COMPLETION_VALUES = 100;
-function normalizeCompletionPrefix(value) {
-    return value.trim().toLowerCase();
-}
-function sortAndLimitValues(values) {
-    return [...values]
-        .sort((left, right) => left.localeCompare(right))
-        .slice(0, MAX_COMPLETION_VALUES);
-}
-function isValidCacheResourceParts(parts) {
-    return (CACHE_NAMESPACE_PATTERN.test(parts.namespace) &&
-        CACHE_HASH_PATTERN.test(parts.hash));
-}
-function decodeSegment(value) {
-    try {
-        return decodeURIComponent(value);
-    }
-    catch {
-        return value;
-    }
-}
-function trimToValue(value) {
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-}
-function firstVariableValue(value) {
-    if (typeof value === 'string') {
-        return trimToValue(value);
-    }
-    if (Array.isArray(value)) {
-        const first = value[0];
-        if (typeof first !== 'string')
-            return undefined;
-        return trimToValue(first);
-    }
-    return undefined;
-}
-function validateCacheResourceParts(namespace, hash) {
-    const decoded = {
-        namespace: decodeSegment(namespace),
-        hash: decodeSegment(hash),
-    };
-    return isValidCacheResourceParts(decoded) ? decoded : null;
-}
-function parseCacheResourceFromVariables(variables) {
-    const namespace = firstVariableValue(variables['namespace']);
-    const hash = firstVariableValue(variables['hash']);
-    if (!namespace || !hash)
-        return null;
-    return validateCacheResourceParts(namespace, hash);
-}
-function parseCacheResourceFromUri(uri) {
-    if (!uri.href.startsWith(CACHE_RESOURCE_PREFIX))
-        return null;
-    const rawPath = uri.pathname.startsWith('/')
-        ? uri.pathname.slice(1)
-        : uri.pathname;
-    const segments = rawPath.split('/');
-    if (segments.length !== 2)
-        return null;
-    const namespace = segments[0];
-    const hash = segments[1];
-    if (!namespace || !hash)
-        return null;
-    return validateCacheResourceParts(namespace, hash);
-}
-function toCacheResourceUri(parts) {
-    const namespace = encodeURIComponent(parts.namespace);
-    const hash = encodeURIComponent(parts.hash);
-    return `${CACHE_RESOURCE_PREFIX}${namespace}/${hash}`;
-}
-export function isCacheEntryVisibleToScope(scopeId, meta) {
-    return meta.scopeIds.includes(scopeId);
-}
-function getVisibleCacheEntries(scopeId) {
-    return listCacheKeys()
-        .map((key) => parseCacheKey(key))
-        .filter((parts) => parts !== null)
-        .map((parts) => ({ namespace: parts.namespace, hash: parts.urlHash }))
-        .filter((parts) => {
-        const meta = getEntryMeta(`${parts.namespace}:${parts.hash}`);
-        return meta ? isCacheEntryVisibleToScope(scopeId, meta) : false;
-    });
-}
-function completeCacheNamespaces(value, scopeId) {
-    const normalized = normalizeCompletionPrefix(value);
-    const namespaces = [
-        ...new Set(getVisibleCacheEntries(scopeId).map((entry) => entry.namespace)),
-    ].filter((ns) => ns.toLowerCase().startsWith(normalized));
-    return sortAndLimitValues(namespaces);
-}
-function completeCacheHashes(value, scopeId, context) {
-    const normalized = normalizeCompletionPrefix(value);
-    const namespace = context?.arguments?.['namespace']?.trim();
-    const hashes = getVisibleCacheEntries(scopeId)
-        .filter((entry) => namespace === undefined || entry.namespace === namespace)
-        .map((entry) => entry.hash)
-        .filter((h) => h.toLowerCase().startsWith(normalized));
-    return sortAndLimitValues(hashes);
-}
-function getServerCacheScopeId(server) {
-    return toCacheScopeId(resolveMcpSessionIdByServer(server));
-}
-export function listCacheResourcesForScope(scopeId) {
-    const resources = getVisibleCacheEntries(scopeId)
-        .map((parts) => {
-        const cacheParts = {
-            namespace: parts.namespace,
-            hash: parts.hash,
-        };
-        const cacheKey = `${parts.namespace}:${parts.hash}`;
-        const meta = getEntryMeta(cacheKey);
-        if (!meta)
-            return null; // expired between keys() and meta read — skip
-        return {
-            uri: toCacheResourceUri(cacheParts),
-            name: `${parts.namespace}:${parts.hash}`,
-            title: meta.title ?? 'Cached Markdown',
-            description: 'Cached markdown output generated by fetch-url',
-            mimeType: 'text/markdown',
-            annotations: {
-                audience: ['assistant'],
-                priority: 0.6,
-                ...(meta.fetchedAt ? { lastModified: meta.fetchedAt } : {}),
-            },
-        };
-    })
-        .filter((r) => r !== null);
-    return { resources };
-}
-function normalizeSubscriptionUri(uri) {
-    const parsedUri = URL.parse(uri);
-    if (!parsedUri) {
-        throw new McpError(ErrorCode.InvalidParams, 'Invalid resource URI');
-    }
-    const cacheParts = parseCacheResourceFromUri(parsedUri);
-    if (cacheParts)
-        return toCacheResourceUri(cacheParts);
-    return parsedUri.href;
-}
-const cacheNotificationServers = new WeakSet();
-function registerCacheResourceNotifications(server) {
-    if (cacheNotificationServers.has(server))
-        return;
-    cacheNotificationServers.add(server);
-    const subscribedResourceUris = new Set();
-    const setSubscription = (uri, subscribed) => {
-        const normalized = normalizeSubscriptionUri(uri);
-        if (subscribed) {
-            subscribedResourceUris.add(normalized);
-        }
-        else {
-            subscribedResourceUris.delete(normalized);
-        }
-    };
-    server.server.setRequestHandler(SubscribeRequestSchema, async (request) => {
-        setSubscription(request.params.uri, true);
-        return Promise.resolve({});
-    });
-    server.server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
-        setSubscription(request.params.uri, false);
-        return Promise.resolve({});
-    });
-    const unsubscribe = onCacheUpdate((event) => {
-        const scopeId = getServerCacheScopeId(server);
-        const changedUri = toCacheResourceUri({
-            namespace: event.namespace,
-            hash: event.urlHash,
-        });
-        const isVisibleToServer = event.scopeIds.includes(scopeId);
-        if (isVisibleToServer &&
-            server.isConnected() &&
-            subscribedResourceUris.has(changedUri)) {
-            void server.server
-                .sendResourceUpdated({ uri: changedUri })
-                .catch((error) => {
-                logWarn('Failed to send resource updated notification', {
-                    uri: changedUri,
-                    error,
-                });
-            });
-        }
-        if (!event.listChanged)
-            return;
-        if (!server.isConnected() || !isVisibleToServer)
-            return;
-        try {
-            server.sendResourceListChanged();
-        }
-        catch (error) {
-            logWarn('Failed to send resources list changed notification', { error });
-        }
-    });
-    let cleanedUp = false;
-    const cleanup = () => {
-        if (cleanedUp)
-            return;
-        cleanedUp = true;
-        unsubscribe();
-    };
-    registerServerLifecycleCleanup(server, cleanup);
-}
-function normalizeTemplateVariables(variables) {
-    if (!isObject(variables))
-        return {};
-    const normalized = {};
-    for (const [key, value] of Object.entries(variables)) {
-        if (typeof value === 'string' || value === undefined) {
-            normalized[key] = value;
-            continue;
-        }
-        if (Array.isArray(value)) {
-            normalized[key] = value.filter((item) => typeof item === 'string');
-        }
-    }
-    return normalized;
-}
-function resolveCacheResourceParts(uri, variables) {
-    const fromVariables = parseCacheResourceFromVariables(variables);
-    if (fromVariables)
-        return fromVariables;
-    const fromUri = parseCacheResourceFromUri(uri);
-    if (fromUri)
-        return fromUri;
-    throw new McpError(ErrorCode.InvalidParams, 'Invalid cache resource URI or template arguments');
-}
-export function readCacheResourceForScope(uri, variables, scopeId) {
-    const parts = resolveCacheResourceParts(uri, variables);
-    const cacheKey = `${parts.namespace}:${parts.hash}`;
-    const meta = getEntryMeta(cacheKey);
-    if (!meta || !isCacheEntryVisibleToScope(scopeId, meta)) {
-        throw new McpError(RESOURCE_NOT_FOUND_ERROR_CODE, 'Resource not found', {
-            uri: uri.href,
-        });
-    }
-    const entry = getCacheEntry(cacheKey);
-    if (!entry) {
-        throw new McpError(RESOURCE_NOT_FOUND_ERROR_CODE, 'Resource not found', {
-            uri: uri.href,
-        });
-    }
-    const payload = parseCachedPayload(entry.content);
-    const markdown = payload ? resolveCachedPayloadContent(payload) : null;
-    const text = markdown ?? entry.content;
-    return {
-        contents: [
-            {
-                uri: uri.href,
-                mimeType: 'text/markdown',
-                text,
-            },
-        ],
-    };
-}
 export function registerInstructionResource(server, instructions, iconInfo) {
     server.registerResource('fetch-url-mcp-instructions', 'internal://instructions', {
         title: 'Server Instructions',
@@ -286,48 +21,22 @@ export function registerInstructionResource(server, instructions, iconInfo) {
         ],
     }));
 }
-export function registerCacheResourceTemplate(server, iconInfo) {
-    const template = new ResourceTemplate(CACHE_RESOURCE_TEMPLATE_URI, {
-        list: () => listCacheResourcesForScope(getServerCacheScopeId(server)),
-        complete: {
-            namespace: (value) => completeCacheNamespaces(value, getServerCacheScopeId(server)),
-            hash: (value, context) => completeCacheHashes(value, getServerCacheScopeId(server), context),
-        },
-    });
-    server.registerResource('fetch-url-mcp-cache-entry', template, {
-        title: 'Cached Fetch Output',
-        description: 'Read cached markdown generated by previous fetch-url calls.',
-        mimeType: 'text/markdown',
-        annotations: {
-            audience: ['assistant'],
-            priority: 0.6,
-        },
-        ...buildOptionalIcons(iconInfo),
-    }, (uri, variables) => readCacheResourceForScope(uri, normalizeTemplateVariables(variables), getServerCacheScopeId(server)));
-    registerCacheResourceNotifications(server);
-}
 export function buildServerInstructions() {
     const maxHtmlSizeMb = config.constants.maxHtmlBytes / 1024 / 1024;
-    const cacheSizeMb = config.cache.maxSizeBytes / 1024 / 1024;
-    const cacheTtlHours = config.cache.ttl / 3600;
     return `# Fetch public webpages and return clean, readable Markdown.
 
 # Capabilities
 - Tool: \`${FETCH_URL_TOOL_NAME}\` (fetch URL, return Markdown)
 - Resource: \`internal://instructions\` (this document)
-- Resource template: \`internal://cache/{namespace}/{hash}\` (cached Markdown)
 - Prompt: \`get-help\` (returns these instructions)
-- Completions: resource-template argument completion for cache entries
 
 # Workflows
 1. Standard: Call \`${FETCH_URL_TOOL_NAME}\` → read \`markdown\`. \`truncated: true\` means content was cut at server size limit.
-2. Fresh: \`forceRefresh: true\` bypasses cache (does not fix truncation).
-3. Async: \`task: { ttl: <ms> }\` in \`tools/call\` → poll \`tasks/get\` → \`tasks/result\`.
+2. Async: \`task: { ttl: <ms> }\` in \`tools/call\` → poll \`tasks/get\` → \`tasks/result\`.
 
 # Constraints
 - Blocked URLs: localhost, private IPs (10.x, 172.16-31.x, 192.168.x), metadata (169.254.169.254), .local/.internal.
 - Max HTML: ${maxHtmlSizeMb}MB. Max redirects: ${config.fetcher.maxRedirects}.
-- Cache: ${config.cache.maxKeys} entries, ${cacheSizeMb}MB, ${cacheTtlHours}h TTL. Process-local, ephemeral.
 - No JS rendering — client-side pages may be incomplete.
 - Binary: not supported.
 - Batch JSON-RPC (\`[{...}]\`): rejected with HTTP 400.
@@ -343,7 +52,7 @@ export function buildServerInstructions() {
 - queue_full: worker pool busy. Wait and retry, or use task mode.`;
 }
 export function registerGetHelpPrompt(server, instructions, iconInfo) {
-    const description = 'Return Fetch URL server instructions: workflows, cache usage, task mode, and error handling.';
+    const description = 'Return Fetch URL server instructions: workflows, task mode, and error handling.';
     server.registerPrompt('get-help', {
         title: 'Get Help',
         description,

package/dist/schemas.d.ts

@@ -3,16 +3,8 @@ import type { ExtractedMetadata } from './transform/types.js';
 export declare const extractedMetadataSchema: z.ZodType<ExtractedMetadata>;
 export declare function normalizeExtractedMetadata(value: unknown): ExtractedMetadata | undefined;
 export declare function normalizePageTitle(value: unknown): string | undefined;
-export interface CachedPayload {
-    markdown: string;
-    title?: string | undefined;
-    metadata?: ExtractedMetadata | undefined;
-    truncated?: boolean | undefined;
-}
-export declare const cachedPayloadValueSchema: z.ZodType<CachedPayload>;
 export declare const fetchUrlInputSchema: z.ZodObject<{
     url: z.ZodURL;
-    forceRefresh: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 export declare const fetchUrlOutputSchema: z.ZodObject<{
     url: z.ZodURL;
@@ -22,14 +14,8 @@ export declare const fetchUrlOutputSchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
     metadata: z.ZodOptional<z.ZodType<ExtractedMetadata, unknown, z.core.$ZodTypeInternals<ExtractedMetadata, unknown>>>;
     markdown: z.ZodOptional<z.ZodString>;
-    fromCache: z.ZodOptional<z.ZodBoolean>;
     fetchedAt: z.ZodOptional<z.ZodISODateTime>;
     contentSize: z.ZodOptional<z.ZodNumber>;
     truncated: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
-export declare function parseCachedPayload(raw: string): CachedPayload | null;
-export declare function stringifyCachedPayload(payload: z.input<typeof cachedPayloadValueSchema>): string;
-export declare function resolveCachedPayloadContent(payload: {
-    markdown?: string | null;
-}): string | null;
 //# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAoD9D,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAG9D,CAAC;AAgBJ,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,iBAAiB,GAAG,SAAS,CAQ/B;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAErE;AAUD,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,QAAQ,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACzC,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACjC;AAED,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAM1D,CAAC;AAwCL,eAAO,MAAM,mBAAmB;;;kBAkB/B,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;kBAqC/B,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAkBpE;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,GAChD,MAAM,CAER;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE;IACnD,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,GAAG,MAAM,GAAG,IAAI,CAEhB"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAoD9D,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAG9D,CAAC;AAgBJ,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,iBAAiB,GAAG,SAAS,CAQ/B;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAErE;AAED,eAAO,MAAM,mBAAmB;;kBAc/B,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;kBAoC/B,CAAC"}

package/dist/schemas.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { config, logWarn } from './lib/core.js';
+import { config } from './lib/core.js';
 const URL_FIELD_MAX_LENGTH = 2048;
 const METADATA_LIMITS = {
     title: 512,
@@ -49,61 +49,12 @@ export function normalizeExtractedMetadata(value) {
 export function normalizePageTitle(value) {
     return normalizeWithSchema(pageTitleSchema, value);
 }
-function normalizeString(value) {
-    return typeof value === 'string' ? value : undefined;
-}
-function normalizeBoolean(value) {
-    return typeof value === 'boolean' ? value : undefined;
-}
-export const cachedPayloadValueSchema = z.strictObject({
-    markdown: z.string(),
-    title: pageTitleSchema.optional(),
-    metadata: extractedMetadataSchema.optional(),
-    truncated: z.boolean().optional(),
-});
-const cachedPayloadCompatSchema = z.object({
-    markdown: z.unknown().transform((value) => normalizeString(value)),
-    title: z
-        .unknown()
-        .transform((value) => normalizePageTitle(value))
-        .optional(),
-    metadata: z
-        .unknown()
-        .transform((value) => normalizeExtractedMetadata(value))
-        .optional(),
-    truncated: z
-        .unknown()
-        .transform((value) => normalizeBoolean(value))
-        .optional(),
-});
-const cachedPayloadSchema = cachedPayloadCompatSchema
-    .superRefine((value, ctx) => {
-    if (typeof value.markdown === 'string')
-        return;
-    ctx.addIssue({
-        code: 'custom',
-        message: 'Missing markdown',
-        path: ['markdown'],
-    });
-})
-    .transform((value) => cachedPayloadValueSchema.parse({
-    markdown: value.markdown,
-    ...(value.title !== undefined ? { title: value.title } : {}),
-    ...(value.metadata ? { metadata: value.metadata } : {}),
-    ...(value.truncated !== undefined
-        ? { truncated: value.truncated }
-        : {}),
-}));
 export const fetchUrlInputSchema = z.strictObject({
     url: z
         .httpUrl('Expected HTTP or HTTPS URL')
         .min(1, 'URL required')
         .max(config.constants.maxUrlLength, `URL exceeds ${config.constants.maxUrlLength} chars`)
         .describe(`Target URL. Max ${config.constants.maxUrlLength} chars. Example: https://example.com`),
-    forceRefresh: z
-        .boolean('Expected boolean')
-        .optional()
-        .describe('Bypass cache and fetch fresh content.'),
 }, 'Invalid input');
 export const fetchUrlOutputSchema = z.strictObject({
     url: z.httpUrl().max(config.constants.maxUrlLength).describe('Fetched URL.'),
@@ -131,7 +82,6 @@ export const fetchUrlOutputSchema = z.strictObject({
         : z.string())
         .optional()
         .describe('Extracted Markdown. May be truncated (check truncated field).'),
-    fromCache: z.boolean().optional().describe('True if served from cache.'),
     fetchedAt: z.iso.datetime().optional().describe('ISO timestamp of fetch.'),
     contentSize: z
         .number()
@@ -142,29 +92,3 @@ export const fetchUrlOutputSchema = z.strictObject({
         .describe('Markdown fragment size before final inline truncation.'),
     truncated: z.boolean().optional().describe('True if markdown was truncated.'),
 });
-export function parseCachedPayload(raw) {
-    try {
-        const parsed = JSON.parse(raw);
-        const result = cachedPayloadSchema.safeParse(parsed);
-        if (!result.success) {
-            logWarn('Rejected invalid cached payload', {
-                issues: result.error.issues.map((issue) => ({
-                    path: issue.path,
-                    message: issue.message,
-                    code: issue.code,
-                })),
-            });
-            return null;
-        }
-        return result.data;
-    }
-    catch {
-        return null;
-    }
-}
-export function stringifyCachedPayload(payload) {
-    return JSON.stringify(cachedPayloadValueSchema.parse(payload));
-}
-export function resolveCachedPayloadContent(payload) {
-    return typeof payload.markdown === 'string' ? payload.markdown : null;
-}

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA+GpE,wBAAsB,eAAe,IAAI,OAAO,CAAC,SAAS,CAAC,CAE1D;AAmDD,wBAAsB,6BAA6B,IAAI,OAAO,CAAC,SAAS,CAAC,CAExE;AA4FD,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAMtD"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA8GpE,wBAAsB,eAAe,IAAI,OAAO,CAAC,SAAS,CAAC,CAE1D;AAkDD,wBAAsB,6BAA6B,IAAI,OAAO,CAAC,SAAS,CAAC,CAExE;AA4FD,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAMtD"}

package/dist/server.js

@@ -7,7 +7,7 @@ import { config } from './lib/core.js';
 import { getSessionId, logError, logInfo, setLogLevel, setMcpServer, } from './lib/core.js';
 import { setTaskToolCallCapability } from './lib/mcp-interop.js';
 import { toError } from './lib/utils.js';
-import { buildServerInstructions, registerCacheResourceTemplate, registerGetHelpPrompt, registerInstructionResource, } from './resources/index.js';
+import { buildServerInstructions, registerGetHelpPrompt, registerInstructionResource, } from './resources/index.js';
 import { abortAllTaskExecutions, registerTaskHandlers, } from './tasks/handlers.js';
 import { registerTools as registerFetchUrlTool } from './tools/fetch-url.js';
 import { shutdownTransformWorkerPool } from './transform/transform.js';
@@ -89,7 +89,6 @@ async function createMcpServerWithOptions(options) {
     const toolControls = registerFetchUrlTool(server);
     registerGetHelpPrompt(server, serverInstructions, localIcon);
     registerInstructionResource(server, serverInstructions, localIcon);
-    registerCacheResourceTemplate(server, localIcon);
     const taskRegistration = registerTaskHandlers(server, {
         requireInterception: config.tasks.requireInterception,
     });

package/dist/tools/fetch-url.d.ts

@@ -18,13 +18,11 @@ export declare function getFetchCompletionStatusMessage(result: ServerResult): s
 export declare class FetchUrlProgressPlan {
     private readonly reporter;
     private readonly context;
-    private cacheStatus;
     constructor(reporter: ProgressReporter, context: string);
     reportStart(): void;
     reportStage(stage: SharedFetchStage): void;
     reportSuccess(contentSize: number): void;
     reportFailure(cancelled: boolean): void;
-    private updateCacheStatus;
     private mapStage;
 }
 export declare function fetchUrlToolHandler(input: FetchUrlInput, extra?: ToolHandlerExtra): Promise<ToolResponseBase>;

package/dist/tools/fetch-url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch-url.d.ts","sourceRoot":"","sources":["../../src/tools/fetch-url.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EACV,YAAY,EAEb,MAAM,oCAAoC,CAAC;AAE5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAc7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACtB,MAAM,uBAAuB,CAAC;AAU/B,OAAO,EACL,mBAAmB,EAIpB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAIL,KAAK,sBAAsB,EAE5B,MAAM,sBAAsB,CAAC;AAE9B,KAAK,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEzD,UAAU,gBAAgB;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IACxD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,eAAO,MAAM,mBAAmB,cAAc,CAAC;AAwI/C,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,YAAY,GACnB,MAAM,GAAG,SAAS,CAUpB;AAED,qBAAa,oBAAoB;IAI7B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,OAAO,CAAC,WAAW,CAA0B;gBAG1B,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,MAAM;IAGlC,WAAW,IAAI,IAAI;IAInB,WAAW,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAO1C,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAIxC,aAAa,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI;IAIvC,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,QAAQ;CAmCjB;AAuED,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,aAAa,EACpB,KAAK,CAAC,EAAE,gBAAgB,GACvB,OAAO,CAAC,gBAAgB,CAAC,CAQ3B;AAqBD,MAAM,WAAW,wBAAwB;IACvC,cAAc,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,IAAI,CAAC;CAC3D;AAqBD,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,wBAAwB,CAoCzE"}
+{"version":3,"file":"fetch-url.d.ts","sourceRoot":"","sources":["../../src/tools/fetch-url.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EACV,YAAY,EAEb,MAAM,oCAAoC,CAAC;AAE5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAY7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACtB,MAAM,uBAAuB,CAAC;AAU/B,OAAO,EACL,mBAAmB,EAIpB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAIL,KAAK,sBAAsB,EAE5B,MAAM,sBAAsB,CAAC;AAE9B,KAAK,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEzD,UAAU,gBAAgB;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IACxD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,eAAO,MAAM,mBAAmB,cAAc,CAAC;AAoI/C,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,YAAY,GACnB,MAAM,GAAG,SAAS,CAUpB;AAED,qBAAa,oBAAoB;IAE7B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,MAAM;IAGlC,WAAW,IAAI,IAAI;IAInB,WAAW,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAM1C,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAIxC,aAAa,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI;IAIvC,OAAO,CAAC,QAAQ;CAqBjB;AAmED,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,aAAa,EACpB,KAAK,CAAC,EAAE,gBAAgB,GACvB,OAAO,CAAC,gBAAgB,CAAC,CAQ3B;AAqBD,MAAM,WAAW,wBAAwB;IACvC,cAAc,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,IAAI,CAAC;CAC3D;AAqBD,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,wBAAwB,CAoCzE"}

package/dist/tools/fetch-url.js

@@ -1,6 +1,6 @@
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
 import { config, logDebug, logError, logWarn } from '../lib/core.js';
-import { finalizeInlineMarkdown, markdownTransform, parseCachedMarkdownResult, performSharedFetch, serializeMarkdownResult, withSignal, } from '../lib/fetch-pipeline.js';
+import { finalizeInlineMarkdown, markdownTransform, performSharedFetch, withSignal, } from '../lib/fetch-pipeline.js';
 import { createProgressReporter, handleToolError, } from '../lib/mcp-interop.js';
 import { composeAbortSignal, isAbortError, isObject, parseUrlOrNull, toError, } from '../lib/utils.js';
 import { formatZodError } from '../lib/zod.js';
@@ -57,7 +57,6 @@ function buildStructuredContent(pipeline, inlineResult, inputUrl) {
         ...(title ? { title } : {}),
         ...(metadata ? { metadata } : {}),
         markdown,
-        fromCache: pipeline.fromCache,
         fetchedAt: pipeline.fetchedAt,
         contentSize: inlineResult.contentSize,
         ...(truncated ? { truncated: true } : {}),
@@ -88,12 +87,11 @@ function buildResponse(pipeline, inlineResult, inputUrl) {
 const Step = {
     START: 1,
     RESOLVE_URL: 2,
-    CHECK_CACHE: 3,
-    CACHE_OR_FETCH: 4,
-    RESTORE_OR_RESPONSE: 5,
-    TRANSFORM: 6,
-    PREPARE: 7,
-    DONE: 8,
+    FETCH: 3,
+    RESPONSE: 4,
+    TRANSFORM: 5,
+    PREPARE: 6,
+    DONE: 7,
 };
 function formatContentSize(contentSize) {
     if (contentSize < 1000)
@@ -119,7 +117,6 @@ export function getFetchCompletionStatusMessage(result) {
 export class FetchUrlProgressPlan {
     reporter;
     context;
-    cacheStatus = 'unknown';
     constructor(reporter, context) {
         this.reporter = reporter;
         this.context = context;
@@ -128,7 +125,6 @@ export class FetchUrlProgressPlan {
         this.reporter.report(Step.START, 'Preparing request');
     }
     reportStage(stage) {
-        this.updateCacheStatus(stage);
         const mapped = this.mapStage(stage);
         if (!mapped)
             return;
@@ -140,47 +136,23 @@ export class FetchUrlProgressPlan {
     reportFailure(cancelled) {
         this.reporter.report(Step.DONE, cancelled ? 'Cancelled' : 'Failed');
     }
-    updateCacheStatus(stage) {
-        if (stage === 'cache_hit' || stage === 'cache_restore') {
-            this.cacheStatus = 'cache_hit';
-        }
-        else if (stage === 'fetch_remote' ||
-            stage === 'response_ready' ||
-            stage === 'transform_start') {
-            this.cacheStatus = 'cache_miss';
-        }
-    }
     mapStage(stage) {
         switch (stage) {
             case 'resolve_url':
                 return { step: Step.RESOLVE_URL, message: 'Resolving URL' };
-            case 'check_cache':
-                return { step: Step.CHECK_CACHE, message: 'Checking cache' };
-            case 'cache_hit':
-                return { step: Step.CACHE_OR_FETCH, message: 'Loaded from cache' };
-            case 'cache_restore':
-                return {
-                    step: Step.RESTORE_OR_RESPONSE,
-                    message: 'Restoring cached content',
-                };
             case 'fetch_remote':
                 return {
-                    step: Step.CACHE_OR_FETCH,
+                    step: Step.FETCH,
                     message: `Fetching ${this.context}`,
                 };
             case 'response_ready':
-                return { step: Step.RESTORE_OR_RESPONSE, message: 'Received response' };
+                return { step: Step.RESPONSE, message: 'Received response' };
             case 'transform_start':
                 return { step: Step.TRANSFORM, message: 'Parsing HTML -> Markdown' };
             case 'prepare_output':
-                return {
-                    step: this.cacheStatus === 'cache_miss' ? Step.PREPARE : Step.TRANSFORM,
-                    message: 'Fetch completed',
-                };
+                return { step: Step.PREPARE, message: 'Fetch completed' };
             case 'finalize_output':
-                if (this.cacheStatus === 'cache_miss')
-                    return undefined;
-                return { step: Step.PREPARE, message: 'Finalizing output' };
+                return undefined;
         }
     }
 }
@@ -195,19 +167,16 @@ function buildToolAbortSignal(extraSignal) {
     }
     return signal;
 }
-function buildFetchOptions(url, signal, progressPlan, forceRefresh) {
+function buildFetchOptions(url, signal, progressPlan) {
     return {
         url,
         ...withSignal(signal),
-        ...(forceRefresh ? { forceRefresh: true } : {}),
         onStage: (stage) => {
             progressPlan.reportStage(stage);
         },
         transform: async ({ buffer, encoding, truncated }, normalizedUrl) => {
             return markdownTransform({ buffer, encoding, ...(truncated ? { truncated } : {}) }, normalizedUrl, signal);
         },
-        serialize: serializeMarkdownResult,
-        deserialize: parseCachedMarkdownResult,
     };
 }
 async function executeFetch(input, extra) {
@@ -217,7 +186,7 @@ async function executeFetch(input, extra) {
     logDebug('Fetching URL', { url });
     try {
         progressPlan.reportStart();
-        const { pipeline, inlineResult } = await performSharedFetch(buildFetchOptions(url, signal, progressPlan, input.forceRefresh));
+        const { pipeline, inlineResult } = await performSharedFetch(buildFetchOptions(url, signal, progressPlan));
         progressPlan.reportSuccess(inlineResult.contentSize);
         return buildResponse(pipeline, inlineResult, url);
     }