@j0hanz/fetch-url-mcp 1.1.0 → 1.1.2

package/dist/tools.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { CallToolResult, ContentBlock } from '@modelcontextprotocol/sdk/types.js';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import type { MarkdownTransformResult } from './transform-types.js';
 export interface FetchUrlInput {
     url: string;
@@ -8,12 +8,7 @@ export interface FetchUrlInput {
     forceRefresh?: boolean | undefined;
     maxInlineChars?: number | undefined;
 }
-export interface ToolContentBlock {
-    type: 'text';
-    text: string;
-}
-export type ToolContentBlockUnion = ContentBlock;
-export type ToolErrorResponse = CallToolResult & {
+type ToolErrorResponse = CallToolResult & {
     structuredContent: {
         error: string;
         url: string;
@@ -22,10 +17,10 @@ export type ToolErrorResponse = CallToolResult & {
     };
     isError: true;
 };
-export type ToolResponseBase = CallToolResult & {
+type ToolResponseBase = CallToolResult & {
     structuredContent: Record<string, unknown>;
 };
-export interface FetchPipelineOptions<T> {
+interface FetchPipelineOptions<T> {
     url: string;
     cacheNamespace: string;
     signal?: AbortSignal;
@@ -39,7 +34,7 @@ export interface FetchPipelineOptions<T> {
     serialize?: (result: T) => string;
     deserialize?: (cached: string) => T | undefined;
 }
-export interface PipelineResult<T> {
+interface PipelineResult<T> {
     data: T;
     fromCache: boolean;
     url: string;
@@ -48,8 +43,8 @@ export interface PipelineResult<T> {
     fetchedAt: string;
     cacheKey?: string | null;
 }
-export type ProgressToken = string | number;
-export interface RequestMeta {
+type ProgressToken = string | number;
+interface RequestMeta {
     progressToken?: ProgressToken | undefined;
     [key: string]: unknown;
 }
@@ -64,7 +59,7 @@ export interface ProgressNotification {
     method: 'notifications/progress';
     params: ProgressNotificationParams;
 }
-export interface ToolHandlerExtra {
+interface ToolHandlerExtra {
     signal?: AbortSignal;
     requestId?: string | number;
     sessionId?: unknown;
@@ -89,7 +84,7 @@ interface InlineContentResult {
     contentSize: number;
     truncated?: boolean;
 }
-export type InlineResult = ReturnType<InlineContentLimiter['apply']>;
+type InlineResult = ReturnType<InlineContentLimiter['apply']>;
 declare class InlineContentLimiter {
     apply(content: string, inlineLimitOverride?: number): InlineContentResult;
     private resolveInlineLimit;

package/dist/tools.js

@@ -708,12 +708,7 @@ function serializeMarkdownResult(result) {
 function buildStructuredContent(pipeline, inlineResult, inputUrl) {
     const cacheResourceUri = resolveCacheResourceUri(pipeline.cacheKey);
     const truncated = inlineResult.truncated ?? pipeline.data.truncated;
-    let markdown = inlineResult.content;
-    if (pipeline.data.truncated &&
-        !inlineResult.truncated &&
-        typeof markdown === 'string') {
-        markdown = appendTruncationMarker(markdown, TRUNCATION_MARKER);
-    }
+    const markdown = applyTruncationMarker(inlineResult.content, pipeline.data.truncated);
     const { metadata } = pipeline.data;
     return {
         url: pipeline.originalUrl ?? pipeline.url,
@@ -730,6 +725,11 @@ function buildStructuredContent(pipeline, inlineResult, inputUrl) {
         ...(truncated ? { truncated: true } : {}),
     };
 }
+function applyTruncationMarker(content, truncated) {
+    if (!truncated || typeof content !== 'string')
+        return content;
+    return appendTruncationMarker(content, TRUNCATION_MARKER);
+}
 function resolveCacheResourceUri(cacheKey) {
     if (!cacheKey)
         return undefined;
@@ -866,14 +866,14 @@ function resolveSessionIdFromExtra(extra) {
 export function registerTools(server) {
     if (!config.tools.enabled.includes(FETCH_URL_TOOL_NAME))
         return;
-    server.registerTool(TOOL_DEFINITION.name, {
+    const registeredTool = 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,
         execution: TOOL_DEFINITION.execution,
-        // Use specific tool icon here
         icons: [TOOL_ICON],
     }, withRequestContextIfMissing(TOOL_DEFINITION.handler));
+    registeredTool.execution = TOOL_DEFINITION.execution;
 }

package/dist/transform-types.d.ts

@@ -102,6 +102,10 @@ export interface TransformWorkerCancelMessage {
     type: 'cancel';
     id: string;
 }
+export interface TransformWorkerCancelledMessage {
+    type: 'cancelled';
+    id: string;
+}
 export interface TransformWorkerResultMessage {
     type: 'result';
     id: string;
@@ -123,4 +127,4 @@ export interface TransformWorkerErrorMessage {
         details?: Record<string, unknown>;
     };
 }
-export type TransformWorkerOutgoingMessage = TransformWorkerResultMessage | TransformWorkerErrorMessage;
+export type TransformWorkerOutgoingMessage = TransformWorkerResultMessage | TransformWorkerErrorMessage | TransformWorkerCancelledMessage;

package/dist/transform.d.ts

@@ -1,5 +1,5 @@
 import type { ExtractedArticle, ExtractedMetadata, ExtractionResult, MarkdownTransformResult, MetadataBlock, TransformOptions, TransformStageContext } from './transform-types.js';
-export interface StageBudget {
+interface StageBudget {
     totalBudgetMs: number;
     elapsedMs: number;
 }
@@ -21,7 +21,7 @@ export declare function isExtractionSufficient(article: ExtractedArticle | null,
 export declare function determineContentExtractionSource(article: ExtractedArticle | null): article is ExtractedArticle;
 export declare function createContentMetadataBlock(url: string, article: ExtractedArticle | null, extractedMeta: ExtractedMetadata, shouldExtractFromArticle: boolean, includeMetadata: boolean): MetadataBlock | undefined;
 export declare function transformHtmlToMarkdownInProcess(html: string, url: string, options: TransformOptions): MarkdownTransformResult;
-export interface TransformPoolStats {
+interface TransformPoolStats {
     queueDepth: number;
     activeWorkers: number;
     capacity: number;

package/dist/transform.js

@@ -42,6 +42,9 @@ function getTagName(node) {
     const raw = node.tagName;
     return typeof raw === 'string' ? raw.toUpperCase() : '';
 }
+function asError(value) {
+    return value instanceof Error ? value : undefined;
+}
 function getAbortReason(signal) {
     const record = isObject(signal) ? signal : null;
     return record && 'reason' in record ? record['reason'] : undefined;
@@ -513,7 +516,7 @@ function extractArticle(document, url, signal) {
         };
     }
     catch (error) {
-        logError('Failed to extract article with Readability', error instanceof Error ? error : undefined);
+        logError('Failed to extract article with Readability', asError(error));
         return null;
     }
 }
@@ -573,7 +576,7 @@ function extractContentContext(html, url, options) {
         if (error instanceof FetchError)
             throw error;
         abortPolicy.throwIfAborted(options.signal, url, 'extract:error');
-        logError('Failed to extract content', error instanceof Error ? error : undefined);
+        logError('Failed to extract content', asError(error));
         const { document } = parseHTML('<html></html>');
         return { article: null, metadata: {}, document };
     }
@@ -1149,7 +1152,7 @@ function translateHtmlToMarkdown(params) {
     abortPolicy.throwIfAborted(signal, url, 'markdown:cleaned');
     const content = stageTracker.run(url, 'markdown:translate', () => translateHtmlFragmentToMarkdown(cleanedHtml));
     abortPolicy.throwIfAborted(signal, url, 'markdown:translated');
-    const cleaned = cleanupMarkdownArtifacts(content);
+    const cleaned = cleanupMarkdownArtifacts(content, signal ? { signal, url } : { url });
     return url ? resolveRelativeUrls(cleaned, url) : cleaned;
 }
 function appendMetadataFooter(content, metadata, url) {
@@ -1177,7 +1180,7 @@ export function htmlToMarkdown(html, metadata, options) {
     catch (error) {
         if (error instanceof FetchError)
             throw error;
-        logError('Failed to convert HTML to markdown', error instanceof Error ? error : undefined);
+        logError('Failed to convert HTML to markdown', asError(error));
         throw new FetchError('Failed to convert HTML to markdown', url, 500, {
             reason: 'markdown_convert_failed',
         });
@@ -1647,6 +1650,9 @@ function isWorkerResponse(raw) {
     if (raw['type'] === 'error') {
         return isWorkerErrorPayload(raw['error']);
     }
+    if (raw['type'] === 'cancelled') {
+        return true;
+    }
     return false;
 }
 function createTaskContext() {
@@ -1836,6 +1842,7 @@ class WorkerPool {
     queue = [];
     queueHead = 0;
     inflight = new Map();
+    cancelAcks = new Map();
     timeoutMs;
     queueMax;
     spawnWorkerImpl;
@@ -1963,7 +1970,7 @@ class WorkerPool {
         }
         const inflight = this.inflight.get(id);
         if (inflight) {
-            this.abortInflight(id, url, inflight.workerIndex);
+            void this.abortInflight(id, url, inflight.workerIndex);
             return;
         }
         const queuedIndex = this.findQueuedIndex(id);
@@ -1985,8 +1992,36 @@ class WorkerPool {
             this.maybeCompactQueue();
         }
     }
-    abortInflight(id, url, workerIndex) {
+    resolveCancelAck(id) {
+        const pending = this.cancelAcks.get(id);
+        if (!pending)
+            return;
+        pending.timeout.cancel();
+        pending.resolve();
+    }
+    waitForCancelAck(id) {
+        const existing = this.cancelAcks.get(id);
+        if (existing) {
+            return existing.promise;
+        }
+        let resolve = () => { };
+        const timeout = createUnrefTimeout(200, undefined);
+        const racePromise = new Promise((finish) => {
+            resolve = finish;
+        });
+        const promise = Promise.race([racePromise, timeout.promise]).finally(() => {
+            this.cancelAcks.delete(id);
+            timeout.cancel();
+        });
+        this.cancelAcks.set(id, { promise, resolve, timeout });
+        return promise;
+    }
+    async abortInflight(id, url, workerIndex) {
         const slot = this.workers[workerIndex];
+        const inflight = this.inflight.get(id);
+        if (inflight) {
+            inflight.cancelPending = true;
+        }
         if (slot) {
             try {
                 slot.host.postMessage({ type: 'cancel', id });
@@ -1995,6 +2030,7 @@ class WorkerPool {
                 // Worker may be unavailable; failure is acceptable during abort
             }
         }
+        await this.waitForCancelAck(id);
         this.failTask(id, abortPolicy.createAbortError(url, 'transform:signal-abort'));
         if (slot)
             this.restartWorker(workerIndex, slot);
@@ -2059,6 +2095,15 @@ class WorkerPool {
         if (!isWorkerResponse(raw))
             return;
         const message = raw;
+        if (message.type === 'cancelled') {
+            this.resolveCancelAck(message.id);
+            return;
+        }
+        const inflightPeek = this.inflight.get(message.id);
+        if (inflightPeek?.cancelPending) {
+            this.resolveCancelAck(message.id);
+            return;
+        }
         const inflight = this.takeInflight(message.id);
         if (!inflight)
             return;
@@ -2208,6 +2253,7 @@ class WorkerPool {
             abortListener: task.abortListener,
             workerIndex,
             context: task.context,
+            cancelPending: false,
         });
         try {
             const { message, transferList } = buildWorkerDispatchPayload(task, slot.host.supportsTransferList);

package/dist/type-guards.d.ts

@@ -1,6 +1,6 @@
 export declare function isObject(value: unknown): value is Record<PropertyKey, unknown>;
 export declare function isError(value: unknown): value is Error;
-export interface LikeNode {
+interface LikeNode {
     readonly tagName?: string | undefined;
     readonly nodeName?: string | undefined;
     readonly nodeType?: number | undefined;
@@ -12,3 +12,4 @@ export interface LikeNode {
     getAttribute?(name: string): string | null;
 }
 export declare function isLikeNode(value: unknown): value is LikeNode;
+export {};

package/dist/type-guards.js

@@ -2,9 +2,9 @@ export function isObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 export function isError(value) {
-    const ErrorConstructor = Error;
-    if (typeof ErrorConstructor.isError === 'function') {
-        return ErrorConstructor.isError(value);
+    const { isError: isErrorFn } = Error;
+    if (typeof isErrorFn === 'function') {
+        return isErrorFn(value);
     }
     return value instanceof Error;
 }

package/dist/workers/transform-child.js

@@ -4,11 +4,15 @@ import { transformHtmlToMarkdownInProcess } from '../transform.js';
 const send = process.send?.bind(process);
 if (!send)
     throw new Error('transform-child started without IPC channel');
+const sendMessage = send;
+function postMessage(message) {
+    sendMessage(message);
+}
 const controllersById = new Map();
 const decoder = new TextDecoder('utf-8');
 function postError(id, url, error) {
     if (error instanceof FetchError) {
-        send?.({
+        postMessage({
             type: 'error',
             id,
             error: {
@@ -21,7 +25,7 @@ function postError(id, url, error) {
         });
         return;
     }
-    send?.({
+    postMessage({
         type: 'error',
         id,
         error: {
@@ -52,7 +56,7 @@ function isValidMessage(msg) {
     return true;
 }
 function postValidationError(id, url, message) {
-    send?.({
+    postMessage({
         type: 'error',
         id,
         error: { name: 'ValidationError', message, url },
@@ -94,7 +98,7 @@ function handleTransform(msg) {
             ...(inputTruncated ? { inputTruncated: true } : {}),
         });
         const { markdown, metadata, title, truncated } = result;
-        send?.({
+        postMessage({
             type: 'result',
             id,
             result: title === undefined

package/dist/workers/transform-worker.js

@@ -61,6 +61,9 @@ function decodeHtmlBuffer(htmlBuffer, encoding) {
         return decoder.decode(htmlBuffer);
     }
 }
+function resolveHtmlContent(html, htmlBuffer, encoding) {
+    return htmlBuffer ? decodeHtmlBuffer(htmlBuffer, encoding) : (html ?? '');
+}
 function handleTransform(msg) {
     if (!isValidMessage(msg))
         return;
@@ -76,9 +79,7 @@ function handleTransform(msg) {
     const controller = new AbortController();
     controllersById.set(id, controller);
     try {
-        const content = htmlBuffer
-            ? decodeHtmlBuffer(htmlBuffer, encoding)
-            : (html ?? '');
+        const content = resolveHtmlContent(html, htmlBuffer, encoding);
         const result = transformHtmlToMarkdownInProcess(content, url, {
             includeMetadata,
             signal: controller.signal,
@@ -121,6 +122,7 @@ port.on('message', (raw) => {
         const controller = controllersById.get(id);
         if (controller)
             controller.abort(new Error('Canceled'));
+        port.postMessage({ type: 'cancelled', id });
         return;
     }
     if (type === 'transform') {

package/package.json

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